address nits 2: electric boogaloo

Author: basil-cow

chalk-integration/src/db.rs

@@ -21,9 +21,9 @@ use chalk_rust_ir::AssociatedTyDatum;
 use chalk_rust_ir::AssociatedTyValue;
 use chalk_rust_ir::AssociatedTyValueId;
 use chalk_rust_ir::ImplDatum;
-use chalk_rust_ir::LangItem;
 use chalk_rust_ir::StructDatum;
 use chalk_rust_ir::TraitDatum;
+use chalk_rust_ir::WellKnownTrait;
 use chalk_solve::RustIrDatabase;
 use chalk_solve::Solution;
 use chalk_solve::SolverChoice;
@@ -138,8 +138,8 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
             .impl_provided_for(auto_trait_id, struct_id)
     }
 
-    fn require_lang_item(&self, lang_item: LangItem) -> TraitId<ChalkIr> {
-        self.program_ir().unwrap().require_lang_item(lang_item)
+    fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> TraitId<ChalkIr> {
+        self.program_ir().unwrap().well_known_trait_id(well_known_trait)
     }
 
     fn interner(&self) -> &ChalkIr {

chalk-integration/src/error.rs

@@ -1,6 +1,5 @@
 use chalk_ir::interner::ChalkIr;
 use chalk_parse::ast::{Identifier, Kind};
-use chalk_rust_ir::LangItem;
 use chalk_solve::coherence::CoherenceError;
 use chalk_solve::wf::WfError;
 
@@ -57,7 +56,6 @@ impl std::error::Error for ChalkError {}
 pub enum RustIrError {
     InvalidTypeName(Identifier),
     InvalidLifetimeName(Identifier),
-    DuplicateLangItem(LangItem),
     NotTrait(Identifier),
     NotStruct(Identifier),
     DuplicateOrShadowedParameters,
@@ -100,7 +98,6 @@ impl std::fmt::Display for RustIrError {
         match self {
             RustIrError::InvalidTypeName(name) => write!(f, "invalid type name `{}`", name),
             RustIrError::InvalidLifetimeName(name) => write!(f, "invalid lifetime name `{}`", name),
-            RustIrError::DuplicateLangItem(item) => write!(f, "duplicate lang item `{:?}`", item),
             RustIrError::NotTrait(name) => write!(
                 f,
                 "expected a trait, found `{}`, which is not a trait",

chalk-integration/src/lowering.rs

@@ -3,7 +3,7 @@ use chalk_ir::interner::ChalkIr;
 use chalk_ir::{self, AssocTypeId, BoundVar, DebruijnIndex, ImplId, StructId, TraitId};
 use chalk_parse::ast::*;
 use chalk_rust_ir as rust_ir;
-use chalk_rust_ir::{Anonymize, AssociatedTyValueId, IntoWhereClauses, LangItem, ToParameter};
+use chalk_rust_ir::{Anonymize, AssociatedTyValueId, IntoWhereClauses, ToParameter};
 use lalrpop_intern::intern;
 use std::collections::BTreeMap;
 use std::sync::Arc;
@@ -246,7 +246,7 @@ impl LowerProgram for Program {
 
         let mut struct_data = BTreeMap::new();
         let mut trait_data = BTreeMap::new();
-        let mut trait_lang_items = BTreeMap::new();
+        let mut well_known_traits = BTreeMap::new();
         let mut impl_data = BTreeMap::new();
         let mut associated_ty_data = BTreeMap::new();
         let mut associated_ty_values = BTreeMap::new();
@@ -271,18 +271,7 @@ impl LowerProgram for Program {
                     let trait_datum = trait_defn.lower_trait(trait_id, &empty_env)?;
 
                     if let Some(well_known) = trait_datum.well_known {
-                        if let Some(lang_item) = match well_known {
-                            rust_ir::WellKnownTrait::SizedTrait => Some(LangItem::SizedTrait),
-                            _ => None,
-                        } {
-                            use std::collections::btree_map::Entry;
-                            match trait_lang_items.entry(lang_item) {
-                                Entry::Vacant(vacant) => vacant.insert(trait_id),
-                                Entry::Occupied(_) => {
-                                    return Err(RustIrError::DuplicateLangItem(lang_item))
-                                }
-                            };
-                        }
+                        well_known_traits.insert(well_known, trait_id);
                     }
 
                     trait_data.insert(trait_id, Arc::new(trait_datum));
@@ -382,7 +371,7 @@ impl LowerProgram for Program {
             trait_kinds,
             struct_data,
             trait_data,
-            trait_lang_items,
+            well_known_traits,
             impl_data,
             associated_ty_values,
             associated_ty_data,

chalk-integration/src/program.rs

@@ -6,11 +6,11 @@ use chalk_ir::tls;
 use chalk_ir::{
     debug::SeparatorTraitRef, AliasTy, ApplicationTy, AssocTypeId, Goal, Goals, ImplId, Lifetime,
     Parameter, ProgramClause, ProgramClauseImplication, ProgramClauses, StructId, Substitution,
-    TraitId, Ty, TyData, TypeName,
+    TraitId, Ty, TyData, TypeName, 
 };
 use chalk_rust_ir::{
-    AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType, LangItem,
-    StructDatum, TraitDatum,
+    AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType,
+    StructDatum, TraitDatum, WellKnownTrait
 };
 use chalk_solve::split::Split;
 use chalk_solve::RustIrDatabase;
@@ -46,7 +46,7 @@ pub struct Program {
     pub trait_data: BTreeMap<TraitId<ChalkIr>, Arc<TraitDatum<ChalkIr>>>,
 
     /// For each trait lang item
-    pub trait_lang_items: BTreeMap<LangItem, TraitId<ChalkIr>>,
+    pub well_known_traits: BTreeMap<WellKnownTrait, TraitId<ChalkIr>>,
 
     /// For each associated ty declaration `type Foo` found in a trait:
     pub associated_ty_data: BTreeMap<AssocTypeId<ChalkIr>, Arc<AssociatedTyDatum<ChalkIr>>>,
@@ -312,11 +312,11 @@ impl RustIrDatabase<ChalkIr> for Program {
         })
     }
 
-    fn require_lang_item(&self, lang_item: LangItem) -> TraitId<ChalkIr> {
+    fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> TraitId<ChalkIr> {
         *self
-            .trait_lang_items
-            .get(&lang_item)
-            .unwrap_or_else(|| panic!("No lang item found for {:?}", lang_item))
+            .well_known_traits
+            .get(&well_known_trait)
+            .unwrap_or_else(|| panic!("No lang item found for {:?}", well_known_trait))
     }
 
     fn interner(&self) -> &ChalkIr {

chalk-rust-ir/src/lib.rs

@@ -15,11 +15,6 @@ use chalk_ir::{
 };
 use std::iter;
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum LangItem {
-    SizedTrait,
-}
-
 /// Identifier for an "associated type value" found in some impl.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct AssociatedTyValueId<I: Interner>(pub I::DefId);
@@ -136,7 +131,7 @@ pub struct TraitDatum<I: Interner> {
 
 /// A list of the traits that are "well known" to chalk, which means that
 /// the chalk-solve crate has special, hard-coded impls for them.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
 pub enum WellKnownTrait {
     SizedTrait,
     CopyTrait,

chalk-solve/src/lib.rs

@@ -77,7 +77,7 @@ pub trait RustIrDatabase<I: Interner>: Debug {
     }
 
     /// Returns id of a trait lang item, if found
-    fn require_lang_item(&self, lang_item: LangItem) -> TraitId<I>;
+    fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> TraitId<I>;
 
     fn interner(&self) -> &I;
 }

chalk-solve/src/wf.rs

@@ -493,7 +493,7 @@ fn compute_struct_sized_constraint<I: Interner>(
 
     let interner = db.interner();
 
-    let sized_trait = db.require_lang_item(LangItem::SizedTrait);
+    let sized_trait = db.well_known_trait_id(WellKnownTrait::SizedTrait);
 
     Some(Goal::all(
         interner,

tests/test/wf_lowering.rs

@@ -637,21 +637,6 @@ fn assoc_type_recursive_bound() {
     }
 }
 
-#[test]
-fn duplicate_lang_item() {
-    lowering_error! {
-        program {
-            #[lang(sized)]
-            trait Sized { }
-
-            #[lang(sized)]
-            trait Sized2 { }
-        } error_msg {
-            "duplicate lang item `SizedTrait`"
-        }
-    }
-}
-
 #[test]
 fn struct_sized_constraints() {
     lowering_error! {