Adjust implementation of coherence ambiguity for OGCA

This actually doesn't work yet because there are pre-existing
fundamental issues with equate relations involving consts that need to
be normalized. The problem is that we normalize only one layer of the
const item and don't actually process the resulting anon const. Normally
the created inference variable should be handled, which in this case
would cause us to hit the anon const, but that's not happening.
Specifically, `visit_const` on `Generalizer` should be updated to be
similar to `visit_ty`.

Author: camelid

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

@@ -1,4 +1,4 @@
-use rustc_type_ir::{self as ty, Interner};
+use rustc_type_ir::{self as ty, Interner, TypingMode};
 use tracing::instrument;
 
 use crate::delegate::SolverDelegate;
@@ -14,8 +14,18 @@ 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(
+        if self.typing_mode() == TypingMode::Coherence
+            && self.cx().anon_const_kind(goal.predicate.alias.def_id) == 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.)
+            //
+            // We can't rely on evaluate_const below because that particular wrapper
+            // treats too-generic consts as a successful evaluation.
+            self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
+        } else if let Some(normalized_const) = self.evaluate_const(
             goal.param_env,
             ty::UnevaluatedConst::new(
                 goal.predicate.alias.def_id.try_into().unwrap(),

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

@@ -4,8 +4,7 @@
 //! 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::inherent::*;
-use rustc_type_ir::{self as ty, Interner, TypingMode};
+use rustc_type_ir::{self as ty, Interner};
 
 use crate::delegate::SolverDelegate;
 use crate::solve::{Certainty, EvalCtxt, Goal, GoalSource, QueryResult};
@@ -33,19 +32,7 @@ where
         let actual = if free_alias.kind(cx).is_type() {
             cx.type_of(free_alias.def_id).instantiate(cx, free_alias.args).into()
         } else {
-            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()
+            cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()
         };
 
         self.instantiate_normalizes_to_term(goal, actual);

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

@@ -1,3 +1,6 @@
+// FIXME(ogca): this should ERROR not pass!!
+//@ check-pass
+
 #![feature(generic_const_items, min_generic_const_args, opaque_generic_const_args)]
 #![expect(incomplete_features)]
 
@@ -11,8 +14,8 @@ trait Trait {}
 
 impl Trait for [(); FOO::<1>] {}
 impl Trait for [(); BAR::<1>] {}
-//~^ ERROR conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+// FIXME(ogca): this should ERROR!
 impl Trait for [(); BAR::<2>] {}
-//~^ ERROR conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+// FIXME(ogca): this should ERROR!
 
 fn main() {}