Extend parser and IR to support impl/dyn Trait

Author: KiChjang

chalk-ir/src/debug.rs

@@ -85,6 +85,8 @@ impl Debug for Ty {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
         match self {
             Ty::BoundVar(depth) => write!(fmt, "^{}", depth),
+            Ty::Dyn(clauses) => write!(fmt, "{:?}", clauses),
+            Ty::Opaque(clauses) => write!(fmt, "{:?}", clauses),
             Ty::InferenceVar(var) => write!(fmt, "{:?}", var),
             Ty::Apply(apply) => write!(fmt, "{:?}", apply),
             Ty::Projection(proj) => write!(fmt, "{:?}", proj),

chalk-ir/src/fold.rs

@@ -341,6 +341,8 @@ pub fn super_fold_ty(folder: &mut dyn Folder, ty: &Ty, binders: usize) -> Fallib
                 Ok(Ty::BoundVar(depth))
             }
         }
+        Ty::Dyn(ref clauses) => Ok(Ty::Dyn(clauses.fold_with(folder, binders)?)),
+        Ty::Opaque(ref clauses) => Ok(Ty::Opaque(clauses.fold_with(folder, binders)?)),
         Ty::InferenceVar(var) => folder.fold_inference_ty(var, binders),
         Ty::Apply(ref apply) => {
             let ApplicationTy {

chalk-ir/src/lib.rs

@@ -235,6 +235,19 @@ pub enum Ty {
     /// an empty list).
     Apply(ApplicationTy),
 
+    /// A "dyn" type is a trait object type created via the "dyn Trait" syntax.
+    /// In the chalk parser, the traits that the object represents is parsed as
+    /// a QuantifiedInlineBound, and is then changed to a list of where clauses
+    /// during lowering.
+    Dyn(Binders<Vec<QuantifiedWhereClause>>),
+
+    /// An "opaque" type is one that is created via the "impl Trait" syntax.
+    /// They are named so because the concrete type implementing the trait
+    /// is unknown, and hence the type is opaque to us. The only information
+    /// that we know of is that this type implements the traits listed by the
+    /// user.
+    Opaque(Binders<Vec<QuantifiedWhereClause>>),
+
     /// A "projection" type corresponds to an (unnormalized)
     /// projection like `<P0 as Trait<P1..Pn>>::Foo`. Note that the
     /// trait and all its parameters are fully known.

chalk-parse/src/ast.rs

@@ -153,6 +153,12 @@ pub enum Ty {
     Id {
         name: Identifier,
     },
+    Dyn {
+        bounds: Vec<QuantifiedInlineBound>,
+    },
+    Opaque {
+        bounds: Vec<QuantifiedInlineBound>,
+    },
     Apply {
         name: Identifier,
         args: Vec<Parameter>,

chalk-parse/src/parser.lalrpop

@@ -171,6 +171,12 @@ pub Ty: Ty = {
 
 TyWithoutFor: Ty = {
     <n:Id> => Ty::Id { name: n},
+    "dyn" <b:Plus<QuantifiedInlineBound>> => Ty::Dyn {
+        bounds: b,
+    },
+    "impl" <b:Plus<QuantifiedInlineBound>> => Ty::Opaque {
+        bounds: b,
+    },
     <n:Id> "<" <a:Comma<Parameter>> ">" => Ty::Apply { name: n, args: a },
     <p:ProjectionTy> => Ty::Projection { proj: p },
     "(" <Ty> ")",

chalk-solve/src/solve/slg.rs

@@ -447,7 +447,11 @@ impl MayInvalidate {
             }
 
             // For everything else, be conservative here and just say we may invalidate.
-            (Ty::ForAll(_), _) | (Ty::Apply(_), _) | (Ty::Projection(_), _) => true,
+            (Ty::ForAll(_), _)
+            | (Ty::Dyn(_), _)
+            | (Ty::Opaque(_), _)
+            | (Ty::Apply(_), _)
+            | (Ty::Projection(_), _) => true,
         }
     }
 

src/lowering.rs

@@ -64,6 +64,7 @@ enum LifetimeLookup {
 }
 
 const SELF: &str = "Self";
+const FIXME_SELF: &str = "__FIXME_SELF__";
 
 impl<'k> Env<'k> {
     fn lookup(&self, name: Identifier) -> Fallible<NameLookup> {
@@ -857,6 +858,28 @@ impl LowerTy for Ty {
                 NameLookup::Parameter(d) => Ok(chalk_ir::Ty::BoundVar(d)),
             },
 
+            Ty::Dyn { bounds } => Ok(chalk_ir::Ty::Dyn(env.in_binders(
+                // FIXME: Figure out a proper name for this type parameter
+                Some(chalk_ir::ParameterKind::Ty(intern(FIXME_SELF))),
+                |env| {
+                    bounds
+                        .lower()?
+                        .flat_map(|qil| qil.into_where_clauses(chalk_ir::Ty::BoundVar(0)))
+                        .collect()
+                },
+            ))),
+
+            Ty::Opaque { bounds } => Ok(chalk_ir::Ty::Opaque(env.in_binders(
+                // FIXME: Figure out a proper name for this type parameter
+                Some(chalk_ir::ParameterKind::Ty(intern(FIXME_SELF))),
+                |env| {
+                    bounds
+                        .lower()?
+                        .flat_map(|qil| qil.into_where_clauses(chalk_ir::Ty::BoundVar(0)))
+                        .collect()
+                },
+            ))),
+
             Ty::Apply { name, ref args } => {
                 let id = match env.lookup(name)? {
                     NameLookup::Type(id) => id,