Address review comments.

Author: nnethercote

compiler/rustc_parse/src/parser/expr.rs

@@ -993,7 +993,21 @@ impl<'a> Parser<'a> {
                 (span.shrink_to_hi(), format!("`{}`", snippet))
             }
             (token::CloseDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(_))), _) => {
-                // Don't need to report an error in this case.
+                // No need to report an error. This case will only occur when parsing a pasted
+                // metavariable, and we should have emitted an error when parsing the macro call in
+                // the first place. E.g. in this code:
+                // ```
+                // macro_rules! m { ($e:expr) => { $e }; }
+                //
+                // fn main() {
+                //     let f = 1;
+                //     m!(f.);
+                // }
+                // ```
+                // we'll get an error "unexpected token: `)` when parsing the `m!(f.)`, so we don't
+                // want to issue a second error when parsing the expansion `«f.»` (where `«`/`»`
+                // represent the invisible delimiters).
+                self.dcx().span_delayed_bug(span, "bad dot expr in metavariable");
                 return;
             }
             _ => (span, actual),
@@ -2086,7 +2100,7 @@ impl<'a> Parser<'a> {
             .or_else(|()| self.handle_missing_lit(Parser::mk_meta_item_lit_char))
     }
 
-    fn recover_after_dot(&mut self) -> Option<Token> {
+    fn recover_after_dot(&mut self) {
         let mut recovered = None;
         if self.token == token::Dot {
             // Attempt to recover `.4` as `0.4`. We don't currently have any syntax where
@@ -2121,12 +2135,14 @@ impl<'a> Parser<'a> {
             }
         }
 
-        recovered
+        if let Some(recovered) = recovered {
+            self.token = recovered;
+        }
     }
 
     /// Keep this in sync with `Token::can_begin_literal_maybe_minus` and
     /// `Lit::from_token` (excluding unary negation).
-    pub fn eat_token_lit(&mut self) -> Option<token::Lit> {
+    fn eat_token_lit(&mut self) -> Option<token::Lit> {
         match self.token.uninterpolate().kind {
             token::Ident(name, IdentIsRaw::No) if name.is_bool_lit() => {
                 self.bump();
@@ -2165,34 +2181,28 @@ impl<'a> Parser<'a> {
     /// Matches `lit = true | false | token_lit`.
     /// Returns `None` if the next token is not a literal.
     fn parse_opt_token_lit(&mut self) -> Option<(token::Lit, Span)> {
-        match self.recover_after_dot() {
-            Some(recovered) => self.token = recovered,
-            None => {}
-        }
+        self.recover_after_dot();
         let span = self.token.span;
         self.eat_token_lit().map(|token_lit| (token_lit, span))
     }
 
     /// Matches `lit = true | false | token_lit`.
     /// Returns `None` if the next token is not a literal.
     fn parse_opt_meta_item_lit(&mut self) -> Option<MetaItemLit> {
-        match self.recover_after_dot() {
-            Some(recovered) => self.token = recovered,
-            None => {}
-        }
+        self.recover_after_dot();
         let span = self.token.span;
-        let span2 = self.uninterpolated_token_span();
+        let uninterpolated_span = self.uninterpolated_token_span();
         self.eat_token_lit().map(|token_lit| {
             match MetaItemLit::from_token_lit(token_lit, span) {
                 Ok(lit) => lit,
                 Err(err) => {
-                    let guar = report_lit_error(&self.psess, err, token_lit, span2);
+                    let guar = report_lit_error(&self.psess, err, token_lit, uninterpolated_span);
                     // Pack possible quotes and prefixes from the original literal into
                     // the error literal's symbol so they can be pretty-printed faithfully.
                     let suffixless_lit = token::Lit::new(token_lit.kind, token_lit.symbol, None);
                     let symbol = Symbol::intern(&suffixless_lit.to_string());
                     let token_lit = token::Lit::new(token::Err(guar), symbol, token_lit.suffix);
-                    MetaItemLit::from_token_lit(token_lit, span2).unwrap_or_else(|_| unreachable!())
+                    MetaItemLit::from_token_lit(token_lit, uninterpolated_span).unwrap()
                 }
             }
         })

compiler/rustc_parse/src/parser/mod.rs

@@ -1303,11 +1303,7 @@ impl<'a> Parser<'a> {
         looker: impl FnOnce(&TokenTree) -> R,
     ) -> Option<R> {
         assert_ne!(dist, 0);
-
-        match self.token_cursor.curr.look_ahead(dist - 1) {
-            Some(tt) => Some(looker(tt)),
-            _ => None,
-        }
+        self.token_cursor.curr.look_ahead(dist - 1).map(looker)
     }
 
     /// Returns whether any of the given keywords are `dist` tokens ahead of the current one.