Require const blocks to only use const stable things

Author: oli-obk

compiler/rustc_ast_lowering/src/asm.rs

@@ -197,7 +197,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         }
                     }
                     InlineAsmOperand::Const { anon_const } => hir::InlineAsmOperand::Const {
-                        anon_const: self.lower_const_block(anon_const),
+                        anon_const: self.lower_const_block(anon_const, &[]),
                     },
                     InlineAsmOperand::Sym { sym } => {
                         let static_def_id = self

compiler/rustc_ast_lowering/src/expr.rs

@@ -106,7 +106,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
             let kind = match &e.kind {
                 ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
-                ExprKind::ConstBlock(c) => hir::ExprKind::ConstBlock(self.lower_const_block(c)),
+                ExprKind::ConstBlock(c) => {
+                    hir::ExprKind::ConstBlock(self.lower_const_block(c, attrs))
+                }
                 ExprKind::Repeat(expr, count) => {
                     let expr = self.lower_expr(expr);
                     let count = self.lower_array_length_to_const_arg(count);
@@ -391,12 +393,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
         })
     }
 
-    pub(crate) fn lower_const_block(&mut self, c: &AnonConst) -> hir::ConstBlock {
+    pub(crate) fn lower_const_block(
+        &mut self,
+        c: &AnonConst,
+        attrs: &'hir [hir::Attribute],
+    ) -> hir::ConstBlock {
         self.with_new_scopes(c.value.span, |this| {
             let def_id = this.local_def_id(c.id);
+            let hir_id = this.lower_node_id(c.id);
+            if !attrs.is_empty() {
+                this.attrs.insert(hir_id.local_id, attrs);
+            }
             hir::ConstBlock {
                 def_id,
-                hir_id: this.lower_node_id(c.id),
+                hir_id,
                 body: this.lower_const_body(c.value.span, Some(&c.value)),
             }
         })

compiler/rustc_ast_lowering/src/pat.rs

@@ -399,7 +399,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             ExprKind::Lit(lit) => {
                 hir::PatExprKind::Lit { lit: self.lower_lit(lit, span), negated: false }
             }
-            ExprKind::ConstBlock(c) => hir::PatExprKind::ConstBlock(self.lower_const_block(c)),
+            ExprKind::ConstBlock(c) => hir::PatExprKind::ConstBlock(self.lower_const_block(c, &[])),
             ExprKind::IncludedBytes(byte_sym) => hir::PatExprKind::Lit {
                 lit: respan(span, LitKind::ByteStr(*byte_sym, StrStyle::Cooked)),
                 negated: false,

compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs

@@ -63,6 +63,7 @@ impl<S: Stage> CombineAttributeParser<S> for AllowConstFnUnstableParser {
         Allow(Target::Method(MethodKind::Inherent)),
         Allow(Target::Method(MethodKind::Trait { body: true })),
         Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Expression), // FIXME: should only allow inline consts
     ]);
     const TEMPLATE: AttributeTemplate = template!(Word, List: &["feat1, feat2, ..."]);
 

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -255,6 +255,7 @@ impl<S: Stage> AttributeParser<S> for ConstStabilityParser {
         Allow(Target::AssocConst),
         Allow(Target::Trait),
         Allow(Target::Static),
+        Allow(Target::Expression), // FIXME: we really only want to allow inline consts
         Allow(Target::Crate),
         Allow(Target::MacroDef), // FIXME(oli-obk): remove this and eliminate the manual check for it
     ]);

compiler/rustc_const_eval/src/check_consts/mod.rs

@@ -54,9 +54,11 @@ impl<'mir, 'tcx> ConstCx<'mir, 'tcx> {
     pub fn enforce_recursive_const_stability(&self) -> bool {
         // We can skip this if neither `staged_api` nor `-Zforce-unstable-if-unmarked` are enabled,
         // since in such crates `lookup_const_stability` will always be `None`.
-        self.const_kind == Some(hir::ConstContext::ConstFn)
-            && (self.tcx.features().staged_api()
-                || self.tcx.sess.opts.unstable_opts.force_unstable_if_unmarked)
+        matches!(
+            self.const_kind,
+            Some(hir::ConstContext::ConstFn | hir::ConstContext::Const { inline: true })
+        ) && (self.tcx.features().staged_api()
+            || self.tcx.sess.opts.unstable_opts.force_unstable_if_unmarked)
             && is_fn_or_trait_safe_to_expose_on_stable(self.tcx, self.def_id().to_def_id())
     }
 

compiler/rustc_passes/src/stability.rs

@@ -601,7 +601,6 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     let attrs = self.tcx.hir_attrs(item.hir_id());
                     let stab = find_attr!(attrs, AttributeKind::Stability{stability, span} => (*stability, *span));
 
-                    // FIXME(jdonszelmann): make it impossible to miss the or_else in the typesystem
                     let const_stab = find_attr!(attrs, AttributeKind::ConstStability{stability, ..} => *stability);
 
                     let unstable_feature_stab =

library/alloc/src/boxed/thin.rs

@@ -321,7 +321,12 @@ impl<H> WithHeader<H> {
         // of the header, past the padding, so the assigned type makes sense.
         // It also ensures that the address at the end of the header is sufficiently
         // aligned for T.
-        let alloc: &<Dyn as Pointee>::Metadata = const {
+        // We generate the vtable in a const block instead of having the compiler
+        // generate it for us. The basics to allocate new memory during ctfe are
+        // unstable, but we can always change the intrinsic logic to support the
+        // needs of new_unsize_zst in the future.
+        let alloc: &<Dyn as Pointee>::Metadata = #[rustc_allow_const_fn_unstable(const_heap)]
+        const {
             // FIXME: just call `WithHeader::alloc_layout` with size reset to 0.
             // Currently that's blocked on `Layout::extend` not being `const fn`.
 

library/core/src/any.rs

@@ -864,7 +864,10 @@ impl fmt::Debug for TypeId {
 #[stable(feature = "type_name", since = "1.38.0")]
 #[rustc_const_unstable(feature = "const_type_name", issue = "63084")]
 pub const fn type_name<T: ?Sized>() -> &'static str {
-    const { intrinsics::type_name::<T>() }
+    #[rustc_const_unstable(feature = "const_type_name", issue = "63084")]
+    const {
+        intrinsics::type_name::<T>()
+    }
 }
 
 /// Returns the type name of the pointed-to value as a string slice.

library/core/src/intrinsics/mod.rs

@@ -2881,6 +2881,7 @@ pub const fn type_name<T: ?Sized>() -> &'static str;
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
+#[rustc_intrinsic_const_stable_indirect]
 pub const fn type_id<T: ?Sized + 'static>() -> crate::any::TypeId;
 
 /// Tests (at compile-time) if two [`crate::any::TypeId`] instances identify the