Continue adding associated consts

Author: JulianKnodt

chalk-integration/src/lowering.rs

@@ -892,11 +892,18 @@ impl LowerWithEnv for Lifetime {
     }
 }
 
-impl LowerWithEnv for (&Impl, ImplId<ChalkIr>, &AssociatedTyValueIds) {
+impl LowerWithEnv
+    for (
+        &Impl,
+        ImplId<ChalkIr>,
+        &AssociatedTyValueIds,
+        &AssociatedConstValueIds,
+    )
+{
     type Lowered = rust_ir::ImplDatum<ChalkIr>;
 
     fn lower(&self, env: &Env) -> LowerResult<Self::Lowered> {
-        let (impl_, impl_id, associated_ty_value_ids) = self;
+        let (impl_, impl_id, associated_ty_value_ids, associated_const_value_ids) = self;
 
         let polarity = impl_.polarity.lower();
         let binders = env.in_binders(impl_.all_parameters(), |env| {
@@ -926,13 +933,20 @@ impl LowerWithEnv for (&Impl, ImplId<ChalkIr>, &AssociatedTyValueIds) {
             .map(|atv| associated_ty_value_ids[&(*impl_id, atv.name.str.clone())])
             .collect();
 
+        let associated_const_value_ids = impl_
+            .assoc_const_values
+            .iter()
+            .map(|acv| associated_const_value_ids[&(*impl_id, acv.name.str.clone())])
+            .collect();
+
         debug!(?associated_ty_value_ids);
 
         Ok(rust_ir::ImplDatum {
             polarity,
             binders,
             impl_type: impl_.impl_type.lower(),
             associated_ty_value_ids,
+            associated_const_value_ids,
         })
     }
 }

chalk-integration/src/lowering/env.rs

@@ -5,7 +5,7 @@ use chalk_ir::{
 };
 use chalk_ir::{cast::Cast, ForeignDefId, WithKind};
 use chalk_parse::ast::*;
-use chalk_solve::rust_ir::AssociatedTyValueId;
+use chalk_solve::rust_ir::{AssociatedConstValueId, AssociatedTyValueId};
 use std::collections::BTreeMap;
 
 use crate::error::RustIrError;
@@ -28,6 +28,10 @@ pub type GeneratorKinds = BTreeMap<chalk_ir::GeneratorId<ChalkIr>, TypeKind>;
 pub type AssociatedTyLookups = BTreeMap<(chalk_ir::TraitId<ChalkIr>, Ident), AssociatedTyLookup>;
 pub type AssociatedTyValueIds =
     BTreeMap<(chalk_ir::ImplId<ChalkIr>, Ident), AssociatedTyValueId<ChalkIr>>;
+
+pub type AssociatedConstLookups = BTreeMap<(chalk_ir::TraitId<ChalkIr>, Ident), AssociatedConstLookup>;
+pub type AssociatedConstValueIds =
+    BTreeMap<(chalk_ir::ImplId<ChalkIr>, Ident), AssociatedConstValueId<ChalkIr>>;
 pub type ForeignIds = BTreeMap<Ident, chalk_ir::ForeignDefId<ChalkIr>>;
 
 pub type ParameterMap = BTreeMap<Ident, chalk_ir::WithKind<ChalkIr, BoundVar>>;
@@ -75,6 +79,21 @@ pub struct AssociatedTyLookup {
     pub addl_variable_kinds: Vec<chalk_ir::VariableKind<ChalkIr>>,
 }
 
+/// Information about an associated const **declaration** (i.e., an
+/// `AssociatedConstDatum`). This information is gathered in the first
+/// phase of creating the Rust IR and is then later used to lookup the
+/// "id" of an associated const.
+///
+/// ```ignore
+/// trait Foo {
+///     const Bar: <Ty> = XXX; // <-- associated const declaration
+/// }
+/// ```
+#[derive(Debug, PartialEq, Eq)]
+pub struct AssociatedConstLookup {
+    pub id: chalk_ir::AssocItemId<ChalkIr>,
+}
+
 pub enum TypeLookup<'k> {
     Parameter(&'k WithKind<ChalkIr, BoundVar>),
     Adt(AdtId<ChalkIr>),

chalk-integration/src/lowering/program_lowerer.rs

@@ -25,6 +25,10 @@ pub(super) struct ProgramLowerer {
 
     associated_ty_lookups: AssociatedTyLookups,
     associated_ty_value_ids: AssociatedTyValueIds,
+
+    associated_const_lookups: AssociatedConstLookups,
+    associated_const_value_ids: AssociatedConstValueIds,
+
     adt_ids: AdtIds,
     fn_def_ids: FnDefIds,
     closure_ids: ClosureIds,
@@ -153,6 +157,7 @@ impl ProgramLowerer {
         let mut trait_data = BTreeMap::new();
         let mut well_known_traits = BTreeMap::new();
         let mut impl_data = BTreeMap::new();
+        let mut associated_const_values = BTreeMap::new();
         let mut associated_ty_data = BTreeMap::new();
         let mut associated_ty_values = BTreeMap::new();
         let mut opaque_ty_data = BTreeMap::new();
@@ -316,7 +321,13 @@ impl ProgramLowerer {
                 Item::Impl(ref impl_defn) => {
                     let impl_id = ImplId(raw_id);
                     let impl_datum = Arc::new(
-                        (impl_defn, impl_id, &self.associated_ty_value_ids).lower(&empty_env)?,
+                        (
+                            impl_defn,
+                            impl_id,
+                            &self.associated_ty_value_ids,
+                            &self.associated_const_value_ids,
+                        )
+                            .lower(&empty_env)?,
                     );
                     impl_data.insert(impl_id, impl_datum.clone());
                     let trait_id = impl_datum.trait_id();
@@ -348,6 +359,19 @@ impl ProgramLowerer {
                             }),
                         );
                     }
+
+                    for acv in &impl_defn.assoc_const_values {
+                        let acv_id = self.associated_const_value_ids[&(impl_id, acv.name.str.clone())];
+                        let lookup = &self.associated_const_lookups[&(trait_id, acv.name.str.clone())];
+
+                        associated_const_values.insert(
+                          acv_id,
+                          Arc::new(rust_ir::AssociatedConstValue {
+                            impl_id,
+                            associated_const_id: lookup.id,
+                          }),
+                        );
+                    }
                 }
                 Item::Clause(ref clause) => {
                     custom_clauses.extend(clause.lower(&empty_env)?);
@@ -495,6 +519,7 @@ impl ProgramLowerer {
             trait_data,
             well_known_traits,
             impl_data,
+            associated_const_values,
             associated_ty_values,
             associated_ty_data,
             opaque_ty_ids: self.opaque_ty_ids,

chalk-integration/src/program.rs

@@ -10,6 +10,7 @@ use chalk_ir::{
 };
 use chalk_solve::rust_ir::{
     AdtDatum, AdtRepr, AdtSizeAlign, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId,
+    AssociatedConstValue, AssociatedConstValueId,
     ClosureKind, FnDefDatum, FnDefInputsAndOutputDatum, GeneratorDatum, GeneratorWitnessDatum,
     ImplDatum, ImplType, OpaqueTyDatum, TraitDatum, WellKnownTrait,
 };
@@ -78,6 +79,10 @@ pub struct Program {
     pub associated_ty_values:
         BTreeMap<AssociatedTyValueId<ChalkIr>, Arc<AssociatedTyValue<ChalkIr>>>,
 
+    /// For each associated const value `const Foo: <Ty> = XXX` found in an impl:
+    pub associated_const_values:
+        BTreeMap<AssociatedConstValueId<ChalkIr>, Arc<AssociatedConstValue<ChalkIr>>>,
+
     // From opaque type name to item-id. Used during lowering only.
     pub opaque_ty_ids: BTreeMap<Identifier, OpaqueTyId<ChalkIr>>,
 

chalk-parse/src/ast.rs

@@ -276,6 +276,7 @@ pub struct Impl {
     pub polarity: Polarity,
     pub where_clauses: Vec<QuantifiedWhereClause>,
     pub assoc_ty_values: Vec<AssocTyValue>,
+    pub assoc_const_values: Vec<AssocConstValue>,
     pub impl_type: ImplType,
 }
 
@@ -293,6 +294,13 @@ pub struct AssocTyValue {
     pub default: bool,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct AssocConstValue {
+    pub name: Identifier,
+    pub ty: Ty,
+    pub value: Const,
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum Ty {
     Id {

chalk-parse/src/parser.lalrpop

@@ -354,7 +354,7 @@ QuantifiedInlineBound: QuantifiedInlineBound = {
 
 Impl: Impl = {
     <external:UpstreamKeyword?> "impl" <p:Angle<VariableKind>> <mark:"!"?> <t:Id> <a:Angle<GenericArg>> "for" <s:Ty>
-        <w:QuantifiedWhereClauses> "{" <assoc:AssocTyValue*> "}" =>
+        <w:QuantifiedWhereClauses> "{" <assoc:AssocTyValue*> <assoc_const:AssocConstValue*> "}" =>
     {
         let mut args = vec![GenericArg::Ty(s)];
         args.extend(a);
@@ -367,6 +367,7 @@ Impl: Impl = {
             },
             where_clauses: w,
             assoc_ty_values: assoc,
+            assoc_const_values: assoc_const,
             impl_type: external.map(|_| ImplType::External).unwrap_or(ImplType::Local),
         }
     },
@@ -397,6 +398,14 @@ AssocTyValue: AssocTyValue = {
     },
 };
 
+AssocConstValue: AssocConstValue = {
+  "const" <n: Id> ":" <ty:Ty> "=" <v:Const> ";" => AssocConstValue {
+    name:n,
+    ty: ty,
+    value:v,
+  },
+};
+
 pub Ty: Ty = {
     <n:Id> => Ty::Id { name: n },
     TyWithoutId,

chalk-solve/src/rust_ir.rs

@@ -18,15 +18,23 @@ use std::ops::ControlFlow;
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct AssociatedTyValueId<I: Interner>(pub I::DefId);
 
+/// Identifier for an "associated const value" found in some impl.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct AssociatedConstValueId<I: Interner>(pub I::DefId);
+
 chalk_ir::id_visit!(AssociatedTyValueId);
 chalk_ir::id_fold!(AssociatedTyValueId);
 
+chalk_ir::id_visit!(AssociatedConstValueId);
+chalk_ir::id_fold!(AssociatedConstValueId);
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Visit)]
 pub struct ImplDatum<I: Interner> {
     pub polarity: Polarity,
     pub binders: Binders<ImplDatumBound<I>>,
     pub impl_type: ImplType,
     pub associated_ty_value_ids: Vec<AssociatedTyValueId<I>>,
+    pub associated_const_value_ids: Vec<AssociatedConstValueId<I>>,
 }
 
 impl<I: Interner> ImplDatum<I> {
@@ -619,6 +627,33 @@ pub struct AssociatedTyValue<I: Interner> {
     pub value: Binders<AssociatedTyValueBound<I>>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, Visit)]
+pub struct AssociatedConstValue<I: Interner> {
+    /// Impl in which this associated type value is found.  You might
+    /// need to look at this to find the generic parameters defined on
+    /// the impl, for example.
+    ///
+    /// ```ignore
+    /// impl Iterator for Foo { // <-- refers to this impl
+    ///     const Item: usize = XXX; // <-- (where this is self)
+    /// }
+    /// ```
+    pub impl_id: ImplId<I>,
+
+    /// Associated type being defined.
+    ///
+    /// ```ignore
+    /// impl Iterator for Foo {
+    ///     const Item: usize = XXX; // <-- (where this is self)
+    /// }
+    /// ...
+    /// trait Iterator {
+    ///     const Item: usize; // <-- refers to this declaration here!
+    /// }
+    /// ```
+    pub associated_const_id: AssocItemId<I>,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, Visit, HasInterner)]
 pub struct AssociatedTyValueBound<I: Interner> {
     /// Type that we normalize to. The X in `type Foo<'a> = X`.

tests/integration/panic.rs

@@ -115,6 +115,7 @@ impl RustIrDatabase<ChalkIr> for MockDatabase {
             binders,
             impl_type: ImplType::Local,
             associated_ty_value_ids: vec![],
+            associated_const_value_ids: vec![],
         })
     }
 

tests/test/projection.rs

@@ -1107,3 +1107,27 @@ fn projection_to_opaque() {
         }
     }
 }
+
+#[test]
+fn const_projection() {
+    test! {
+        program {
+          trait ConstTrait {
+              const ID: usize;
+          }
+          trait OtherTrait {}
+          impl OtherTrait for U where U: ConstTrait<ID = 3> {}
+          impl ConstTrait for () {
+            const ID: usize = 3;
+          }
+          impl ConstTrait for i32 {
+            const ID: usize = 5;
+          }
+        }
+
+        goal {
+        } yields {
+          expect![["Unique"]]
+        }
+    }
+}