Deref domain goal.

Author: leoyvens

src/fold/mod.rs

@@ -425,7 +425,7 @@ enum_fold!(PolarizedTraitRef[] { Positive(a), Negative(a) });
 enum_fold!(ParameterKind[T,L] { Ty(a), Lifetime(a) } where T: Fold, L: Fold);
 enum_fold!(WhereClauseAtom[] { Implemented(a), ProjectionEq(a) });
 enum_fold!(DomainGoal[] { Holds(a), WellFormed(a), FromEnv(a), Normalize(a), UnselectedNormalize(a),
-                          WellFormedTy(a), FromEnvTy(a), InScope(a) });
+                          WellFormedTy(a), FromEnvTy(a), InScope(a), Deref(a) });
 enum_fold!(LeafGoal[] { EqGoal(a), DomainGoal(a) });
 enum_fold!(Constraint[] { LifetimeEq(a, b) });
 enum_fold!(Goal[] { Quantified(qkind, subgoal), Implies(wc, subgoal), And(g1, g2), Not(g),
@@ -571,6 +571,7 @@ struct_fold!(AssociatedTyValueBound { ty, where_clauses });
 struct_fold!(Environment { clauses });
 struct_fold!(InEnvironment[F] { environment, goal } where F: Fold<Result = F>);
 struct_fold!(EqGoal { a, b });
+struct_fold!(Deref { source, target });
 struct_fold!(ProgramClauseImplication {
     consequence,
     conditions,

src/ir/debug.rs

@@ -205,6 +205,7 @@ impl Debug for DomainGoal {
             DomainGoal::WellFormedTy(t) => write!(fmt, "WellFormed({:?})", t),
             DomainGoal::FromEnvTy(t) => write!(fmt, "FromEnv({:?})", t),
             DomainGoal::InScope(n) => write!(fmt, "InScope({:?})", n),
+            DomainGoal::Deref(n) => write!(fmt, "Deref({:?})", n),
         }
     }
 }

src/ir/mod.rs

@@ -454,6 +454,12 @@ pub enum WhereClauseAtom {
     ProjectionEq(ProjectionEq),
 }
 
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+pub struct Deref {
+    pub source: Ty,
+    pub target: Ty,
+}
+
 /// A "domain goal" is a goal that is directly about Rust, rather than a pure
 /// logical statement. As much as possible, the Chalk solver should avoid
 /// decomposing this enum, and instead treat its values opaquely.
@@ -516,6 +522,14 @@ pub enum DomainGoal {
     FromEnvTy(Ty),
 
     InScope(ItemId),
+
+    /// Whether a type can Deref into another. Right now this is just:
+    /// ```notrust
+    /// Deref(T, U) :- Implemented(T: Deref<Target = U>)
+    /// ```
+    /// In Rust there are also raw pointers which can be deref'd
+    /// but do not implement Deref.
+    Deref(Deref)
 }
 
 pub type QuantifiedDomainGoal = Binders<DomainGoal>;

src/lower/wf.rs

@@ -138,7 +138,8 @@ impl FoldInputTypes for DomainGoal {
             DomainGoal::WellFormed(..) |
             DomainGoal::FromEnv(..) |
             DomainGoal::WellFormedTy(..) |
-            DomainGoal::FromEnvTy(..) => panic!("unexpected where clause"),
+            DomainGoal::FromEnvTy(..) |
+            DomainGoal::Deref(..) => panic!("unexpected where clause"),
 
             DomainGoal::InScope(..) => (),
         }

src/zip.rs

@@ -182,6 +182,7 @@ struct_zip!(ProjectionEq { projection, ty });
 struct_zip!(UnselectedNormalize { projection, ty });
 struct_zip!(EqGoal { a, b });
 struct_zip!(ProgramClauseImplication { consequence, conditions });
+struct_zip!(Deref { source, target });
 
 impl Zip for Environment {
     fn zip_with<Z: Zipper>(zipper: &mut Z, a: &Self, b: &Self) -> Fallible<()> {
@@ -225,6 +226,7 @@ enum_zip!(DomainGoal {
     WellFormedTy,
     FromEnvTy,
     InScope,
+    Deref
 });
 enum_zip!(LeafGoal { DomainGoal, EqGoal });
 enum_zip!(ProgramClause { Implies, ForAll });