Auto merge of #778 - lowr:fix/projection-ty-self, r=jackh726

Fix `Self` type retrieval from `ProjectionTy`

As I understand it, a `ProjectionTy`'s substitution is in the order of the args for the associated type, and then the args for its parent (i.e. impl or trait). `ProjectionTy::self_type_parameter()` has been returning the first type argument in the substitution, which is not the `Self` type its callers would expect when the associated type has its own type parameters.

The added test shows the problem: it fails in current master as the recursive solver reports ambiguity after it gets wrong `Self` type and flounders in [here](https://github.com/rust-lang/chalk/blob/c8bc9aae199d5c424044f6608eb1e553648bce2c/chalk-solve/src/clauses.rs#L615-L622). It hasn't been uncovered because all the traits in tests for GATs are not `#[non_enumerable]` (and rust-analyzer hasn't implemented GATs yet).

Author: bors

chalk-ir/src/lib.rs

@@ -1643,17 +1643,6 @@ pub struct ProjectionTy<I: Interner> {
 
 impl<I: Interner> Copy for ProjectionTy<I> where I::InternedSubstitution: Copy {}
 
-impl<I: Interner> ProjectionTy<I> {
-    /// Gets the type parameters of the `Self` type in this alias type.
-    pub fn self_type_parameter(&self, interner: I) -> Ty<I> {
-        self.substitution
-            .iter(interner)
-            .find_map(move |p| p.ty(interner))
-            .unwrap()
-            .clone()
-    }
-}
-
 /// An opaque type `opaque type T<..>: Trait = HiddenTy`.
 #[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct OpaqueTy<I: Interner> {

chalk-solve/src/clauses.rs

@@ -603,11 +603,12 @@ pub fn program_clauses_that_could_match<I: Interner>(
                 // ```
                 let associated_ty_datum = db.associated_ty_data(proj.associated_ty_id);
                 let trait_id = associated_ty_datum.trait_id;
-                let trait_parameters = db.trait_parameters_from_projection(proj);
+                let trait_ref = db.trait_ref_from_projection(proj);
+                let trait_parameters = trait_ref.substitution.as_parameters(interner);
 
                 let trait_datum = db.trait_datum(trait_id);
 
-                let self_ty = proj.self_type_parameter(interner);
+                let self_ty = trait_ref.self_type_parameter(interner);
                 if let TyKind::InferenceVar(_, _) = self_ty.kind(interner) {
                     panic!("Inference vars not allowed when getting program clauses");
                 }
@@ -804,10 +805,11 @@ fn push_alias_alias_eq_clause<I: Interner>(
     alias: AliasTy<I>,
 ) {
     let interner = builder.interner();
-    assert_eq!(
-        *projection_ty.self_type_parameter(interner).kind(interner),
-        TyKind::Alias(alias.clone())
-    );
+    let self_ty = builder
+        .db
+        .trait_ref_from_projection(&projection_ty)
+        .self_type_parameter(interner);
+    assert_eq!(*self_ty.kind(interner), TyKind::Alias(alias.clone()));
 
     // TODO: instead generate clauses without reference to the specific type parameters of the goal?
     let generalized = generalize::Generalize::apply(interner, (projection_ty, ty, alias));

chalk-solve/src/rust_ir.rs

@@ -214,10 +214,11 @@ pub struct FnDefDatumBound<I: Interner> {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+// FIXME: unignore the doctest below when GATs hit stable.
 /// A rust intermediate representation (rust_ir) of a Trait Definition. For
 /// example, given the following rust code:
 ///
-/// ```compile_fail
+/// ```ignore
 /// use std::fmt::Debug;
 ///
 /// trait Foo<T>

tests/test/projection.rs

@@ -687,6 +687,33 @@ fn forall_projection_gat() {
     }
 }
 
+#[test]
+fn gat_in_non_enumerable_trait() {
+    test! {
+        program {
+            #[non_enumerable]
+            trait Deref { }
+
+            #[non_enumerable]
+            trait PointerFamily {
+                type Pointer<T>: Deref;
+            }
+        }
+
+        goal {
+            forall<T> {
+                forall<U> {
+                    if (T: PointerFamily) {
+                        <T as PointerFamily>::Pointer<U>: Deref
+                    }
+                }
+            }
+        } yields {
+            expect![[r#"Unique"#]]
+        }
+    }
+}
+
 #[test]
 fn normalize_under_binder() {
     test! {