Merge pull request #84 from scalexm/issue-70

Fix `UnselectedProjectionTy` parameters

Author: nikomatsakis

chalk-parse/src/parser.lalrpop

@@ -139,8 +139,8 @@ ProjectionTy: ProjectionTy = {
 
 UnselectedProjectionTy: UnselectedProjectionTy = {
     <ty:TyWithoutFor> "::" <name:Id> <a:Angle<Parameter>> => {
-        let mut args = vec![Parameter::Ty(ty)];
-        args.extend(a);
+        let mut args = a;
+        args.push(Parameter::Ty(ty));
         UnselectedProjectionTy {
             name: name,
             args: args,

src/ir/debug.rs

@@ -121,12 +121,13 @@ impl Debug for ProjectionTy {
 
 impl Debug for UnselectedProjectionTy {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        let len = self.parameters.len();
         write!(
             fmt,
             "{:?}::{}{:?}",
-            self.parameters[0],
+            self.parameters[len - 1],
             self.type_name,
-            Angle(&self.parameters[1..])
+            Angle(&self.parameters[0..(len - 1)])
         )
     }
 }

src/lower/mod.rs

@@ -1117,7 +1117,7 @@ impl ir::AssociatedTyValue {
     ///
     /// ```notrust
     /// forall<'a, T> {
-    ///     (Vec<T>: Iterable<IntoIter<'a> = Iter<'a, T>>) :-
+    ///     Normalize(<Vec<T> as Iterable>::IntoIter<'a> -> Iter<'a, T>>) :-
     ///         (Vec<T>: Iterable),  // (1)
     ///         (T: 'a)              // (2)
     /// }
@@ -1127,9 +1127,9 @@ impl ir::AssociatedTyValue {
     ///
     /// ```notrust
     /// forall<'a, T> {
-    ///     Vec<T>::IntoIter<'a> ==> Iter<'a, T> :-
+    ///     UnselectedNormalize(Vec<T>::IntoIter<'a> -> Iter<'a, T>) :-
     ///         InScope(Iterable),
-    ///         <Vec<T> as Iterable>::IntoIter<'a> ==> Iter<'a, T>
+    ///         Normalize(<Vec<T> as Iterable>::IntoIter<'a> -> Iter<'a, T>)
     /// }
     /// ```
     fn to_program_clauses(
@@ -1161,19 +1161,25 @@ impl ir::AssociatedTyValue {
             .chain(self.value.value.where_clauses.clone().cast())
             .collect();
 
+        // Bound parameters + `Self` type of the trait-ref
         let parameters: Vec<_> = {
             // First add refs to the bound parameters (`'a`, in above example)
             let parameters = self.value.binders.iter().zip(0..).map(|p| p.to_parameter());
 
-            // Then add the trait-ref parameters (`Vec<T>`, in above example)
+            // Then add the `Self` type (`Vec<T>`, in above example)
             parameters
-                .chain(impl_trait_ref.parameters.clone())
+                .chain(Some(impl_trait_ref.parameters[0].clone()))
                 .collect()
         };
 
         let projection = ir::ProjectionTy {
             associated_ty_id: self.associated_ty_id,
-            parameters: parameters.clone(),
+
+            // Add the remaining parameters of the trait-ref if any
+            parameters: parameters.iter()
+                                  .chain(&impl_trait_ref.parameters[1..])
+                                  .cloned()
+                                  .collect(),
         };
 
         let normalize_goal = ir::DomainGoal::Normalize(ir::Normalize {

src/solve/test/mod.rs

@@ -1794,6 +1794,57 @@ fn unselected_projection() {
     }
 }
 
+#[test]
+fn unselected_projection_with_atc() {
+    test! {
+        program {
+            trait Foo {
+                type Item<'a>;
+            }
+
+            struct Ref<'a, T> { }
+            struct i32 { }
+
+            impl Foo for i32 {
+                type Item<'a> = Ref<'a, i32>;
+            }
+        }
+        goal {
+            forall<'a> {
+                if (InScope(Foo)) {
+                    i32::Item<'a> = Ref<'a, i32>
+                }
+            }
+        } yields {
+            "Unique"
+        }
+    }
+}
+
+#[test]
+fn unselected_projection_with_parametric_trait() {
+    test! {
+        program {
+            trait Foo<T> {
+                type Item;
+            }
+
+            struct i32 { }
+
+            impl Foo<i32> for i32 {
+                type Item = i32;
+            }
+        }
+        goal {
+            if (InScope(Foo)) {
+                i32::Item = i32
+            }
+        } yields {
+            "Unique"
+        }
+    }
+}
+
 #[test]
 fn overflow_universe() {
     test! {