implement name resolution in parser

Author: basil-cow

chalk-integration/src/error.rs

@@ -54,9 +54,8 @@ impl std::error::Error for ChalkError {}
 
 #[derive(Debug)]
 pub enum RustIrError {
-    InvalidTypeName(Identifier),
-    InvalidLifetimeName(Identifier),
-    InvalidConstName(Identifier),
+    InvalidParameterName(Identifier),
+    InvalidTraitName(Identifier),
     NotTrait(Identifier),
     NotStruct(Identifier),
     DuplicateOrShadowedParameters,
@@ -97,9 +96,10 @@ pub enum RustIrError {
 impl std::fmt::Display for RustIrError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            RustIrError::InvalidTypeName(name) => write!(f, "invalid type name `{}`", name),
-            RustIrError::InvalidLifetimeName(name) => write!(f, "invalid lifetime name `{}`", name),
-            RustIrError::InvalidConstName(name) => write!(f, "invalid const name `{}`", name),
+            RustIrError::InvalidParameterName(name) => {
+                write!(f, "invalid parameter name `{}`", name)
+            }
+            RustIrError::InvalidTraitName(name) => write!(f, "invalid trait name `{}`", name),
             RustIrError::NotTrait(name) => write!(
                 f,
                 "expected a trait, found `{}`, which is not a trait",

chalk-integration/src/lowering.rs

@@ -26,7 +26,7 @@ type TraitKinds = BTreeMap<chalk_ir::TraitId<ChalkIr>, TypeKind>;
 type AssociatedTyLookups = BTreeMap<(chalk_ir::TraitId<ChalkIr>, Ident), AssociatedTyLookup>;
 type AssociatedTyValueIds =
     BTreeMap<(chalk_ir::ImplId<ChalkIr>, Ident), AssociatedTyValueId<ChalkIr>>;
-type ParameterMap = BTreeMap<chalk_ir::ParameterKind<Ident>, BoundVar>;
+type ParameterMap = BTreeMap<Ident, chalk_ir::ParameterKind<BoundVar>>;
 
 pub type LowerResult<T> = Result<T, RustIrError>;
 
@@ -68,85 +68,96 @@ struct AssociatedTyLookup {
     addl_parameter_kinds: Vec<chalk_ir::ParameterKind<()>>,
 }
 
-enum TypeLookup {
-    Struct(chalk_ir::StructId<ChalkIr>),
-    Parameter(BoundVar),
-    Opaque(chalk_ir::OpaqueTyId<ChalkIr>),
-}
-
-enum LifetimeLookup {
-    Parameter(BoundVar),
-}
-
-enum ConstLookup {
-    Parameter(BoundVar),
+enum ApplyTypeLookup {
+    Struct(StructId<ChalkIr>),
 }
 
 const SELF: &str = "Self";
 const FIXME_SELF: &str = "__FIXME_SELF__";
 
 impl<'k> Env<'k> {
-    fn lookup_type(&self, name: Identifier) -> LowerResult<TypeLookup> {
-        if let Some(k) = self
-            .parameter_map
-            .get(&chalk_ir::ParameterKind::Ty(name.str))
-        {
-            return Ok(TypeLookup::Parameter(*k));
+    fn lookup_parameter(&self, name: Identifier) -> LowerResult<chalk_ir::Parameter<ChalkIr>> {
+        let interner = self.interner();
+
+        if let Some(p) = self.parameter_map.get(&name.str) {
+            return match *p {
+                chalk_ir::ParameterKind::Ty(b) => Ok(chalk_ir::TyData::BoundVar(b)
+                    .intern(interner)
+                    .cast(interner)),
+                chalk_ir::ParameterKind::Lifetime(b) => Ok(chalk_ir::LifetimeData::BoundVar(b)
+                    .intern(interner)
+                    .cast(interner)),
+                chalk_ir::ParameterKind::Const(b) => Ok(chalk_ir::ConstData::BoundVar(b)
+                    .intern(interner)
+                    .cast(interner)),
+            };
         }
 
         if let Some(id) = self.struct_ids.get(&name.str) {
-            return Ok(TypeLookup::Struct(*id));
+            let k = self.struct_kind(*id);
+            if k.binders.len(interner) > 0 {
+                return Err(RustIrError::IncorrectNumberOfTypeParameters {
+                    identifier: name,
+                    expected: k.binders.len(interner),
+                    actual: 0,
+                });
+            } else {
+                return Ok(chalk_ir::TyData::Apply(chalk_ir::ApplicationTy {
+                    name: chalk_ir::TypeName::Struct(*id),
+                    substitution: chalk_ir::Substitution::empty(interner),
+                })
+                .intern(interner)
+                .cast(interner));
+            };
         }
 
         if let Some(id) = self.opaque_ty_ids.get(&name.str) {
-            return Ok(TypeLookup::Opaque(*id));
+            return Ok(
+                chalk_ir::TyData::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
+                    opaque_ty_id: *id,
+                    substitution: chalk_ir::Substitution::empty(interner),
+                }))
+                .intern(interner)
+                .cast(interner),
+            );
         }
         if let Some(_) = self.trait_ids.get(&name.str) {
             return Err(RustIrError::NotStruct(name));
         }
 
-        Err(RustIrError::InvalidTypeName(name))
+        Err(RustIrError::InvalidParameterName(name))
     }
 
-    fn lookup_trait(&self, name: Identifier) -> LowerResult<TraitId<ChalkIr>> {
-        if let Some(_) = self
-            .parameter_map
-            .get(&chalk_ir::ParameterKind::Ty(name.str))
-        {
-            return Err(RustIrError::NotTrait(name));
+    fn lookup_apply_type(&self, name: Identifier) -> LowerResult<ApplyTypeLookup> {
+        if let Some(_) = self.parameter_map.get(&name.str) {
+            return Err(RustIrError::CannotApplyTypeParameter(name));
         }
 
-        if let Some(_) = self.struct_ids.get(&name.str) {
-            return Err(RustIrError::NotTrait(name));
+        if let Some(_) = self.opaque_ty_ids.get(&name.str) {
+            return Err(RustIrError::CannotApplyTypeParameter(name));
         }
 
-        if let Some(id) = self.trait_ids.get(&name.str) {
-            return Ok(*id);
+        if let Some(id) = self.struct_ids.get(&name.str) {
+            return Ok(ApplyTypeLookup::Struct(*id));
         }
 
-        Err(RustIrError::InvalidTypeName(name))
+        Err(RustIrError::NotStruct(name))
     }
 
-    fn lookup_lifetime(&self, name: Identifier) -> LowerResult<LifetimeLookup> {
-        if let Some(k) = self
-            .parameter_map
-            .get(&chalk_ir::ParameterKind::Lifetime(name.str))
-        {
-            return Ok(LifetimeLookup::Parameter(*k));
+    fn lookup_trait(&self, name: Identifier) -> LowerResult<TraitId<ChalkIr>> {
+        if let Some(_) = self.parameter_map.get(&name.str) {
+            return Err(RustIrError::NotTrait(name));
         }
 
-        Err(RustIrError::InvalidLifetimeName(name))
-    }
+        if let Some(_) = self.struct_ids.get(&name.str) {
+            return Err(RustIrError::NotTrait(name));
+        }
 
-    fn lookup_const(&self, name: Identifier) -> LowerResult<ConstLookup> {
-        if let Some(k) = self
-            .parameter_map
-            .get(&chalk_ir::ParameterKind::Const(name.str))
-        {
-            return Ok(ConstLookup::Parameter(*k));
+        if let Some(id) = self.trait_ids.get(&name.str) {
+            return Ok(*id);
         }
 
-        Err(RustIrError::InvalidConstName(name))
+        Err(RustIrError::InvalidTraitName(name))
     }
 
     fn struct_kind(&self, id: chalk_ir::StructId<ChalkIr>) -> &TypeKind {
@@ -165,15 +176,23 @@ impl<'k> Env<'k> {
         I: IntoIterator<Item = chalk_ir::ParameterKind<Ident>>,
         I::IntoIter: ExactSizeIterator,
     {
+        // As binders to introduce we recieve `ParameterKind<Ident>`,
+        // which we need to transform into `(Ident, ParameterKind<BoundVar>)`,
+        // because that is the key-value pair for ParameterMap.
+        // `swap_inner` lets us do precisely that, replacing `Ident` inside
+        // `ParameterKind<Ident>` with a `BoundVar` and returning both.
         let binders = binders
             .into_iter()
             .enumerate()
-            .map(|(i, k)| (k, BoundVar::new(DebruijnIndex::INNERMOST, i)));
+            .map(|(i, k)| k.swap_inner(BoundVar::new(DebruijnIndex::INNERMOST, i)));
         let len = binders.len();
+
+        // For things already in the parameter map, we take each existing key-value pair
+        // `(Ident, ParameterKind<BoundVar>)` and shift in the inner `BoundVar`.
         let parameter_map: ParameterMap = self
             .parameter_map
             .iter()
-            .map(|(&k, &v)| (k, v.shifted_in()))
+            .map(|(&k, &v)| (k, v.map(|b| b.shifted_in())))
             .chain(binders)
             .collect();
         if parameter_map.len() != self.parameter_map.len() + len {
@@ -521,6 +540,7 @@ trait LowerParameterMap {
         self.all_parameters()
             .into_iter()
             .zip((0..).map(|i| BoundVar::new(DebruijnIndex::INNERMOST, i)))
+            .map(|(k, v)| k.swap_inner(v))
             .collect()
     }
 
@@ -787,17 +807,7 @@ impl LowerLeafGoal for LeafGoal {
             LeafGoal::DomainGoal { goal } => {
                 chalk_ir::Goal::all(interner, goal.lower(env)?.into_iter().casted(interner))
             }
-            LeafGoal::UnifyTys { a, b } => chalk_ir::EqGoal {
-                a: a.lower(env)?.cast(interner),
-                b: b.lower(env)?.cast(interner),
-            }
-            .cast::<chalk_ir::Goal<ChalkIr>>(interner),
-            LeafGoal::UnifyLifetimes { ref a, ref b } => chalk_ir::EqGoal {
-                a: a.lower(env)?.cast(interner),
-                b: b.lower(env)?.cast(interner),
-            }
-            .cast::<chalk_ir::Goal<ChalkIr>>(interner),
-            LeafGoal::UnifyConsts { ref a, ref b } => chalk_ir::EqGoal {
+            LeafGoal::UnifyParameters { a, b } => chalk_ir::EqGoal {
                 a: a.lower(env)?.cast(interner),
                 b: b.lower(env)?.cast(interner),
             }
@@ -1096,33 +1106,16 @@ impl LowerTy for Ty {
     fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Ty<ChalkIr>> {
         let interner = env.interner();
         match *self {
-            Ty::Id { name } => match env.lookup_type(name)? {
-                TypeLookup::Struct(id) => {
-                    let k = env.struct_kind(id);
-                    if k.binders.len(interner) > 0 {
-                        Err(RustIrError::IncorrectNumberOfTypeParameters {
-                            identifier: name,
-                            expected: k.binders.len(interner),
-                            actual: 0,
-                        })
-                    } else {
-                        Ok(chalk_ir::TyData::Apply(chalk_ir::ApplicationTy {
-                            name: chalk_ir::TypeName::Struct(id),
-                            substitution: chalk_ir::Substitution::empty(interner),
-                        })
-                        .intern(interner))
+            Ty::Id { name } => {
+                let parameter = env.lookup_parameter(name)?;
+                parameter.ty(interner).map(|ty| ty.clone()).ok_or_else(|| {
+                    RustIrError::IncorrectParameterKind {
+                        identifier: name,
+                        expected: Kind::Ty,
+                        actual: parameter.kind(),
                     }
-                }
-                TypeLookup::Parameter(d) => Ok(chalk_ir::TyData::BoundVar(d).intern(interner)),
-                TypeLookup::Opaque(id) => Ok(chalk_ir::TyData::Alias(chalk_ir::AliasTy::Opaque(
-                    chalk_ir::OpaqueTy {
-                        opaque_ty_id: id,
-                        substitution: chalk_ir::Substitution::empty(interner),
-                    },
-                ))
-                .intern(interner)),
-            },
-
+                })
+            }
             Ty::Dyn { ref bounds } => Ok(chalk_ir::TyData::Dyn(chalk_ir::DynTy {
                 bounds: env.in_binders(
                     // FIXME: Figure out a proper name for this type parameter
@@ -1147,11 +1140,8 @@ impl LowerTy for Ty {
             .intern(interner)),
 
             Ty::Apply { name, ref args } => {
-                let id = match env.lookup_type(name)? {
-                    TypeLookup::Struct(id) => id,
-                    TypeLookup::Parameter(_) | TypeLookup::Opaque(_) => {
-                        Err(RustIrError::CannotApplyTypeParameter(name))?
-                    }
+                let id = match env.lookup_apply_type(name)? {
+                    ApplyTypeLookup::Struct(id) => id,
                 };
 
                 let k = env.struct_kind(id);
@@ -1168,7 +1158,12 @@ impl LowerTy for Ty {
                     args.iter().map(|t| Ok(t.lower(env)?)),
                 )?;
 
-                for (param, arg) in k.binders.binders.iter(interner).zip(args.iter()) {
+                for (param, arg) in k
+                    .binders
+                    .binders
+                    .iter(interner)
+                    .zip(substitution.iter(interner))
+                {
                     if param.kind() != arg.kind() {
                         Err(RustIrError::IncorrectParameterKind {
                             identifier: name,
@@ -1237,28 +1232,12 @@ impl LowerParameter for Parameter {
         match *self {
             Parameter::Ty(ref t) => Ok(t.lower(env)?.cast(interner)),
             Parameter::Lifetime(ref l) => Ok(l.lower(env)?.cast(interner)),
-            Parameter::Const(ref c) => Ok(c.lower(env)?.cast(interner)),
-        }
-    }
-}
-
-trait LowerConst {
-    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Const<ChalkIr>>;
-}
-
-impl LowerConst for Const {
-    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Const<ChalkIr>> {
-        let interner = env.interner();
-        match *self {
-            Const::Id { name } => match env.lookup_const(name)? {
-                ConstLookup::Parameter(d) => Ok(chalk_ir::ConstData::BoundVar(d).intern(interner)),
-            },
-            Const::Value { value } => {
-                Ok(
-                    chalk_ir::ConstData::Concrete(chalk_ir::ConcreteConst { interned: value })
-                        .intern(interner),
-                )
-            }
+            Parameter::Id(name) => env.lookup_parameter(name),
+            Parameter::ConstValue(value) => Ok(chalk_ir::ConstData::Concrete(
+                chalk_ir::ConcreteConst { interned: value },
+            )
+            .intern(interner)
+            .cast(interner)),
         }
     }
 }
@@ -1271,11 +1250,17 @@ impl LowerLifetime for Lifetime {
     fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Lifetime<ChalkIr>> {
         let interner = env.interner();
         match *self {
-            Lifetime::Id { name } => match env.lookup_lifetime(name)? {
-                LifetimeLookup::Parameter(d) => {
-                    Ok(chalk_ir::LifetimeData::BoundVar(d).intern(interner))
-                }
-            },
+            Lifetime::Id { name } => {
+                let parameter = env.lookup_parameter(name)?;
+                parameter
+                    .lifetime(interner)
+                    .map(|l| l.clone())
+                    .ok_or_else(|| RustIrError::IncorrectParameterKind {
+                        identifier: name,
+                        expected: Kind::Lifetime,
+                        actual: parameter.kind(),
+                    })
+            }
         }
     }
 }
@@ -1575,16 +1560,6 @@ impl Kinded for ParameterKind {
     }
 }
 
-impl Kinded for Parameter {
-    fn kind(&self) -> Kind {
-        match *self {
-            Parameter::Ty(_) => Kind::Ty,
-            Parameter::Lifetime(_) => Kind::Lifetime,
-            Parameter::Const(_) => Kind::Const,
-        }
-    }
-}
-
 impl<T, L, C> Kinded for chalk_ir::ParameterKind<T, L, C> {
     fn kind(&self) -> Kind {
         match *self {

chalk-ir/src/lib.rs

@@ -859,6 +859,14 @@ impl<T> ParameterKind<T> {
         }
     }
 
+    pub fn swap_inner<U>(self, u: U) -> (T, ParameterKind<U>) {
+        match self {
+            ParameterKind::Ty(t) => (t, ParameterKind::Ty(u)),
+            ParameterKind::Lifetime(t) => (t, ParameterKind::Lifetime(u)),
+            ParameterKind::Const(t) => (t, ParameterKind::Const(u)),
+        }
+    }
+
     pub fn map<OP, U>(self, op: OP) -> ParameterKind<U>
     where
         OP: FnOnce(T) -> U,