Update comments and error message to use new syntax instead of old type_const attribute.

Author: Keith-Cancel

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -345,7 +345,7 @@ where
     let uneval = match constant.const_ {
         Const::Ty(_, ct) => match ct.kind() {
             ty::ConstKind::Param(_) | ty::ConstKind::Error(_) => None,
-            // Unevaluated consts in MIR bodies don't have associated MIR (e.g. `#[type_const]`).
+            // Unevaluated consts in MIR bodies don't have associated MIR (e.g. `type const`).
             ty::ConstKind::Unevaluated(_) => None,
             // FIXME(mgca): Investigate whether using `None` for `ConstKind::Value` is overly
             // strict, and if instead we should be doing some kind of value-based analysis.

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -394,7 +394,7 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
     typing_env: ty::TypingEnv<'tcx>,
 ) -> Result<R, ErrorHandled> {
     let def = cid.instance.def.def_id();
-    // #[type_const] don't have bodys
+    // `type const` don't have bodys
     debug_assert!(!tcx.is_type_const(def), "CTFE tried to evaluate type-const: {:?}", def);
 
     let is_static = tcx.is_static(def);

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -2060,14 +2060,14 @@ fn compare_type_const<'tcx>(
             .dcx()
             .struct_span_err(
                 tcx.def_span(impl_const_item.def_id),
-                "implementation of `#[type_const]` const must be marked with `#[type_const]`",
+                "implementation of a `type const` must also be marked as `type const`",
             )
             .with_span_note(
                 MultiSpan::from_spans(vec![
                     tcx.def_span(trait_const_item.def_id),
                     trait_type_const_span,
                 ]),
-                "trait declaration of const is marked with `#[type_const]`",
+                "trait declaration of const is marked as `type const`",
             )
             .emit());
     }

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -420,17 +420,17 @@ fn infer_placeholder_type<'tcx>(
     kind: &'static str,
 ) -> Ty<'tcx> {
     let tcx = cx.tcx();
-    // If the type is omitted on a #[type_const] we can't run
+    // If the type is omitted on a `type const` we can't run
     // type check on since that requires the const have a body
-    // which type_consts don't.
+    // which `type const`s don't.
     let ty = if tcx.is_type_const(def_id.to_def_id()) {
         if let Some(trait_item_def_id) = tcx.trait_item_of(def_id.to_def_id()) {
             tcx.type_of(trait_item_def_id).instantiate_identity()
         } else {
             Ty::new_error_with_message(
                 tcx,
                 ty_span,
-                "constant with #[type_const] requires an explicit type",
+                "constant with `type const` requires an explicit type",
             )
         }
     } else {

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -607,14 +607,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                             if tcx.features().min_generic_const_args() {
                                 let mut err = self.dcx().struct_span_err(
                                     constraint.span,
-                                    "use of trait associated const without `#[type_const]`",
+                                    "use of trait associated const not defined as `type const`",
                                 );
-                                err.note("the declaration in the trait must be marked with `#[type_const]`");
+                                err.note("the declaration in the trait must begin with `type const` not just `const` alone");
                                 return Err(err.emit());
                             } else {
                                 let err = self.dcx().span_delayed_bug(
                                     constraint.span,
-                                    "use of trait associated const without `#[type_const]`",
+                                    "use of trait associated const defined as `type const`",
                                 );
                                 return Err(err);
                             }

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2844,19 +2844,20 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         if tcx.is_type_const(def_id) {
             Ok(())
         } else {
-            let mut err = self
-                .dcx()
-                .struct_span_err(span, "use of `const` in the type system without `#[type_const]`");
+            let mut err = self.dcx().struct_span_err(
+                span,
+                "use of `const` in the type system not defined as `type const`",
+            );
             if def_id.is_local() {
                 let name = tcx.def_path_str(def_id);
                 err.span_suggestion(
                     tcx.def_span(def_id).shrink_to_lo(),
-                    format!("add `#[type_const]` attribute to `{name}`"),
-                    format!("#[type_const]\n"),
+                    format!("add `type` before `const` for `{name}`"),
+                    format!("type const\n"),
                     Applicability::MaybeIncorrect,
                 );
             } else {
-                err.note("only consts marked with `#[type_const]` may be used in types");
+                err.note("only consts marked defined as `type const` may be used in types");
             }
             Err(err.emit())
         }

compiler/rustc_middle/src/queries.rs

@@ -293,13 +293,13 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    /// Returns the const of the RHS of a (free or assoc) const item, if it is a `#[type_const]`.
+    /// Returns the const of the RHS of a (free or assoc) const item, if it is a `type const`.
     ///
     /// When a const item is used in a type-level expression, like in equality for an assoc const
     /// projection, this allows us to retrieve the typesystem-appropriate representation of the
     /// const value.
     ///
-    /// This query will ICE if given a const that is not marked with `#[type_const]`.
+    /// This query will ICE if given a const that is not marked with `type const`.
     query const_of_item(def_id: DefId) -> ty::EarlyBinder<'tcx, ty::Const<'tcx>> {
         desc { |tcx| "computing the type-level value for `{}`", tcx.def_path_str(def_id)  }
         cache_on_disk_if { def_id.is_local() }

compiler/rustc_middle/src/traits/mod.rs

@@ -845,7 +845,7 @@ impl DynCompatibilityViolation {
                 format!("it contains generic associated const `{name}`").into()
             }
             Self::AssocConst(name, AssocConstViolation::NonType, _) => {
-                format!("it contains associated const `{name}` that's not marked `#[type_const]`")
+                format!("it contains associated const `{name}` that's not defined as `type const`")
                     .into()
             }
             Self::AssocConst(name, AssocConstViolation::TypeReferencesSelf, _) => format!(
@@ -999,7 +999,7 @@ pub enum AssocConstViolation {
     /// Has own generic parameters (GAC).
     Generic,
 
-    /// Isn't marked `#[type_const]`.
+    /// Isn't defined as `type const`.
     NonType,
 
     /// Its type mentions the `Self` type parameter.

compiler/rustc_middle/src/ty/context.rs

@@ -2928,7 +2928,7 @@ impl<'tcx> TyCtxt<'tcx> {
     ) -> bool {
         let generics = self.generics_of(def_id);
 
-        // IATs and IACs (inherent associated types/consts with #[type_const]) themselves have a
+        // IATs and IACs (inherent associated types/consts with `type const`) themselves have a
         // weird arg setup (self + own args), but nested items *in* IATs (namely: opaques, i.e.
         // ATPITs) do not.
         let is_inherent_assoc_ty = matches!(self.def_kind(def_id), DefKind::AssocTy)

compiler/rustc_passes/src/reachable.rs

@@ -209,7 +209,7 @@ impl<'tcx> ReachableContext<'tcx> {
                             self.visit_nested_body(body);
                         }
                     }
-                    // For #[type_const] we want to evaluate the RHS.
+                    // For `type const` we want to evaluate the RHS.
                     hir::ItemKind::Const(_, _, _, init @ hir::ConstItemRhs::TypeConst(_)) => {
                         self.visit_const_item_rhs(init);
                     }