Start implementing #[type_const]

Author: camelid

compiler/rustc_feature/src/builtin_attrs.rs

@@ -576,6 +576,13 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         EncodeCrossCrate::Yes, experimental!(patchable_function_entry)
     ),
 
+    // Probably temporary component of min_generic_const_args.
+    // `#[type_const] const ASSOC: usize;`
+    gated!(
+        type_const, Normal, template!(Word), ErrorFollowing,
+        EncodeCrossCrate::Yes, min_generic_const_args, experimental!(type_const),
+    ),
+
     // ==========================================================================
     // Internal attributes: Stability, deprecation, and unsafe:
     // ==========================================================================

compiler/rustc_hir_analysis/src/collect.rs

@@ -557,7 +557,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
                     let item = self
                         .tcx
                         .hir()
-                        .expect_item(self.tcx.hir().get_parent_item(self.hir_id()).def_id);
+                        .expect_item(self.tcx.hir_get_parent_item(self.hir_id()).def_id);
                     match &item.kind {
                         hir::ItemKind::Enum(_, generics)
                         | hir::ItemKind::Struct(_, generics)

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2399,7 +2399,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let assoc_const = self
             .probe_assoc_item(assoc_ident, ty::AssocKind::Const, hir_ref_id, span, trait_did)
             .expect("failed to find associated const");
-        self.lower_assoc_const(span, assoc_const.def_id, assoc_segment, bound)
+        if assoc_const.has_type_const_attr(tcx) {
+            self.lower_assoc_const(span, assoc_const.def_id, assoc_segment, bound)
+        } else {
+            let mut err = tcx
+                .dcx()
+                .struct_span_err(span, "use of trait associated const without `#[type_const]`");
+            err.note("the declaration in the trait must be marked with `#[type_const]`");
+            Const::new_error(tcx, err.emit())
+        }
     }
 
     /// Literals are eagerly converted to a constant, everything else becomes `Unevaluated`.

compiler/rustc_middle/src/ty/assoc.rs

@@ -3,7 +3,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::def_id::DefId;
 use rustc_macros::{Decodable, Encodable, HashStable};
-use rustc_span::{Ident, Symbol};
+use rustc_span::{Ident, Symbol, sym};
 
 use super::{TyCtxt, Visibility};
 use crate::ty;
@@ -108,6 +108,23 @@ impl AssocItem {
     pub fn is_impl_trait_in_trait(&self) -> bool {
         self.opt_rpitit_info.is_some()
     }
+
+    /// Does this associated item have the `#[type_const]` attribute,
+    /// or (if it is in a trait impl), does the item from the original
+    /// trait have this attribute?
+    pub fn has_type_const_attr(&self, tcx: TyCtxt<'_>) -> bool {
+        if self.kind != ty::AssocKind::Const {
+            return false;
+        }
+
+        let def_id = match (self.container, self.trait_item_def_id) {
+            (AssocItemContainer::Trait, _) => self.def_id,
+            (AssocItemContainer::Impl, Some(trait_item_did)) => trait_item_did,
+            // Inherent impl but this attr is only applied to trait assoc items.
+            (AssocItemContainer::Impl, None) => return false,
+        };
+        tcx.has_attr(def_id, sym::type_const)
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Debug, HashStable, Eq, Hash, Encodable, Decodable)]

compiler/rustc_passes/src/check_attr.rs

@@ -14,6 +14,7 @@ use rustc_attr_parsing::{AttributeKind, ReprAttr, find_attr};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey};
 use rustc_feature::{AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute};
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalModDefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{
@@ -257,6 +258,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::coroutine, ..] => {
                             self.check_coroutine(attr, target);
                         }
+                        [sym::type_const, ..] => {
+                            self.check_type_const(hir_id,attr, target);
+                        }
                         [sym::linkage, ..] => self.check_linkage(attr, span, target),
                         [sym::rustc_pub_transparent, ..] => self.check_rustc_pub_transparent(attr.span(), span, attrs),
                         [
@@ -2519,6 +2523,23 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
+    fn check_type_const(&self, hir_id: HirId, attr: &Attribute, target: Target) {
+        let tcx = self.tcx;
+        if target == Target::AssocConst
+            && let parent = tcx.parent(hir_id.expect_owner().to_def_id())
+            && self.tcx.def_kind(parent) == DefKind::Trait
+        {
+            return;
+        } else {
+            self.dcx()
+                .struct_span_err(
+                    attr.span(),
+                    "`#[type_const]` must only be applied to trait associated constants",
+                )
+                .emit();
+        }
+    }
+
     fn check_linkage(&self, attr: &Attribute, span: Span, target: Target) {
         match target {
             Target::Fn

compiler/rustc_span/src/symbol.rs

@@ -2083,6 +2083,7 @@ symbols! {
         type_ascribe,
         type_ascription,
         type_changing_struct_update,
+        type_const,
         type_id,
         type_ir_inherent,
         type_length_limit,

tests/ui/const-generics/mgca/assoc-const-without-type_const.rs

@@ -0,0 +1,14 @@
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
+
+pub trait Tr {
+    const SIZE: usize;
+}
+
+fn mk_array<T: Tr>(_x: T) -> [(); T::SIZE] {
+    //~^ ERROR type_const
+    [(); T::SIZE]
+    //~^ ERROR type_const
+}
+
+fn main() {}

tests/ui/const-generics/mgca/assoc-const-without-type_const.stderr

@@ -0,0 +1,18 @@
+error: use of trait associated const without `#[type_const]`
+  --> $DIR/assoc-const-without-type_const.rs:8:35
+   |
+LL | fn mk_array<T: Tr>(_x: T) -> [(); T::SIZE] {
+   |                                   ^^^^^^^
+   |
+   = note: the declaration in the trait must be marked with `#[type_const]`
+
+error: use of trait associated const without `#[type_const]`
+  --> $DIR/assoc-const-without-type_const.rs:10:10
+   |
+LL |     [(); T::SIZE]
+   |          ^^^^^^^
+   |
+   = note: the declaration in the trait must be marked with `#[type_const]`
+
+error: aborting due to 2 previous errors
+

tests/ui/const-generics/mgca/assoc-const.rs

@@ -4,6 +4,7 @@
 #![allow(incomplete_features)]
 
 pub trait Tr {
+    #[type_const]
     const SIZE: usize;
 }
 

tests/ui/const-generics/mgca/bad-type_const-syntax.rs

@@ -0,0 +1,17 @@
+trait Tr {
+    #[type_const()]
+    //~^ ERROR malformed
+    //~| ERROR experimental
+    const N: usize;
+}
+
+struct S;
+
+impl Tr for S {
+    #[type_const]
+    //~^ ERROR must only be applied to trait associated constants
+    //~| ERROR experimental
+    const N: usize = 0;
+}
+
+fn main() {}