Merge pull request #110 from leodasvacas/deref-first-class-domain-goal

Deref domain goal

Author: nikomatsakis

chalk-parse/src/ast.rs

@@ -48,6 +48,7 @@ pub struct TraitFlags {
     pub auto: bool,
     pub marker: bool,
     pub external: bool,
+    pub deref: bool,
 }
 
 pub struct AssocTyDefn {
@@ -192,6 +193,7 @@ pub enum WhereClause {
     UnifyTys { a: Ty, b: Ty },
     UnifyLifetimes { a: Lifetime, b: Lifetime },
     TraitInScope { trait_name: Identifier },
+    Derefs { source: Ty, target: Ty },
 }
 
 pub struct QuantifiedWhereClause {

chalk-parse/src/parser.lalrpop

@@ -38,6 +38,7 @@ Goal1: Box<Goal> = {
 ExternalKeyword: () = "extern";
 AutoKeyword: () = "#" "[" "auto" "]";
 MarkerKeyword: () = "#" "[" "marker" "]";
+DerefLangItem: () = "#" "[" "lang_deref" "]";
 
 StructDefn: StructDefn = {
     <external:ExternalKeyword?> "struct" <n:Id><p:Angle<ParameterKind>>
@@ -54,7 +55,7 @@ StructDefn: StructDefn = {
 };
 
 TraitDefn: TraitDefn = {
-    <external:ExternalKeyword?> <auto:AutoKeyword?> <marker:MarkerKeyword?> "trait" <n:Id><p:Angle<ParameterKind>>
+    <external:ExternalKeyword?> <auto:AutoKeyword?> <marker:MarkerKeyword?> <deref:DerefLangItem?> "trait" <n:Id><p:Angle<ParameterKind>>
         <w:QuantifiedWhereClauses> "{" <a:AssocTyDefn*> "}" => TraitDefn
     {
         name: n,
@@ -65,6 +66,7 @@ TraitDefn: TraitDefn = {
             auto: auto.is_some(),
             marker: marker.is_some(),
             external: external.is_some(),
+            deref: deref.is_some(),
         },
     }
 };
@@ -239,6 +241,7 @@ WhereClause: WhereClause = {
     },
 
     "InScope" "(" <t:Id> ")" => WhereClause::TraitInScope { trait_name: t },
+    "Derefs" "(" <source:Ty> "," <target:Ty> ")" => WhereClause::Derefs { source, target },
 };
 
 QuantifiedWhereClause: QuantifiedWhereClause = {

src/errors.rs

@@ -50,5 +50,10 @@ error_chain! {
             description("could not match")
                 display("could not match")
         }
+
+        DuplicateLangItem(item: ir::LangItem) {
+            description("Duplicate lang item")
+                display("Duplicate lang item `{:?}`", item)
+        }
     }
 }

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), Derefs(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!(Derefs { 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::Derefs(n) => write!(fmt, "Derefs({:?})", n),
         }
     }
 }

src/ir/mod.rs

@@ -38,6 +38,9 @@ pub struct Program {
 
     /// For each user-specified clause
     crate custom_clauses: Vec<ProgramClause>,
+
+    /// Special types and traits.
+    crate lang_items: BTreeMap<LangItem, ItemId>,
 }
 
 impl Program {
@@ -71,6 +74,11 @@ pub struct ProgramEnvironment {
     crate program_clauses: Vec<ProgramClause>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum LangItem {
+    DerefTrait,
+}
+
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 /// The set of assumptions we've made so far, and the current number of
 /// universal (forall) quantifiers we're within.
@@ -244,6 +252,7 @@ pub struct TraitFlags {
     crate auto: bool,
     crate marker: bool,
     crate external: bool,
+    pub deref: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -454,6 +463,12 @@ pub enum WhereClauseAtom {
     ProjectionEq(ProjectionEq),
 }
 
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+pub struct Derefs {
+    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 +531,13 @@ pub enum DomainGoal {
     FromEnvTy(Ty),
 
     InScope(ItemId),
+
+    /// Whether a type can deref into another. Right now this is just:
+    /// ```notrust
+    /// Derefs(T, U) :- Implemented(T: Deref<Target = U>)
+    /// ```
+    /// In Rust there are also raw pointers which can be deref'd but do not implement Deref.
+    Derefs(Derefs)
 }
 
 pub type QuantifiedDomainGoal = Binders<DomainGoal>;

src/lower/mod.rs

@@ -172,6 +172,7 @@ impl LowerProgram for Program {
         let mut impl_data = BTreeMap::new();
         let mut associated_ty_data = BTreeMap::new();
         let mut custom_clauses = Vec::new();
+        let mut lang_items = BTreeMap::new();
         for (item, &item_id) in self.items.iter().zip(&item_ids) {
             let empty_env = Env {
                 type_ids: &type_ids,
@@ -204,6 +205,16 @@ impl LowerProgram for Program {
                             },
                         );
                     }
+
+                    if d.flags.deref {
+                        use std::collections::btree_map::Entry::*;
+                        match lang_items.entry(ir::LangItem::DerefTrait) {
+                            Vacant(entry) => { entry.insert(item_id); },
+                            Occupied(_) => {
+                                bail!(ErrorKind::DuplicateLangItem(ir::LangItem::DerefTrait))
+                            }
+                        }
+                    }
                 }
                 Item::Impl(ref d) => {
                     impl_data.insert(item_id, d.lower_impl(&empty_env)?);
@@ -222,6 +233,7 @@ impl LowerProgram for Program {
             impl_data,
             associated_ty_data,
             custom_clauses,
+            lang_items,
             default_impl_data: Vec::new(),
         };
         program.add_default_impls();
@@ -472,6 +484,12 @@ impl LowerWhereClause<ir::DomainGoal> for WhereClause {
 
                 ir::DomainGoal::InScope(id)
             }
+            WhereClause::Derefs { source, target } => {
+                ir::DomainGoal::Derefs(ir::Derefs { 
+                                        source: source.lower(env)?, 
+                                        target: target.lower(env)?
+                                    })
+            }
         })
     }
 }
@@ -499,7 +517,8 @@ impl LowerWhereClause<ir::LeafGoal> for WhereClause {
             | WhereClause::TyWellFormed { .. }
             | WhereClause::TraitRefWellFormed { .. }
             | WhereClause::TyFromEnv { .. }
-            | WhereClause::TraitRefFromEnv { .. } => {
+            | WhereClause::TraitRefFromEnv { .. }
+            | WhereClause::Derefs { .. } => {
                 let g: ir::DomainGoal = self.lower(env)?;
                 g.cast()
             }
@@ -903,6 +922,7 @@ impl LowerTrait for TraitDefn {
                     auto: self.flags.auto,
                     marker: self.flags.marker,
                     external: self.flags.external,
+                    deref: self.flags.deref,
                 },
             })
         })?;
@@ -1026,6 +1046,31 @@ impl ir::Program {
         );
         program_clauses.extend(self.default_impl_data.iter().map(|d| d.to_program_clause()));
 
+        // Adds clause that defines the Derefs domain goal:
+        // forall<T, U> { Derefs(T, U) :- ProjectionEq(<T as Deref>::Target = U>) }
+        if let Some(trait_id) = self.lang_items.get(&ir::LangItem::DerefTrait) {
+            // Find `Deref::Target`.
+            let associated_ty_id = self.associated_ty_data.values()
+                                                        .find(|d| d.trait_id == *trait_id)
+                                                        .expect("Deref has no assoc item")
+                                                        .id;
+            let t = || ir::Ty::Var(0);
+            let u = || ir::Ty::Var(1);
+            program_clauses.push(ir::Binders {
+                binders: vec![ir::ParameterKind::Ty(()), ir::ParameterKind::Ty(())],
+                value: ir::ProgramClauseImplication {
+                    consequence: ir::DomainGoal::Derefs(ir::Derefs { source: t(), target: u() }),
+                    conditions: vec![ir::ProjectionEq {
+                        projection: ir::ProjectionTy { 
+                            associated_ty_id,
+                            parameters: vec![t().cast()]
+                        },
+                        ty: u(),
+                    }.cast()]
+                },
+            }.cast());
+        }
+
         for datum in self.impl_data.values() {
             // If we encounter a negative impl, do not generate any rule. Negative impls
             // are currently just there to deactivate default impls for auto traits.

src/lower/test.rs

@@ -850,3 +850,21 @@ fn higher_ranked_cyclic_requirements() {
         }
     }
 }
+
+#[test]
+fn deref_trait() {
+    lowering_success! {
+        program {
+            #[lang_deref] trait Deref { type Target; }
+        }
+    }
+
+    lowering_error! {
+        program {
+            #[lang_deref] trait Deref { }
+            #[lang_deref] trait DerefDupe { }
+        } error_msg {
+            "Duplicate lang item `DerefTrait`"
+        }
+    }
+}

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::Derefs(..) => panic!("unexpected where clause"),
 
             DomainGoal::InScope(..) => (),
         }

src/solve/test/mod.rs

@@ -2058,3 +2058,52 @@ fn higher_ranked_implied_bounds() {
         }
     }
 }
+
+#[test]
+fn deref_goal() {
+    test! {
+        program {
+            #[lang_deref]
+            trait Deref { type Target; }
+            struct Foo { }
+            struct Bar { }
+            struct Baz { }
+            impl Deref for Foo { type Target = Bar; }
+        }
+
+        goal {
+            Derefs(Foo, Bar)
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            Derefs(Foo, Baz)
+        } yields {
+            "No possible solution"
+        }
+    }
+    
+    test! {
+        program {
+            #[lang_deref]
+            trait Deref { type Target; }
+            struct Arc<T> { }
+            struct i32 { }
+            struct u64 { }
+            impl<T> Deref for Arc<T> { type Target = T; }
+        }
+
+        goal {
+            Derefs(Arc<i32>, i32)
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            Derefs(Arc<i32>, u64)
+        } yields {
+            "No possible solution"
+        }
+    }
+}

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!(Derefs { 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,
+    Derefs
 });
 enum_zip!(LeafGoal { DomainGoal, EqGoal });
 enum_zip!(ProgramClause { Implies, ForAll });