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,8 @@ 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 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>>;

chalk-integration/src/lowering/program_lowerer.rs

@@ -25,6 +25,7 @@ pub(super) struct ProgramLowerer {
 
     associated_ty_lookups: AssociatedTyLookups,
     associated_ty_value_ids: AssociatedTyValueIds,
+    associated_const_value_ids: AssociatedConstValueIds,
     adt_ids: AdtIds,
     fn_def_ids: FnDefIds,
     closure_ids: ClosureIds,
@@ -316,7 +317,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();

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`.