Skip to content

Commit bddbf38

Browse files
WaffleLapkinWaffleLapkin
committed
rustc_expand: remove ref patterns
1 parent fc6cda8 commit bddbf38

File tree

8 files changed

+75
-82
lines changed

8 files changed

+75
-82
lines changed

‎compiler/rustc_expand/src/base.rs

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -63,21 +63,21 @@ pub enum Annotatable {
6363

6464
impl Annotatable {
6565
pub fn span(&self) -> Span {
66-
match *self {
67-
Annotatable::Item(ref item) => item.span,
68-
Annotatable::TraitItem(ref trait_item) => trait_item.span,
69-
Annotatable::ImplItem(ref impl_item) => impl_item.span,
70-
Annotatable::ForeignItem(ref foreign_item) => foreign_item.span,
71-
Annotatable::Stmt(ref stmt) => stmt.span,
72-
Annotatable::Expr(ref expr) => expr.span,
73-
Annotatable::Arm(ref arm) => arm.span,
74-
Annotatable::ExprField(ref field) => field.span,
75-
Annotatable::PatField(ref fp) => fp.pat.span,
76-
Annotatable::GenericParam(ref gp) => gp.ident.span,
77-
Annotatable::Param(ref p) => p.span,
78-
Annotatable::FieldDef(ref sf) => sf.span,
79-
Annotatable::Variant(ref v) => v.span,
80-
Annotatable::Crate(ref c) => c.spans.inner_span,
66+
match self {
67+
Annotatable::Item(item) => item.span,
68+
Annotatable::TraitItem(trait_item) => trait_item.span,
69+
Annotatable::ImplItem(impl_item) => impl_item.span,
70+
Annotatable::ForeignItem(foreign_item) => foreign_item.span,
71+
Annotatable::Stmt(stmt) => stmt.span,
72+
Annotatable::Expr(expr) => expr.span,
73+
Annotatable::Arm(arm) => arm.span,
74+
Annotatable::ExprField(field) => field.span,
75+
Annotatable::PatField(fp) => fp.pat.span,
76+
Annotatable::GenericParam(gp) => gp.ident.span,
77+
Annotatable::Param(p) => p.span,
78+
Annotatable::FieldDef(sf) => sf.span,
79+
Annotatable::Variant(v) => v.span,
80+
Annotatable::Crate(c) => c.spans.inner_span,
8181
}
8282
}
8383

‎compiler/rustc_expand/src/config.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -298,7 +298,7 @@ impl<'a> StripUnconfigured<'a> {
298298
Some(AttrTokenTree::Delimited(sp, delim, inner))
299299
.into_iter()
300300
}
301-
AttrTokenTree::Token(ref token, _) if let TokenKind::Interpolated(ref nt) = token.kind => {
301+
AttrTokenTree::Token(ref token, _) if let TokenKind::Interpolated(nt) = &token.kind => {
302302
panic!(
303303
"Nonterminal should have been flattened at {:?}: {:?}",
304304
token.span, nt

‎compiler/rustc_expand/src/expand.rs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -144,12 +144,12 @@ macro_rules! ast_fragments {
144144
}
145145

146146
pub fn visit_with<'a, V: Visitor<'a>>(&'a self, visitor: &mut V) {
147-
match *self {
148-
AstFragment::OptExpr(Some(ref expr)) => visitor.visit_expr(expr),
147+
match self {
148+
AstFragment::OptExpr(Some(expr)) => visitor.visit_expr(expr),
149149
AstFragment::OptExpr(None) => {}
150-
AstFragment::MethodReceiverExpr(ref expr) => visitor.visit_method_receiver_expr(expr),
151-
$($(AstFragment::$Kind(ref ast) => visitor.$visit_ast(ast),)?)*
152-
$($(AstFragment::$Kind(ref ast) => for ast_elt in &ast[..] {
150+
AstFragment::MethodReceiverExpr(expr) => visitor.visit_method_receiver_expr(expr),
151+
$($(AstFragment::$Kind(ast) => visitor.$visit_ast(ast),)?)*
152+
$($(AstFragment::$Kind(ast) => for ast_elt in &ast[..] {
153153
visitor.$visit_ast_elt(ast_elt, $($args)*);
154154
})?)*
155155
}
@@ -592,7 +592,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
592592
let expn_id = invoc.expansion_data.id;
593593
let parent_def = self.cx.resolver.invocation_parent(expn_id);
594594
let span = match &mut invoc.kind {
595-
InvocationKind::Bang { ref mut span, .. } => span,
595+
InvocationKind::Bang { span, .. } => span,
596596
InvocationKind::Attr { attr, .. } => &mut attr.span,
597597
InvocationKind::Derive { path, .. } => &mut path.span,
598598
};
@@ -945,8 +945,8 @@ pub fn ensure_complete_parse<'a>(
945945
let def_site_span = parser.token.span.with_ctxt(SyntaxContext::root());
946946

947947
let semi_span = parser.sess.source_map().next_point(span);
948-
let add_semicolon = match parser.sess.source_map().span_to_snippet(semi_span) {
949-
Ok(ref snippet) if &snippet[..] != ";" && kind_name == "expression" => {
948+
let add_semicolon = match &parser.sess.source_map().span_to_snippet(semi_span) {
949+
Ok(snippet) if &snippet[..] != ";" && kind_name == "expression" => {
950950
Some(span.shrink_to_hi())
951951
}
952952
_ => None,

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

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -151,9 +151,9 @@ impl<'a, T> Iterator for &'a Stack<'a, T> {
151151

152152
// Iterates from top to bottom of the stack.
153153
fn next(&mut self) -> Option<&'a T> {
154-
match *self {
154+
match self {
155155
Stack::Empty => None,
156-
Stack::Push { ref top, ref prev } => {
156+
Stack::Push { top, prev } => {
157157
*self = prev;
158158
Some(top)
159159
}
@@ -437,8 +437,8 @@ fn check_nested_occurrences(
437437
// We check that the meta-variable is correctly used.
438438
check_occurrences(sess, node_id, tt, macros, binders, ops, valid);
439439
}
440-
(NestedMacroState::MacroRulesNotName, &TokenTree::Delimited(_, ref del))
441-
| (NestedMacroState::MacroName, &TokenTree::Delimited(_, ref del))
440+
(NestedMacroState::MacroRulesNotName, TokenTree::Delimited(_, del))
441+
| (NestedMacroState::MacroName, TokenTree::Delimited(_, del))
442442
if del.delim == Delimiter::Brace =>
443443
{
444444
let macro_rules = state == NestedMacroState::MacroRulesNotName;
@@ -497,7 +497,7 @@ fn check_nested_occurrences(
497497
valid,
498498
);
499499
}
500-
(_, ref tt) => {
500+
(_, tt) => {
501501
state = NestedMacroState::Empty;
502502
check_occurrences(sess, node_id, tt, macros, binders, ops, valid);
503503
}

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

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -486,11 +486,11 @@ pub fn compile_declarative_macro(
486486
let mut valid = true;
487487

488488
// Extract the arguments:
489-
let lhses = match argument_map[&MacroRulesNormalizedIdent::new(lhs_nm)] {
490-
MatchedSeq(ref s) => s
489+
let lhses = match &argument_map[&MacroRulesNormalizedIdent::new(lhs_nm)] {
490+
MatchedSeq(s) => s
491491
.iter()
492492
.map(|m| {
493-
if let MatchedTokenTree(ref tt) = *m {
493+
if let MatchedTokenTree(tt) = m {
494494
let tt = mbe::quoted::parse(
495495
TokenStream::new(vec![tt.clone()]),
496496
true,
@@ -510,11 +510,11 @@ pub fn compile_declarative_macro(
510510
_ => sess.parse_sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs"),
511511
};
512512

513-
let rhses = match argument_map[&MacroRulesNormalizedIdent::new(rhs_nm)] {
514-
MatchedSeq(ref s) => s
513+
let rhses = match &argument_map[&MacroRulesNormalizedIdent::new(rhs_nm)] {
514+
MatchedSeq(s) => s
515515
.iter()
516516
.map(|m| {
517-
if let MatchedTokenTree(ref tt) = *m {
517+
if let MatchedTokenTree(tt) = m {
518518
return mbe::quoted::parse(
519519
TokenStream::new(vec![tt.clone()]),
520520
false,
@@ -624,21 +624,21 @@ fn check_lhs_nt_follows(sess: &ParseSess, def: &ast::Item, lhs: &mbe::TokenTree)
624624
fn check_lhs_no_empty_seq(sess: &ParseSess, tts: &[mbe::TokenTree]) -> bool {
625625
use mbe::TokenTree;
626626
for tt in tts {
627-
match *tt {
627+
match tt {
628628
TokenTree::Token(..)
629629
| TokenTree::MetaVar(..)
630630
| TokenTree::MetaVarDecl(..)
631631
| TokenTree::MetaVarExpr(..) => (),
632-
TokenTree::Delimited(_, ref del) => {
632+
TokenTree::Delimited(_, del) => {
633633
if !check_lhs_no_empty_seq(sess, &del.tts) {
634634
return false;
635635
}
636636
}
637-
TokenTree::Sequence(span, ref seq) => {
637+
TokenTree::Sequence(span, seq) => {
638638
if seq.separator.is_none()
639-
&& seq.tts.iter().all(|seq_tt| match *seq_tt {
639+
&& seq.tts.iter().all(|seq_tt| match seq_tt {
640640
TokenTree::MetaVarDecl(_, _, Some(NonterminalKind::Vis)) => true,
641-
TokenTree::Sequence(_, ref sub_seq) => {
641+
TokenTree::Sequence(_, sub_seq) => {
642642
sub_seq.kleene.op == mbe::KleeneOp::ZeroOrMore
643643
|| sub_seq.kleene.op == mbe::KleeneOp::ZeroOrOne
644644
}
@@ -736,21 +736,21 @@ impl<'tt> FirstSets<'tt> {
736736
fn build_recur<'tt>(sets: &mut FirstSets<'tt>, tts: &'tt [TokenTree]) -> TokenSet<'tt> {
737737
let mut first = TokenSet::empty();
738738
for tt in tts.iter().rev() {
739-
match *tt {
739+
match tt {
740740
TokenTree::Token(..)
741741
| TokenTree::MetaVar(..)
742742
| TokenTree::MetaVarDecl(..)
743743
| TokenTree::MetaVarExpr(..) => {
744744
first.replace_with(TtHandle::TtRef(tt));
745745
}
746-
TokenTree::Delimited(span, ref delimited) => {
746+
TokenTree::Delimited(span, delimited) => {
747747
build_recur(sets, &delimited.tts);
748748
first.replace_with(TtHandle::from_token_kind(
749749
token::OpenDelim(delimited.delim),
750750
span.open,
751751
));
752752
}
753-
TokenTree::Sequence(sp, ref seq_rep) => {
753+
TokenTree::Sequence(sp, seq_rep) => {
754754
let subfirst = build_recur(sets, &seq_rep.tts);
755755

756756
match sets.first.entry(sp.entire()) {
@@ -804,22 +804,22 @@ impl<'tt> FirstSets<'tt> {
804804
let mut first = TokenSet::empty();
805805
for tt in tts.iter() {
806806
assert!(first.maybe_empty);
807-
match *tt {
807+
match tt {
808808
TokenTree::Token(..)
809809
| TokenTree::MetaVar(..)
810810
| TokenTree::MetaVarDecl(..)
811811
| TokenTree::MetaVarExpr(..) => {
812812
first.add_one(TtHandle::TtRef(tt));
813813
return first;
814814
}
815-
TokenTree::Delimited(span, ref delimited) => {
815+
TokenTree::Delimited(span, delimited) => {
816816
first.add_one(TtHandle::from_token_kind(
817817
token::OpenDelim(delimited.delim),
818818
span.open,
819819
));
820820
return first;
821821
}
822-
TokenTree::Sequence(sp, ref seq_rep) => {
822+
TokenTree::Sequence(sp, seq_rep) => {
823823
let subfirst_owned;
824824
let subfirst = match self.first.get(&sp.entire()) {
825825
Some(Some(subfirst)) => subfirst,
@@ -1041,7 +1041,7 @@ fn check_matcher_core<'tt>(
10411041

10421042
// First, update `last` so that it corresponds to the set
10431043
// of NT tokens that might end the sequence `... token`.
1044-
match *token {
1044+
match token {
10451045
TokenTree::Token(..)
10461046
| TokenTree::MetaVar(..)
10471047
| TokenTree::MetaVarDecl(..)
@@ -1057,7 +1057,7 @@ fn check_matcher_core<'tt>(
10571057
suffix_first = build_suffix_first();
10581058
}
10591059
}
1060-
TokenTree::Delimited(span, ref d) => {
1060+
TokenTree::Delimited(span, d) => {
10611061
let my_suffix = TokenSet::singleton(TtHandle::from_token_kind(
10621062
token::CloseDelim(d.delim),
10631063
span.close,
@@ -1070,7 +1070,7 @@ fn check_matcher_core<'tt>(
10701070
// against SUFFIX
10711071
continue 'each_token;
10721072
}
1073-
TokenTree::Sequence(_, ref seq_rep) => {
1073+
TokenTree::Sequence(_, seq_rep) => {
10741074
suffix_first = build_suffix_first();
10751075
// The trick here: when we check the interior, we want
10761076
// to include the separator (if any) as a potential
@@ -1372,8 +1372,8 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
13721372
}
13731373

13741374
fn quoted_tt_to_string(tt: &mbe::TokenTree) -> String {
1375-
match *tt {
1376-
mbe::TokenTree::Token(ref token) => pprust::token_to_string(&token).into(),
1375+
match tt {
1376+
mbe::TokenTree::Token(token) => pprust::token_to_string(&token).into(),
13771377
mbe::TokenTree::MetaVar(_, name) => format!("${}", name),
13781378
mbe::TokenTree::MetaVarDecl(_, name, Some(kind)) => format!("${}:{}", name, kind),
13791379
mbe::TokenTree::MetaVarDecl(_, name, None) => format!("${}:", name),

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

Lines changed: 15 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -47,8 +47,7 @@ impl<'a> Iterator for Frame<'a> {
4747

4848
fn next(&mut self) -> Option<&'a mbe::TokenTree> {
4949
match self {
50-
Frame::Delimited { tts, ref mut idx, .. }
51-
| Frame::Sequence { tts, ref mut idx, .. } => {
50+
Frame::Delimited { tts, idx, .. } | Frame::Sequence { tts, idx, .. } => {
5251
let res = tts.get(*idx);
5352
*idx += 1;
5453
res
@@ -220,13 +219,13 @@ pub(super) fn transcribe<'a>(
220219
let ident = MacroRulesNormalizedIdent::new(original_ident);
221220
if let Some(cur_matched) = lookup_cur_matched(ident, interp, &repeats) {
222221
match cur_matched {
223-
MatchedTokenTree(ref tt) => {
222+
MatchedTokenTree(tt) => {
224223
// `tt`s are emitted into the output stream directly as "raw tokens",
225224
// without wrapping them into groups.
226225
let token = tt.clone();
227226
result.push(token);
228227
}
229-
MatchedNonterminal(ref nt) => {
228+
MatchedNonterminal(nt) => {
230229
// Other variables are emitted into the output stream as groups with
231230
// `Delimiter::Invisible` to maintain parsing priorities.
232231
// `Interpolated` is currently used for such groups in rustc parser.
@@ -299,12 +298,11 @@ fn lookup_cur_matched<'a>(
299298
interpolations: &'a FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
300299
repeats: &[(usize, usize)],
301300
) -> Option<&'a NamedMatch> {
302-
interpolations.get(&ident).map(|matched| {
303-
let mut matched = matched;
301+
interpolations.get(&ident).map(|mut matched| {
304302
for &(idx, _) in repeats {
305303
match matched {
306304
MatchedTokenTree(_) | MatchedNonterminal(_) => break,
307-
MatchedSeq(ref ads) => matched = ads.get(idx).unwrap(),
305+
MatchedSeq(ads) => matched = ads.get(idx).unwrap(),
308306
}
309307
}
310308

@@ -339,7 +337,7 @@ impl LockstepIterSize {
339337
match self {
340338
LockstepIterSize::Unconstrained => other,
341339
LockstepIterSize::Contradiction(_) => self,
342-
LockstepIterSize::Constraint(l_len, ref l_id) => match other {
340+
LockstepIterSize::Constraint(l_len, l_id) => match other {
343341
LockstepIterSize::Unconstrained => self,
344342
LockstepIterSize::Contradiction(_) => other,
345343
LockstepIterSize::Constraint(r_len, _) if l_len == r_len => self,
@@ -378,33 +376,33 @@ fn lockstep_iter_size(
378376
repeats: &[(usize, usize)],
379377
) -> LockstepIterSize {
380378
use mbe::TokenTree;
381-
match *tree {
382-
TokenTree::Delimited(_, ref delimited) => {
379+
match tree {
380+
TokenTree::Delimited(_, delimited) => {
383381
delimited.tts.iter().fold(LockstepIterSize::Unconstrained, |size, tt| {
384382
size.with(lockstep_iter_size(tt, interpolations, repeats))
385383
})
386384
}
387-
TokenTree::Sequence(_, ref seq) => {
385+
TokenTree::Sequence(_, seq) => {
388386
seq.tts.iter().fold(LockstepIterSize::Unconstrained, |size, tt| {
389387
size.with(lockstep_iter_size(tt, interpolations, repeats))
390388
})
391389
}
392390
TokenTree::MetaVar(_, name) | TokenTree::MetaVarDecl(_, name, _) => {
393-
let name = MacroRulesNormalizedIdent::new(name);
391+
let name = MacroRulesNormalizedIdent::new(*name);
394392
match lookup_cur_matched(name, interpolations, repeats) {
395393
Some(matched) => match matched {
396394
MatchedTokenTree(_) | MatchedNonterminal(_) => LockstepIterSize::Unconstrained,
397-
MatchedSeq(ref ads) => LockstepIterSize::Constraint(ads.len(), name),
395+
MatchedSeq(ads) => LockstepIterSize::Constraint(ads.len(), name),
398396
},
399397
_ => LockstepIterSize::Unconstrained,
400398
}
401399
}
402-
TokenTree::MetaVarExpr(_, ref expr) => {
400+
TokenTree::MetaVarExpr(_, expr) => {
403401
let default_rslt = LockstepIterSize::Unconstrained;
404402
let Some(ident) = expr.ident() else { return default_rslt; };
405403
let name = MacroRulesNormalizedIdent::new(ident);
406404
match lookup_cur_matched(name, interpolations, repeats) {
407-
Some(MatchedSeq(ref ads)) => {
405+
Some(MatchedSeq(ads)) => {
408406
default_rslt.with(LockstepIterSize::Constraint(ads.len(), name))
409407
}
410408
_ => default_rslt,
@@ -449,7 +447,7 @@ fn count_repetitions<'a>(
449447
Some(_) => Err(out_of_bounds_err(cx, declared_lhs_depth, sp.entire(), "count")),
450448
}
451449
}
452-
MatchedSeq(ref named_matches) => {
450+
MatchedSeq(named_matches) => {
453451
let new_declared_lhs_depth = declared_lhs_depth + 1;
454452
match depth_opt {
455453
None => named_matches
@@ -472,7 +470,7 @@ fn count_repetitions<'a>(
472470
// before we start counting. `matched` contains the various levels of the
473471
// tree as we descend, and its final value is the subtree we are currently at.
474472
for &(idx, _) in repeats {
475-
if let MatchedSeq(ref ads) = matched {
473+
if let MatchedSeq(ads) = matched {
476474
matched = &ads[idx];
477475
}
478476
}

0 commit comments

Comments
 (0)