WIP

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

@@ -222,6 +222,15 @@ pub enum Ty {
     /// an empty list).
     Apply(ApplicationTy),
 
+    Dyn(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(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

@@ -151,6 +151,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

@@ -168,6 +168,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 },
     <proj:UnselectedProjectionTy> => Ty::UnselectedProjection { <> },

chalk-solve/src/solve/slg.rs

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

src/lowering.rs

@@ -876,6 +876,18 @@ impl LowerTy for Ty {
                 NameLookup::Parameter(d) => Ok(chalk_ir::Ty::BoundVar(d)),
             },
 
+            Ty::Dyn { bounds } => Ok(chalk_ir::Ty::Dyn(
+                bounds.lower()?
+                    .flat_map(|qil| qil.into_where_clauses(chalk_ir::Ty::BoundVar(qil.binders.len())))
+                    .collect()
+            )),
+
+            Ty::Opaque { bounds } => Ok(chalk_ir::Ty::Opaque(
+                bounds.lower()?
+                    .flat_map(|qil| qil.into_where_clauses(chalk_ir::Ty::BoundVar(qil.binders.len())))
+                    .collect()
+            )),
+
             Ty::Apply { name, ref args } => {
                 let id = match env.lookup(name)? {
                     NameLookup::Type(id) => id,