Add and lower to ir::InlineBounds

Author: tmandry

src/ir.rs

@@ -258,6 +258,32 @@ pub struct TraitFlags {
     pub deref: bool,
 }
 
+/// An inline bound, e.g. `: Foo<K>` in `impl<K, T: Foo<K>> SomeType<T>`.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum InlineBound {
+    TraitBound(TraitBound),
+    ProjectionEqBound(ProjectionEqBound),
+}
+
+/// Represents a trait bound on e.g. a type or type parameter.
+/// Does not know anything about what it's binding.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TraitBound {
+    crate trait_id: ItemId,
+    crate args_no_self: Vec<Parameter>,
+}
+
+/// Represents a projection equality bound on e.g. a type or type parameter.
+/// Does not know anything about what it's binding.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ProjectionEqBound {
+    crate trait_bound: TraitBound,
+    crate associated_ty_id: ItemId,
+    /// Does not include trait parameters.
+    crate parameters: Vec<Parameter>,
+    crate value: Ty,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct AssociatedTyDatum {
     /// The trait this associated type is defined in.
@@ -273,7 +299,11 @@ pub struct AssociatedTyDatum {
     /// but possibly including more.
     crate parameter_kinds: Vec<ParameterKind<Identifier>>,
 
-    // FIXME: inline bounds on the associated ty need to be implemented
+    /// Bounds on the associated type itself.
+    ///
+    /// These must be proven by the implementer, for all possible parameters that
+    /// would result in a well-formed projection.
+    crate bounds: Vec<InlineBound>,
 
     /// Where clauses that must hold for the projection be well-formed.
     crate where_clauses: Vec<QuantifiedDomainGoal>,

src/ir/lowering.rs

@@ -191,6 +191,7 @@ impl LowerProgram for Program {
                                 id: info.id,
                                 name: defn.name.str,
                                 parameter_kinds: parameter_kinds,
+                                bounds: defn.bounds.lower(&env)?,
                                 where_clauses: defn.where_clauses.lower(&env)?,
                             },
                         );
@@ -638,6 +639,107 @@ impl LowerTraitRef for TraitRef {
     }
 }
 
+trait LowerTraitBound {
+    fn lower_trait_bound(&self, env: &Env) -> Result<ir::TraitBound>;
+}
+
+impl LowerTraitBound for TraitBound {
+    fn lower_trait_bound(&self, env: &Env) -> Result<ir::TraitBound> {
+        let id = match env.lookup(self.trait_name)? {
+            NameLookup::Type(id) => id,
+            NameLookup::Parameter(_) => bail!(ErrorKind::NotTrait(self.trait_name)),
+        };
+
+        let k = env.type_kind(id);
+        if k.sort != ir::TypeSort::Trait {
+            bail!(ErrorKind::NotTrait(self.trait_name));
+        }
+
+        let parameters = self.args_no_self
+                             .iter()
+                             .map(|a| Ok(a.lower(env)?))
+                             .collect::<Result<Vec<_>>>()?;
+
+        if parameters.len() != k.binders.len() {
+            bail!(
+                "wrong number of parameters, expected `{:?}`, got `{:?}`",
+                k.binders.len(),
+                parameters.len()
+            )
+        }
+
+        for (binder, param) in k.binders.binders.iter().zip(parameters.iter()) {
+            check_type_kinds("incorrect kind for trait parameter", binder, param)?;
+        }
+
+        Ok(ir::TraitBound {
+            trait_id: id,
+            args_no_self: parameters,
+        })
+    }
+}
+
+trait LowerInlineBound {
+    fn lower(&self, env: &Env) -> Result<ir::InlineBound>;
+}
+
+impl LowerInlineBound for TraitBound {
+    fn lower(&self, env: &Env) -> Result<ir::InlineBound> {
+        Ok(ir::InlineBound::TraitBound(self.lower_trait_bound(&env)?))
+    }
+}
+
+impl LowerInlineBound for ProjectionEqBound {
+    fn lower(&self, env: &Env) -> Result<ir::InlineBound> {
+        let trait_bound = self.trait_bound.lower_trait_bound(env)?;
+        let info = match env.associated_ty_infos.get(&(trait_bound.trait_id, self.name.str)) {
+            Some(info) => info,
+            None => bail!("no associated type `{}` defined in trait", self.name.str),
+        };
+        let args: Vec<_> = try!(self.args.iter().map(|a| a.lower(env)).collect());
+
+        if args.len() != info.addl_parameter_kinds.len() {
+            bail!(
+                "wrong number of parameters for associated type (expected {}, got {})",
+                info.addl_parameter_kinds.len(),
+                args.len()
+            )
+        }
+
+        for (param, arg) in info.addl_parameter_kinds.iter().zip(args.iter()) {
+            check_type_kinds("incorrect kind for associated type parameter", param, arg)?;
+        }
+
+        Ok(ir::InlineBound::ProjectionEqBound(ir::ProjectionEqBound {
+            trait_bound,
+            associated_ty_id: info.id,
+            parameters: args,
+            value: self.value.lower(env)?,
+        }))
+    }
+}
+
+impl LowerInlineBound for InlineBound {
+    fn lower(&self, env: &Env) -> Result<ir::InlineBound> {
+        match self {
+            InlineBound::TraitBound(b) => b.lower(&env),
+            InlineBound::ProjectionEqBound(b) => b.lower(&env),
+        }
+    }
+}
+
+trait LowerInlineBounds {
+    fn lower(&self, env: &Env) -> Result<Vec<ir::InlineBound>>;
+}
+
+impl LowerInlineBounds for Vec<InlineBound> {
+    fn lower(&self, env: &Env) -> Result<Vec<ir::InlineBound>> {
+        self.iter()
+            .map(|b| b.lower(env))
+            .collect()
+    }
+}
+
 trait LowerPolarizedTraitRef {
     fn lower(&self, env: &Env) -> Result<ir::PolarizedTraitRef>;
 }