Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 38a6a50

Browse files
nnethercotennethercote
committed
Impl Copy for Token and TokenKind.
1 parent b0bc56a commit 38a6a50

File tree

19 files changed

+57
-58
lines changed

19 files changed

+57
-58
lines changed

‎compiler/rustc_ast/src/token.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -345,7 +345,7 @@ impl From<IdentIsRaw> for bool {
345345
}
346346
}
347347

348-
#[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
348+
#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
349349
pub enum TokenKind {
350350
/* Expression-operator symbols. */
351351
/// `=`
@@ -443,7 +443,7 @@ pub enum TokenKind {
443443
Eof,
444444
}
445445

446-
#[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
446+
#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
447447
pub struct Token {
448448
pub kind: TokenKind,
449449
pub span: Span,

‎compiler/rustc_ast/src/tokenstream.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -482,7 +482,7 @@ impl TokenStream {
482482
Delimiter::Invisible(InvisibleOrigin::FlattenToken),
483483
TokenStream::token_alone(token::Lifetime(ident.name, is_raw), ident.span),
484484
),
485-
_ => TokenTree::Token(token.clone(), spacing),
485+
_ => TokenTree::Token(*token, spacing),
486486
}
487487
}
488488

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -161,7 +161,7 @@ impl<'dcx, 'matcher> Tracker<'matcher> for CollectTrackerAndEmitter<'dcx, 'match
161161
.map_or(true, |failure| failure.is_better_position(*approx_position))
162162
{
163163
self.best_failure = Some(BestFailure {
164-
token: token.clone(),
164+
token: *token,
165165
position_in_tokenstream: *approx_position,
166166
msg,
167167
remaining_matcher: self

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,7 @@ pub(super) fn compute_locs(matcher: &[TokenTree]) -> Vec<MatcherLoc> {
180180
for tt in tts {
181181
match tt {
182182
TokenTree::Token(token) => {
183-
locs.push(MatcherLoc::Token { token: token.clone() });
183+
locs.push(MatcherLoc::Token { token: *token });
184184
}
185185
TokenTree::Delimited(span, _, delimited) => {
186186
let open_token = Token::new(token::OpenDelim(delimited.delim), span.open);
@@ -649,7 +649,7 @@ impl TtParser {
649649
// There are no possible next positions AND we aren't waiting for the black-box
650650
// parser: syntax error.
651651
return Failure(T::build_failure(
652-
parser.token.clone(),
652+
parser.token,
653653
parser.approx_token_stream_pos(),
654654
"no rules expected this token in macro call",
655655
));

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

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -790,7 +790,7 @@ impl<'tt> FirstSets<'tt> {
790790
// token could be the separator token itself.
791791

792792
if let (Some(sep), true) = (&seq_rep.separator, subfirst.maybe_empty) {
793-
first.add_one_maybe(TtHandle::from_token(sep.clone()));
793+
first.add_one_maybe(TtHandle::from_token(*sep));
794794
}
795795

796796
// Reverse scan: Sequence comes before `first`.
@@ -853,7 +853,7 @@ impl<'tt> FirstSets<'tt> {
853853
// If the sequence contents can be empty, then the first
854854
// token could be the separator token itself.
855855
if let (Some(sep), true) = (&seq_rep.separator, subfirst.maybe_empty) {
856-
first.add_one_maybe(TtHandle::from_token(sep.clone()));
856+
first.add_one_maybe(TtHandle::from_token(*sep));
857857
}
858858

859859
assert!(first.maybe_empty);
@@ -929,7 +929,7 @@ impl<'tt> Clone for TtHandle<'tt> {
929929
// This variant *must* contain a `mbe::TokenTree::Token`, and not
930930
// any other variant of `mbe::TokenTree`.
931931
TtHandle::Token(mbe::TokenTree::Token(tok)) => {
932-
TtHandle::Token(mbe::TokenTree::Token(tok.clone()))
932+
TtHandle::Token(mbe::TokenTree::Token(*tok))
933933
}
934934

935935
_ => unreachable!(),
@@ -1105,7 +1105,7 @@ fn check_matcher_core<'tt>(
11051105
let mut new;
11061106
let my_suffix = if let Some(sep) = &seq_rep.separator {
11071107
new = suffix_first.clone();
1108-
new.add_one_maybe(TtHandle::from_token(sep.clone()));
1108+
new.add_one_maybe(TtHandle::from_token(*sep));
11091109
&new
11101110
} else {
11111111
&suffix_first

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -314,7 +314,7 @@ fn parse_tree<'a>(
314314
}
315315

316316
// `tree` is an arbitrary token. Keep it.
317-
tokenstream::TokenTree::Token(token, _) => TokenTree::Token(token.clone()),
317+
tokenstream::TokenTree::Token(token, _) => TokenTree::Token(*token),
318318

319319
// `tree` is the beginning of a delimited set of tokens (e.g., `(` or `{`). We need to
320320
// descend into the delimited set and further parse it.
@@ -350,7 +350,7 @@ fn parse_kleene_op<'a>(
350350
match input.next() {
351351
Some(tokenstream::TokenTree::Token(token, _)) => match kleene_op(token) {
352352
Some(op) => Ok(Ok((op, token.span))),
353-
None => Ok(Err(token.clone())),
353+
None => Ok(Err(*token)),
354354
},
355355
tree => Err(tree.map_or(span, tokenstream::TokenTree::span)),
356356
}

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -163,7 +163,7 @@ pub(super) fn transcribe<'a>(
163163
if repeat_idx < repeat_len {
164164
frame.idx = 0;
165165
if let Some(sep) = sep {
166-
result.push(TokenTree::Token(sep.clone(), Spacing::Alone));
166+
result.push(TokenTree::Token(*sep, Spacing::Alone));
167167
}
168168
continue;
169169
}
@@ -418,7 +418,7 @@ pub(super) fn transcribe<'a>(
418418
// Nothing much to do here. Just push the token to the result, being careful to
419419
// preserve syntax context.
420420
mbe::TokenTree::Token(token) => {
421-
let mut token = token.clone();
421+
let mut token = *token;
422422
mut_visit::visit_token(&mut marker, &mut token);
423423
let tt = TokenTree::Token(token, Spacing::Alone);
424424
result.push(tt);

‎compiler/rustc_parse/src/lexer/unicode_chars.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -377,7 +377,7 @@ pub(super) fn check_for_substitution(
377377
ascii_name,
378378
})
379379
};
380-
(token.clone(), sugg)
380+
(*token, sugg)
381381
}
382382

383383
/// Extract string if found at current position with given delimiters

‎compiler/rustc_parse/src/parser/attr_wrapper.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -120,7 +120,7 @@ impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
120120
// produce an empty `TokenStream` if no calls were made, and omit the
121121
// final token otherwise.
122122
let mut cursor_snapshot = self.cursor_snapshot.clone();
123-
let tokens = iter::once(FlatToken::Token(self.start_token.clone()))
123+
let tokens = iter::once(FlatToken::Token(self.start_token))
124124
.chain(iter::repeat_with(|| FlatToken::Token(cursor_snapshot.next())))
125125
.take(self.num_calls as usize);
126126

@@ -173,7 +173,7 @@ impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
173173
impl<'a> Parser<'a> {
174174
pub(super) fn collect_pos(&self) -> CollectPos {
175175
CollectPos {
176-
start_token: (self.token.clone(), self.token_spacing),
176+
start_token: (self.token, self.token_spacing),
177177
cursor_snapshot: self.token_cursor.clone(),
178178
start_pos: self.num_bump_calls,
179179
}

‎compiler/rustc_parse/src/parser/diagnostics.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -320,7 +320,7 @@ impl<'a> Parser<'a> {
320320
let mut recovered_ident = None;
321321
// we take this here so that the correct original token is retained in
322322
// the diagnostic, regardless of eager recovery.
323-
let bad_token = self.token.clone();
323+
let bad_token = self.token;
324324

325325
// suggest prepending a keyword in identifier position with `r#`
326326
let suggest_raw = if let Some((ident, IdentIsRaw::No)) = self.token.ident()
@@ -380,7 +380,7 @@ impl<'a> Parser<'a> {
380380
// if the previous token is a valid keyword
381381
// that might use a generic, then suggest a correct
382382
// generic placement (later on)
383-
let maybe_keyword = self.prev_token.clone();
383+
let maybe_keyword = self.prev_token;
384384
if valid_prev_keywords.into_iter().any(|x| maybe_keyword.is_keyword(x)) {
385385
// if we have a valid keyword, attempt to parse generics
386386
// also obtain the keywords symbol
@@ -496,7 +496,7 @@ impl<'a> Parser<'a> {
496496
false
497497
}
498498

499-
if **token != parser::TokenType::Token(self.token.kind.clone()) {
499+
if **token != parser::TokenType::Token(self.token.kind) {
500500
let eq = is_ident_eq_keyword(&self.token.kind, &token);
501501
// If the suggestion is a keyword and the found token is an ident,
502502
// the content of which are equal to the suggestion's content,
@@ -560,7 +560,7 @@ impl<'a> Parser<'a> {
560560
// let y = 42;
561561
let guar = self.dcx().emit_err(ExpectedSemi {
562562
span: self.token.span,
563-
token: self.token.clone(),
563+
token: self.token,
564564
unexpected_token_label: None,
565565
sugg: ExpectedSemiSugg::ChangeToSemi(self.token.span),
566566
});
@@ -585,7 +585,7 @@ impl<'a> Parser<'a> {
585585
let span = self.prev_token.span.shrink_to_hi();
586586
let guar = self.dcx().emit_err(ExpectedSemi {
587587
span,
588-
token: self.token.clone(),
588+
token: self.token,
589589
unexpected_token_label: Some(self.token.span),
590590
sugg: ExpectedSemiSugg::AddSemi(span),
591591
});
@@ -830,7 +830,7 @@ impl<'a> Parser<'a> {
830830
let span = self.prev_token.span.shrink_to_hi();
831831
let mut err = self.dcx().create_err(ExpectedSemi {
832832
span,
833-
token: self.token.clone(),
833+
token: self.token,
834834
unexpected_token_label: Some(self.token.span),
835835
sugg: ExpectedSemiSugg::AddSemi(span),
836836
});

‎compiler/rustc_parse/src/parser/expr.rs

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -381,7 +381,7 @@ impl<'a> Parser<'a> {
381381
fn error_found_expr_would_be_stmt(&self, lhs: &Expr) {
382382
self.dcx().emit_err(errors::FoundExprWouldBeStmt {
383383
span: self.token.span,
384-
token: self.token.clone(),
384+
token: self.token,
385385
suggestion: ExprParenthesesNeeded::surrounding(lhs.span),
386386
});
387387
}
@@ -456,7 +456,7 @@ impl<'a> Parser<'a> {
456456
cur_op_span: Span,
457457
) -> PResult<'a, P<Expr>> {
458458
let rhs = if self.is_at_start_of_range_notation_rhs() {
459-
let maybe_lt = self.token.clone();
459+
let maybe_lt = self.token;
460460
let attrs = self.parse_outer_attributes()?;
461461
Some(
462462
self.parse_expr_assoc_with(prec + 1, attrs)
@@ -650,7 +650,7 @@ impl<'a> Parser<'a> {
650650

651651
/// Recover on `not expr` in favor of `!expr`.
652652
fn recover_not_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
653-
let negated_token = self.look_ahead(1, |t| t.clone());
653+
let negated_token = self.look_ahead(1, |t| *t);
654654

655655
let sub_diag = if negated_token.is_numeric_lit() {
656656
errors::NotAsNegationOperatorSub::SuggestNotBitwise
@@ -1610,7 +1610,7 @@ impl<'a> Parser<'a> {
16101610
}
16111611

16121612
fn parse_expr_path_start(&mut self) -> PResult<'a, P<Expr>> {
1613-
let maybe_eq_tok = self.prev_token.clone();
1613+
let maybe_eq_tok = self.prev_token;
16141614
let (qself, path) = if self.eat_lt() {
16151615
let lt_span = self.prev_token.span;
16161616
let (qself, path) = self.parse_qpath(PathStyle::Expr).map_err(|mut err| {
@@ -2056,7 +2056,7 @@ impl<'a> Parser<'a> {
20562056
&mut self,
20572057
mk_lit_char: impl FnOnce(Symbol, Span) -> L,
20582058
) -> PResult<'a, L> {
2059-
let token = self.token.clone();
2059+
let token = self.token;
20602060
let err = |self_: &Self| {
20612061
let msg = format!("unexpected token: {}", super::token_descr(&token));
20622062
self_.dcx().struct_span_err(token.span, msg)
@@ -2364,7 +2364,7 @@ impl<'a> Parser<'a> {
23642364
fn parse_expr_closure(&mut self) -> PResult<'a, P<Expr>> {
23652365
let lo = self.token.span;
23662366

2367-
let before = self.prev_token.clone();
2367+
let before = self.prev_token;
23682368
let binder = if self.check_keyword(kw::For) {
23692369
let lo = self.token.span;
23702370
let (lifetime_defs, _) = self.parse_late_bound_lifetime_defs()?;
@@ -2395,8 +2395,8 @@ impl<'a> Parser<'a> {
23952395
FnRetTy::Default(_) => {
23962396
let restrictions =
23972397
self.restrictions - Restrictions::STMT_EXPR - Restrictions::ALLOW_LET;
2398-
let prev = self.prev_token.clone();
2399-
let token = self.token.clone();
2398+
let prev = self.prev_token;
2399+
let token = self.token;
24002400
let attrs = self.parse_outer_attributes()?;
24012401
match self.parse_expr_res(restrictions, attrs) {
24022402
Ok((expr, _)) => expr,
@@ -2595,7 +2595,7 @@ impl<'a> Parser<'a> {
25952595
}
25962596
} else {
25972597
let attrs = self.parse_outer_attributes()?; // For recovery.
2598-
let maybe_fatarrow = self.token.clone();
2598+
let maybe_fatarrow = self.token;
25992599
let block = if self.check(&token::OpenDelim(Delimiter::Brace)) {
26002600
self.parse_block()?
26012601
} else if let Some(block) = recover_block_from_condition(self) {
@@ -3803,7 +3803,7 @@ impl<'a> Parser<'a> {
38033803
return Err(this.dcx().create_err(errors::ExpectedStructField {
38043804
span: this.look_ahead(1, |t| t.span),
38053805
ident_span: this.token.span,
3806-
token: this.look_ahead(1, |t| t.clone()),
3806+
token: this.look_ahead(1, |t| *t),
38073807
}));
38083808
}
38093809
let (ident, expr) = if is_shorthand {

‎compiler/rustc_parse/src/parser/item.rs

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1696,8 +1696,7 @@ impl<'a> Parser<'a> {
16961696
self.expect_semi()?;
16971697
body
16981698
} else {
1699-
let err =
1700-
errors::UnexpectedTokenAfterStructName::new(self.token.span, self.token.clone());
1699+
let err = errors::UnexpectedTokenAfterStructName::new(self.token.span, self.token);
17011700
return Err(self.dcx().create_err(err));
17021701
};
17031702

@@ -2227,7 +2226,7 @@ impl<'a> Parser<'a> {
22272226
|| self.token.is_keyword(kw::Union))
22282227
&& self.look_ahead(1, |t| t.is_ident())
22292228
{
2230-
let kw_token = self.token.clone();
2229+
let kw_token = self.token;
22312230
let kw_str = pprust::token_to_string(&kw_token);
22322231
let item = self.parse_item(ForceCollect::No)?;
22332232
let mut item = item.unwrap().span;

‎compiler/rustc_parse/src/parser/mod.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -294,12 +294,12 @@ impl TokenCursor {
294294
// below can be removed.
295295
if let Some(tree) = self.tree_cursor.next_ref() {
296296
match tree {
297-
&TokenTree::Token(ref token, spacing) => {
297+
&TokenTree::Token(token, spacing) => {
298298
debug_assert!(!matches!(
299299
token.kind,
300300
token::OpenDelim(_) | token::CloseDelim(_)
301301
));
302-
return (token.clone(), spacing);
302+
return (token, spacing);
303303
}
304304
&TokenTree::Delimited(sp, spacing, delim, ref tts) => {
305305
let trees = tts.clone().into_trees();
@@ -591,7 +591,7 @@ impl<'a> Parser<'a> {
591591
fn check(&mut self, tok: &TokenKind) -> bool {
592592
let is_present = self.token == *tok;
593593
if !is_present {
594-
self.expected_tokens.push(TokenType::Token(tok.clone()));
594+
self.expected_tokens.push(TokenType::Token(*tok));
595595
}
596596
is_present
597597
}
@@ -1487,7 +1487,7 @@ impl<'a> Parser<'a> {
14871487
_ => {
14881488
let prev_spacing = self.token_spacing;
14891489
self.bump();
1490-
TokenTree::Token(self.prev_token.clone(), prev_spacing)
1490+
TokenTree::Token(self.prev_token, prev_spacing)
14911491
}
14921492
}
14931493
}
@@ -1680,7 +1680,7 @@ impl<'a> Parser<'a> {
16801680
dbg_fmt.field("prev_token", &parser.prev_token);
16811681
let mut tokens = vec![];
16821682
for i in 0..*lookahead {
1683-
let tok = parser.look_ahead(i, |tok| tok.kind.clone());
1683+
let tok = parser.look_ahead(i, |tok| tok.kind);
16841684
let is_eof = tok == TokenKind::Eof;
16851685
tokens.push(tok);
16861686
if is_eof {

‎compiler/rustc_parse/src/parser/nonterminal.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -169,7 +169,7 @@ impl<'a> Parser<'a> {
169169
} else {
170170
Err(self.dcx().create_err(UnexpectedNonterminal::Ident {
171171
span: self.token.span,
172-
token: self.token.clone(),
172+
token: self.token,
173173
}))
174174
}
175175
}
@@ -192,7 +192,7 @@ impl<'a> Parser<'a> {
192192
} else {
193193
Err(self.dcx().create_err(UnexpectedNonterminal::Lifetime {
194194
span: self.token.span,
195-
token: self.token.clone(),
195+
token: self.token,
196196
}))
197197
}
198198
}

‎compiler/rustc_parse/src/parser/pat.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -335,7 +335,7 @@ impl<'a> Parser<'a> {
335335
self.dcx().emit_err(TrailingVertNotAllowed {
336336
span: self.token.span,
337337
start: lo,
338-
token: self.token.clone(),
338+
token: self.token,
339339
note_double_vert: matches!(self.token.kind, token::OrOr),
340340
});
341341
self.bump();
@@ -1494,8 +1494,8 @@ impl<'a> Parser<'a> {
14941494
etc = PatFieldsRest::Rest;
14951495
let mut etc_sp = self.token.span;
14961496
if first_etc_and_maybe_comma_span.is_none() {
1497-
if let Some(comma_tok) = self
1498-
.look_ahead(1, |t| if *t == token::Comma { Some(t.clone()) } else { None })
1497+
if let Some(comma_tok) =
1498+
self.look_ahead(1, |&t| if t == token::Comma { Some(t) } else { None })
14991499
{
15001500
let nw_span = self
15011501
.psess

‎compiler/rustc_parse/src/parser/path.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -388,8 +388,8 @@ impl<'a> Parser<'a> {
388388
} else {
389389
// `(T, U) -> R`
390390

391-
let prev_token_before_parsing = self.prev_token.clone();
392-
let token_before_parsing = self.token.clone();
391+
let prev_token_before_parsing = self.prev_token;
392+
let token_before_parsing = self.token;
393393
let mut snapshot = None;
394394
if self.may_recover()
395395
&& prev_token_before_parsing == token::PathSep

0 commit comments

Comments
 (0)