Add test implied_from_env and clean up

Author: tmandry

src/ir.rs

@@ -269,9 +269,9 @@ pub enum InlineBound {
 impl InlineBound {
     /// Applies the `InlineBound` to `self_ty` and lowers to a [`DomainGoal`].
     /// 
-    /// Because an `InlineBound` not know anything about what it's binding, you
-    /// must provide that type as `self_ty`.
-    pub fn lower_with_self(&self, self_ty: Ty) -> Vec<DomainGoal> {
+    /// Because an `InlineBound` does not know anything about what it's binding,
+    /// you must provide that type as `self_ty`.
+    crate fn lower_with_self(&self, self_ty: Ty) -> Vec<DomainGoal> {
         match self {
             InlineBound::TraitBound(b) => b.lower_with_self(self_ty),
             InlineBound::ProjectionEqBound(b) => b.lower_with_self(self_ty),
@@ -288,7 +288,7 @@ pub struct TraitBound {
 }
 
 impl TraitBound {
-    pub fn lower_with_self(&self, self_ty: Ty) -> Vec<DomainGoal> {
+    crate fn lower_with_self(&self, self_ty: Ty) -> Vec<DomainGoal> {
         let trait_ref = self.as_trait_ref(self_ty);
         vec![DomainGoal::Holds(WhereClauseAtom::Implemented(trait_ref))]
     }
@@ -314,7 +314,7 @@ pub struct ProjectionEqBound {
 }
 
 impl ProjectionEqBound {
-    pub fn lower_with_self(&self, self_ty: Ty) -> Vec<DomainGoal> {
+    crate fn lower_with_self(&self, self_ty: Ty) -> Vec<DomainGoal> {
         let trait_ref = self.trait_bound.as_trait_ref(self_ty);
 
         let mut parameters = self.parameters.clone();
@@ -354,7 +354,7 @@ pub struct AssociatedTyDatum {
     /// would result in a well-formed projection.
     crate bounds: Vec<InlineBound>,
 
-    /// Where clauses that must hold for the projection be well-formed.
+    /// Where clauses that must hold for the projection to be well-formed.
     crate where_clauses: Vec<QuantifiedDomainGoal>,
 }
 
@@ -364,7 +364,7 @@ impl AssociatedTyDatum {
     /// ```notrust
     /// Implemented(<?0 as Foo>::Item<?1>: Sized)
     /// ```
-    pub fn bounds_on_self(&self) -> Vec<DomainGoal> {
+    crate fn bounds_on_self(&self) -> Vec<DomainGoal> {
         let parameters = self.parameter_kinds
                              .anonymize()
                              .iter()

src/rules.rs

@@ -237,7 +237,7 @@ impl ir::AssociatedTyValue {
         let projection = ir::ProjectionTy {
             associated_ty_id: self.associated_ty_id,
 
-            // Add the remaining parameters of the trait-ref if any
+            // Add the remaining parameters of the trait-ref, if any
             parameters: parameters.iter()
                                   .chain(&impl_trait_ref.parameters[1..])
                                   .cloned()
@@ -528,10 +528,7 @@ impl ir::AssociatedTyDatum {
         }.cast());
 
         // Assuming well-formedness of projection type means we can assume
-        // the trait ref as well.
-        //
-        // Currently we do not use this rule in chalk (it's used in fn bodies),
-        // but it's here for completeness.
+        // the trait ref as well. Mostly used in function bodies.
         //
         //    forall<Self> {
         //        FromEnv(Self: Foo) :- FromEnv((Foo::Assoc)<Self>).

src/rules/wf.rs

@@ -258,7 +258,9 @@ impl WfSolver {
                                       .map(|p| p.to_parameter())
                                       .chain(trait_ref.parameters.iter().cloned())
                                       .collect();
-            
+
+            // Add bounds from the trait. Because they are defined on the trait,
+            // their parameters must be substituted with those of the impl.
             let bound_goals =
                 bounds.iter()
                       .map(|b| Subst::apply(&all_parameters, b))
@@ -271,14 +273,16 @@ impl WfSolver {
                 None => return None,
             };
 
+            // Add where clauses from the associated ty definition. We must
+            // substitute parameters here, like we did with the bounds above.
             let hypotheses =
                 assoc_ty_datum.where_clauses
                               .iter()
                               .map(|wc| Subst::apply(&all_parameters, wc))
                               .map(|wc| wc.map(|bound| bound.into_from_env_goal()))
                               .casted()
                               .collect();
-            
+
             let goal = Goal::Implies(
                 hypotheses,
                 Box::new(goal)

src/solve/test.rs

@@ -740,7 +740,7 @@ fn normalize_gat_with_higher_ranked_trait_bound() {
 }
 
 #[test]
-fn normalize_implied_bound() {
+fn implied_bounds() {
     test! {
         program {
             trait Clone { }
@@ -761,7 +761,7 @@ fn normalize_implied_bound() {
 }
 
 #[test]
-fn normalize_implied_bound_gat() {
+fn gat_implied_bounds() {
     test! {
         program {
             trait Clone { }
@@ -800,6 +800,36 @@ fn normalize_implied_bound_gat() {
     }
 }
 
+#[test]
+fn implied_from_env() {
+    test! {
+        program {
+            trait Clone { }
+            trait Foo<U> { type Item<V>; }
+        }
+
+        goal {
+            forall<T, U, V> {
+                if (FromEnv(<T as Foo<U>>::Item<V>)) {
+                    FromEnv(T: Foo<U>)
+                }
+            }
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            forall<T, U, V> {
+                if (FromEnv(<T as Foo<U>>::Item<V>)) {
+                    FromEnv(T: Clone)
+                }
+            }
+        } yields {
+            "No possible solution"
+        }
+    }
+}
+
 /// Demonstrates that, given the expected value of the associated
 /// type, we can use that to narrow down the relevant impls.
 #[test]