Lower bounds on associated types

Adds reverse rule and WF rules for associated type bounds.

The WF rules aren't quite right, but they'll be fixed in a later commit.

Author: tmandry

chalk-parse/src/ast.rs

@@ -86,7 +86,7 @@ pub struct TraitBound {
 pub struct ProjectionEqBound {
     pub trait_bound: TraitBound,
     pub name: Identifier,
-    pub parameters: Vec<Parameter>,
+    pub args: Vec<Parameter>,
     pub value: Ty,
 }
 

chalk-parse/src/parser.lalrpop

@@ -107,7 +107,7 @@ ProjectionEqBound: ProjectionEqBound = {
             args_no_self: a.unwrap_or(vec![]),
         },
         name,
-        parameters: a2,
+        args: a2,
         value: ty,
     }
 };

src/ir.rs

@@ -5,6 +5,7 @@ use fold::shift::Shift;
 use lalrpop_intern::InternedString;
 use std::collections::{BTreeMap, BTreeSet};
 use std::sync::Arc;
+use std::iter;
 
 #[macro_use]
 mod macros;
@@ -265,6 +266,19 @@ pub enum InlineBound {
     ProjectionEqBound(ProjectionEqBound),
 }
 
+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> {
+        match self {
+            InlineBound::TraitBound(b) => b.lower_with_self(self_ty),
+            InlineBound::ProjectionEqBound(b) => b.lower_with_self(self_ty),
+        }
+    }
+}
+
 /// Represents a trait bound on e.g. a type or type parameter.
 /// Does not know anything about what it's binding.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -273,6 +287,21 @@ pub struct TraitBound {
     crate args_no_self: Vec<Parameter>,
 }
 
+impl TraitBound {
+    pub 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))]
+    }
+
+    fn as_trait_ref(&self, self_ty: Ty) -> TraitRef {
+        let self_ty = ParameterKind::Ty(self_ty);
+        TraitRef {
+            trait_id: self.trait_id,
+            parameters: iter::once(self_ty).chain(self.args_no_self.iter().cloned()).collect(),
+        }
+    }
+}
+
 /// Represents a projection equality bound on e.g. a type or type parameter.
 /// Does not know anything about what it's binding.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -284,6 +313,26 @@ pub struct ProjectionEqBound {
     crate value: Ty,
 }
 
+impl ProjectionEqBound {
+    pub 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();
+        parameters.extend(trait_ref.parameters.clone());
+
+        vec![
+            DomainGoal::Holds(WhereClauseAtom::Implemented(trait_ref)),
+            DomainGoal::Holds(WhereClauseAtom::ProjectionEq(ProjectionEq {
+                projection: ProjectionTy {
+                    associated_ty_id: self.associated_ty_id,
+                    parameters: parameters,
+                },
+                ty: self.value.clone(),
+            }))
+        ]
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct AssociatedTyDatum {
     /// The trait this associated type is defined in.
@@ -309,6 +358,27 @@ pub struct AssociatedTyDatum {
     crate where_clauses: Vec<QuantifiedDomainGoal>,
 }
 
+impl AssociatedTyDatum {
+    /// Returns the associated ty's bounds applied to the projection type, e.g.:
+    ///
+    /// ```notrust
+    /// Implemented(<?0 as Foo>::Item<?1>: Sized)
+    /// ```
+    pub fn bounds_on_self(&self) -> Vec<DomainGoal> {
+        let parameters = self.parameter_kinds
+                             .anonymize()
+                             .iter()
+                             .zip(0..)
+                             .map(|p| p.to_parameter())
+                             .collect();
+        let self_ty = Ty::Projection(ProjectionTy {
+            associated_ty_id: self.id,
+            parameters
+        });
+        self.bounds.iter().flat_map(|b| b.lower_with_self(self_ty.clone())).collect()
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct AssociatedTyValue {
     crate associated_ty_id: ItemId,

src/rules.rs

@@ -529,6 +529,23 @@ impl ir::AssociatedTyDatum {
             }.cast()
         }));
 
+        // Reverse rule for implied bounds.
+        //
+        //    forall<T> {
+        //        FromEnv(<T as Foo>::Assoc: Bounds) :- FromEnv(Self: Foo)
+        //    }
+        clauses.extend(self.bounds_on_self().into_iter().map(|bound| {
+            ir::Binders {
+                binders: binders.clone(),
+                value: ir::ProgramClauseImplication {
+                    consequence: bound.into_from_env_goal(),
+                    conditions: vec![
+                        ir::DomainGoal::FromEnv(trait_ref.clone().cast()).cast()
+                    ],
+                }
+            }.cast()
+        }));
+
         // add new type parameter U
         let mut binders = binders;
         binders.push(ir::ParameterKind::Ty(()));
@@ -554,55 +571,6 @@ impl ir::AssociatedTyDatum {
             },
         }.cast());
 
-        
-        let projection_wc = ir::WhereClauseAtom::ProjectionEq(projection_eq.clone());
-        let trait_ref_wc = ir::WhereClauseAtom::Implemented(trait_ref.clone());
-
-        // We generate a proxy rule for the well-formedness of `T: Foo<Assoc = U>` which really
-        // means two things: `T: Foo` and `Normalize(<T as Foo>::Assoc -> U)`. So we have the
-        // following rule:
-        //
-        //    forall<T> {
-        //        WellFormed(T: Foo<Assoc = U>) :-
-        //            WellFormed(T: Foo), ProjectionEq(<T as Foo>::Assoc = U)
-        //    }
-        clauses.push(ir::Binders {
-            binders: binders.clone(),
-            value: ir::ProgramClauseImplication {
-                consequence: ir::DomainGoal::WellFormed(projection_wc.clone()),
-                conditions: vec![
-                    ir::DomainGoal::WellFormed(trait_ref_wc.clone()).cast(),
-                    projection_eq.clone().cast()
-                ],
-            }
-        }.cast());
-
-        // We also have two proxy reverse rules, the first one being:
-        //
-        //    forall<T> {
-        //        FromEnv(T: Foo) :- FromEnv(T: Foo<Assoc = U>)
-        //    }
-        clauses.push(ir::Binders {
-            binders: binders.clone(),
-            value: ir::ProgramClauseImplication {
-                consequence: ir::DomainGoal::FromEnv(trait_ref_wc).cast(),
-                conditions: vec![ir::DomainGoal::FromEnv(projection_wc.clone()).cast()],
-            },
-        }.cast());
-
-        // And the other one being:
-        //
-        //    forall<T> {
-        //        ProjectionEq(<T as Foo>::Assoc = U) :- FromEnv(T: Foo<Assoc = U>)
-        //    }
-        clauses.push(ir::Binders {
-            binders,
-            value: ir::ProgramClauseImplication {
-                consequence: projection_eq.clone().cast(),
-                conditions: vec![ir::DomainGoal::FromEnv(projection_wc).cast()],
-            },
-        }.cast());
-
         clauses
     }
 }

src/rules/wf.rs

@@ -254,17 +254,52 @@ impl WfSolver {
         // ```
         // we would issue the following subgoal: `forall<'a> { WellFormed(Box<&'a T>) }`.
         let compute_assoc_ty_goal = |assoc_ty: &AssociatedTyValue| {
+            let assoc_ty_datum = &self.env.associated_ty_data[&assoc_ty.associated_ty_id];
+            let bounds = &assoc_ty_datum.bounds;
+
+            let trait_datum = &self.env.trait_data[&assoc_ty_datum.trait_id];
+
             let mut input_types = Vec::new();
             assoc_ty.value.value.ty.fold(&mut input_types);
 
-            if input_types.is_empty() {
-                return None;
-            }
-
-            let goals = input_types.into_iter().map(|ty| DomainGoal::WellFormedTy(ty).cast());
-            let goal = goals.fold1(|goal, leaf| Goal::And(Box::new(goal), Box::new(leaf)))
-                            .expect("at least one goal");
-            Some(goal.quantify(QuantifierKind::ForAll, assoc_ty.value.binders.clone()))
+            let goals = input_types.into_iter()
+                                   .map(|ty| DomainGoal::WellFormedTy(ty).cast());
+                                   //.chain(bounds.iter()
+                                   //             .flat_map(|b| b.clone()
+                                   //                            .lower_with_self(assoc_ty.value.value.ty.clone()))
+                                   //             .map(|g| g.into_well_formed_goal().cast()));
+            let goal = goals.fold1(|goal, leaf| Goal::And(Box::new(goal), Box::new(leaf)));
+                            //.expect("at least one goal");
+            let goal = goal //Goal::Implies(hypotheses, Box::new(goal))
+                .map(|goal| goal.quantify(QuantifierKind::ForAll, assoc_ty.value.binders.clone()));//binders);
+
+            // FIXME this is wrong (and test)!
+            let mut bound_binders = assoc_ty.value.binders.clone();
+            bound_binders.extend(trait_datum.binders.binders.iter());
+
+            let hypotheses =
+                assoc_ty_datum.where_clauses
+                              .iter()
+                              .chain(impl_datum.binders.value.where_clauses.iter())  // FIXME binders (and test)!
+                              .cloned()
+                              .map(|wc| wc.map(|bound| bound.into_from_env_goal()))
+                              .casted()
+                              .collect();
+            let bound_goal = bounds.iter()
+                                   .flat_map(|b| b.clone()
+                                   .lower_with_self(assoc_ty.value.value.ty.clone()))
+                                   .map(|g| g.into_well_formed_goal().cast())
+                                   .fold1(|goal, leaf| Goal::And(Box::new(goal), Box::new(leaf)));
+            let bound_goal = bound_goal.map(|g| {
+                Goal::Implies(hypotheses, Box::new(g)).quantify(QuantifierKind::ForAll, bound_binders)
+            });
+
+            let goal = goal.into_iter()
+                           .chain(bound_goal.into_iter())
+                           .fold1(|goal, leaf| Goal::And(Box::new(goal), Box::new(leaf)));
+            println!("{:?}", goal);
+
+            goal
         };
 
         let assoc_ty_goals =