diff --git a/src/attr.rs b/src/attr.rs
index 5bff9be..2a58082 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -382,19 +382,19 @@
     }
 
     fn lit_doc_comment(input: Cursor) -> PResult<TokenTree> {
-        let mut tokens = input.iter();
-        let tok = match tokens.next() {
-            Some(tok) => tok,
-            None => return parse_error(),
-        };
-        let literal = match tok.kind {
-            TokenKind::Literal(ref l) => l.to_string(),
-            _ => return parse_error(),
-        };
-        if literal.starts_with("//") || literal.starts_with("/*") {
-            Ok((tokens.as_slice(), tok.clone()))
-        } else {
-            parse_error()
+        match input.literal() {
+            Some((rest, span, lit)) => {
+                let literal = lit.to_string();
+                if literal.starts_with("//") || literal.starts_with("/*") {
+                    Ok((rest, TokenTree {
+                        span: span,
+                        kind: TokenKind::Literal(lit)
+                    }))
+                } else {
+                    parse_error()
+                }
+            }
+            _ => parse_error()
         }
     }
 }
diff --git a/src/generics.rs b/src/generics.rs
index 2ab61bf..2c30a5f 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -213,7 +213,6 @@
 
     use synom::{PResult, Cursor, Synom, parse_error};
     use synom::tokens::*;
-    use proc_macro2::TokenKind;
 
     impl Synom for Generics {
         named!(parse -> Self, map!(
@@ -243,20 +242,18 @@
 
     impl Synom for Lifetime {
         fn parse(input: Cursor) -> PResult<Self> {
-            let mut tokens = input.iter();
-            let token = match tokens.next() {
-                Some(token) => token,
-                None => return parse_error(),
-            };
-            if let TokenKind::Word(s) = token.kind {
-                if s.as_str().starts_with('\'') {
-                    return Ok((tokens.as_slice(), Lifetime {
-                        ident: Ident {
-                            span: Span(token.span),
-                            sym: s,
-                        },
-                    }))
+            match input.word() {
+                Some((rest, span, sym)) => {
+                    if sym.as_str().starts_with('\'') {
+                        return Ok((rest, Lifetime {
+                            ident: Ident {
+                                span: Span(span),
+                                sym: sym
+                            }
+                        }));
+                    }
                 }
+                _ => {}
             }
             parse_error()
         }
diff --git a/src/ident.rs b/src/ident.rs
index 181bac9..afc8a3a 100644
--- a/src/ident.rs
+++ b/src/ident.rs
@@ -108,24 +108,18 @@
 #[cfg(feature = "parsing")]
 pub mod parsing {
     use super::*;
-    use proc_macro2::TokenKind;
     use synom::{Synom, PResult, Cursor, parse_error};
 
     impl Synom for Ident {
         fn parse(input: Cursor) -> PResult<Self> {
-            let mut tokens = input.iter();
-            let token = match tokens.next() {
-                Some(token) => token,
-                None => return parse_error(),
-            };
-            let word = match token.kind {
-                TokenKind::Word(s) => s,
+            let (rest, span, sym) = match input.word() {
+                Some(word) => word,
                 _ => return parse_error(),
             };
-            if word.as_str().starts_with('\'') {
+            if sym.as_str().starts_with('\'') {
                 return parse_error();
             }
-            match word.as_str() {
+            match sym.as_str() {
                 // From https://doc.rust-lang.org/grammar.html#keywords
                 "abstract" | "alignof" | "as" | "become" | "box" | "break" | "const" | "continue" |
                 "crate" | "do" | "else" | "enum" | "extern" | "false" | "final" | "fn" | "for" |
@@ -137,9 +131,9 @@
                 _ => {}
             }
 
-            Ok((tokens.as_slice(), Ident {
-                span: Span(token.span),
-                sym: word,
+            Ok((rest, Ident {
+                span: Span(span),
+                sym: sym,
             }))
         }
 
diff --git a/src/lit.rs b/src/lit.rs
index c9b4229..659571e 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -105,21 +105,31 @@
 
     impl Synom for Lit {
         fn parse(input: Cursor) -> PResult<Self> {
-            let mut tokens = input.iter();
-            let token = match tokens.next() {
-                Some(token) => token,
-                None => return parse_error(),
-            };
-            let kind = match token.kind {
-                TokenKind::Literal(ref l) => LitKind::Other(l.clone()),
-                TokenKind::Word(ref s) if s.as_str() == "true" => LitKind::Bool(true),
-                TokenKind::Word(ref s) if s.as_str() == "false" => LitKind::Bool(false),
-                _ => return parse_error(),
-            };
-            Ok((tokens.as_slice(), Lit {
-                span: Span(token.span),
-                value: kind,
-            }))
+            match input.literal() {
+                Some((rest, span, lit)) => {
+                    Ok((rest, Lit {
+                        span: Span(span),
+                        value: LitKind::Other(lit)
+                    }))
+                }
+                _ => match input.word() {
+                    Some((rest, span, sym)) => {
+                        let kind = if sym.as_str() == "true" {
+                            LitKind::Bool(true)
+                        } else if sym.as_str() == "false" {
+                            LitKind::Bool(false)
+                        } else {
+                            return parse_error();
+                        };
+
+                        Ok((rest, Lit {
+                            span: Span(span),
+                            value: kind
+                        }))
+                    }
+                    _ => parse_error(),
+                }
+            }
         }
     }
 }
diff --git a/src/mac.rs b/src/mac.rs
index b822051..3517ac8 100644
--- a/src/mac.rs
+++ b/src/mac.rs
@@ -154,14 +154,13 @@
 
     impl ::TokenTree {
         pub fn parse_list(input: Cursor) -> PResult<Vec<Self>> {
-            Ok((&[], input.iter().cloned().map(::TokenTree).collect()))
+            Ok((Cursor::empty(), input.token_stream().into_iter().map(::TokenTree).collect()))
         }
 
         pub fn parse_delimited(input: Cursor) -> PResult<Self> {
-            let mut tokens = input.iter();
-            match tokens.next() {
-                Some(token @ &TokenTree { kind: TokenKind::Sequence(..), .. }) => {
-                    Ok((tokens.as_slice(), ::TokenTree(token.clone())))
+            match input.token_tree() {
+                Some((rest, token @ TokenTree { kind: TokenKind::Sequence(..), .. })) => {
+                    Ok((rest, ::TokenTree(token)))
                 }
                 _ => parse_error(),
             }