Normalize OGCA ambiguously for coherence purposes

During coherence, OGCA consts should be normalized ambiguously because
they are opaque but eventually resolved to a real value. We don't want
two OGCAs that have the same value to be treated as distinct for
coherence purposes. (Just like opaque types.)

Author: camelid

compiler/rustc_middle/src/ty/consts.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use rustc_data_structures::intern::Interned;
 use rustc_error_messages::MultiSpan;
-use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+use rustc_macros::HashStable;
 use rustc_type_ir::walk::TypeWalker;
 use rustc_type_ir::{self as ir, TypeFlags, WithCachedTypeInfo};
 
@@ -335,19 +335,3 @@ impl<'tcx> Const<'tcx> {
         TypeWalker::new(self.into())
     }
 }
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable, HashStable)]
-pub enum AnonConstKind {
-    /// `feature(generic_const_exprs)` anon consts are allowed to use arbitrary generic parameters in scope
-    GCE,
-    /// stable `min_const_generics` anon consts are not allowed to use any generic parameters
-    MCG,
-    /// `feature(opaque_generic_const_args)` anon consts are allowed to use arbitrary
-    /// generic parameters in scope, but only if they syntactically reference them.
-    OGCA,
-    /// anon consts used as the length of a repeat expr are syntactically allowed to use generic parameters
-    /// but must not depend on the actual instantiation. See #76200 for more information
-    RepeatExprCount,
-    /// anon consts outside of the type system, e.g. enum discriminants
-    NonTypeSystem,
-}

compiler/rustc_middle/src/ty/context.rs

@@ -245,6 +245,9 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     fn const_of_item(self, def_id: DefId) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
         self.const_of_item(def_id)
     }
+    fn anon_const_kind(self, def_id: DefId) -> ty::AnonConstKind {
+        self.anon_const_kind(def_id)
+    }
 
     type AdtDef = ty::AdtDef<'tcx>;
     fn adt_def(self, adt_def_id: DefId) -> Self::AdtDef {

compiler/rustc_middle/src/ty/mod.rs

@@ -76,8 +76,8 @@ pub use self::closure::{
     place_to_string_for_capture,
 };
 pub use self::consts::{
-    AnonConstKind, AtomicOrdering, Const, ConstInt, ConstKind, ConstToValTreeResult, Expr,
-    ExprKind, ScalarInt, SimdAlign, UnevaluatedConst, ValTree, ValTreeKindExt, Value,
+    AtomicOrdering, Const, ConstInt, ConstKind, ConstToValTreeResult, Expr, ExprKind, ScalarInt,
+    SimdAlign, UnevaluatedConst, ValTree, ValTreeKindExt, Value,
 };
 pub use self::context::{
     CtxtInterners, CurrentGcx, Feed, FreeRegionInfo, GlobalCtxt, Lift, TyCtxt, TyCtxtFeed, tls,

compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs

@@ -14,6 +14,7 @@ where
         &mut self,
         goal: Goal<I, ty::NormalizesTo<I>>,
     ) -> QueryResult<I> {
+        // FIXME(ogca): should we also stop ogca normalization during coherence here or just in normalize_free_alias?
         if let Some(normalized_const) = self.evaluate_const(
             goal.param_env,
             ty::UnevaluatedConst::new(

compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs

@@ -4,7 +4,8 @@
 //! Since a free alias is never ambiguous, this just computes the `type_of` of
 //! the alias and registers the where-clauses of the type alias.
 
-use rustc_type_ir::{self as ty, Interner};
+use rustc_type_ir::inherent::*;
+use rustc_type_ir::{self as ty,TypingMode, Interner};
 
 use crate::delegate::SolverDelegate;
 use crate::solve::{Certainty, EvalCtxt, Goal, GoalSource, QueryResult};
@@ -32,7 +33,19 @@ where
         let actual = if free_alias.kind(cx).is_type() {
             cx.type_of(free_alias.def_id).instantiate(cx, free_alias.args).into()
         } else {
-            cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()
+            let ct = cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args);
+            if self.typing_mode() == TypingMode::Coherence
+                && let ty::ConstKind::Unevaluated(uv) = ct.kind()
+                && self.cx().anon_const_kind(uv.def.into()) == ty::AnonConstKind::OGCA
+            {
+                // During coherence, OGCA consts should be normalized ambiguously
+                // because they are opaque but eventually resolved to a real value.
+                // We don't want two OGCAs that have the same value to be treated
+                // as distinct for coherence purposes.
+                // (Just like opaque types.)
+                return self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
+            }
+            ct.into()
         };
 
         self.instantiate_normalizes_to_term(goal, actual);

compiler/rustc_type_ir/src/const_kind.rs

@@ -200,3 +200,23 @@ impl<I: Interner> ValTreeKind<I> {
         }
     }
 }
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+#[cfg_attr(
+    feature = "nightly",
+    derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
+)]
+pub enum AnonConstKind {
+    /// `feature(generic_const_exprs)` anon consts are allowed to use arbitrary generic parameters in scope
+    GCE,
+    /// stable `min_const_generics` anon consts are not allowed to use any generic parameters
+    MCG,
+    /// `feature(opaque_generic_const_args)` anon consts are allowed to use arbitrary
+    /// generic parameters in scope, but only if they syntactically reference them.
+    OGCA,
+    /// anon consts used as the length of a repeat expr are syntactically allowed to use generic parameters
+    /// but must not depend on the actual instantiation. See #76200 for more information
+    RepeatExprCount,
+    /// anon consts outside of the type system, e.g. enum discriminants
+    NonTypeSystem,
+}

compiler/rustc_type_ir/src/interner.rs

@@ -207,6 +207,7 @@ pub trait Interner:
     fn type_of_opaque_hir_typeck(self, def_id: Self::LocalDefId)
     -> ty::EarlyBinder<Self, Self::Ty>;
     fn const_of_item(self, def_id: Self::DefId) -> ty::EarlyBinder<Self, Self::Const>;
+    fn anon_const_kind(self, def_id: Self::DefId) -> ty::AnonConstKind;
 
     type AdtDef: AdtDef<Self>;
     fn adt_def(self, adt_def_id: Self::AdtId) -> Self::AdtDef;

tests/ui/const-generics/ogca/coherence-ambiguous.rs

@@ -0,0 +1,18 @@
+#![feature(generic_const_items, min_generic_const_args, opaque_generic_const_args)]
+#![expect(incomplete_features)]
+
+#[type_const]
+const FOO<const N: usize>: usize = const { N + 1 };
+
+#[type_const]
+const BAR<const N: usize>: usize = const { N + 1 };
+
+trait Trait {}
+
+impl Trait for [(); FOO::<1>] {}
+impl Trait for [(); BAR::<1>] {}
+//~^ ERROR conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+impl Trait for [(); BAR::<2>] {}
+//~^ ERROR conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+
+fn main() {}

tests/ui/const-generics/ogca/coherence-ambiguous.stderr

@@ -0,0 +1,20 @@
+error[E0119]: conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+  --> $DIR/coherence-ambiguous.rs:13:1
+   |
+LL | impl Trait for [(); FOO::<1>] {}
+   | ----------------------------- first implementation here
+LL | impl Trait for [(); BAR::<1>] {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); FOO::<1>]`
+
+error[E0119]: conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+  --> $DIR/coherence-ambiguous.rs:15:1
+   |
+LL | impl Trait for [(); FOO::<1>] {}
+   | ----------------------------- first implementation here
+...
+LL | impl Trait for [(); BAR::<2>] {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); FOO::<1>]`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0119`.