Add very basic "comptime" fn implementation

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_attr_parsing/src/attributes/semantics.rs

@@ -7,3 +7,14 @@ impl<S: Stage> NoArgsAttributeParser<S> for MayDangleParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS); //FIXME Still checked fully in `check_attr.rs`
     const CREATE: fn(span: Span) -> AttributeKind = AttributeKind::MayDangle;
 }
+
+pub(crate) struct ComptimeParser;
+impl<S: Stage> NoArgsAttributeParser<S> for ComptimeParser {
+    const PATH: &[Symbol] = &[sym::rustc_comptime];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Fn),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Comptime;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -58,7 +58,7 @@ use crate::attributes::rustc_internal::{
     RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser, RustcMainParser,
     RustcObjectLifetimeDefaultParser, RustcSimdMonomorphizeLaneLimitParser,
 };
-use crate::attributes::semantics::MayDangleParser;
+use crate::attributes::semantics::{ComptimeParser, MayDangleParser};
 use crate::attributes::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
 };
@@ -216,6 +216,7 @@ attribute_parsers!(
         Single<WithoutArgs<AutomaticallyDerivedParser>>,
         Single<WithoutArgs<CoinductiveParser>>,
         Single<WithoutArgs<ColdParser>>,
+        Single<WithoutArgs<ComptimeParser>>,
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<CoroutineParser>>,

compiler/rustc_const_eval/src/const_eval/fn_queries.rs

@@ -32,8 +32,8 @@ fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness {
         hir::Node::Expr(e) if let hir::ExprKind::Closure(c) = e.kind => c.constness,
         _ => {
             if let Some(fn_kind) = node.fn_kind() {
-                if fn_kind.constness() == hir::Constness::Const {
-                    return hir::Constness::Const;
+                if fn_kind.constness() != hir::Constness::NotConst {
+                    return fn_kind.constness();
                 }
 
                 // If the function itself is not annotated with `const`, it may still be a `const fn`

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1390,6 +1390,11 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         rustc_force_inline, Normal, template!(Word, NameValueStr: "reason"), WarnFollowing, EncodeCrossCrate::Yes,
         "`#[rustc_force_inline]` forces a free function to be inlined"
     ),
+    rustc_attr!(
+        rustc_comptime, Normal, template!(Word), ErrorFollowing,
+        EncodeCrossCrate::Yes,
+        "the `#[rustc_comptime]` attribute is just used to avoid adding syntax for `comptime fn`"
+    ),
 
     // ==========================================================================
     // Internal attributes, Testing:

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -479,6 +479,9 @@ pub enum AttributeKind {
     /// Represents `#[cold]`.
     Cold(Span),
 
+    /// Represents `#[rustc_comptime]`
+    Comptime(Span),
+
     /// Represents `#[rustc_confusables]`.
     Confusables {
         symbols: ThinVec<Symbol>,

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -28,6 +28,7 @@ impl AttributeKind {
             BodyStability { .. } => No,
             Coinductive(..) => No,
             Cold(..) => No,
+            Comptime(..) => Yes,
             Confusables { .. } => Yes,
             ConstContinue(..) => No,
             ConstStability { .. } => Yes,

compiler/rustc_hir/src/hir.rs

@@ -2264,10 +2264,12 @@ pub enum ConstContext {
     /// - Array length expressions
     /// - Enum discriminants
     /// - Const generics
-    ///
-    /// For the most part, other contexts are treated just like a regular `const`, so they are
-    /// lumped into the same category.
-    Const { inline: bool },
+    Const {
+        /// For backwards compatibility `const` items allow
+        /// calls to `const fn` to get promoted.
+        /// We forbid that in comptime fns and inline consts.
+        allow_const_fn_promotion: bool,
+    },
 }
 
 impl ConstContext {
@@ -4225,13 +4227,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_hir_typeck/src/callee.rs

@@ -917,7 +917,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return;
         }
 
-        let host = match self.tcx.hir_body_const_context(self.body_id) {
+        let const_context = self.tcx.hir_body_const_context(self.body_id);
+
+        if let hir::Constness::Comptime = self.tcx.constness(callee_did) {
+            match const_context {
+                Some(hir::ConstContext::Const { .. } | hir::ConstContext::Static(_)) => {}
+                Some(hir::ConstContext::ConstFn) | None => {
+                    self.dcx().span_err(span, "comptime fns can only be called at compile time");
+                }
+            }
+        }
+
+        let host = match const_context {
             Some(hir::ConstContext::Const { .. } | hir::ConstContext::Static(_)) => {
                 ty::BoundConstness::Const
             }

compiler/rustc_metadata/src/rmeta/table.rs

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

compiler/rustc_middle/src/hir/map.rs

@@ -314,12 +314,18 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn hir_body_const_context(self, def_id: LocalDefId) -> Option<ConstContext> {
         let def_id = def_id.into();
         let ccx = match self.hir_body_owner_kind(def_id) {
-            BodyOwnerKind::Const { inline } => ConstContext::Const { inline },
+            BodyOwnerKind::Const { inline } => {
+                ConstContext::Const { allow_const_fn_promotion: !inline }
+            }
             BodyOwnerKind::Static(mutability) => ConstContext::Static(mutability),
 
             BodyOwnerKind::Fn if self.is_constructor(def_id) => return None,
             BodyOwnerKind::Fn | BodyOwnerKind::Closure if self.is_const_fn(def_id) => {
-                ConstContext::ConstFn
+                if self.constness(def_id) == rustc_hir::Constness::Comptime {
+                    ConstContext::Const { allow_const_fn_promotion: false }
+                } else {
+                    ConstContext::ConstFn
+                }
             }
             BodyOwnerKind::Fn if self.is_const_default_method(def_id) => ConstContext::ConstFn,
             BodyOwnerKind::Fn | BodyOwnerKind::Closure | BodyOwnerKind::GlobalAsm => return None,

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_middle/src/ty/mod.rs

@@ -2138,7 +2138,7 @@ impl<'tcx> TyCtxt<'tcx> {
         matches!(
             self.def_kind(def_id),
             DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::Closure
-        ) && self.constness(def_id) == hir::Constness::Const
+        ) && self.constness(def_id) != hir::Constness::NotConst
     }
 
     /// Whether this item is conditionally constant for the purposes of the

compiler/rustc_mir_transform/src/promote_consts.rs

@@ -668,7 +668,10 @@ impl<'tcx> Validator<'_, 'tcx> {
         // backwards compatibility reason to allow more promotion inside of them.
         let promote_all_fn = matches!(
             self.const_kind,
-            Some(hir::ConstContext::Static(_) | hir::ConstContext::Const { inline: false })
+            Some(
+                hir::ConstContext::Static(_)
+                    | hir::ConstContext::Const { allow_const_fn_promotion: false }
+            )
         );
         if !promote_all_fn {
             return Err(Unpromotable);

compiler/rustc_parse/messages.ftl

@@ -143,6 +143,11 @@ parse_compound_assignment_expression_in_let = can't reassign to an uninitialized
     .suggestion = initialize the variable
     .help = if you meant to overwrite, remove the `let` binding
 
+parse_const_comptime_fn = a function cannot be both `comptime` and `const`
+    .suggestion = remove the `const`
+    .label = `comptime` because of this
+    .note = `const` implies the function can be called at runtime, too
+
 parse_const_generic_without_braces = expressions must be enclosed in braces to be used as const generic arguments
     .suggestion = enclose the `const` expression in braces
 

compiler/rustc_parse/src/errors.rs

@@ -1686,6 +1686,16 @@ pub(crate) struct UnexpectedIfWithIf(
     pub Span,
 );
 
+#[derive(Diagnostic)]
+#[diag(parse_const_comptime_fn)]
+pub(crate) struct ConstComptimeFn {
+    #[primary_span]
+    #[suggestion(applicability = "machine-applicable", code = "")]
+    pub span: Span,
+    #[label]
+    pub attr_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_maybe_fn_typo_with_impl)]
 pub(crate) struct FnTypoWithImpl {

compiler/rustc_parse/src/parser/item.rs

@@ -2449,7 +2449,20 @@ impl<'a> Parser<'a> {
         case: Case,
     ) -> PResult<'a, (Ident, FnSig, Generics, Option<Box<FnContract>>, Option<Box<Block>>)> {
         let fn_span = self.token.span;
-        let header = self.parse_fn_front_matter(vis, case, FrontMatterParsingMode::Function)?; // `const ... fn`
+        let mut header = self.parse_fn_front_matter(vis, case, FrontMatterParsingMode::Function)?; // `const ... fn`
+        if let Some(attr) = attrs.iter().find(|attr| attr.has_name(sym::rustc_comptime)) {
+            match std::mem::replace(&mut header.constness, Const::Comptime(attr.span)) {
+                Const::Comptime(_) => unreachable!("there is no syntax for comptime fn"),
+                // A function can't be `const` and `comptime` at the same time
+                Const::Yes(span) => {
+                    return Err(self
+                        .dcx()
+                        .create_err(errors::ConstComptimeFn { span, attr_span: attr.span }));
+                }
+                // Good
+                Const::No => {}
+            }
+        }
         let ident = self.parse_ident()?; // `foo`
         let mut generics = self.parse_generics()?; // `<'a, T, ...>`
         let decl = match self.parse_fn_decl(&fn_parse_mode, AllowPlus::Yes, RecoverReturnSign::Yes)
@@ -2786,7 +2799,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_passes/src/check_attr.rs

@@ -232,6 +232,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Marker(..)
                     | AttributeKind::SkipDuringMethodDispatch { .. }
                     | AttributeKind::Coinductive(..)
+                    | AttributeKind::Comptime(..)
                     | AttributeKind::DenyExplicitImpl(..)
                     | AttributeKind::DoNotImplementViaObject(..)
                     | AttributeKind::SpecializationTrait(..)

compiler/rustc_span/src/symbol.rs

@@ -1907,6 +1907,7 @@ symbols! {
         rustc_clean,
         rustc_coherence_is_core,
         rustc_coinductive,
+        rustc_comptime,
         rustc_confusables,
         rustc_const_stable,
         rustc_const_stable_indirect,

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)

src/librustdoc/html/format.rs

@@ -1445,14 +1445,18 @@ pub(crate) fn print_constness_with_space(
     const_stab: Option<ConstStability>,
 ) -> &'static str {
     match c {
-        hir::Constness::Const => match (overall_stab, const_stab) {
+        hir::Constness::Comptime | hir::Constness::Const => match (overall_stab, const_stab) {
             // const stable...
             (_, Some(ConstStability { level: StabilityLevel::Stable { .. }, .. }))
             // ...or when feature(staged_api) is not set...
             | (_, None)
             // ...or when const unstable, but overall unstable too
             | (None, Some(ConstStability { level: StabilityLevel::Unstable { .. }, .. })) => {
-                "const "
+                match c {
+                    hir::Constness::Comptime => "comptime ",
+                    hir::Constness::Const => "const ",
+                    _ => unreachable!(),
+                }
             }
             // const unstable (and overall stable)
             (Some(_), Some(ConstStability { level: StabilityLevel::Unstable { .. }, .. })) => "",

src/tools/rustfmt/src/utils.rs

@@ -86,6 +86,7 @@ pub(crate) fn format_coro(coroutine_kind: &ast::CoroutineKind) -> &'static str {
 #[inline]
 pub(crate) fn format_constness(constness: ast::Const) -> &'static str {
     match constness {
+        ast::Const::Comptime(..) => "comptime ",
         ast::Const::Yes(..) => "const ",
         ast::Const::No => "",
     }
@@ -94,6 +95,7 @@ pub(crate) fn format_constness(constness: ast::Const) -> &'static str {
 #[inline]
 pub(crate) fn format_constness_right(constness: ast::Const) -> &'static str {
     match constness {
+        ast::Const::Comptime(..) => " comptime",
         ast::Const::Yes(..) => " const",
         ast::Const::No => "",
     }

tests/ui/comptime/const_comptime.rs

@@ -0,0 +1,7 @@
+#![feature(rustc_attrs)]
+
+#[rustc_comptime]
+const fn foo() {}
+//~^ ERROR a function cannot be both `comptime` and `const`
+
+fn main() {}

tests/ui/comptime/const_comptime.stderr

@@ -0,0 +1,10 @@
+error: a function cannot be both `comptime` and `const`
+  --> $DIR/const_comptime.rs:4:1
+   |
+LL | #[rustc_comptime]
+   | ----------------- `comptime` because of this
+LL | const fn foo() {}
+   | ^^^^^ help: remove the `const`
+
+error: aborting due to 1 previous error
+

tests/ui/comptime/not_callable.rs

@@ -0,0 +1,24 @@
+#![feature(rustc_attrs, const_trait_impl)]
+
+#[rustc_comptime]
+fn foo() {}
+
+fn main() {
+    // Ok
+    const { foo() };
+    // Not ok
+    foo();
+    //~^ ERROR: comptime fns can only be called at compile time
+}
+
+const fn bar() {
+    // Not ok
+    foo();
+    //~^ ERROR: comptime fns can only be called at compile time
+}
+
+#[rustc_comptime]
+fn baz() {
+    // Ok
+    foo();
+}