fix associated_const_equality tests

Author: BoxyUwU

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -5,6 +5,8 @@ use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
+use rustc_hir::find_attr;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::PolyTraitRef;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
@@ -573,7 +575,26 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                                 term,
                             })
                         });
-                        bounds.push((bound.upcast(tcx), constraint.span));
+
+                        if let ty::AssocTag::Const = assoc_tag
+                            && !find_attr!(self.tcx().get_all_attrs(assoc_item.def_id), AttributeKind::TypeConst(_))
+                        {
+                            if tcx.features().min_generic_const_args() ||
+                                tcx.features().associated_const_equality()
+                            {
+                                let mut err = self.dcx().struct_span_err(
+                                    constraint.span,
+                                    "use of trait associated const without `#[type_const]`",
+                                );
+                                err.note("the declaration in the trait must be marked with `#[type_const]`");
+                                return Err(err.emit());
+                            } else {
+                                let err = self.dcx().span_delayed_bug(constraint.span, "use of trait associated const without `#[type_const]`");
+                                return Err(err);
+                            }
+                        } else {
+                            bounds.push((bound.upcast(tcx), constraint.span));
+                        }
                     }
                     // SelfTraitThatDefines is only interested in trait predicates.
                     PredicateFilter::SelfTraitThatDefines(_) => {}

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -29,7 +29,8 @@ use rustc_errors::{
 };
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::{self as hir, AnonConst, GenericArg, GenericArgs, HirId};
+use rustc_hir::{self as hir, find_attr, AnonConst, GenericArg, GenericArgs, HirId};
+use rustc_hir::attrs::AttributeKind;
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::DynCompatibilityViolation;
 use rustc_macros::{TypeFoldable, TypeVisitable};
@@ -1231,7 +1232,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             LowerTypeRelativePathMode::Const,
         )? {
             TypeRelativePath::AssocItem(def_id, args) => {
-                if !tcx.associated_item(def_id).is_type_const_capable(tcx) {
+                if !find_attr!(self.tcx().get_all_attrs(def_id), AttributeKind::TypeConst(_)) {
                     let mut err = self.dcx().struct_span_err(
                         span,
                         "use of trait associated const without `#[type_const]`",
@@ -1672,6 +1673,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             ty::AssocTag::Const,
         ) {
             Ok((item_def_id, item_args)) => {
+                if !find_attr!(self.tcx().get_all_attrs(item_def_id), AttributeKind::TypeConst(_)) {
+                    let mut err = self.dcx().struct_span_err(
+                        span,
+                        "use of `const` in the type system without `#[type_const]`",
+                    );
+                    err.note("the declaration must be marked with `#[type_const]`");
+                    return Const::new_error(self.tcx(), err.emit());
+                }
+
                 let uv = ty::UnevaluatedConst::new(item_def_id, item_args);
                 Const::new_unevaluated(self.tcx(), uv)
             }

compiler/rustc_middle/src/ty/assoc.rs

@@ -1,9 +1,7 @@
 use rustc_data_structures::sorted_map::SortedIndexMultiMap;
 use rustc_hir as hir;
-use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::def_id::DefId;
-use rustc_hir::find_attr;
 use rustc_macros::{Decodable, Encodable, HashStable};
 use rustc_span::{ErrorGuaranteed, Ident, Symbol};
 
@@ -173,24 +171,6 @@ impl AssocItem {
     pub fn is_impl_trait_in_trait(&self) -> bool {
         matches!(self.kind, AssocKind::Type { data: AssocTypeData::Rpitit(_) })
     }
-
-    /// Returns true if:
-    /// - This trait associated item has the `#[type_const]` attribute,
-    /// - If it is in a trait impl, the item from the original trait has this attribute, or
-    /// - It is an inherent assoc const.
-    pub fn is_type_const_capable(&self, tcx: TyCtxt<'_>) -> bool {
-        if !matches!(self.kind, ty::AssocKind::Const { .. }) {
-            return false;
-        }
-
-        let def_id = match self.container {
-            AssocContainer::Trait => self.def_id,
-            AssocContainer::TraitImpl(Ok(trait_item_did)) => trait_item_did,
-            AssocContainer::TraitImpl(Err(_)) => return false,
-            AssocContainer::InherentImpl => return true,
-        };
-        find_attr!(tcx.get_all_attrs(def_id), AttributeKind::TypeConst(_))
-    }
 }
 
 #[derive(Copy, Clone, PartialEq, Debug, HashStable, Eq, Hash, Encodable, Decodable)]

compiler/rustc_passes/src/check_attr.rs

@@ -2047,18 +2047,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_type_const(&self, hir_id: HirId, attr_span: Span, 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
-        {
+    fn check_type_const(&self, _hir_id: HirId, attr_span: Span, target: Target) {
+        if matches!(target, Target::AssocConst | Target::Const) {
             return;
         } else {
             self.dcx()
                 .struct_span_err(
                     attr_span,
-                    "`#[type_const]` must only be applied to trait associated constants",
+                    "`#[type_const]` must only be applied to const items",
                 )
                 .emit();
         }

tests/ui/associated-consts/assoc-const-eq-ambiguity.rs

@@ -1,17 +1,27 @@
 // We used to say "ambiguous associated type" on ambiguous associated consts.
 // Ensure that we now use the correct label.
 
-#![feature(associated_const_equality)]
+#![feature(associated_const_equality, min_generic_const_args)]
+#![allow(incomplete_features)]
 
 trait Trait0: Parent0<i32> + Parent0<u32> {}
-trait Parent0<T> { const K: (); }
+trait Parent0<T> {
+    #[type_const]
+    const K: ();
+}
 
 fn take0(_: impl Trait0<K = { () }>) {}
 //~^ ERROR ambiguous associated constant `K` in bounds of `Trait0`
 
 trait Trait1: Parent1 + Parent2 {}
-trait Parent1 { const C: i32; }
-trait Parent2 { const C: &'static str; }
+trait Parent1 { 
+    #[type_const]
+    const C: i32;
+}
+trait Parent2 {
+    #[type_const]
+    const C: &'static str;
+}
 
 fn take1(_: impl Trait1<C = "?">) {}
 //~^ ERROR ambiguous associated constant `C` in bounds of `Trait1`

tests/ui/associated-consts/assoc-const-eq-ambiguity.stderr

@@ -1,12 +1,12 @@
 error[E0222]: ambiguous associated constant `K` in bounds of `Trait0`
-  --> $DIR/assoc-const-eq-ambiguity.rs:9:25
+  --> $DIR/assoc-const-eq-ambiguity.rs:13:25
    |
-LL | trait Parent0<T> { const K: (); }
-   |                    -----------
-   |                    |
-   |                    ambiguous `K` from `Parent0<u32>`
-   |                    ambiguous `K` from `Parent0<i32>`
-LL |
+LL |     const K: ();
+   |     -----------
+   |     |
+   |     ambiguous `K` from `Parent0<u32>`
+   |     ambiguous `K` from `Parent0<i32>`
+...
 LL | fn take0(_: impl Trait0<K = { () }>) {}
    |                         ^^^^^^^^^^ ambiguous associated constant `K`
    |
@@ -17,13 +17,14 @@ LL | fn take0(_: impl Trait0<K = { () }>) {}
                    T: Parent0<i32>::K = { () }
 
 error[E0222]: ambiguous associated constant `C` in bounds of `Trait1`
-  --> $DIR/assoc-const-eq-ambiguity.rs:16:25
+  --> $DIR/assoc-const-eq-ambiguity.rs:26:25
    |
-LL | trait Parent1 { const C: i32; }
-   |                 ------------ ambiguous `C` from `Parent1`
-LL | trait Parent2 { const C: &'static str; }
-   |                 --------------------- ambiguous `C` from `Parent2`
-LL |
+LL |     const C: i32;
+   |     ------------ ambiguous `C` from `Parent1`
+...
+LL |     const C: &'static str;
+   |     --------------------- ambiguous `C` from `Parent2`
+...
 LL | fn take1(_: impl Trait1<C = "?">) {}
    |                         ^^^^^^^ ambiguous associated constant `C`
 

tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.rs

@@ -1,8 +1,10 @@
 // Check that we eventually catch types of assoc const bounds
 // (containing late-bound vars) that are ill-formed.
-#![feature(associated_const_equality)]
+#![feature(associated_const_equality, min_generic_const_args)]
+#![allow(incomplete_features)]
 
 trait Trait<T> {
+    #[type_const]
     const K: T;
 }
 

tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.stderr

@@ -1,19 +1,19 @@
 error: higher-ranked subtype error
-  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:12:13
+  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:14:13
    |
 LL |         K = { () }
    |             ^^^^^^
 
 error: higher-ranked subtype error
-  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:12:13
+  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:14:13
    |
 LL |         K = { () }
    |             ^^^^^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: implementation of `Project` is not general enough
-  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:10:13
+  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:12:13
    |
 LL |       _: impl Trait<
    |  _____________^

tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty.rs

@@ -3,9 +3,11 @@
 //
 //@ check-pass
 
-#![feature(associated_const_equality)]
+#![feature(associated_const_equality, min_generic_const_args)]
+#![allow(incomplete_features)]
 
 trait Trait<T> {
+    #[type_const]
     const K: T;
 }
 

tests/ui/associated-consts/assoc-const-eq-const_evaluatable_unchecked.rs

@@ -4,9 +4,13 @@
 //
 // issue: <https://github.com/rust-lang/rust/issues/108220>
 //@ check-pass
-#![feature(associated_const_equality)]
+#![feature(associated_const_equality, min_generic_const_args)]
+#![allow(incomplete_features)]
 
-pub trait TraitA<T> { const K: u8 = 0; }
+pub trait TraitA<T> {
+    #[type_const]
+    const K: u8 = 0;
+}
 pub trait TraitB<T> {}
 
 impl<T> TraitA<T> for () {}