Add Constness::Comptime

Author: oli-obk

compiler/rustc_ast/src/ast.rs

@@ -3097,6 +3097,7 @@ impl CoroutineKind {
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, Debug)]
 #[derive(HashStable_Generic, Walkable)]
 pub enum Const {
+    Comptime(Span),
     Yes(Span),
     No,
 }

compiler/rustc_ast_lowering/src/item.rs

@@ -1603,6 +1603,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     pub(super) fn lower_constness(&mut self, c: Const) -> hir::Constness {
         match c {
+            Const::Comptime(_) => hir::Constness::Comptime,
             Const::Yes(_) => hir::Constness::Const,
             Const::No => hir::Constness::NotConst,
         }

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -637,6 +637,7 @@ impl<'a> AstValidator<'a> {
             None => (),
         }
         match constness {
+            Const::Comptime(span) => report_err(span, "comptime"),
             Const::Yes(span) => report_err(span, "const"),
             Const::No => (),
         }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -2109,6 +2109,7 @@ impl<'a> State<'a> {
         match s {
             ast::Const::No => {}
             ast::Const::Yes(_) => self.word_nbsp("const"),
+            ast::Const::Comptime(_) => self.word_nbsp("comptime"),
         }
     }
 

compiler/rustc_hir/src/hir.rs

@@ -4225,13 +4225,15 @@ impl fmt::Display for Safety {
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Encodable, Decodable, HashStable_Generic)]
 pub enum Constness {
+    Comptime,
     Const,
     NotConst,
 }
 
 impl fmt::Display for Constness {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match *self {
+            Self::Comptime => "comptime",
             Self::Const => "const",
             Self::NotConst => "non-const",
         })

compiler/rustc_hir_pretty/src/lib.rs

@@ -2567,6 +2567,7 @@ impl<'a> State<'a> {
         match s {
             hir::Constness::NotConst => {}
             hir::Constness::Const => self.word_nbsp("const"),
+            hir::Constness::Comptime => self.word_nbsp("comptime"),
         }
     }
 

compiler/rustc_metadata/src/rmeta/table.rs

@@ -180,6 +180,7 @@ fixed_size_enum! {
     hir::Constness {
         ( NotConst )
         ( Const    )
+        ( Comptime )
     }
 }
 

compiler/rustc_middle/src/ty/adt.rs

@@ -247,6 +247,7 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
 
     fn destructor(self, tcx: TyCtxt<'tcx>) -> Option<AdtDestructorKind> {
         Some(match tcx.constness(self.destructor(tcx)?.did) {
+            hir::Constness::Comptime => todo!("FIXME(comptime)"),
             hir::Constness::Const => AdtDestructorKind::Const,
             hir::Constness::NotConst => AdtDestructorKind::NotConst,
         })

compiler/rustc_parse/src/parser/item.rs

@@ -2786,7 +2786,7 @@ impl<'a> Parser<'a> {
                     // that the keyword is already present and the second instance should be removed.
                     let wrong_kw = if self.check_keyword(exp!(Const)) {
                         match constness {
-                            Const::Yes(sp) => Some(WrongKw::Duplicated(sp)),
+                            Const::Comptime(sp) | Const::Yes(sp) => Some(WrongKw::Duplicated(sp)),
                             Const::No => {
                                 recover_constness = Const::Yes(self.token.span);
                                 match parsing_mode {

compiler/rustc_trait_selection/src/traits/effects.rs

@@ -435,6 +435,7 @@ fn evaluate_host_effect_for_destruct_goal<'tcx>(
                 .map(|field| ty::TraitRef::new(tcx, destruct_def_id, [field.ty(tcx, args)]))
                 .collect();
             match adt_def.destructor(tcx).map(|dtor| tcx.constness(dtor.did)) {
+                Some(hir::Constness::Comptime) => todo!("FIXME(comptime)"),
                 // `Drop` impl exists, but it's not const. Type cannot be `[const] Destruct`.
                 Some(hir::Constness::NotConst) => return Err(EvaluationFailure::NoSolution),
                 // `Drop` impl exists, and it's const. Require `Ty: [const] Drop` to hold.
@@ -530,6 +531,8 @@ fn evaluate_host_effect_for_fn_goal<'tcx>(
     };
 
     match tcx.constness(def) {
+        // FIXME(comptime)
+        hir::Constness::Comptime => Err(EvaluationFailure::NoSolution),
         hir::Constness::Const => Ok(tcx
             .const_conditions(def)
             .instantiate(tcx, args)