Merge pull request #492 from Areredify/dyn_lifetime

add lifetimes to trait objects

Author: nikomatsakis

chalk-integration/src/lowering.rs

@@ -1307,7 +1307,10 @@ impl LowerTy for Ty {
                     }
                 })
             }
-            Ty::Dyn { ref bounds } => Ok(chalk_ir::TyData::Dyn(chalk_ir::DynTy {
+            Ty::Dyn {
+                ref bounds,
+                ref lifetime,
+            } => Ok(chalk_ir::TyData::Dyn(chalk_ir::DynTy {
                 bounds: env.in_binders(
                     // FIXME: Figure out a proper name for this type parameter
                     Some(chalk_ir::WithKind::new(
@@ -1330,6 +1333,7 @@ impl LowerTy for Ty {
                         ))
                     },
                 )?,
+                lifetime: lifetime.lower(env)?,
             })
             .intern(interner)),
 

chalk-ir/src/debug.rs

@@ -206,8 +206,8 @@ impl Debug for DebruijnIndex {
 
 impl<I: Interner> Debug for DynTy<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        let DynTy { bounds } = self;
-        write!(fmt, "dyn {:?}", bounds)
+        let DynTy { bounds, lifetime } = self;
+        write!(fmt, "dyn {:?} + {:?}", bounds, lifetime)
     }
 }
 

chalk-ir/src/lib.rs

@@ -680,32 +680,33 @@ impl DebruijnIndex {
     }
 }
 
-/// A "DynTy" could be either a `dyn Trait` or an (opaque) `impl
-/// Trait`. Both of them are conceptually very related to a
-/// "existential type" of the form `exists<T> { T: Trait }`. The
-/// `DynTy` type represents those bounds.
+/// A "DynTy" represents a trait object (`dyn Trait`). Trait objects
+/// are conceptually very related to an "existential type" of the form
+/// `exists<T> { T: Trait }` (another exaple of such type is `impl Trait`).
+/// `DynTy` represents the bounds on that type.
 ///
 /// The "binder" here represents the unknown self type. So, a type like
-/// `impl for<'a> Fn(&'a u32)` would be represented with two-levels of
+/// `dyn for<'a> Fn(&'a u32)` would be represented with two-levels of
 /// binder, as "depicted" here:
 ///
 /// ```notrust
 /// exists<type> {
 ///    vec![
 ///        // A QuantifiedWhereClause:
-///        forall<region> { ^1: Fn(&^0 u32) }
+///        forall<region> { ^1.0: Fn(&^0.0 u32) }
 ///    ]
 /// }
 /// ```
 ///
 /// The outer `exists<type>` binder indicates that there exists
 /// some type that meets the criteria within, but that type is not
-/// known. It is referenced within the type using `^1`, indicating
+/// known. It is referenced within the type using `^1.0`, indicating
 /// a bound type with debruijn index 1 (i.e., skipping through one
 /// level of binder).
 #[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner, Zip)]
 pub struct DynTy<I: Interner> {
     pub bounds: Binders<QuantifiedWhereClauses<I>>,
+    pub lifetime: Lifetime<I>,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

chalk-parse/src/ast.rs

@@ -199,6 +199,7 @@ pub enum Ty {
     },
     Dyn {
         bounds: Vec<QuantifiedInlineBound>,
+        lifetime: Lifetime,
     },
     Apply {
         name: Identifier,

chalk-parse/src/parser.lalrpop

@@ -231,8 +231,9 @@ TyWithoutId: Ty = {
         lifetime_names: vec![],
         ty: Box::new(t)
     },
-    "dyn" <b:Plus<QuantifiedInlineBound>> => Ty::Dyn {
+    "dyn" <b:Plus<QuantifiedInlineBound>> "+" <l:Lifetime> => Ty::Dyn {
         bounds: b,
+        lifetime: l,
     },
     <n:Id> "<" <a:Comma<GenericArg>> ">" => Ty::Apply { name: n, args: a },
     <p:ProjectionTy> => Ty::Projection { proj: p },