normalization: avoid incompletely constraining GAT args

Author: lcnr

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

@@ -123,6 +123,36 @@ where
                     return Err(NoSolution);
                 }
                 ecx.probe_trait_candidate(source).enter(|ecx| {
+                    // FIXME(generic_associated_types): Addresses aggressive inference in #92917.
+                    //
+                    // If this type is a GAT with currently unconstrained arguments, we do not
+                    // want to normalize it via a candidate which only applies for a specific
+                    // instantiation. We could otherwise keep the GAT as rigid and succeed this way.
+                    // See tests/ui/generic-associated-types/no-incomplete-gat-arg-inference.rs.
+                    //
+                    // This only avoids normalization if the GAT arguments are fully unconstrained.
+                    // This is quite arbitrary but fixing it causes some ambiguity, see #125196.
+                    match goal.predicate.alias.kind(cx) {
+                        ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
+                            for arg in goal.predicate.alias.own_args(cx).iter() {
+                                let Some(term) = arg.as_term() else {
+                                    continue;
+                                };
+                                let term = ecx.structurally_normalize_term(goal.param_env, term)?;
+                                if term.is_infer() {
+                                    return ecx.evaluate_added_goals_and_make_canonical_response(
+                                        Certainty::AMBIGUOUS,
+                                    );
+                                }
+                            }
+                        }
+                        ty::AliasTermKind::OpaqueTy
+                        | ty::AliasTermKind::InherentTy
+                        | ty::AliasTermKind::InherentConst
+                        | ty::AliasTermKind::FreeTy
+                        | ty::AliasTermKind::FreeConst
+                        | ty::AliasTermKind::UnevaluatedConst => {}
+                    }
                     let assumption_projection_pred =
                         ecx.instantiate_binder_with_infer(projection_pred);
                     ecx.eq(

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1760,12 +1760,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         if is_match {
             let generics = self.tcx().generics_of(obligation.predicate.def_id);
-            // FIXME(generic-associated-types): Addresses aggressive inference in #92917.
+            // FIXME(generic_associated_types): Addresses aggressive inference in #92917.
             // If this type is a GAT, and of the GAT args resolve to something new,
             // that means that we must have newly inferred something about the GAT.
             // We should give up in that case.
-            // FIXME(generic-associated-types): This only detects one layer of inference,
-            // which is probably not what we actually want, but fixing it causes some ambiguity:
+            //
+            // This only detects one layer of inference, which is probably not what we actually
+            // want, but fixing it causes some ambiguity:
             // <https://github.com/rust-lang/rust/issues/125196>.
             if !generics.is_own_empty()
                 && obligation.predicate.args[generics.parent_count..].iter().any(|&p| {

compiler/rustc_type_ir/src/inherent.rs

@@ -298,6 +298,14 @@ pub trait GenericArg<I: Interner<GenericArg = Self>>:
     + From<I::Region>
     + From<I::Const>
 {
+    fn as_term(&self) -> Option<I::Term> {
+        match self.kind() {
+            ty::GenericArgKind::Lifetime(_) => None,
+            ty::GenericArgKind::Type(ty) => Some(ty.into()),
+            ty::GenericArgKind::Const(ct) => Some(ct.into()),
+        }
+    }
+
     fn as_type(&self) -> Option<I::Ty> {
         if let ty::GenericArgKind::Type(ty) = self.kind() { Some(ty) } else { None }
     }

compiler/rustc_type_ir/src/predicate.rs

@@ -682,6 +682,13 @@ impl<I: Interner> AliasTerm<I> {
     pub fn trait_ref(self, interner: I) -> TraitRef<I> {
         self.trait_ref_and_own_args(interner).0
     }
+
+    /// Extract the own args from this projection.
+    /// For example, if this is a projection of `<T as StreamingIterator>::Item<'a>`,
+    /// then this function would return the slice `['a]` as the own args.
+    pub fn own_args(self, interner: I) -> I::GenericArgsSlice {
+        self.trait_ref_and_own_args(interner).1
+    }
 }
 
 /// The following methods work only with inherent associated term projections.

tests/ui/generic-associated-types/guide-inference-in-gat-arg-deeper.rs

@@ -1,5 +1,9 @@
-// Fix for <https://github.com/rust-lang/rust/issues/125196>.
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+// Fix for <https://github.com/rust-lang/rust/issues/125196>.
 
 trait Tr {
     type Gat<T>;

tests/ui/generic-associated-types/no-incomplete-gat-arg-inference.rs

@@ -0,0 +1,33 @@
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+// Regression test for trait-system-refactor-initiative#202. We have
+// to make sure we don't constrain ambiguous GAT args when normalizing
+// via where bounds or item bounds.
+
+trait Trait {
+    type Assoc<U>;
+}
+
+fn ret<T: Trait, U>(x: U) -> <T as Trait>::Assoc<U> {
+    loop {}
+}
+
+fn where_bound<T: Trait<Assoc<u32> = u32>>() {
+    let inf = Default::default();
+    let x = ret::<T, _>(inf);
+    let _: i32 = inf;
+}
+
+trait ItemBound {
+    type Bound: Trait<Assoc<u32> = u32>;
+}
+fn item_bound<T: ItemBound>() {
+    let inf = Default::default();
+    let x = ret::<T::Bound, _>(inf);
+    let _: i32 = inf;
+}
+
+fn main() {}