Skip to content

Commit 8456c40

Browse files
CentrilCentril
committed
extract parse_not_expr
1 parent efdea63 commit 8456c40

File tree

11 files changed

+86
-108
lines changed

11 files changed

+86
-108
lines changed

‎src/librustc_parse/parser/attr.rs

+4-3
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,10 @@
11
use super::{Parser, PathStyle, TokenType};
22
use rustc_errors::PResult;
33
use syntax::ast;
4-
use syntax::attr;
4+
use syntax::print::pprust;
55
use syntax::token::{self, Nonterminal};
66
use syntax::util::comments;
7+
use syntax::util::comments;
78
use syntax_pos::{Span, Symbol};
89

910
use log::debug;
@@ -154,7 +155,7 @@ impl<'a> Parser<'a> {
154155
(attr_sp, item, style)
155156
}
156157
_ => {
157-
let token_str = self.this_token_to_string();
158+
let token_str = pprust::token_to_string(&self.token);
158159
return Err(self.fatal(&format!("expected `#`, found `{}`", token_str)));
159160
}
160161
};
@@ -329,7 +330,7 @@ impl<'a> Parser<'a> {
329330
Err(ref mut err) => err.cancel(),
330331
}
331332

332-
let found = self.this_token_to_string();
333+
let found = pprust::token_to_string(&self.token);
333334
let msg = format!("expected unsuffixed literal or identifier, found `{}`", found);
334335
Err(self.diagnostic().struct_span_err(self.token.span, &msg))
335336
}

‎src/librustc_parse/parser/diagnostics.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -200,7 +200,7 @@ impl<'a> Parser<'a> {
200200
pub(super) fn expected_ident_found(&self) -> DiagnosticBuilder<'a> {
201201
let mut err = self.struct_span_err(
202202
self.token.span,
203-
&format!("expected identifier, found {}", self.this_token_descr()),
203+
&format!("expected identifier, found {}", super::token_descr(&self.token)),
204204
);
205205
let valid_follow = &[
206206
TokenKind::Eq,
@@ -225,7 +225,7 @@ impl<'a> Parser<'a> {
225225
);
226226
}
227227
}
228-
if let Some(token_descr) = self.token_descr() {
228+
if let Some(token_descr) = super::token_descr_opt(&self.token) {
229229
err.span_label(self.token.span, format!("expected identifier, found {}", token_descr));
230230
} else {
231231
err.span_label(self.token.span, "expected identifier");
@@ -272,7 +272,7 @@ impl<'a> Parser<'a> {
272272
expected.sort_by_cached_key(|x| x.to_string());
273273
expected.dedup();
274274
let expect = tokens_to_string(&expected[..]);
275-
let actual = self.this_token_descr();
275+
let actual = super::token_descr(&self.token);
276276
let (msg_exp, (label_sp, label_exp)) = if expected.len() > 1 {
277277
let short_expect = if expected.len() > 6 {
278278
format!("{} possible tokens", expected.len())
@@ -815,7 +815,7 @@ impl<'a> Parser<'a> {
815815
t: &TokenKind,
816816
) -> PResult<'a, bool /* recovered */> {
817817
let token_str = pprust::token_kind_to_string(t);
818-
let this_token_str = self.this_token_descr();
818+
let this_token_str = super::token_descr(&self.token);
819819
let (prev_sp, sp) = match (&self.token.kind, self.subparser_name) {
820820
// Point at the end of the macro call when reaching end of macro arguments.
821821
(token::Eof, Some(_)) => {
@@ -862,7 +862,7 @@ impl<'a> Parser<'a> {
862862
return Ok(());
863863
}
864864
let sm = self.sess.source_map();
865-
let msg = format!("expected `;`, found `{}`", self.this_token_descr());
865+
let msg = format!("expected `;`, found `{}`", super::token_descr(&self.token));
866866
let appl = Applicability::MachineApplicable;
867867
if self.token.span == DUMMY_SP || self.prev_span == DUMMY_SP {
868868
// Likely inside a macro, can't provide meaninful suggestions.
@@ -1270,7 +1270,7 @@ impl<'a> Parser<'a> {
12701270
}
12711271

12721272
pub(super) fn expected_semi_or_open_brace<T>(&mut self) -> PResult<'a, T> {
1273-
let token_str = self.this_token_descr();
1273+
let token_str = super::token_descr(&self.token);
12741274
let mut err = self.fatal(&format!("expected `;` or `{{`, found {}", token_str));
12751275
err.span_label(self.token.span, "expected `;` or `{`");
12761276
Err(err)
@@ -1447,7 +1447,7 @@ impl<'a> Parser<'a> {
14471447
}
14481448
_ => (
14491449
self.token.span,
1450-
format!("expected expression, found {}", self.this_token_descr(),),
1450+
format!("expected expression, found {}", super::token_descr(&self.token),),
14511451
),
14521452
};
14531453
let mut err = self.struct_span_err(span, &msg);

‎src/librustc_parse/parser/expr.rs

+34-52
Original file line numberDiff line numberDiff line change
@@ -442,35 +442,37 @@ impl<'a> Parser<'a> {
442442
}
443443

444444
/// Parses a prefix-unary-operator expr.
445-
fn parse_prefix_expr(&mut self, already_parsed_attrs: Option<AttrVec>) -> PResult<'a, P<Expr>> {
446-
let attrs = self.parse_or_use_outer_attributes(already_parsed_attrs)?;
445+
fn parse_prefix_expr(&mut self, attrs: Option<AttrVec>) -> PResult<'a, P<Expr>> {
446+
let attrs = self.parse_or_use_outer_attributes(attrs)?;
447447
let lo = self.token.span;
448448
// Note: when adding new unary operators, don't forget to adjust TokenKind::can_begin_expr()
449449
let (hi, ex) = match self.token.kind {
450-
token::Not => {
451-
self.bump();
452-
let e = self.parse_prefix_expr(None);
453-
let (span, e) = self.interpolated_or_expr_span(e)?;
454-
(lo.to(span), self.mk_unary(UnOp::Not, e))
455-
}
456-
token::Tilde => self.recover_tilde_expr(lo)?,
457-
token::BinOp(token::Minus) => self.parse_neg_expr(lo)?,
458-
token::BinOp(token::Star) => self.parse_deref_expr(lo)?,
459-
token::BinOp(token::And) | token::AndAnd => self.parse_borrow_expr(lo)?,
460-
token::Ident(..) if self.token.is_keyword(kw::Box) => self.parse_box_expr(lo)?,
461-
token::Ident(..) if self.is_mistaken_not_ident_negation() => {
462-
self.recover_not_expr(lo)?
463-
}
450+
token::Not => self.parse_unary_expr(lo, UnOp::Not), // `!expr`
451+
token::Tilde => self.recover_tilde_expr(lo), // `~expr`
452+
token::BinOp(token::Minus) => self.parse_unary_expr(lo, UnOp::Neg), // `-expr`
453+
token::BinOp(token::Star) => self.parse_unary_expr(lo, UnOp::Deref), // `*expr`
454+
token::BinOp(token::And) | token::AndAnd => self.parse_borrow_expr(lo),
455+
token::Ident(..) if self.token.is_keyword(kw::Box) => self.parse_box_expr(lo),
456+
token::Ident(..) if self.is_mistaken_not_ident_negation() => self.recover_not_expr(lo),
464457
_ => return self.parse_dot_or_call_expr(Some(attrs)),
465-
};
466-
return Ok(self.mk_expr(lo.to(hi), ex, attrs));
458+
}?;
459+
Ok(self.mk_expr(lo.to(hi), ex, attrs))
467460
}
468461

469-
// Recover on `!` suggesting for bitwise negation instead.
470-
fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
462+
fn parse_prefix_expr_common(&mut self, lo: Span) -> PResult<'a, (Span, P<Expr>)> {
471463
self.bump();
472464
let expr = self.parse_prefix_expr(None);
473465
let (span, expr) = self.interpolated_or_expr_span(expr)?;
466+
Ok((lo.to(span), expr))
467+
}
468+
469+
fn parse_unary_expr(&mut self, lo: Span, op: UnOp) -> PResult<'a, (Span, ExprKind)> {
470+
let (span, expr) = self.parse_prefix_expr_common(lo)?;
471+
Ok((span, self.mk_unary(op, expr)))
472+
}
473+
474+
// Recover on `!` suggesting for bitwise negation instead.
475+
fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
474476
self.struct_span_err(lo, "`~` cannot be used as a unary operator")
475477
.span_suggestion_short(
476478
lo,
@@ -479,31 +481,13 @@ impl<'a> Parser<'a> {
479481
Applicability::MachineApplicable,
480482
)
481483
.emit();
482-
Ok((lo.to(span), self.mk_unary(UnOp::Not, expr)))
483-
}
484484

485-
/// Parse `-expr`.
486-
fn parse_neg_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
487-
self.bump(); // `-`
488-
let expr = self.parse_prefix_expr(None);
489-
let (span, expr) = self.interpolated_or_expr_span(expr)?;
490-
Ok((lo.to(span), self.mk_unary(UnOp::Neg, expr)))
491-
}
492-
493-
/// Parse `*expr`.
494-
fn parse_deref_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
495-
self.bump(); // `*`
496-
let expr = self.parse_prefix_expr(None);
497-
let (span, expr) = self.interpolated_or_expr_span(expr)?;
498-
Ok((lo.to(span), self.mk_unary(UnOp::Deref, expr)))
485+
self.parse_unary_expr(lo, UnOp::Not)
499486
}
500487

501488
/// Parse `box expr`.
502489
fn parse_box_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
503-
self.bump(); // `box`
504-
let expr = self.parse_prefix_expr(None);
505-
let (span, expr) = self.interpolated_or_expr_span(expr)?;
506-
let span = lo.to(span);
490+
let (span, expr) = self.parse_prefix_expr_common(lo)?;
507491
self.sess.gated_spans.gate(sym::box_syntax, span);
508492
Ok((span, ExprKind::Box(expr)))
509493
}
@@ -521,26 +505,24 @@ impl<'a> Parser<'a> {
521505

522506
/// Recover on `not expr` in favor of `!expr`.
523507
fn recover_not_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
524-
self.bump();
525-
// Emit the error ...
508+
// Emit the error...
509+
let not_token = self.look_ahead(1, |t| t.clone());
526510
self.struct_span_err(
527-
self.token.span,
528-
&format!("unexpected {} after identifier", self.this_token_descr()),
511+
not_token.span,
512+
&format!("unexpected {} after identifier", super::token_descr(&not_token)),
529513
)
530514
.span_suggestion_short(
531515
// Span the `not` plus trailing whitespace to avoid
532516
// trailing whitespace after the `!` in our suggestion
533-
self.sess.source_map().span_until_non_whitespace(lo.to(self.token.span)),
517+
self.sess.source_map().span_until_non_whitespace(lo.to(not_token.span)),
534518
"use `!` to perform logical negation",
535519
"!".to_owned(),
536520
Applicability::MachineApplicable,
537521
)
538522
.emit();
539-
// —and recover! (just as if we were in the block
540-
// for the `token::Not` arm)
541-
let expr = self.parse_prefix_expr(None);
542-
let (span, e) = self.interpolated_or_expr_span(expr)?;
543-
Ok((lo.to(span), self.mk_unary(UnOp::Not, e)))
523+
524+
// ...and recover!
525+
self.parse_unary_expr(lo, UnOp::Not)
544526
}
545527

546528
/// Returns the span of expr, if it was not interpolated or the span of the interpolated token.
@@ -738,7 +720,7 @@ impl<'a> Parser<'a> {
738720

739721
fn error_unexpected_after_dot(&self) {
740722
// FIXME Could factor this out into non_fatal_unexpected or something.
741-
let actual = self.this_token_to_string();
723+
let actual = pprust::token_to_string(&self.token);
742724
self.struct_span_err(self.token.span, &format!("unexpected token: `{}`", actual)).emit();
743725
}
744726

@@ -1142,7 +1124,7 @@ impl<'a> Parser<'a> {
11421124

11431125
pub(super) fn parse_lit(&mut self) -> PResult<'a, Lit> {
11441126
self.parse_opt_lit().ok_or_else(|| {
1145-
let msg = format!("unexpected token: {}", self.this_token_descr());
1127+
let msg = format!("unexpected token: {}", super::token_descr(&self.token));
11461128
self.span_fatal(self.token.span, &msg)
11471129
})
11481130
}

‎src/librustc_parse/parser/item.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -1348,7 +1348,7 @@ impl<'a> Parser<'a> {
13481348
self.expect_semi()?;
13491349
body
13501350
} else {
1351-
let token_str = self.this_token_descr();
1351+
let token_str = super::token_descr(&self.token);
13521352
let mut err = self.fatal(&format!(
13531353
"expected `where`, `{{`, `(`, or `;` after struct name, found {}",
13541354
token_str
@@ -1374,7 +1374,7 @@ impl<'a> Parser<'a> {
13741374
let (fields, recovered) = self.parse_record_struct_body()?;
13751375
VariantData::Struct(fields, recovered)
13761376
} else {
1377-
let token_str = self.this_token_descr();
1377+
let token_str = super::token_descr(&self.token);
13781378
let mut err = self
13791379
.fatal(&format!("expected `where` or `{{` after union name, found {}", token_str));
13801380
err.span_label(self.token.span, "expected `where` or `{` after union name");
@@ -1411,7 +1411,7 @@ impl<'a> Parser<'a> {
14111411
}
14121412
self.eat(&token::CloseDelim(token::Brace));
14131413
} else {
1414-
let token_str = self.this_token_descr();
1414+
let token_str = super::token_descr(&self.token);
14151415
let mut err = self.fatal(&format!(
14161416
"expected `where`, or `{{` after struct name, found {}",
14171417
token_str
@@ -1498,7 +1498,7 @@ impl<'a> Parser<'a> {
14981498
let sp = self.sess.source_map().next_point(self.prev_span);
14991499
let mut err = self.struct_span_err(
15001500
sp,
1501-
&format!("expected `,`, or `}}`, found {}", self.this_token_descr()),
1501+
&format!("expected `,`, or `}}`, found {}", super::token_descr(&self.token)),
15021502
);
15031503
if self.token.is_ident() {
15041504
// This is likely another field; emit the diagnostic and keep going

‎src/librustc_parse/parser/mod.rs

+18-23
Original file line numberDiff line numberDiff line change
@@ -354,6 +354,24 @@ pub enum FollowedByType {
354354
No,
355355
}
356356

357+
fn token_descr_opt(token: &Token) -> Option<&'static str> {
358+
Some(match token.kind {
359+
_ if token.is_special_ident() => "reserved identifier",
360+
_ if token.is_used_keyword() => "keyword",
361+
_ if token.is_unused_keyword() => "reserved keyword",
362+
token::DocComment(..) => "doc comment",
363+
_ => return None,
364+
})
365+
}
366+
367+
pub(super) fn token_descr(token: &Token) -> String {
368+
let token_str = pprust::token_to_string(token);
369+
match token_descr_opt(token) {
370+
Some(prefix) => format!("{} `{}`", prefix, token_str),
371+
_ => format!("`{}`", token_str),
372+
}
373+
}
374+
357375
impl<'a> Parser<'a> {
358376
pub fn new(
359377
sess: &'a ParseSess,
@@ -422,29 +440,6 @@ impl<'a> Parser<'a> {
422440
next
423441
}
424442

425-
/// Converts the current token to a string using `self`'s reader.
426-
pub fn this_token_to_string(&self) -> String {
427-
pprust::token_to_string(&self.token)
428-
}
429-
430-
fn token_descr(&self) -> Option<&'static str> {
431-
Some(match &self.token.kind {
432-
_ if self.token.is_special_ident() => "reserved identifier",
433-
_ if self.token.is_used_keyword() => "keyword",
434-
_ if self.token.is_unused_keyword() => "reserved keyword",
435-
token::DocComment(..) => "doc comment",
436-
_ => return None,
437-
})
438-
}
439-
440-
pub(super) fn this_token_descr(&self) -> String {
441-
if let Some(prefix) = self.token_descr() {
442-
format!("{} `{}`", prefix, self.this_token_to_string())
443-
} else {
444-
format!("`{}`", self.this_token_to_string())
445-
}
446-
}
447-
448443
crate fn unexpected<T>(&mut self) -> PResult<'a, T> {
449444
match self.expect_one_of(&[], &[]) {
450445
Err(e) => Err(e),

‎src/librustc_parse/parser/module.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ impl<'a> Parser<'a> {
7979
}
8080

8181
if !self.eat(term) {
82-
let token_str = self.this_token_descr();
82+
let token_str = super::token_descr(&self.token);
8383
if !self.maybe_consume_incorrect_semicolon(&items) {
8484
let mut err = self.fatal(&format!("expected item, found {}", token_str));
8585
err.span_label(self.token.span, "expected item");

‎src/librustc_parse/parser/pat.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -670,7 +670,7 @@ impl<'a> Parser<'a> {
670670
err.cancel();
671671

672672
let expected = expected.unwrap_or("pattern");
673-
let msg = format!("expected {}, found {}", expected, self.this_token_descr());
673+
let msg = format!("expected {}, found {}", expected, super::token_descr(&self.token));
674674

675675
let mut err = self.fatal(&msg);
676676
err.span_label(self.token.span, format!("expected {}", expected));
@@ -875,7 +875,7 @@ impl<'a> Parser<'a> {
875875
etc_span = Some(etc_sp);
876876
break;
877877
}
878-
let token_str = self.this_token_descr();
878+
let token_str = super::token_descr(&self.token);
879879
let mut err = self.fatal(&format!("expected `}}`, found {}", token_str));
880880

881881
err.span_label(self.token.span, "expected `}`");

‎src/librustc_parse/parser/stmt.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -323,7 +323,7 @@ impl<'a> Parser<'a> {
323323

324324
fn error_block_no_opening_brace<T>(&mut self) -> PResult<'a, T> {
325325
let sp = self.token.span;
326-
let tok = self.this_token_descr();
326+
let tok = super::token_descr(&self.token);
327327
let mut e = self.span_fatal(sp, &format!("expected `{{`, found {}", tok));
328328
let do_not_suggest_help = self.token.is_keyword(kw::In) || self.token == token::Colon;
329329

@@ -463,7 +463,7 @@ impl<'a> Parser<'a> {
463463
fn warn_missing_semicolon(&self) {
464464
self.diagnostic()
465465
.struct_span_warn(self.token.span, {
466-
&format!("expected `;`, found {}", self.this_token_descr())
466+
&format!("expected `;`, found {}", super::token_descr(&self.token))
467467
})
468468
.note({
469469
"this was erroneously allowed and will become a hard error in a future release"

‎src/librustc_parse/parser/ty.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,7 @@ impl<'a> Parser<'a> {
135135
TyKind::Err
136136
}
137137
} else {
138-
let msg = format!("expected type, found {}", self.this_token_descr());
138+
let msg = format!("expected type, found {}", super::token_descr(&self.token));
139139
let mut err = self.struct_span_err(self.token.span, &msg);
140140
err.span_label(self.token.span, "expected type");
141141
self.maybe_annotate_with_ascription(&mut err, true);

‎src/libsyntax_expand/expand.rs

+2-4
Original file line numberDiff line numberDiff line change
@@ -904,10 +904,8 @@ pub fn ensure_complete_parse<'a>(
904904
span: Span,
905905
) {
906906
if this.token != token::Eof {
907-
let msg = format!(
908-
"macro expansion ignores token `{}` and any following",
909-
this.this_token_to_string()
910-
);
907+
let token = pprust::token_to_string(&this.token);
908+
let msg = format!("macro expansion ignores token `{}` and any following", token);
911909
// Avoid emitting backtrace info twice.
912910
let def_site_span = this.token.span.with_ctxt(SyntaxContext::root());
913911
let mut err = this.struct_span_err(def_site_span, &msg);

0 commit comments

Comments
 (0)