Rename TokenTree collections to "tokens"

Author: dtolnay

src/lib.rs

@@ -292,8 +292,8 @@ impl From<TokenTree> for TokenStream {
 }
 
 impl Extend<TokenTree> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) {
-        self.inner.extend(streams);
+    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, tokens: I) {
+        self.inner.extend(tokens);
     }
 }
 
@@ -306,10 +306,11 @@ impl Extend<TokenStream> for TokenStream {
 
 /// Collects a number of token trees into a single stream.
 impl FromIterator<TokenTree> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenTree>>(streams: I) -> Self {
-        TokenStream::_new(streams.into_iter().collect())
+    fn from_iter<I: IntoIterator<Item = TokenTree>>(tokens: I) -> Self {
+        TokenStream::_new(tokens.into_iter().collect())
     }
 }
+
 impl FromIterator<TokenStream> for TokenStream {
     fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
         TokenStream::_new(streams.into_iter().map(|i| i.inner).collect())

src/parse.rs

@@ -166,13 +166,13 @@ fn word_break(input: Cursor) -> Result<Cursor, Reject> {
 const ERROR: &str = "(/*ERROR*/)";
 
 pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
-    let mut trees = TokenStreamBuilder::new();
+    let mut tokens = TokenStreamBuilder::new();
     let mut stack = Vec::new();
 
     loop {
         input = skip_whitespace(input);
 
-        if let Ok((rest, ())) = doc_comment(input, &mut trees) {
+        if let Ok((rest, ())) = doc_comment(input, &mut tokens) {
             input = rest;
             continue;
         }
@@ -182,7 +182,7 @@ pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
 
         let Some(first) = input.bytes().next() else {
             return match stack.last() {
-                None => Ok(trees.build()),
+                None => Ok(tokens.build()),
                 #[cfg(span_locations)]
                 Some((lo, _frame)) => Err(LexError {
                     span: Span { lo: *lo, hi: *lo },
@@ -199,11 +199,11 @@ pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
             _ => None,
         } {
             input = input.advance(1);
-            let frame = (open_delimiter, trees);
+            let frame = (open_delimiter, tokens);
             #[cfg(span_locations)]
             let frame = (lo, frame);
             stack.push(frame);
-            trees = TokenStreamBuilder::new();
+            tokens = TokenStreamBuilder::new();
         } else if let Some(close_delimiter) = match first {
             b')' => Some(Delimiter::Parenthesis),
             b']' => Some(Delimiter::Bracket),
@@ -220,15 +220,15 @@ pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
                 return Err(lex_error(input));
             }
             input = input.advance(1);
-            let mut g = Group::new(open_delimiter, trees.build());
+            let mut g = Group::new(open_delimiter, tokens.build());
             g.set_span(Span {
                 #[cfg(span_locations)]
                 lo,
                 #[cfg(span_locations)]
                 hi: input.off,
             });
-            trees = outer;
-            trees.push_token_from_parser(TokenTree::Group(crate::Group::_new_fallback(g)));
+            tokens = outer;
+            tokens.push_token_from_parser(TokenTree::Group(crate::Group::_new_fallback(g)));
         } else {
             let (rest, mut tt) = match leaf_token(input) {
                 Ok((rest, tt)) => (rest, tt),
@@ -240,7 +240,7 @@ pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
                 #[cfg(span_locations)]
                 hi: rest.off,
             }));
-            trees.push_token_from_parser(tt);
+            tokens.push_token_from_parser(tt);
             input = rest;
         }
     }
@@ -902,7 +902,7 @@ fn punct_char(input: Cursor) -> PResult<char> {
     }
 }
 
-fn doc_comment<'a>(input: Cursor<'a>, trees: &mut TokenStreamBuilder) -> PResult<'a, ()> {
+fn doc_comment<'a>(input: Cursor<'a>, tokens: &mut TokenStreamBuilder) -> PResult<'a, ()> {
     #[cfg(span_locations)]
     let lo = input.off;
     let (rest, (comment, inner)) = doc_comment_contents(input)?;
@@ -925,12 +925,12 @@ fn doc_comment<'a>(input: Cursor<'a>, trees: &mut TokenStreamBuilder) -> PResult
 
     let mut pound = Punct::new('#', Spacing::Alone);
     pound.set_span(span);
-    trees.push_token_from_parser(TokenTree::Punct(pound));
+    tokens.push_token_from_parser(TokenTree::Punct(pound));
 
     if inner {
         let mut bang = Punct::new('!', Spacing::Alone);
         bang.set_span(span);
-        trees.push_token_from_parser(TokenTree::Punct(bang));
+        tokens.push_token_from_parser(TokenTree::Punct(bang));
     }
 
     let doc_ident = crate::Ident::_new_fallback(Ident::new_unchecked("doc", fallback_span));
@@ -945,7 +945,7 @@ fn doc_comment<'a>(input: Cursor<'a>, trees: &mut TokenStreamBuilder) -> PResult
     let group = Group::new(Delimiter::Bracket, bracketed.build());
     let mut group = crate::Group::_new_fallback(group);
     group.set_span(span);
-    trees.push_token_from_parser(TokenTree::Group(group));
+    tokens.push_token_from_parser(TokenTree::Group(group));
 
     Ok((rest, ()))
 }

src/wrapper.rs

@@ -188,13 +188,13 @@ impl From<TokenTree> for TokenStream {
 }
 
 impl FromIterator<TokenTree> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenTree>>(trees: I) -> Self {
+    fn from_iter<I: IntoIterator<Item = TokenTree>>(tokens: I) -> Self {
         if inside_proc_macro() {
             TokenStream::Compiler(DeferredTokenStream::new(
-                trees.into_iter().map(into_compiler_token).collect(),
+                tokens.into_iter().map(into_compiler_token).collect(),
             ))
         } else {
-            TokenStream::Fallback(trees.into_iter().collect())
+            TokenStream::Fallback(tokens.into_iter().collect())
         }
     }
 }
@@ -224,15 +224,15 @@ impl FromIterator<TokenStream> for TokenStream {
 }
 
 impl Extend<TokenTree> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, stream: I) {
+    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, tokens: I) {
         match self {
             TokenStream::Compiler(tts) => {
                 // Here is the reason for DeferredTokenStream.
-                for token in stream {
+                for token in tokens {
                     tts.extra.push(into_compiler_token(token));
                 }
             }
-            TokenStream::Fallback(tts) => tts.extend(stream),
+            TokenStream::Fallback(tts) => tts.extend(tokens),
         }
     }
 }