Fix overeager cycle detection in dyn impl clause generation

The same trait can appear multiple times in the super trait graph without
forming a cycle (see the test).

Author: flodiebold

chalk-solve/src/clauses/dyn_ty.rs

@@ -133,6 +133,10 @@ pub fn super_traits<I: Interner>(
     ) {
         let interner = db.interner();
         let trait_id = trait_ref.skip_binders().trait_id;
+        // Avoid cycles
+        if !seen_traits.insert(trait_id) {
+            return;
+        }
         trait_refs.push(trait_ref.clone());
         let trait_datum = db.trait_datum(trait_id);
         let super_trait_refs = trait_datum
@@ -153,10 +157,6 @@ pub fn super_traits<I: Interner>(
                                 {
                                     return None;
                                 }
-                                // Avoid cycles
-                                if !seen_traits.insert(tr.trait_id) {
-                                    return None;
-                                }
                                 Some(tr.clone())
                             }
                             WhereClause::AliasEq(_) => None,
@@ -175,6 +175,7 @@ pub fn super_traits<I: Interner>(
             let q_super_trait_ref = actual_binders.fuse_binders(interner);
             go(db, q_super_trait_ref, seen_traits, trait_refs);
         }
+        seen_traits.remove(&trait_id);
     }
 
     Binders::new(trait_datum.binders.binders.clone(), trait_refs)

tests/test/existential_types.rs

@@ -181,6 +181,38 @@ fn dyn_super_trait_cycle() {
     }
 }
 
+#[test]
+fn dyn_super_trait_not_a_cycle() {
+    test! {
+        program {
+            trait Thing<T> {}
+            trait Foo where Self: Thing<B> {}
+            trait Bar where Self: Foo, Self: Thing<A> {}
+
+            struct A {}
+            struct B {}
+        }
+
+        goal {
+            dyn Bar: Foo
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            dyn Bar: Thing<A>
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            dyn Bar: Thing<B>
+        } yields {
+            "Unique"
+        }
+    }
+}
+
 #[test]
 fn dyn_super_trait_higher_ranked() {
     test! {