Skip to content

Commit 809975c

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 3575e79 commit 809975c

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
@@ -366,22 +366,22 @@ impl MetaItem {
366366
}
367367
}
368368

369-
fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem>
369+
fn from_tokens<'a, I>(iter: &mut iter::Peekable<I>) -> Option<MetaItem>
370370
where
371371
I: Iterator<Item = &'a TokenTree>,
372372
{
373373
// FIXME: Share code with `parse_path`.
374-
let tt = tokens.next().map(|tt| TokenTree::uninterpolate(tt));
374+
let tt = iter.next().map(|tt| TokenTree::uninterpolate(tt));
375375
let path = match tt.as_deref() {
376376
Some(&TokenTree::Token(
377377
Token { kind: ref kind @ (token::Ident(..) | token::PathSep), span },
378378
_,
379379
)) => 'arm: {
380380
let mut segments = if let &token::Ident(name, _) = kind {
381381
if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
382-
tokens.peek()
382+
iter.peek()
383383
{
384-
tokens.next();
384+
iter.next();
385385
thin_vec![PathSegment::from_ident(Ident::new(name, span))]
386386
} else {
387387
break 'arm Path::from_ident(Ident::new(name, span));
@@ -391,16 +391,16 @@ impl MetaItem {
391391
};
392392
loop {
393393
if let Some(&TokenTree::Token(Token { kind: token::Ident(name, _), span }, _)) =
394-
tokens.next().map(|tt| TokenTree::uninterpolate(tt)).as_deref()
394+
iter.next().map(|tt| TokenTree::uninterpolate(tt)).as_deref()
395395
{
396396
segments.push(PathSegment::from_ident(Ident::new(name, span)));
397397
} else {
398398
return None;
399399
}
400400
if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
401-
tokens.peek()
401+
iter.peek()
402402
{
403-
tokens.next();
403+
iter.next();
404404
} else {
405405
break;
406406
}
@@ -421,8 +421,8 @@ impl MetaItem {
421421
}
422422
_ => return None,
423423
};
424-
let list_closing_paren_pos = tokens.peek().map(|tt| tt.span().hi());
425-
let kind = MetaItemKind::from_tokens(tokens)?;
424+
let list_closing_paren_pos = iter.peek().map(|tt| tt.span().hi());
425+
let kind = MetaItemKind::from_tokens(iter)?;
426426
let hi = match &kind {
427427
MetaItemKind::NameValue(lit) => lit.span.hi(),
428428
MetaItemKind::List(..) => list_closing_paren_pos.unwrap_or(path.span.hi()),
@@ -439,12 +439,12 @@ impl MetaItem {
439439
impl MetaItemKind {
440440
// public because it can be called in the hir
441441
pub fn list_from_tokens(tokens: TokenStream) -> Option<ThinVec<MetaItemInner>> {
442-
let mut tokens = tokens.trees().peekable();
442+
let mut iter = tokens.iter().peekable();
443443
let mut result = ThinVec::new();
444-
while tokens.peek().is_some() {
445-
let item = MetaItemInner::from_tokens(&mut tokens)?;
444+
while iter.peek().is_some() {
445+
let item = MetaItemInner::from_tokens(&mut iter)?;
446446
result.push(item);
447-
match tokens.next() {
447+
match iter.next() {
448448
None | Some(TokenTree::Token(Token { kind: token::Comma, .. }, _)) => {}
449449
_ => return None,
450450
}
@@ -453,11 +453,11 @@ impl MetaItemKind {
453453
}
454454

455455
fn name_value_from_tokens<'a>(
456-
tokens: &mut impl Iterator<Item = &'a TokenTree>,
456+
iter: &mut impl Iterator<Item = &'a TokenTree>,
457457
) -> Option<MetaItemKind> {
458-
match tokens.next() {
458+
match iter.next() {
459459
Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
460-
MetaItemKind::name_value_from_tokens(&mut inner_tokens.trees())
460+
MetaItemKind::name_value_from_tokens(&mut inner_tokens.iter())
461461
}
462462
Some(TokenTree::Token(token, _)) => {
463463
MetaItemLit::from_token(token).map(MetaItemKind::NameValue)
@@ -467,18 +467,18 @@ impl MetaItemKind {
467467
}
468468

469469
fn from_tokens<'a>(
470-
tokens: &mut iter::Peekable<impl Iterator<Item = &'a TokenTree>>,
470+
iter: &mut iter::Peekable<impl Iterator<Item = &'a TokenTree>>,
471471
) -> Option<MetaItemKind> {
472-
match tokens.peek() {
472+
match iter.peek() {
473473
Some(TokenTree::Delimited(.., Delimiter::Parenthesis, inner_tokens)) => {
474474
let inner_tokens = inner_tokens.clone();
475-
tokens.next();
475+
iter.next();
476476
MetaItemKind::list_from_tokens(inner_tokens).map(MetaItemKind::List)
477477
}
478478
Some(TokenTree::Delimited(..)) => None,
479479
Some(TokenTree::Token(Token { kind: token::Eq, .. }, _)) => {
480-
tokens.next();
481-
MetaItemKind::name_value_from_tokens(tokens)
480+
iter.next();
481+
MetaItemKind::name_value_from_tokens(iter)
482482
}
483483
_ => Some(MetaItemKind::Word),
484484
}
@@ -594,22 +594,22 @@ impl MetaItemInner {
594594
self.meta_item().is_some()
595595
}
596596

597-
fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItemInner>
597+
fn from_tokens<'a, I>(iter: &mut iter::Peekable<I>) -> Option<MetaItemInner>
598598
where
599599
I: Iterator<Item = &'a TokenTree>,
600600
{
601-
match tokens.peek() {
601+
match iter.peek() {
602602
Some(TokenTree::Token(token, _)) if let Some(lit) = MetaItemLit::from_token(token) => {
603-
tokens.next();
603+
iter.next();
604604
return Some(MetaItemInner::Lit(lit));
605605
}
606606
Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
607-
tokens.next();
608-
return MetaItemInner::from_tokens(&mut inner_tokens.trees().peekable());
607+
iter.next();
608+
return MetaItemInner::from_tokens(&mut inner_tokens.iter().peekable());
609609
}
610610
_ => {}
611611
}
612-
MetaItem::from_tokens(tokens).map(MetaItemInner::MetaItem)
612+
MetaItem::from_tokens(iter).map(MetaItemInner::MetaItem)
613613
}
614614
}
615615

‎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
@@ -725,7 +725,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
725725
// E.g. we have seen cases where a proc macro can handle `a :: b` but not
726726
// `a::b`. See #117433 for some examples.
727727
fn print_tts(&mut self, tts: &TokenStream, convert_dollar_crate: bool) {
728-
let mut iter = tts.trees().peekable();
728+
let mut iter = tts.iter().peekable();
729729
while let Some(tt) = iter.next() {
730730
let spacing = self.print_tt(tt, convert_dollar_crate);
731731
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)