Implement NormalizeFn in the back end

Author: lf-

chalk-integration/src/db.rs

@@ -13,9 +13,9 @@ use chalk_ir::{
     UnificationDatabase, Variances,
 };
 use chalk_solve::rust_ir::{
-    AdtDatum, AdtRepr, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ClosureKind,
-    FnDefDatum, FnDefInputsAndOutputDatum, GeneratorDatum, GeneratorWitnessDatum, ImplDatum,
-    OpaqueTyDatum, TraitDatum, WellKnownTrait,
+    AdtDatum, AdtRepr, AssociatedFnValue, AssociatedFnValueId, AssociatedTyDatum,
+    AssociatedTyValue, AssociatedTyValueId, ClosureKind, FnDefDatum, FnDefInputsAndOutputDatum,
+    GeneratorDatum, GeneratorWitnessDatum, ImplDatum, OpaqueTyDatum, TraitDatum, WellKnownTrait,
 };
 use chalk_solve::{RustIrDatabase, Solution, SubstitutionResult};
 use salsa::Database;
@@ -91,6 +91,13 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         self.program_ir().unwrap().associated_ty_data(ty)
     }
 
+    fn associated_fn_data(
+        &self,
+        f: chalk_ir::AssocFnDefId<ChalkIr>,
+    ) -> Arc<chalk_solve::rust_ir::AssociatedFnDatum<ChalkIr>> {
+        self.program_ir().unwrap().associated_fn_data(f)
+    }
+
     fn trait_datum(&self, id: TraitId<ChalkIr>) -> Arc<TraitDatum<ChalkIr>> {
         self.program_ir().unwrap().trait_datum(id)
     }
@@ -106,6 +113,13 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         self.program_ir().unwrap().associated_ty_values[&id].clone()
     }
 
+    fn associated_fn_value(
+        &self,
+        id: AssociatedFnValueId<ChalkIr>,
+    ) -> Arc<AssociatedFnValue<ChalkIr>> {
+        self.program_ir().unwrap().associated_fn_values[&id].clone()
+    }
+
     fn opaque_ty_data(&self, id: OpaqueTyId<ChalkIr>) -> Arc<OpaqueTyDatum<ChalkIr>> {
         self.program_ir().unwrap().opaque_ty_data(id)
     }

chalk-integration/src/error.rs

@@ -57,15 +57,21 @@ impl std::error::Error for ChalkError {}
 pub enum RustIrError {
     InvalidParameterName(Identifier),
     InvalidTraitName(Identifier),
+    InvalidImplName(Identifier),
+    InvalidImplMemberName(Identifier, Identifier),
     NotTrait(Identifier),
     NotStruct(Identifier),
+    NotAssociatedType(Identifier),
+    NotAssociatedFn(Identifier),
+    AmbiguousProjection(Identifier),
     DuplicateOrShadowedParameters,
     AutoTraitAssociatedTypes(Identifier),
     AutoTraitParameters(Identifier),
     AutoTraitWhereClauses(Identifier),
     InvalidFundamentalTypesParameters(Identifier),
     NegativeImplAssociatedValues(Identifier),
     MissingAssociatedType(Identifier),
+    MissingAssociatedFn(Identifier),
     IncorrectNumberOfVarianceParameters {
         identifier: Identifier,
         expected: usize,
@@ -81,6 +87,11 @@ pub enum RustIrError {
         expected: usize,
         actual: usize,
     },
+    IncorrectNumberOfAssociatedFnParameters {
+        identifier: Identifier,
+        expected: usize,
+        actual: usize,
+    },
     IncorrectParameterKind {
         identifier: Identifier,
         expected: Kind,
@@ -96,6 +107,11 @@ pub enum RustIrError {
         expected: Kind,
         actual: Kind,
     },
+    IncorrectAssociatedFnParameterKind {
+        identifier: Identifier,
+        expected: Kind,
+        actual: Kind,
+    },
     CannotApplyTypeParameter(Identifier),
     InvalidExternAbi(Atom),
 }
@@ -107,6 +123,12 @@ impl std::fmt::Display for RustIrError {
                 write!(f, "invalid parameter name `{}`", name)
             }
             RustIrError::InvalidTraitName(name) => write!(f, "invalid trait name `{}`", name),
+            RustIrError::InvalidImplName(name) => write!(f, "invalid impl name `{}`", name),
+            RustIrError::InvalidImplMemberName(impl_name, member_name) => write!(
+                f,
+                "invalid impl member name `{}::{}`",
+                impl_name, member_name
+            ),
             RustIrError::NotTrait(name) => write!(
                 f,
                 "expected a trait, found `{}`, which is not a trait",
@@ -117,6 +139,22 @@ impl std::fmt::Display for RustIrError {
                 "expected a struct, found `{}`, which is not a struct",
                 name
             ),
+            RustIrError::NotAssociatedType(name) => write!(
+                f,
+                "expected an associated type, found `{}`, which is not",
+                name
+            ),
+            RustIrError::NotAssociatedFn(name) => write!(
+                f,
+                "expected an associated fn, found `{}`, which is not",
+                name
+            ),
+            RustIrError::AmbiguousProjection(name) => write!(
+                f,
+                "projection refers to `{}` which is both a fn and a type",
+                name
+            ),
+
             RustIrError::DuplicateOrShadowedParameters => {
                 write!(f, "duplicate or shadowed parameters")
             }
@@ -142,6 +180,9 @@ impl std::fmt::Display for RustIrError {
             RustIrError::MissingAssociatedType(name) => {
                 write!(f, "no associated type `{}` defined in trait", name)
             }
+            RustIrError::MissingAssociatedFn(name) => {
+                write!(f, "no associated fn `{}` defined in trait", name)
+            }
             RustIrError::IncorrectNumberOfVarianceParameters {
                 identifier,
                 expected,
@@ -169,6 +210,15 @@ impl std::fmt::Display for RustIrError {
                 "wrong number of parameters for associated type `{}` (expected {}, got {})",
                 identifier, expected, actual
             ),
+            RustIrError::IncorrectNumberOfAssociatedFnParameters {
+                identifier,
+                expected,
+                actual,
+            } => write!(
+                f,
+                "wrong number of parameters for associated fn `{}` (expected {}, got {})",
+                identifier, expected, actual
+            ),
             RustIrError::IncorrectParameterKind {
                 identifier,
                 expected,
@@ -196,6 +246,15 @@ impl std::fmt::Display for RustIrError {
                 "incorrect associated type parameter kind for `{}`: expected {}, found {}",
                 identifier, expected, actual
             ),
+            RustIrError::IncorrectAssociatedFnParameterKind {
+                identifier,
+                expected,
+                actual,
+            } => write!(
+                f,
+                "incorrect associated fn parameter kind for `{}`: expected {}, found {}",
+                identifier, expected, actual
+            ),
             RustIrError::CannotApplyTypeParameter(name) => {
                 write!(f, "cannot apply type parameter `{}`", name)
             }