fix, seems to hang though

lcnr · lcnr · commit 3620c777ef4d · 2025-10-24T16:12:53.000+02:00
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -47,6 +47,10 @@ enum CurrentGoalKind {
     /// These are currently the only goals whose impl where-clauses are considered to be
     /// productive steps.
     CoinductiveTrait,
+    /// `AliasRelate` goals are used for normalization and their inference constraints are
+    /// necessary to guide inference for other goals. This means that even on overflow, we don't
+    /// discard inference constraints from `AliasRelate` and return them to the caller.
+    AliasRelate,
     /// Unlike other goals, `NormalizesTo` goals act like functions with the expected term
     /// always being fully unconstrained. This would weaken inference however, as the nested
     /// goals never get the inference constraints from the actual normalized-to type.
@@ -67,6 +71,7 @@ impl CurrentGoalKind {
                     CurrentGoalKind::Misc
                 }
             }
+            ty::PredicateKind::AliasRelate(..) => CurrentGoalKind::AliasRelate,
             ty::PredicateKind::NormalizesTo(_) => CurrentGoalKind::NormalizesTo,
             _ => CurrentGoalKind::Misc,
         }
@@ -293,6 +298,7 @@ where
                 // so we treat cycles involving where-clauses of not-yet coinductive
                 // traits as ambiguous for now.
                 CurrentGoalKind::Misc => PathKind::Unknown,
+                CurrentGoalKind::AliasRelate => unreachable!(),
             },
             // Relating types is always unproductive. If we were to map proof trees to
             // corecursive functions as explained in #136824, relating types never
@@ -1276,23 +1282,30 @@ where
                 }
             };
 
-        if let Certainty::Maybe {
-            cause: cause @ MaybeCause::Overflow { keep_constraints: false, .. },
-            opaque_types_jank,
-        } = certainty
-        {
-            // If we have overflow, it's probable that we're substituting a type
-            // into itself infinitely and any partial substitutions in the query
-            // response are probably not useful anyways, so just return an empty
-            // query response.
-            //
-            // This may prevent us from potentially useful inference, e.g.
-            // 2 candidates, one ambiguous and one overflow, which both
-            // have the same inference constraints.
-            //
-            // Changing this to retain some constraints in the future
-            // won't be a breaking change, so this is good enough for now.
-            return Ok(self.make_ambiguous_response_no_constraints(cause, opaque_types_jank));
+        match self.current_goal_kind {
+            CurrentGoalKind::AliasRelate | CurrentGoalKind::NormalizesTo => {}
+            CurrentGoalKind::Misc | CurrentGoalKind::CoinductiveTrait => {
+                if let Certainty::Maybe {
+                    cause: cause @ MaybeCause::Overflow { keep_constraints: false, .. },
+                    opaque_types_jank,
+                } = certainty
+                {
+                    // If we have overflow, it's probable that we're substituting a type
+                    // into itself infinitely and any partial substitutions in the query
+                    // response are probably not useful anyways, so just return an empty
+                    // query response.
+                    //
+                    // This may prevent us from potentially useful inference, e.g.
+                    // 2 candidates, one ambiguous and one overflow, which both
+                    // have the same inference constraints.
+                    //
+                    // Changing this to retain some constraints in the future
+                    // won't be a breaking change, so this is good enough for now.
+                    return Ok(
+                        self.make_ambiguous_response_no_constraints(cause, opaque_types_jank)
+                    );
+                }
+            }
         }
 
         let external_constraints =
@@ -1327,7 +1340,9 @@ where
             // causing a coherence error in diesel, see #131969. We still bail with overflow
             // when later returning from the parent AliasRelate goal.
             CurrentGoalKind::NormalizesTo => {}
-            CurrentGoalKind::Misc | CurrentGoalKind::CoinductiveTrait => {
+            CurrentGoalKind::AliasRelate
+            | CurrentGoalKind::Misc
+            | CurrentGoalKind::CoinductiveTrait => {
                 let num_non_region_vars = canonical
                     .variables
                     .iter()
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.rs b/tests/ui/traits/next-solver/alias-bound-unsound.rs
@@ -26,12 +26,8 @@ impl Foo for () {
 fn main() {
     let x = String::from("hello, world");
     let _ = identity(<() as Foo>::copy_me(&x));
-    //~^ ERROR overflow evaluating the requirement `String <: <() as Foo>::Item`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item well-formed`
-    //~| ERROR overflow evaluating the requirement `&<() as Foo>::Item well-formed`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
+    //~^ ERROR type mismatch resolving `<() as Foo>::Item normalizes-to String`
+    //~| ERROR type mismatch resolving `<() as Foo>::Item normalizes-to String`
+    //~| ERROR mismatched types
     println!("{x}");
 }
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.stderr b/tests/ui/traits/next-solver/alias-bound-unsound.stderr
@@ -12,52 +12,53 @@ LL | trait Foo {
 LL |     type Item: Copy
    |          ^^^^ this trait's associated type doesn't have the requirement `String: Copy`
 
-error[E0275]: overflow evaluating the requirement `String <: <() as Foo>::Item`
+error[E0271]: type mismatch resolving `<() as Foo>::Item normalizes-to String`
   --> $DIR/alias-bound-unsound.rs:28:43
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
-   |                                           ^^
-
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
-  --> $DIR/alias-bound-unsound.rs:28:22
-   |
-LL |     let _ = identity(<() as Foo>::copy_me(&x));
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
-  --> $DIR/alias-bound-unsound.rs:28:22
+   |                                           ^^ types differ
    |
-LL |     let _ = identity(<() as Foo>::copy_me(&x));
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^
+note: required by a bound in `Foo::Item`
+  --> $DIR/alias-bound-unsound.rs:14:30
    |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+LL |     type Item: Copy
+   |          ---- required by a bound in this associated type
+LL |     where
+LL |         <Self as Foo>::Item: Copy;
+   |                              ^^^^ required by this bound in `Foo::Item`
 
-error[E0275]: overflow evaluating the requirement `&<() as Foo>::Item well-formed`
+error[E0308]: mismatched types
   --> $DIR/alias-bound-unsound.rs:28:43
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
-   |                                           ^^
-
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item well-formed`
-  --> $DIR/alias-bound-unsound.rs:28:22
+   |                      -------------------- ^^ types differ
+   |                      |
+   |                      arguments to this function are incorrect
    |
-LL |     let _ = identity(<() as Foo>::copy_me(&x));
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: expected reference `&<() as Foo>::Item`
+              found reference `&String`
+note: associated function defined here
+  --> $DIR/alias-bound-unsound.rs:16:8
+   |
+LL |     fn copy_me(x: &Self::Item) -> Self::Item {
+   |        ^^^^^^^ --------------
 
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
+error[E0271]: type mismatch resolving `<() as Foo>::Item normalizes-to String`
   --> $DIR/alias-bound-unsound.rs:28:22
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^ types differ
    |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
-  --> $DIR/alias-bound-unsound.rs:28:43
+note: required by a bound in `Foo::Item`
+  --> $DIR/alias-bound-unsound.rs:14:30
    |
-LL |     let _ = identity(<() as Foo>::copy_me(&x));
-   |                                           ^^
+LL |     type Item: Copy
+   |          ---- required by a bound in this associated type
+LL |     where
+LL |         <Self as Foo>::Item: Copy;
+   |                              ^^^^ required by this bound in `Foo::Item`
 
-error: aborting due to 8 previous errors
+error: aborting due to 4 previous errors
 
-For more information about this error, try `rustc --explain E0275`.
+Some errors have detailed explanations: E0271, E0275, E0308.
+For more information about an error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/next-solver/alias-relate/no-discard-constraints-on-ambiguity.rs b/tests/ui/traits/next-solver/alias-relate/no-discard-constraints-on-ambiguity.rs
@@ -0,0 +1,49 @@
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#246.
+
+struct MarkedStruct;
+pub trait MarkerTrait {}
+impl MarkerTrait for MarkedStruct {}
+
+// Necessary indirection to get a cycle with `PathKind::Unknown`
+struct ChainStruct;
+trait ChainTrait {}
+impl ChainTrait for ChainStruct where MarkedStruct: MarkerTrait {}
+
+pub struct FooStruct;
+pub trait FooTrait {
+    type Output;
+}
+pub struct FooOut;
+impl FooTrait for FooStruct
+where
+    ChainStruct: ChainTrait,
+{
+    type Output = FooOut;
+}
+
+pub trait Trait<T> {
+    type Output;
+}
+
+// prove <<FooStruct as FooTrait>::Output as Trait<K>>::Output: MarkerTrait
+// normalize <<FooStruct as FooTrait>::Output as Trait<K>>::Output
+//   `<?fresh_infer as Trait<K>>::Output` remains ambiguous, so this alias is never rigid
+// alias-relate <FooStruct as FooTrait>::Output ?fresh_infer
+//   does not constrain `?fresh_infer` as `keep_constraints` is `false`
+// normalize <FooStruct as FooTrait>::Output
+//   result `FooOut` with overflow
+// prove ChainStruct: ChainTrait
+// prove MarkedStruct: MarkerTrait
+//   impl trivial (ignored)
+//   where-clause requires normalize <<FooStruct as FooTrait>::Output as Trait<K>>::Output overflow
+pub fn foo<K>()
+where
+    FooOut: Trait<K>,
+    <<FooStruct as FooTrait>::Output as Trait<K>>::Output: MarkerTrait,
+{
+}
+
+fn main() {}
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr
@@ -10,12 +10,6 @@ note: required by a bound in `transmute`
 LL | fn transmute<L: Trait<R>, R>(r: L) -> <L::Proof as Trait<R>>::Proof { r }
    |                 ^^^^^^^^ required by this bound in `transmute`
 
-error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
-  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
-   |
-LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == String`
   --> $DIR/item-bound-via-impl-where-clause.rs:31:21
    |
@@ -36,14 +30,6 @@ error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::
 LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
-  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
-   |
-LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 6 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs
@@ -30,10 +30,8 @@ fn transmute<L: Trait<R>, R>(r: L) -> <L::Proof as Trait<R>>::Proof { r }
 fn main() {
     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
     //~^ ERROR overflow evaluating the requirement `Vec<u8>: Trait<String>`
-    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
     //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == String`
     //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof: Sized`
     //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof well-formed`
-    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
     println!("{}", s); // ABC
 }
