Implement raw keywords in the lexer and always emit an error, if encountered.

Author: Julian Wollersberger

compiler/rustc_lexer/src/lib.rs

@@ -66,6 +66,9 @@ pub enum TokenKind {
     Ident,
     /// "r#ident"
     RawIdent,
+    /// "k#ident"
+    /// Unstable feature handling is done in rustc_parse/src/lexer/mod.rs
+    RawKeyword,
     /// "12_u8", "1.0e-40", "b"123"". See `LiteralKind` for more details.
     Literal { kind: LiteralKind, suffix_start: usize },
     /// "'a"
@@ -361,6 +364,9 @@ impl Cursor<'_> {
                 _ => self.ident(),
             },
 
+            // Raw keyword
+            'k' if self.first() == '#' && is_id_start(self.second()) => self.raw_keyword(),
+
             // Identifier (this should be checked after other variant that can
             // start as identifier).
             c if is_id_start(c) => self.ident(),
@@ -487,6 +493,15 @@ impl Cursor<'_> {
         RawIdent
     }
 
+    fn raw_keyword(&mut self) -> TokenKind {
+        debug_assert!(self.prev() == 'k' && self.first() == '#' && is_id_start(self.second()));
+        // Eat "#" symbol.
+        self.bump();
+        // Eat the identifier part of the keyword.
+        self.eat_identifier();
+        RawKeyword
+    }
+
     fn ident(&mut self) -> TokenKind {
         debug_assert!(is_id_start(self.prev()));
         // Start is already eaten, eat the rest of identifier.

compiler/rustc_parse/src/lexer/mod.rs

@@ -187,6 +187,25 @@ impl<'a> StringReader<'a> {
                 }
                 token::Ident(sym, is_raw_ident)
             }
+            rustc_lexer::TokenKind::RawKeyword => {
+                let span = self.mk_sp(start, self.pos);
+                self.sess
+                    .span_diagnostic
+                    .struct_span_err(span, "raw keyword syntax is reserved for future use")
+                    // With whitespace, it tokenizes as three tokens, just like before this reservation.
+                    .span_suggestion(
+                        span,
+                        "insert a whitespace",
+                        format!("k #{}", self.str_from(start + BytePos(2))),
+                        Applicability::MachineApplicable,
+                    )
+                    .emit();
+
+                let sym = nfc_normalize(self.str_from(start + BytePos(2)));
+                // For recovery, treat it as a raw ident.
+                // FIXME: Add a flag to Ident to mark it as a raw keyword.
+                token::Ident(sym, true)
+            }
             rustc_lexer::TokenKind::Literal { kind, suffix_start } => {
                 let suffix_start = start + BytePos(suffix_start as u32);
                 let (kind, symbol) = self.cook_lexer_literal(start, suffix_start, kind);

src/librustdoc/html/highlight.rs

@@ -408,6 +408,8 @@ impl<'a> Classifier<'a> {
                 c => c,
             },
             TokenKind::RawIdent => Class::Ident,
+            //TODO How do I test this?
+            TokenKind::RawKeyword => Class::KeyWord,
             TokenKind::Lifetime { .. } => Class::Lifetime,
         };
         // Anything that didn't return above is the simple case where we the