Skip to content

Commit b25038f

Browse files
nnethercotennethercote
committed
Rename RefTokenTreeCursor.
Because `TokenStreamIter` is a much better name for a `TokenStream` iterator. Also rename the `TokenStream::trees` method as `TokenStream::iter`, and some local variables.
1 parent f6125e4 commit b25038f

File tree

17 files changed

+117
-119
lines changed

17 files changed

+117
-119
lines changed

‎compiler/rustc_ast/src/attr/mod.rs

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -368,22 +368,22 @@ impl MetaItem {
368368
}
369369
}
370370

371-
fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem>
371+
fn from_tokens<'a, I>(iter: &mut iter::Peekable<I>) -> Option<MetaItem>
372372
where
373373
I: Iterator<Item = &'a TokenTree>,
374374
{
375375
// FIXME: Share code with `parse_path`.
376-
let tt = tokens.next().map(|tt| TokenTree::uninterpolate(tt));
376+
let tt = iter.next().map(|tt| TokenTree::uninterpolate(tt));
377377
let path = match tt.as_deref() {
378378
Some(&TokenTree::Token(
379379
Token { kind: ref kind @ (token::Ident(..) | token::PathSep), span },
380380
_,
381381
)) => 'arm: {
382382
let mut segments = if let &token::Ident(name, _) = kind {
383383
if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
384-
tokens.peek()
384+
iter.peek()
385385
{
386-
tokens.next();
386+
iter.next();
387387
thin_vec![PathSegment::from_ident(Ident::new(name, span))]
388388
} else {
389389
break 'arm Path::from_ident(Ident::new(name, span));
@@ -393,16 +393,16 @@ impl MetaItem {
393393
};
394394
loop {
395395
if let Some(&TokenTree::Token(Token { kind: token::Ident(name, _), span }, _)) =
396-
tokens.next().map(|tt| TokenTree::uninterpolate(tt)).as_deref()
396+
iter.next().map(|tt| TokenTree::uninterpolate(tt)).as_deref()
397397
{
398398
segments.push(PathSegment::from_ident(Ident::new(name, span)));
399399
} else {
400400
return None;
401401
}
402402
if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
403-
tokens.peek()
403+
iter.peek()
404404
{
405-
tokens.next();
405+
iter.next();
406406
} else {
407407
break;
408408
}
@@ -423,8 +423,8 @@ impl MetaItem {
423423
}
424424
_ => return None,
425425
};
426-
let list_closing_paren_pos = tokens.peek().map(|tt| tt.span().hi());
427-
let kind = MetaItemKind::from_tokens(tokens)?;
426+
let list_closing_paren_pos = iter.peek().map(|tt| tt.span().hi());
427+
let kind = MetaItemKind::from_tokens(iter)?;
428428
let hi = match &kind {
429429
MetaItemKind::NameValue(lit) => lit.span.hi(),
430430
MetaItemKind::List(..) => list_closing_paren_pos.unwrap_or(path.span.hi()),
@@ -440,12 +440,12 @@ impl MetaItem {
440440

441441
impl MetaItemKind {
442442
fn list_from_tokens(tokens: TokenStream) -> Option<ThinVec<MetaItemInner>> {
443-
let mut tokens = tokens.trees().peekable();
443+
let mut iter = tokens.iter().peekable();
444444
let mut result = ThinVec::new();
445-
while tokens.peek().is_some() {
446-
let item = MetaItemInner::from_tokens(&mut tokens)?;
445+
while iter.peek().is_some() {
446+
let item = MetaItemInner::from_tokens(&mut iter)?;
447447
result.push(item);
448-
match tokens.next() {
448+
match iter.next() {
449449
None | Some(TokenTree::Token(Token { kind: token::Comma, .. }, _)) => {}
450450
_ => return None,
451451
}
@@ -454,11 +454,11 @@ impl MetaItemKind {
454454
}
455455

456456
fn name_value_from_tokens<'a>(
457-
tokens: &mut impl Iterator<Item = &'a TokenTree>,
457+
iter: &mut impl Iterator<Item = &'a TokenTree>,
458458
) -> Option<MetaItemKind> {
459-
match tokens.next() {
459+
match iter.next() {
460460
Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
461-
MetaItemKind::name_value_from_tokens(&mut inner_tokens.trees())
461+
MetaItemKind::name_value_from_tokens(&mut inner_tokens.iter())
462462
}
463463
Some(TokenTree::Token(token, _)) => {
464464
MetaItemLit::from_token(token).map(MetaItemKind::NameValue)
@@ -468,18 +468,18 @@ impl MetaItemKind {
468468
}
469469

470470
fn from_tokens<'a>(
471-
tokens: &mut iter::Peekable<impl Iterator<Item = &'a TokenTree>>,
471+
iter: &mut iter::Peekable<impl Iterator<Item = &'a TokenTree>>,
472472
) -> Option<MetaItemKind> {
473-
match tokens.peek() {
473+
match iter.peek() {
474474
Some(TokenTree::Delimited(.., Delimiter::Parenthesis, inner_tokens)) => {
475475
let inner_tokens = inner_tokens.clone();
476-
tokens.next();
476+
iter.next();
477477
MetaItemKind::list_from_tokens(inner_tokens).map(MetaItemKind::List)
478478
}
479479
Some(TokenTree::Delimited(..)) => None,
480480
Some(TokenTree::Token(Token { kind: token::Eq, .. }, _)) => {
481-
tokens.next();
482-
MetaItemKind::name_value_from_tokens(tokens)
481+
iter.next();
482+
MetaItemKind::name_value_from_tokens(iter)
483483
}
484484
_ => Some(MetaItemKind::Word),
485485
}
@@ -598,22 +598,22 @@ impl MetaItemInner {
598598
self.meta_item().is_some()
599599
}
600600

601-
fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItemInner>
601+
fn from_tokens<'a, I>(iter: &mut iter::Peekable<I>) -> Option<MetaItemInner>
602602
where
603603
I: Iterator<Item = &'a TokenTree>,
604604
{
605-
match tokens.peek() {
605+
match iter.peek() {
606606
Some(TokenTree::Token(token, _)) if let Some(lit) = MetaItemLit::from_token(token) => {
607-
tokens.next();
607+
iter.next();
608608
return Some(MetaItemInner::Lit(lit));
609609
}
610610
Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
611-
tokens.next();
612-
return MetaItemInner::from_tokens(&mut inner_tokens.trees().peekable());
611+
iter.next();
612+
return MetaItemInner::from_tokens(&mut inner_tokens.iter().peekable());
613613
}
614614
_ => {}
615615
}
616-
MetaItem::from_tokens(tokens).map(MetaItemInner::MetaItem)
616+
MetaItem::from_tokens(iter).map(MetaItemInner::MetaItem)
617617
}
618618
}
619619

‎compiler/rustc_ast/src/tokenstream.rs

Lines changed: 16 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,7 @@ where
9999
CTX: crate::HashStableContext,
100100
{
101101
fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
102-
for sub_tt in self.trees() {
102+
for sub_tt in self.iter() {
103103
sub_tt.hash_stable(hcx, hasher);
104104
}
105105
}
@@ -406,7 +406,7 @@ impl Eq for TokenStream {}
406406

407407
impl PartialEq<TokenStream> for TokenStream {
408408
fn eq(&self, other: &TokenStream) -> bool {
409-
self.trees().eq(other.trees())
409+
self.iter().eq(other.iter())
410410
}
411411
}
412412

@@ -423,8 +423,8 @@ impl TokenStream {
423423
self.0.len()
424424
}
425425

426-
pub fn trees(&self) -> RefTokenTreeCursor<'_> {
427-
RefTokenTreeCursor::new(self)
426+
pub fn iter(&self) -> TokenStreamIter<'_> {
427+
TokenStreamIter::new(self)
428428
}
429429

430430
pub fn into_trees(self) -> TokenTreeCursor {
@@ -433,14 +433,14 @@ impl TokenStream {
433433

434434
/// Compares two `TokenStream`s, checking equality without regarding span information.
435435
pub fn eq_unspanned(&self, other: &TokenStream) -> bool {
436-
let mut t1 = self.trees();
437-
let mut t2 = other.trees();
438-
for (t1, t2) in iter::zip(&mut t1, &mut t2) {
439-
if !t1.eq_unspanned(t2) {
436+
let mut iter1 = self.iter();
437+
let mut iter2 = other.iter();
438+
for (tt1, tt2) in iter::zip(&mut iter1, &mut iter2) {
439+
if !tt1.eq_unspanned(tt2) {
440440
return false;
441441
}
442442
}
443-
t1.next().is_none() && t2.next().is_none()
443+
iter1.next().is_none() && iter2.next().is_none()
444444
}
445445

446446
/// Create a token stream containing a single token with alone spacing. The
@@ -509,7 +509,7 @@ impl TokenStream {
509509
#[must_use]
510510
pub fn flattened(&self) -> TokenStream {
511511
fn can_skip(stream: &TokenStream) -> bool {
512-
stream.trees().all(|tree| match tree {
512+
stream.iter().all(|tree| match tree {
513513
TokenTree::Token(token, _) => !matches!(
514514
token.kind,
515515
token::NtIdent(..) | token::NtLifetime(..) | token::Interpolated(..)
@@ -522,7 +522,7 @@ impl TokenStream {
522522
return self.clone();
523523
}
524524

525-
self.trees().map(|tree| TokenStream::flatten_token_tree(tree)).collect()
525+
self.iter().map(|tree| TokenStream::flatten_token_tree(tree)).collect()
526526
}
527527

528528
// If `vec` is not empty, try to glue `tt` onto its last token. The return
@@ -665,25 +665,23 @@ impl TokenStream {
665665
}
666666
}
667667

668-
/// By-reference iterator over a [`TokenStream`], that produces `&TokenTree`
669-
/// items.
670668
#[derive(Clone)]
671-
pub struct RefTokenTreeCursor<'t> {
669+
pub struct TokenStreamIter<'t> {
672670
stream: &'t TokenStream,
673671
index: usize,
674672
}
675673

676-
impl<'t> RefTokenTreeCursor<'t> {
674+
impl<'t> TokenStreamIter<'t> {
677675
fn new(stream: &'t TokenStream) -> Self {
678-
RefTokenTreeCursor { stream, index: 0 }
676+
TokenStreamIter { stream, index: 0 }
679677
}
680678

681679
pub fn peek(&self) -> Option<&TokenTree> {
682680
self.stream.0.get(self.index)
683681
}
684682
}
685683

686-
impl<'t> Iterator for RefTokenTreeCursor<'t> {
684+
impl<'t> Iterator for TokenStreamIter<'t> {
687685
type Item = &'t TokenTree;
688686

689687
fn next(&mut self) -> Option<&'t TokenTree> {
@@ -701,7 +699,7 @@ impl<'t> Iterator for RefTokenTreeCursor<'t> {
701699
/// return `&T` from `next`; the need for an explicit lifetime in the `Item`
702700
/// associated type gets in the way. Instead, use `next_ref` (which doesn't
703701
/// involve associated types) for getting individual elements, or
704-
/// `RefTokenTreeCursor` if you really want an `Iterator`, e.g. in a `for`
702+
/// `TokenStreamIter` if you really want an `Iterator`, e.g. in a `for`
705703
/// loop.
706704
#[derive(Clone, Debug)]
707705
pub struct TokenTreeCursor {

‎compiler/rustc_ast_pretty/src/pprust/state.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -732,7 +732,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
732732
// E.g. we have seen cases where a proc macro can handle `a :: b` but not
733733
// `a::b`. See #117433 for some examples.
734734
fn print_tts(&mut self, tts: &TokenStream, convert_dollar_crate: bool) {
735-
let mut iter = tts.trees().peekable();
735+
let mut iter = tts.iter().peekable();
736736
while let Some(tt) = iter.next() {
737737
let spacing = self.print_tt(tt, convert_dollar_crate);
738738
if let Some(next) = iter.peek() {

‎compiler/rustc_builtin_macros/src/concat_idents.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ pub(crate) fn expand_concat_idents<'cx>(
1919
}
2020

2121
let mut res_str = String::new();
22-
for (i, e) in tts.trees().enumerate() {
22+
for (i, e) in tts.iter().enumerate() {
2323
if i & 1 == 1 {
2424
match e {
2525
TokenTree::Token(Token { kind: token::Comma, .. }, _) => {}

‎compiler/rustc_builtin_macros/src/trace_macros.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -10,17 +10,17 @@ pub(crate) fn expand_trace_macros(
1010
sp: Span,
1111
tt: TokenStream,
1212
) -> MacroExpanderResult<'static> {
13-
let mut cursor = tt.trees();
13+
let mut iter = tt.iter();
1414
let mut err = false;
15-
let value = match &cursor.next() {
15+
let value = match iter.next() {
1616
Some(TokenTree::Token(token, _)) if token.is_keyword(kw::True) => true,
1717
Some(TokenTree::Token(token, _)) if token.is_keyword(kw::False) => false,
1818
_ => {
1919
err = true;
2020
false
2121
}
2222
};
23-
err |= cursor.next().is_some();
23+
err |= iter.next().is_some();
2424
if err {
2525
cx.dcx().emit_err(errors::TraceMacros { span: sp });
2626
} else {

‎compiler/rustc_expand/src/mbe/metavar_expr.rs

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use rustc_ast::token::{self, Delimiter, IdentIsRaw, Lit, Token, TokenKind};
2-
use rustc_ast::tokenstream::{RefTokenTreeCursor, TokenStream, TokenTree};
2+
use rustc_ast::tokenstream::{TokenStream, TokenStreamIter, TokenTree};
33
use rustc_ast::{LitIntType, LitKind};
44
use rustc_ast_pretty::pprust;
55
use rustc_errors::{Applicability, PResult};
@@ -39,14 +39,14 @@ impl MetaVarExpr {
3939
outer_span: Span,
4040
psess: &'psess ParseSess,
4141
) -> PResult<'psess, MetaVarExpr> {
42-
let mut tts = input.trees();
43-
let ident = parse_ident(&mut tts, psess, outer_span)?;
44-
let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = tts.next() else {
42+
let mut iter = input.iter();
43+
let ident = parse_ident(&mut iter, psess, outer_span)?;
44+
let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = iter.next() else {
4545
let msg = "meta-variable expression parameter must be wrapped in parentheses";
4646
return Err(psess.dcx().struct_span_err(ident.span, msg));
4747
};
48-
check_trailing_token(&mut tts, psess)?;
49-
let mut iter = args.trees();
48+
check_trailing_token(&mut iter, psess)?;
49+
let mut iter = args.iter();
5050
let rslt = match ident.as_str() {
5151
"concat" => {
5252
let mut result = Vec::new();
@@ -143,7 +143,7 @@ pub(crate) enum MetaVarExprConcatElem {
143143

144144
// Checks if there are any remaining tokens. For example, `${ignore(ident ... a b c ...)}`
145145
fn check_trailing_token<'psess>(
146-
iter: &mut RefTokenTreeCursor<'_>,
146+
iter: &mut TokenStreamIter<'_>,
147147
psess: &'psess ParseSess,
148148
) -> PResult<'psess, ()> {
149149
if let Some(tt) = iter.next() {
@@ -159,7 +159,7 @@ fn check_trailing_token<'psess>(
159159

160160
/// Parse a meta-variable `count` expression: `count(ident[, depth])`
161161
fn parse_count<'psess>(
162-
iter: &mut RefTokenTreeCursor<'_>,
162+
iter: &mut TokenStreamIter<'_>,
163163
psess: &'psess ParseSess,
164164
span: Span,
165165
) -> PResult<'psess, MetaVarExpr> {
@@ -181,7 +181,7 @@ fn parse_count<'psess>(
181181

182182
/// Parses the depth used by index(depth) and len(depth).
183183
fn parse_depth<'psess>(
184-
iter: &mut RefTokenTreeCursor<'_>,
184+
iter: &mut TokenStreamIter<'_>,
185185
psess: &'psess ParseSess,
186186
span: Span,
187187
) -> PResult<'psess, usize> {
@@ -204,7 +204,7 @@ fn parse_depth<'psess>(
204204

205205
/// Parses an generic ident
206206
fn parse_ident<'psess>(
207-
iter: &mut RefTokenTreeCursor<'_>,
207+
iter: &mut TokenStreamIter<'_>,
208208
psess: &'psess ParseSess,
209209
fallback_span: Span,
210210
) -> PResult<'psess, Ident> {
@@ -236,7 +236,7 @@ fn parse_ident_from_token<'psess>(
236236
}
237237

238238
fn parse_token<'psess, 't>(
239-
iter: &mut RefTokenTreeCursor<'t>,
239+
iter: &mut TokenStreamIter<'t>,
240240
psess: &'psess ParseSess,
241241
fallback_span: Span,
242242
) -> PResult<'psess, &'t Token> {
@@ -251,7 +251,7 @@ fn parse_token<'psess, 't>(
251251

252252
/// Tries to move the iterator forward returning `true` if there is a comma. If not, then the
253253
/// iterator is not modified and the result is `false`.
254-
fn try_eat_comma(iter: &mut RefTokenTreeCursor<'_>) -> bool {
254+
fn try_eat_comma(iter: &mut TokenStreamIter<'_>) -> bool {
255255
if let Some(TokenTree::Token(Token { kind: token::Comma, .. }, _)) = iter.peek() {
256256
let _ = iter.next();
257257
return true;
@@ -261,7 +261,7 @@ fn try_eat_comma(iter: &mut RefTokenTreeCursor<'_>) -> bool {
261261

262262
/// Tries to move the iterator forward returning `true` if there is a dollar sign. If not, then the
263263
/// iterator is not modified and the result is `false`.
264-
fn try_eat_dollar(iter: &mut RefTokenTreeCursor<'_>) -> bool {
264+
fn try_eat_dollar(iter: &mut TokenStreamIter<'_>) -> bool {
265265
if let Some(TokenTree::Token(Token { kind: token::Dollar, .. }, _)) = iter.peek() {
266266
let _ = iter.next();
267267
return true;
@@ -271,7 +271,7 @@ fn try_eat_dollar(iter: &mut RefTokenTreeCursor<'_>) -> bool {
271271

272272
/// Expects that the next item is a dollar sign.
273273
fn eat_dollar<'psess>(
274-
iter: &mut RefTokenTreeCursor<'_>,
274+
iter: &mut TokenStreamIter<'_>,
275275
psess: &'psess ParseSess,
276276
span: Span,
277277
) -> PResult<'psess, ()> {

0 commit comments

Comments
 (0)