Merge pull request #451 from jackh726/lifetime_outlives

nikomatsakis · web-flow · commit ea1ca4ddc43a · 2020-05-29T17:04:38.000-04:00
Add lifetime outlives goal
diff --git a/chalk-engine/src/simplify.rs b/chalk-engine/src/simplify.rs
@@ -5,7 +5,8 @@ use crate::{ExClause, Literal, TimeStamp};
 use chalk_ir::debug;
 use chalk_ir::interner::Interner;
 use chalk_ir::{
-    Environment, Fallible, Goal, GoalData, InEnvironment, QuantifierKind, Substitution,
+    Constraint, DomainGoal, Environment, Fallible, Goal, GoalData, InEnvironment, LifetimeOutlives,
+    QuantifierKind, Substitution, WhereClause,
 };
 
 impl<I: Interner, C: Context<I>> Forest<I, C> {
@@ -68,14 +69,22 @@ impl<I: Interner, C: Context<I>> Forest<I, C> {
                     &goal.b,
                     &mut ex_clause,
                 )?,
-                GoalData::DomainGoal(domain_goal) => {
-                    ex_clause
-                        .subgoals
-                        .push(Literal::Positive(InEnvironment::new(
+                GoalData::DomainGoal(domain_goal) => match domain_goal {
+                    DomainGoal::Holds(WhereClause::LifetimeOutlives(LifetimeOutlives { a, b })) => {
+                        ex_clause.constraints.push(InEnvironment::new(
                             &environment,
-                            context.into_goal(domain_goal.clone()),
-                        )));
-                }
+                            Constraint::Outlives(a.clone(), b.clone()),
+                        ));
+                    }
+                    _ => {
+                        ex_clause
+                            .subgoals
+                            .push(Literal::Positive(InEnvironment::new(
+                                &environment,
+                                context.into_goal(domain_goal.clone()),
+                            )));
+                    }
+                },
                 GoalData::CannotProve(()) => {
                     debug!("Marking Strand as ambiguous because of a `CannotProve` subgoal");
                     ex_clause.ambiguous = true;
diff --git a/chalk-integration/src/lowering.rs b/chalk-integration/src/lowering.rs
@@ -874,6 +874,14 @@ impl LowerWhereClause<chalk_ir::WhereClause<ChalkIr>> for WhereClause {
                 }),
                 chalk_ir::WhereClause::Implemented(projection.trait_ref.lower(env)?),
             ],
+            WhereClause::LifetimeOutlives { a, b } => {
+                vec![chalk_ir::WhereClause::LifetimeOutlives(
+                    chalk_ir::LifetimeOutlives {
+                        a: a.lower(env)?,
+                        b: b.lower(env)?,
+                    },
+                )]
+            }
         };
         Ok(where_clauses)
     }
diff --git a/chalk-ir/src/cast.rs b/chalk-ir/src/cast.rs
@@ -98,6 +98,12 @@ impl<I: Interner> CastTo<WhereClause<I>> for AliasEq<I> {
     }
 }
 
+impl<I: Interner> CastTo<WhereClause<I>> for LifetimeOutlives<I> {
+    fn cast_to(self, _interner: &I) -> WhereClause<I> {
+        WhereClause::LifetimeOutlives(self)
+    }
+}
+
 impl<T, I> CastTo<DomainGoal<I>> for T
 where
     T: CastTo<WhereClause<I>>,
diff --git a/chalk-ir/src/debug.rs b/chalk-ir/src/debug.rs
@@ -536,6 +536,12 @@ impl<'me, I: Interner> SeparatorTraitRef<'me, I> {
     }
 }
 
+impl<I: Interner> Debug for LifetimeOutlives<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        write!(fmt, "{:?}: {:?}", self.a, self.b)
+    }
+}
+
 pub struct ProjectionTyDebug<'a, I: Interner> {
     projection_ty: &'a ProjectionTy<I>,
     interner: &'a I,
@@ -630,6 +636,7 @@ impl<I: Interner> Debug for WhereClause<I> {
         match self {
             WhereClause::Implemented(tr) => write!(fmt, "Implemented({:?})", tr.with_colon()),
             WhereClause::AliasEq(a) => write!(fmt, "{:?}", a),
+            WhereClause::LifetimeOutlives(l_o) => write!(fmt, "{:?}", l_o),
         }
     }
 }
diff --git a/chalk-ir/src/lib.rs b/chalk-ir/src/lib.rs
@@ -1184,11 +1184,17 @@ impl<I: Interner> TraitRef<I> {
     }
 }
 
+#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner, Zip)]
+pub struct LifetimeOutlives<I: Interner> {
+    pub a: Lifetime<I>,
+    pub b: Lifetime<I>,
+}
 /// Where clauses that can be written by a Rust programmer.
 #[derive(Clone, PartialEq, Eq, Hash, Fold, SuperVisit, HasInterner, Zip)]
 pub enum WhereClause<I: Interner> {
     Implemented(TraitRef<I>),
     AliasEq(AliasEq<I>),
+    LifetimeOutlives(LifetimeOutlives<I>),
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner, Zip)]
diff --git a/chalk-parse/src/ast.rs b/chalk-parse/src/ast.rs
@@ -331,6 +331,7 @@ impl fmt::Display for Identifier {
 pub enum WhereClause {
     Implemented { trait_ref: TraitRef },
     ProjectionEq { projection: ProjectionTy, ty: Ty },
+    LifetimeOutlives { a: Lifetime, b: Lifetime },
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/chalk-parse/src/parser.lalrpop b/chalk-parse/src/parser.lalrpop
@@ -367,6 +367,11 @@ WhereClause: WhereClause = {
         let projection = ProjectionTy { trait_ref, name, args: a2 };
         WhereClause::ProjectionEq { projection, ty }
     },
+
+    // 'a: 'b
+    <a:Lifetime> ":" <b:Lifetime> => {
+        WhereClause::LifetimeOutlives { a, b }
+    }
 };
 
 QuantifiedWhereClause: QuantifiedWhereClause = {
diff --git a/chalk-solve/src/clauses.rs b/chalk-solve/src/clauses.rs
@@ -322,6 +322,7 @@ fn program_clauses_that_could_match<I: Interner>(
                 .opaque_ty_data(opaque_ty.opaque_ty_id)
                 .to_program_clauses(builder),
         },
+        DomainGoal::Holds(WhereClause::LifetimeOutlives(_)) => {}
         DomainGoal::WellFormed(WellFormed::Trait(trait_ref))
         | DomainGoal::LocalImplAllowed(trait_ref) => {
             db.trait_datum(trait_ref.trait_id)
diff --git a/chalk-solve/src/clauses/dyn_ty.rs b/chalk-solve/src/clauses/dyn_ty.rs
@@ -72,6 +72,7 @@ pub(super) fn build_dyn_self_ty_clauses<I: Interner>(
                 }
                 // Associated item bindings are just taken as facts (?)
                 WhereClause::AliasEq(_) => builder.push_fact(wc),
+                WhereClause::LifetimeOutlives(..) => {}
             });
         }
     });
@@ -160,6 +161,7 @@ pub fn super_traits<I: Interner>(
                                 Some(tr.clone())
                             }
                             WhereClause::AliasEq(_) => None,
+                            WhereClause::LifetimeOutlives(..) => None,
                         })
                     })
                     .collect::<Vec<_>>()
diff --git a/chalk-solve/src/coinductive_goal.rs b/chalk-solve/src/coinductive_goal.rs
@@ -24,6 +24,7 @@ impl<I: Interner> IsCoinductive<I> for Goal<I> {
                         || db.trait_datum(tr.trait_id).is_coinductive_trait()
                 }
                 WhereClause::AliasEq(..) => false,
+                WhereClause::LifetimeOutlives(..) => false,
             },
             GoalData::DomainGoal(DomainGoal::WellFormed(WellFormed::Trait(..))) => true,
             GoalData::Quantified(QuantifierKind::ForAll, goal) => {
diff --git a/chalk-solve/src/infer/unify.rs b/chalk-solve/src/infer/unify.rs
@@ -81,9 +81,8 @@ impl<'t, I: Interner> Unifier<'t, I> {
         })
     }
 
-    fn unify_ty_ty<'a>(&mut self, a: &'a Ty<I>, b: &'a Ty<I>) -> Fallible<()> {
+    fn unify_ty_ty(&mut self, a: &Ty<I>, b: &Ty<I>) -> Fallible<()> {
         let interner = self.interner;
-        //         ^^                 ^^         ^^ FIXME rustc bug
 
         let n_a = self.table.normalize_ty_shallow(interner, a);
         let n_b = self.table.normalize_ty_shallow(interner, b);
@@ -343,28 +342,12 @@ impl<'t, I: Interner> Unifier<'t, I> {
                 Ok(())
             }
 
-            (&LifetimeData::InferenceVar(var), &LifetimeData::Placeholder(idx))
-            | (&LifetimeData::Placeholder(idx), &LifetimeData::InferenceVar(var)) => {
-                let var = EnaVariable::from(var);
-                let var_ui = self.table.universe_of_unbound_var(var);
-                if var_ui.can_see(idx.ui) {
-                    debug!(
-                        "unify_lifetime_lifetime: {:?} in {:?} can see {:?}; unifying",
-                        var, var_ui, idx.ui
-                    );
-                    let v = LifetimeData::Placeholder(idx).intern(interner);
-                    self.table
-                        .unify
-                        .unify_var_value(var, InferenceValue::from_lifetime(interner, v))
-                        .unwrap();
-                    Ok(())
-                } else {
-                    debug!(
-                        "unify_lifetime_lifetime: {:?} in {:?} cannot see {:?}; pushing constraint",
-                        var, var_ui, idx.ui
-                    );
-                    Ok(self.push_lifetime_eq_constraint(a.clone(), b.clone()))
-                }
+            (&LifetimeData::InferenceVar(a_var), &LifetimeData::Placeholder(b_idx)) => {
+                self.unify_lifetime_var(a, b, a_var, b, b_idx.ui)
+            }
+
+            (&LifetimeData::Placeholder(a_idx), &LifetimeData::InferenceVar(b_var)) => {
+                self.unify_lifetime_var(a, b, b_var, a, a_idx.ui)
             }
 
             (&LifetimeData::Placeholder(_), &LifetimeData::Placeholder(_)) => {
@@ -384,6 +367,44 @@ impl<'t, I: Interner> Unifier<'t, I> {
         }
     }
 
+    fn unify_lifetime_var(
+        &mut self,
+        a: &Lifetime<I>,
+        b: &Lifetime<I>,
+        var: InferenceVar,
+        value: &Lifetime<I>,
+        value_ui: UniverseIndex,
+    ) -> Fallible<()> {
+        debug_heading!(
+            "unify_lifetime_var(var={:?}, value={:?}, value_ui={:?})",
+            var,
+            value,
+            value_ui
+        );
+        let var = EnaVariable::from(var);
+        let var_ui = self.table.universe_of_unbound_var(var);
+        if var_ui.can_see(value_ui) {
+            debug!(
+                "unify_lifetime_var: {:?} in {:?} can see {:?}; unifying",
+                var, var_ui, value_ui
+            );
+            self.table
+                .unify
+                .unify_var_value(
+                    var,
+                    InferenceValue::from_lifetime(&self.interner, value.clone()),
+                )
+                .unwrap();
+            Ok(())
+        } else {
+            debug!(
+                "unify_lifetime_var: {:?} in {:?} cannot see {:?}; pushing constraint",
+                var, var_ui, value_ui
+            );
+            Ok(self.push_lifetime_eq_constraint(a.clone(), b.clone()))
+        }
+    }
+
     fn unify_const_const<'a>(&mut self, a: &'a Const<I>, b: &'a Const<I>) -> Fallible<()> {
         let interner = self.interner;
 
diff --git a/chalk-solve/src/recursive/fulfill.rs b/chalk-solve/src/recursive/fulfill.rs
@@ -10,8 +10,9 @@ use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::zip::Zip;
 use chalk_ir::{debug, debug_heading};
 use chalk_ir::{
-    Canonical, ConstrainedSubst, Constraint, Environment, EqGoal, Fallible, Goal, GoalData,
-    InEnvironment, NoSolution, QuantifierKind, Substitution, UCanonical, UniverseMap,
+    Canonical, ConstrainedSubst, Constraint, DomainGoal, Environment, EqGoal, Fallible, Goal,
+    GoalData, InEnvironment, LifetimeOutlives, NoSolution, QuantifierKind, Substitution,
+    UCanonical, UniverseMap, WhereClause,
 };
 use rustc_hash::FxHashSet;
 use std::fmt::Debug;
@@ -207,10 +208,18 @@ impl<'s, 'db, I: Interner> Fulfill<'s, 'db, I> {
                 let in_env = InEnvironment::new(environment, subgoal.clone());
                 self.push_obligation(Obligation::Refute(in_env));
             }
-            GoalData::DomainGoal(_) => {
-                let in_env = InEnvironment::new(environment, goal);
-                self.push_obligation(Obligation::Prove(in_env));
-            }
+            GoalData::DomainGoal(domain_goal) => match domain_goal {
+                DomainGoal::Holds(WhereClause::LifetimeOutlives(LifetimeOutlives { a, b })) => {
+                    self.constraints.insert(InEnvironment::new(
+                        &environment,
+                        Constraint::Outlives(a.clone(), b.clone()),
+                    ));
+                }
+                _ => {
+                    let in_env = InEnvironment::new(environment, goal);
+                    self.push_obligation(Obligation::Prove(in_env));
+                }
+            },
             GoalData::EqGoal(EqGoal { a, b }) => {
                 self.unify(&environment, &a, &b)?;
             }
diff --git a/chalk-solve/src/wf.rs b/chalk-solve/src/wf.rs
@@ -83,6 +83,7 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {
             WhereClause::Implemented(trait_ref) => {
                 trait_ref.visit_with(self, outer_binder);
             }
+            WhereClause::LifetimeOutlives(..) => {}
         }
     }
 
diff --git a/tests/lowering/mod.rs b/tests/lowering/mod.rs
@@ -677,3 +677,12 @@ fn arrays() {
         }
     }
 }
+
+#[test]
+fn lifetime_outlives() {
+    lowering_success! {
+        program {
+            trait Foo<'a, 'b> where 'a: 'b {}
+        }
+    }
+}
diff --git a/tests/test/misc.rs b/tests/test/misc.rs
@@ -612,3 +612,33 @@ fn normalize_ambiguous() {
         }
     }
 }
+
+#[test]
+fn lifetime_outlives_constraints() {
+    test! {
+        program {
+            trait Foo<'a, 'b> where 'a: 'b {}
+            struct Bar {}
+
+            impl<'a, 'b> Foo<'a, 'b> for Bar where 'a: 'b {}
+        }
+
+        goal {
+            exists<'a, 'b> {
+                Bar: Foo<'a, 'b>
+            }
+        } yields {
+            "Unique; for<?U0,?U0> { substitution [?0 := '^0.0, ?1 := '^0.1], lifetime constraints [InEnvironment { environment: Env([]), goal: '^0.0: '^0.1 }] }"
+        }
+
+        goal {
+            forall<'a> {
+                exists<'b> {
+                    Bar: Foo<'a, 'b>
+                }
+            }
+        } yields {
+            "Unique; for<?U1> { substitution [?0 := '^0.0], lifetime constraints [InEnvironment { environment: Env([]), goal: '!1_0: '^0.0 }] }"
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,12 @@ impl<I: Interner> CastTo<WhereClause<I>> for AliasEq<I> {`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
	`101`	`+impl<I: Interner> CastTo<WhereClause<I>> for LifetimeOutlives<I> {`
	`102`	`+ fn cast_to(self, _interner: &I) -> WhereClause<I> {`
	`103`	`+ WhereClause::LifetimeOutlives(self)`
	`104`	`+ }`
	`105`	`+}`
	`106`	`+`
`101`	`107`	`impl<T, I> CastTo<DomainGoal<I>> for T`
`102`	`108`	`where`
`103`	`109`	`T: CastTo<WhereClause<I>>,`
Original file line number	Diff line number	Diff line change
`@@ -536,6 +536,12 @@ impl<'me, I: Interner> SeparatorTraitRef<'me, I> {`
`536`	`536`	`}`
`537`	`537`	`}`
`538`	`538`
	`539`	`+impl<I: Interner> Debug for LifetimeOutlives<I> {`
	`540`	`+ fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {`
	`541`	`+ write!(fmt, "{:?}: {:?}", self.a, self.b)`
	`542`	`+ }`
	`543`	`+}`
	`544`	`+`
`539`	`545`	`pub struct ProjectionTyDebug<'a, I: Interner> {`
`540`	`546`	`projection_ty: &'a ProjectionTy<I>,`
`541`	`547`	`interner: &'a I,`
`@@ -630,6 +636,7 @@ impl<I: Interner> Debug for WhereClause<I> {`
`630`	`636`	`match self {`
`631`	`637`	`WhereClause::Implemented(tr) => write!(fmt, "Implemented({:?})", tr.with_colon()),`
`632`	`638`	`WhereClause::AliasEq(a) => write!(fmt, "{:?}", a),`
	`639`	`+ WhereClause::LifetimeOutlives(l_o) => write!(fmt, "{:?}", l_o),`
`633`	`640`	`}`
`634`	`641`	`}`
`635`	`642`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1184,11 +1184,17 @@ impl<I: Interner> TraitRef<I> {`
`1184`	`1184`	`}`
`1185`	`1185`	`}`
`1186`	`1186`
	`1187`	`+#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner, Zip)]`
	`1188`	`+pub struct LifetimeOutlives<I: Interner> {`
	`1189`	`+ pub a: Lifetime<I>,`
	`1190`	`+ pub b: Lifetime<I>,`
	`1191`	`+}`
`1187`	`1192`	`/// Where clauses that can be written by a Rust programmer.`
`1188`	`1193`	`#[derive(Clone, PartialEq, Eq, Hash, Fold, SuperVisit, HasInterner, Zip)]`
`1189`	`1194`	`pub enum WhereClause<I: Interner> {`
`1190`	`1195`	`Implemented(TraitRef<I>),`
`1191`	`1196`	`AliasEq(AliasEq<I>),`
	`1197`	`+ LifetimeOutlives(LifetimeOutlives<I>),`
`1192`	`1198`	`}`
`1193`	`1199`
`1194`	`1200`	`#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner, Zip)]`
Original file line number	Diff line number	Diff line change
`@@ -331,6 +331,7 @@ impl fmt::Display for Identifier {`
`331`	`331`	`pub enum WhereClause {`
`332`	`332`	`Implemented { trait_ref: TraitRef },`
`333`	`333`	`ProjectionEq { projection: ProjectionTy, ty: Ty },`
	`334`	`+ LifetimeOutlives { a: Lifetime, b: Lifetime },`
`334`	`335`	`}`
`335`	`336`
`336`	`337`	`#[derive(Clone, PartialEq, Eq, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,7 @@ pub(super) fn build_dyn_self_ty_clauses<I: Interner>(`
`72`	`72`	`}`
`73`	`73`	`// Associated item bindings are just taken as facts (?)`
`74`	`74`	`WhereClause::AliasEq(_) => builder.push_fact(wc),`
	`75`	`+ WhereClause::LifetimeOutlives(..) => {}`
`75`	`76`	`});`
`76`	`77`	`}`
`77`	`78`	`});`
`@@ -160,6 +161,7 @@ pub fn super_traits<I: Interner>(`
`160`	`161`	`Some(tr.clone())`
`161`	`162`	`}`
`162`	`163`	`WhereClause::AliasEq(_) => None,`
	`164`	`+ WhereClause::LifetimeOutlives(..) => None,`
`163`	`165`	`})`
`164`	`166`	`})`
`165`	`167`	`.collect::<Vec<_>>()`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ impl<I: Interner> IsCoinductive<I> for Goal<I> {`
`24`	`24`	`\|\| db.trait_datum(tr.trait_id).is_coinductive_trait()`
`25`	`25`	`}`
`26`	`26`	`WhereClause::AliasEq(..) => false,`
	`27`	`+ WhereClause::LifetimeOutlives(..) => false,`
`27`	`28`	`},`
`28`	`29`	`GoalData::DomainGoal(DomainGoal::WellFormed(WellFormed::Trait(..))) => true,`
`29`	`30`	`GoalData::Quantified(QuantifierKind::ForAll, goal) => {`