Update doc and refactor some parts of the lowering process

Author: scalexm

chalk-parse/src/ast.rs

@@ -1,7 +1,7 @@
 use lalrpop_intern::InternedString;
 use std::fmt;
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct Span {
     pub lo: usize,
     pub hi: usize,
@@ -13,17 +13,20 @@ impl Span {
     }
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Program {
     pub items: Vec<Item>
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum Item {
     StructDefn(StructDefn),
     TraitDefn(TraitDefn),
     Impl(Impl),
     Clause(Clause),
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct StructDefn {
     pub name: Identifier,
     pub parameter_kinds: Vec<ParameterKind>,
@@ -32,11 +35,13 @@ pub struct StructDefn {
     pub flags: StructFlags,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct StructFlags {
     pub external: bool,
     pub fundamental: bool,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct TraitDefn {
     pub name: Identifier,
     pub parameter_kinds: Vec<ParameterKind>,
@@ -45,43 +50,50 @@ pub struct TraitDefn {
     pub flags: TraitFlags,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct TraitFlags {
     pub auto: bool,
     pub marker: bool,
     pub external: bool,
     pub deref: bool,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct AssocTyDefn {
     pub name: Identifier,
     pub parameter_kinds: Vec<ParameterKind>,
     pub bounds: Vec<InlineBound>,
     pub where_clauses: Vec<QuantifiedWhereClause>,
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum ParameterKind {
     Ty(Identifier),
     Lifetime(Identifier),
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum Parameter {
     Ty(Ty),
     Lifetime(Lifetime),
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 /// An inline bound, e.g. `: Foo<K>` in `impl<K, T: Foo<K>> SomeType<T>`.
 pub enum InlineBound {
     TraitBound(TraitBound),
     ProjectionEqBound(ProjectionEqBound),
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 /// Represents a trait bound on e.g. a type or type parameter.
 /// Does not know anything about what it's binding.
 pub struct TraitBound {
     pub trait_name: Identifier,
     pub args_no_self: Vec<Parameter>,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 /// Represents a projection equality bound on e.g. a type or type parameter.
 /// Does not know anything about what it's binding.
 pub struct ProjectionEqBound {
@@ -91,7 +103,7 @@ pub struct ProjectionEqBound {
     pub value: Ty,
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum Kind {
     Ty,
     Lifetime,
@@ -130,19 +142,22 @@ impl Kinded for Parameter {
     }
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Impl {
     pub parameter_kinds: Vec<ParameterKind>,
     pub trait_ref: PolarizedTraitRef,
     pub where_clauses: Vec<QuantifiedWhereClause>,
     pub assoc_ty_values: Vec<AssocTyValue>,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct AssocTyValue {
     pub name: Identifier,
     pub parameter_kinds: Vec<ParameterKind>,
     pub value: Ty,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum Ty {
     Id {
         name: Identifier,
@@ -163,28 +178,33 @@ pub enum Ty {
     }
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum Lifetime {
     Id {
         name: Identifier,
     }
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct ProjectionTy {
     pub trait_ref: TraitRef,
     pub name: Identifier,
     pub args: Vec<Parameter>,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct UnselectedProjectionTy {
     pub name: Identifier,
     pub args: Vec<Parameter>,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct TraitRef {
     pub trait_name: Identifier,
     pub args: Vec<Parameter>,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum PolarizedTraitRef {
     Positive(TraitRef),
     Negative(TraitRef),
@@ -200,17 +220,19 @@ impl PolarizedTraitRef {
     }
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct Identifier {
     pub str: InternedString,
     pub span: Span,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum WhereClause {
     Implemented { trait_ref: TraitRef },
     ProjectionEq { projection: ProjectionTy, ty: Ty },
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum DomainGoal {
     Holds { where_clause: WhereClause },
     Normalize { projection: ProjectionTy, ty: Ty },
@@ -223,22 +245,26 @@ pub enum DomainGoal {
     IsLocal { ty: Ty },
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum LeafGoal {
     DomainGoal { goal: DomainGoal },
     UnifyTys { a: Ty, b: Ty },
     UnifyLifetimes { a: Lifetime, b: Lifetime },
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct QuantifiedWhereClause {
     pub parameter_kinds: Vec<ParameterKind>,
     pub where_clause: WhereClause,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Field {
     pub name: Identifier,
     pub ty: Ty,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 /// This allows users to add arbitrary `A :- B` clauses into the
 /// logic; it has no equivalent in Rust, but it's useful for testing.
 pub struct Clause {
@@ -247,6 +273,7 @@ pub struct Clause {
     pub conditions: Vec<Box<Goal>>,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum Goal {
     ForAll(Vec<ParameterKind>, Box<Goal>),
     Exists(Vec<ParameterKind>, Box<Goal>),

src/ir.rs

@@ -295,7 +295,7 @@ impl TraitBound {
         vec![WhereClause::Implemented(trait_ref)]
     }
 
-    fn as_trait_ref(&self, self_ty: Ty) -> TraitRef {
+    crate fn as_trait_ref(&self, self_ty: Ty) -> TraitRef {
         let self_ty = ParameterKind::Ty(self_ty);
         TraitRef {
             trait_id: self.trait_id,

src/ir/lowering.rs

@@ -418,14 +418,14 @@ trait LowerWhereClauseVec<T> {
 
 impl LowerWhereClauseVec<ir::WhereClause> for [WhereClause] {
     fn lower(&self, env: &Env) -> Result<Vec<ir::WhereClause>> {
-        self.iter().flat_map(|wc| LowerWhereClause::lower(wc, env).apply_result()).collect()
+        self.iter().flat_map(|wc| wc.lower(env).apply_result()).collect()
     }
 }
 
 impl LowerWhereClauseVec<ir::QuantifiedWhereClause> for [QuantifiedWhereClause] {
     fn lower(&self, env: &Env) -> Result<Vec<ir::QuantifiedWhereClause>> {
         self.iter()
-            .flat_map(|wc| match LowerWhereClause::lower(wc, env) {
+            .flat_map(|wc| match wc.lower(env) {
                 Ok(v) => v.into_iter().map(Ok).collect(),
                 Err(e) => vec![Err(e)],
             })
@@ -434,6 +434,10 @@ impl LowerWhereClauseVec<ir::QuantifiedWhereClause> for [QuantifiedWhereClause]
 }
 
 trait LowerWhereClause<T> {
+    /// Lower from an AST `where` clause to an internal IR.
+    /// Some AST `where` clauses can lower to multiple ones, this is why we return a `Vec`.
+    /// As for now, this is the only the case for `where T: Foo<Item = U>` which lowers to
+    /// `Implemented(T: Foo)` and `ProjectionEq(<T as Foo>::Item = U)`.
     fn lower(&self, env: &Env) -> Result<Vec<T>>;
 }
 
@@ -464,7 +468,7 @@ impl LowerWhereClause<ir::QuantifiedWhereClause> for QuantifiedWhereClause {
     fn lower(&self, env: &Env) -> Result<Vec<ir::QuantifiedWhereClause>> {
         let parameter_kinds = self.parameter_kinds.iter().map(|pk| pk.lower());
         let binders = env.in_binders(parameter_kinds, |env| {
-            Ok(LowerWhereClause::lower(&self.where_clause, env)?)
+            Ok(self.where_clause.lower(env)?)
         })?;
         Ok(binders.into_iter().collect())
     }
@@ -474,14 +478,6 @@ trait LowerDomainGoal {
     fn lower(&self, env: &Env) -> Result<Vec<ir::DomainGoal>>;
 }
 
-/// Lowers a where-clause in the context of a clause (i.e. in "negative"
-/// position); this is limited to the kinds of where-clauses users can actually
-/// type in Rust and well-formedness checks.
-/// 
-/// Lowers a where-clause in the context of a goal (i.e. in "positive"
-/// position); this is richer in terms of the legal sorts of where-clauses that
-/// can appear, because it includes all the sorts of things that the compiler
-/// must verify.
 impl LowerDomainGoal for DomainGoal {
     fn lower(&self, env: &Env) -> Result<Vec<ir::DomainGoal>> {
         let goals = match self {
@@ -614,46 +610,22 @@ trait LowerTraitRef {
 
 impl LowerTraitRef for TraitRef {
     fn lower(&self, env: &Env) -> Result<ir::TraitRef> {
-        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
-            .iter()
-            .map(|a| Ok(a.lower(env)?))
-            .collect::<Result<Vec<_>>>()?;
-
-        if parameters.len() != k.binders.len() + 1 {
-            bail!(
-                "wrong number of parameters, expected `{:?}`, got `{:?}`",
-                k.binders.len() + 1,
-                parameters.len()
-            )
-        }
-
-        for (binder, param) in k.binders.binders.iter().zip(parameters.iter().skip(1)) {
-            check_type_kinds("incorrect kind for trait parameter", binder, param)?;
-        }
+        let without_self = TraitBound {
+            trait_name: self.trait_name,
+            args_no_self: self.args.iter().cloned().skip(1).collect(),
+        }.lower(env)?;
 
-        Ok(ir::TraitRef {
-            trait_id: id,
-            parameters: parameters,
-        })
+        let self_parameter = self.args[0].lower(env)?;
+        Ok(without_self.as_trait_ref(self_parameter.ty().unwrap()))
     }
 }
 
 trait LowerTraitBound {
-    fn lower_trait_bound(&self, env: &Env) -> Result<ir::TraitBound>;
+    fn lower(&self, env: &Env) -> Result<ir::TraitBound>;
 }
 
 impl LowerTraitBound for TraitBound {
-    fn lower_trait_bound(&self, env: &Env) -> Result<ir::TraitBound> {
+    fn lower(&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)),
@@ -688,19 +660,13 @@ impl LowerTraitBound for TraitBound {
     }
 }
 
-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)?))
-    }
+trait LowerProjectionEqBound {
+    fn lower(&self, env: &Env) -> Result<ir::ProjectionEqBound>;
 }
 
-impl LowerInlineBound for ProjectionEqBound {
-    fn lower(&self, env: &Env) -> Result<ir::InlineBound> {
-        let trait_bound = self.trait_bound.lower_trait_bound(env)?;
+impl LowerProjectionEqBound for ProjectionEqBound {
+    fn lower(&self, env: &Env) -> Result<ir::ProjectionEqBound> {
+        let trait_bound = self.trait_bound.lower(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),
@@ -719,21 +685,30 @@ impl LowerInlineBound for ProjectionEqBound {
             check_type_kinds("incorrect kind for associated type parameter", param, arg)?;
         }
 
-        Ok(ir::InlineBound::ProjectionEqBound(ir::ProjectionEqBound {
+        Ok(ir::ProjectionEqBound {
             trait_bound,
             associated_ty_id: info.id,
             parameters: args,
             value: self.value.lower(env)?,
-        }))
+        })
     }
 }
 
+trait LowerInlineBound {
+    fn lower(&self, env: &Env) -> Result<ir::InlineBound>;
+}
+
 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),
-        }
+        let bound = match self {
+            InlineBound::TraitBound(b) => ir::InlineBound::TraitBound(
+                b.lower(&env)?
+            ),
+            InlineBound::ProjectionEqBound(b) => ir::InlineBound::ProjectionEqBound(
+                b.lower(&env)?
+            ),
+        };
+        Ok(bound)
     }
 }