Handle safe safety keyword for fns (not yet ready, generated unsafe fns)

Author: spastorino

compiler/rustc_ast/src/ast.rs

@@ -2489,6 +2489,7 @@ pub enum Unsafe {
 #[derive(HashStable_Generic)]
 pub enum FnSafety {
     Unsafe(Span),
+    Safe(Span),
     Default,
 }
 

compiler/rustc_ast/src/mut_visit.rs

@@ -867,6 +867,7 @@ fn visit_unsafety<T: MutVisitor>(unsafety: &mut Unsafe, vis: &mut T) {
 fn visit_fn_safety<T: MutVisitor>(safety: &mut FnSafety, vis: &mut T) {
     match safety {
         FnSafety::Unsafe(span) => vis.visit_span(span),
+        FnSafety::Safe(span) => vis.visit_span(span),
         FnSafety::Default => {}
     }
 }

compiler/rustc_ast/src/token.rs

@@ -210,6 +210,7 @@ pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: IdentIsRaw) -> boo
             kw::Unsafe,
             kw::While,
             kw::Yield,
+            kw::Safe,
             kw::Static,
         ]
         .contains(&name)
@@ -563,6 +564,7 @@ impl Token {
                 kw::Impl,
                 kw::Unsafe,
                 kw::Const,
+                kw::Safe,
                 kw::Static,
                 kw::Union,
                 kw::Macro,

compiler/rustc_ast_lowering/src/item.rs

@@ -1411,6 +1411,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_fn_safety(&mut self, u: FnSafety) -> hir::FnSafety {
         match u {
             FnSafety::Unsafe(_) => hir::FnSafety::Unsafe,
+            FnSafety::Safe(_) => hir::FnSafety::Safe,
             FnSafety::Default => hir::FnSafety::Default,
         }
     }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1943,6 +1943,7 @@ impl<'a> State<'a> {
     fn print_fn_safety(&mut self, s: ast::FnSafety) {
         match s {
             ast::FnSafety::Default => {}
+            ast::FnSafety::Safe(_) => self.word_nbsp("safe"),
             ast::FnSafety::Unsafe(_) => self.word_nbsp("unsafe"),
         }
     }

compiler/rustc_hir/src/hir.rs

@@ -3208,13 +3208,15 @@ impl fmt::Display for Unsafety {
 #[derive(Encodable, Decodable, HashStable_Generic)]
 pub enum FnSafety {
     Unsafe,
+    Safe,
     Default,
 }
 
 impl FnSafety {
     pub fn prefix_str(&self) -> &'static str {
         match self {
             Self::Unsafe => "unsafe ",
+            Self::Safe => "safe ",
             Self::Default => "",
         }
     }
@@ -3224,6 +3226,7 @@ impl fmt::Display for FnSafety {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match *self {
             Self::Unsafe => "unsafe",
+            Self::Safe => "safe",
             Self::Default => "normal",
         })
     }

compiler/rustc_hir_pretty/src/lib.rs

@@ -2290,6 +2290,7 @@ impl<'a> State<'a> {
     fn print_fn_safety(&mut self, s: hir::FnSafety) {
         match s {
             hir::FnSafety::Default => {}
+            hir::FnSafety::Safe => self.word_nbsp("safe"),
             hir::FnSafety::Unsafe => self.word_nbsp("unsafe"),
         }
     }

compiler/rustc_parse/src/parser/item.rs

@@ -2376,9 +2376,9 @@ impl<'a> Parser<'a> {
         // `pub` is added in case users got confused with the ordering like `async pub fn`,
         // only if it wasn't preceded by `default` as `default pub` is invalid.
         let quals: &[Symbol] = if check_pub {
-            &[kw::Pub, kw::Gen, kw::Const, kw::Async, kw::Unsafe, kw::Extern]
+            &[kw::Pub, kw::Gen, kw::Const, kw::Async, kw::Unsafe, kw::Safe, kw::Extern]
         } else {
-            &[kw::Gen, kw::Const, kw::Async, kw::Unsafe, kw::Extern]
+            &[kw::Gen, kw::Const, kw::Async, kw::Unsafe, kw::Safe, kw::Extern]
         };
         self.check_keyword_case(kw::Fn, case) // Definitely an `fn`.
             // `$qual fn` or `$qual $qual`:
@@ -2513,11 +2513,27 @@ impl<'a> Parser<'a> {
                     } else if self.check_keyword(kw::Unsafe) {
                         match safety {
                             FnSafety::Unsafe(sp) => Some(WrongKw::Duplicated(sp)),
+                            FnSafety::Safe(sp) => {
+                                recover_safety = FnSafety::Unsafe(self.token.span);
+                                Some(WrongKw::Misplaced(sp))
+                            }
                             FnSafety::Default => {
                                 recover_safety = FnSafety::Unsafe(self.token.span);
                                 Some(WrongKw::Misplaced(ext_start_sp))
                             }
                         }
+                    } else if self.check_keyword(kw::Safe) {
+                        match safety {
+                            FnSafety::Safe(sp) => Some(WrongKw::Duplicated(sp)),
+                            FnSafety::Unsafe(sp) => {
+                                recover_safety = FnSafety::Safe(self.token.span);
+                                Some(WrongKw::Misplaced(sp))
+                            }
+                            FnSafety::Default => {
+                                recover_safety = FnSafety::Safe(self.token.span);
+                                Some(WrongKw::Misplaced(ext_start_sp))
+                            }
+                        }
                     } else {
                         None
                     };

compiler/rustc_parse/src/parser/mod.rs

@@ -1225,6 +1225,8 @@ impl<'a> Parser<'a> {
     fn parse_fn_safety(&mut self, case: Case) -> FnSafety {
         if self.eat_keyword_case(kw::Unsafe, case) {
             FnSafety::Unsafe(self.prev_token.uninterpolated_span())
+        } else if self.eat_keyword_case(kw::Safe, case) {
+            FnSafety::Safe(self.prev_token.uninterpolated_span())
         } else {
             FnSafety::Default
         }

compiler/rustc_smir/src/rustc_internal/internal.rs

@@ -497,6 +497,7 @@ impl RustcInternal for FnSafety {
     fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
         match self {
             FnSafety::Unsafe => rustc_hir::FnSafety::Unsafe,
+            FnSafety::Safe => rustc_hir::FnSafety::Safe,
             FnSafety::Default => rustc_hir::FnSafety::Default,
         }
     }