Wrap token iterator in a new type

This is in prepration for building better behavior into it, such as
transparently stepping into None-delimited groups.

Author: dtolnay

src/iter.rs

@@ -0,0 +1,28 @@
+use proc_macro::{token_stream, TokenStream, TokenTree};
+use std::iter::Peekable;
+
+pub type Iter<'a> = &'a mut IterImpl;
+
+pub struct IterImpl {
+    tokens: Peekable<token_stream::IntoIter>,
+}
+
+pub fn new(tokens: TokenStream) -> IterImpl {
+    IterImpl {
+        tokens: tokens.into_iter().peekable(),
+    }
+}
+
+impl IterImpl {
+    pub fn peek(&mut self) -> Option<&TokenTree> {
+        self.tokens.peek()
+    }
+}
+
+impl Iterator for IterImpl {
+    type Item = TokenTree;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.tokens.next()
+    }
+}

src/lib.rs

@@ -131,17 +131,17 @@ extern crate proc_macro;
 mod quote;
 
 mod error;
+mod iter;
 mod parse;
 
 use crate::error::{compile_error, Error};
+use crate::iter::Iter;
 use crate::parse::{
     parse_define_args, parse_enum_hack, parse_export_args, parse_fake_call_site, parse_input,
 };
-use proc_macro::{token_stream, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
+use proc_macro::{Ident, Punct, Spacing, Span, TokenStream, TokenTree};
 use std::fmt::Write;
-use std::iter::Peekable;
 
-type Iter<'a> = &'a mut Peekable<token_stream::IntoIter>;
 type Visibility = Option<Span>;
 
 enum Input {
@@ -171,8 +171,8 @@ struct Macro {
 
 #[proc_macro_attribute]
 pub fn proc_macro_hack(args: TokenStream, input: TokenStream) -> TokenStream {
-    let ref mut args = args.into_iter().peekable();
-    let ref mut input = input.into_iter().peekable();
+    let ref mut args = iter::new(args);
+    let ref mut input = iter::new(input);
     expand_proc_macro_hack(args, input).unwrap_or_else(compile_error)
 }
 
@@ -192,7 +192,7 @@ fn expand_proc_macro_hack(args: Iter, input: Iter) -> Result<TokenStream, Error>
 #[doc(hidden)]
 #[proc_macro_derive(ProcMacroHack)]
 pub fn enum_hack(input: TokenStream) -> TokenStream {
-    let ref mut input = input.into_iter().peekable();
+    let ref mut input = iter::new(input);
     parse_enum_hack(input).unwrap_or_else(compile_error)
 }
 
@@ -204,8 +204,8 @@ struct FakeCallSite {
 #[doc(hidden)]
 #[proc_macro_attribute]
 pub fn fake_call_site(args: TokenStream, input: TokenStream) -> TokenStream {
-    let ref mut args = args.into_iter().peekable();
-    let ref mut input = input.into_iter().peekable();
+    let ref mut args = iter::new(args);
+    let ref mut input = iter::new(input);
     expand_fake_call_site(args, input).unwrap_or_else(compile_error)
 }
 

src/parse.rs

@@ -1,7 +1,7 @@
-use crate::{Define, Error, Export, ExportArgs, FakeCallSite, Input, Iter, Macro, Visibility};
+use crate::iter::{self, Iter, IterImpl};
+use crate::{Define, Error, Export, ExportArgs, FakeCallSite, Input, Macro, Visibility};
 use proc_macro::Delimiter::{Brace, Bracket, Parenthesis};
-use proc_macro::{token_stream, Delimiter, Ident, Span, TokenStream, TokenTree};
-use std::iter::Peekable;
+use proc_macro::{Delimiter, Ident, Span, TokenStream, TokenTree};
 
 pub(crate) fn parse_input(tokens: Iter) -> Result<Input, Error> {
     let attrs = parse_attributes(tokens)?;
@@ -29,7 +29,7 @@ fn parse_export(attrs: TokenStream, vis: Visibility, tokens: Iter) -> Result<Exp
     let mut macros = Vec::new();
     match tokens.peek() {
         Some(TokenTree::Group(group)) if group.delimiter() == Brace => {
-            let ref mut content = group.stream().into_iter().peekable();
+            let ref mut content = iter::new(group.stream());
             loop {
                 macros.push(parse_macro(content)?);
                 if content.peek().is_none() {
@@ -124,13 +124,10 @@ fn parse_int(tokens: Iter) -> Result<u16, Span> {
     }
 }
 
-fn parse_group(
-    tokens: Iter,
-    delimiter: Delimiter,
-) -> Result<Peekable<token_stream::IntoIter>, Error> {
+fn parse_group(tokens: Iter, delimiter: Delimiter) -> Result<IterImpl, Error> {
     match &tokens.next() {
         Some(TokenTree::Group(group)) if group.delimiter() == delimiter => {
-            Ok(group.stream().into_iter().peekable())
+            Ok(iter::new(group.stream()))
         }
         tt => Err(Error::new(
             tt.as_ref().map_or_else(Span::call_site, TokenTree::span),