Merge pull request #208 from detrumi/splitting-ids

Split ItemId into several id types

Author: nikomatsakis

chalk-ir/src/debug.rs

@@ -2,14 +2,47 @@ use std::fmt::{Debug, Display, Error, Formatter};
 
 use super::*;
 
-impl Debug for ItemId {
+impl Debug for RawId {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        fmt.debug_struct("RawId")
+            .field("index", &self.index)
+            .finish()
+    }
+}
+
+impl Debug for TypeKindId {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        match self {
+            TypeKindId::TypeId(id) => write!(fmt, "{:?}", id),
+            TypeKindId::TraitId(id) => write!(fmt, "{:?}", id),
+            TypeKindId::StructId(id) => write!(fmt, "{:?}", id),
+        }
+    }
+}
+
+impl Debug for TypeId {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        tls::with_current_program(|p| match p {
+            Some(prog) => prog.debug_type_kind_id(TypeKindId::TypeId(*self), fmt),
+            None => write!(fmt, "{:?}", self.0),
+        })
+    }
+}
+
+impl Debug for TraitId {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        tls::with_current_program(|p| match p {
+            Some(prog) => prog.debug_type_kind_id(TypeKindId::TraitId(*self), fmt),
+            None => write!(fmt, "{:?}", self.0),
+        })
+    }
+}
+
+impl Debug for StructId {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
         tls::with_current_program(|p| match p {
-            Some(prog) => prog.debug_item_id(*self, fmt),
-            None => fmt
-                .debug_struct("ItemId")
-                .field("index", &self.index)
-                .finish(),
+            Some(prog) => prog.debug_type_kind_id(TypeKindId::StructId(*self), fmt),
+            None => write!(fmt, "{:?}", self.0),
         })
     }
 }
@@ -29,13 +62,25 @@ impl Debug for UniverseIndex {
 impl Debug for TypeName {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
         match self {
-            TypeName::ItemId(id) => write!(fmt, "{:?}", id),
+            TypeName::TypeKindId(id) => write!(fmt, "{:?}", id),
             TypeName::Placeholder(index) => write!(fmt, "{:?}", index),
             TypeName::AssociatedType(assoc_ty) => write!(fmt, "{:?}", assoc_ty),
         }
     }
 }
 
+impl Debug for ItemId {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        match self {
+            ItemId::StructId(id @ StructId(_)) => write!(fmt, "{:?}", TypeKindId::StructId(*id)),
+            ItemId::TraitId(id @ TraitId(_)) => write!(fmt, "{:?}", TypeKindId::TraitId(*id)),
+            ItemId::TypeId(id @ TypeId(_)) => write!(fmt, "{:?}", TypeKindId::TypeId(*id)),
+            ItemId::ImplId(ImplId(id)) => write!(fmt, "{:?}", id),
+            ItemId::ClauseId(ClauseId(id)) => write!(fmt, "{:?}", id),
+        }
+    }
+}
+
 impl Debug for Ty {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
         match self {

chalk-ir/src/fold.rs

@@ -358,7 +358,7 @@ pub fn super_fold_ty(folder: &mut dyn Folder, ty: &Ty, binders: usize) -> Fallib
                     folder.fold_free_placeholder_ty(ui, binders)
                 }
 
-                TypeName::ItemId(_) | TypeName::AssociatedType(_) => {
+                TypeName::TypeKindId(_) | TypeName::AssociatedType(_) => {
                     let parameters = parameters.fold_with(folder, binders)?;
                     Ok(ApplicationTy { name, parameters }.cast())
                 }
@@ -482,6 +482,10 @@ macro_rules! copy_fold {
 copy_fold!(Identifier);
 copy_fold!(UniverseIndex);
 copy_fold!(ItemId);
+copy_fold!(StructId);
+copy_fold!(TraitId);
+copy_fold!(TypeId);
+copy_fold!(TypeKindId);
 copy_fold!(usize);
 copy_fold!(QuantifierKind);
 copy_fold!(chalk_engine::TableIndex);

chalk-ir/src/lib.rs

@@ -1,3 +1,27 @@
+macro_rules! impl_froms {
+    ($e:ident: $($v:ident), *) => {
+        $(
+            impl From<$v> for $e {
+                fn from(it: $v) -> $e {
+                    $e::$v(it)
+                }
+            }
+        )*
+    }
+}
+
+macro_rules! impl_debugs {
+    ($($id:ident), *) => {
+        $(
+            impl std::fmt::Debug for $id {
+                fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+                    write!(fmt, "{:?}", self.0)
+                }
+            }
+        )*
+    };
+}
+
 use crate::cast::Cast;
 use crate::fold::shift::Shift;
 use crate::fold::{
@@ -33,7 +57,7 @@ pub type Identifier = InternedString;
 pub struct ProgramEnvironment {
     /// Indicates whether a given trait has coinductive semantics --
     /// at present, this is true only for auto traits.
-    pub coinductive_traits: BTreeSet<ItemId>,
+    pub coinductive_traits: BTreeSet<TraitId>,
 
     /// Compiled forms of the above:
     pub program_clauses: Vec<ProgramClause>,
@@ -90,15 +114,15 @@ impl<G> InEnvironment<G> {
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum TypeName {
     /// a type like `Vec<T>`
-    ItemId(ItemId),
+    TypeKindId(TypeKindId),
 
     /// instantiated form a universally quantified type, e.g., from
     /// `forall<T> { .. }`. Stands in as a representative of "some
     /// unknown type".
     Placeholder(PlaceholderIndex),
 
     /// an associated type like `Iterator::Item`; see `AssociatedType` for details
-    AssociatedType(ItemId),
+    AssociatedType(TypeId),
 }
 
 /// An universe index is how a universally quantified parameter is
@@ -132,8 +156,65 @@ impl UniverseIndex {
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ItemId {
-    pub index: usize,
+pub struct StructId(pub RawId);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct TraitId(pub RawId);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ImplId(pub RawId);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ClauseId(pub RawId);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct TypeId(pub RawId);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ItemId {
+    StructId(StructId),
+    TraitId(TraitId),
+    ImplId(ImplId),
+    ClauseId(ClauseId),
+    TypeId(TypeId),
+}
+
+impl_froms!(ItemId: StructId, TraitId, ImplId, ClauseId, TypeId);
+impl_debugs!(ImplId, ClauseId);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum TypeKindId {
+    TypeId(TypeId),
+    TraitId(TraitId),
+    StructId(StructId),
+}
+
+impl TypeKindId {
+    pub fn raw_id(&self) -> RawId {
+        match self {
+            TypeKindId::TypeId(id) => id.0,
+            TypeKindId::TraitId(id) => id.0,
+            TypeKindId::StructId(id) => id.0,
+        }
+    }
+}
+
+impl_froms!(TypeKindId: TypeId, TraitId, StructId);
+
+impl From<TypeKindId> for ItemId {
+    fn from(type_kind_id: TypeKindId) -> ItemId {
+        match type_kind_id {
+            TypeKindId::TypeId(id) => ItemId::TypeId(id),
+            TypeKindId::TraitId(id) => ItemId::TraitId(id),
+            TypeKindId::StructId(id) => ItemId::StructId(id),
+        }
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[allow(non_camel_case_types)]
+pub struct RawId {
+    pub index: u32,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -411,7 +492,7 @@ impl Parameter {
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct ProjectionTy {
-    pub associated_ty_id: ItemId,
+    pub associated_ty_id: TypeId,
     pub parameters: Vec<Parameter>,
 }
 
@@ -431,7 +512,7 @@ pub type ProjectionTyRefEnum<'a> = ProjectionTyEnum<&'a ProjectionTy, &'a Unsele
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct TraitRef {
-    pub trait_id: ItemId,
+    pub trait_id: TraitId,
     pub parameters: Vec<Parameter>,
 }
 
@@ -525,7 +606,7 @@ pub enum DomainGoal {
     Normalize(Normalize),
     UnselectedNormalize(UnselectedNormalize),
 
-    InScope(ItemId),
+    InScope(TypeKindId),
 
     /// Whether a type can deref into another. Right now this is just:
     /// ```notrust

chalk-ir/src/macros.rs

@@ -18,7 +18,7 @@ macro_rules! ty {
 
     (projection (item $n:tt) $($arg:tt)*) => {
         $crate::Ty::Projection(ProjectionTy {
-            associated_ty_id: ItemId { index: $n },
+            associated_ty_id: TypeId(RawId { index: $n }),
             parameters: vec![$(arg!($arg)),*],
         })
     };
@@ -77,7 +77,7 @@ macro_rules! lifetime {
 #[macro_export]
 macro_rules! ty_name {
     ((item $n:expr)) => {
-        $crate::TypeName::ItemId(ItemId { index: $n })
+        $crate::TypeName::TypeKindId(TypeKindId::TypeId(TypeId(RawId { index: $n })))
     };
     ((placeholder $n:expr)) => {
         $crate::TypeName::Placeholder(PlaceholderIndex {

chalk-ir/src/tls.rs

@@ -1,4 +1,4 @@
-use crate::{ItemId, ProjectionTy};
+use crate::{ProjectionTy, TypeKindId};
 use std::cell::RefCell;
 use std::fmt;
 use std::sync::Arc;
@@ -8,7 +8,11 @@ thread_local! {
 }
 
 pub trait DebugContext {
-    fn debug_item_id(&self, item_id: ItemId, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error>;
+    fn debug_type_kind_id(
+        &self,
+        id: TypeKindId,
+        fmt: &mut fmt::Formatter,
+    ) -> Result<(), fmt::Error>;
 
     fn debug_projection(
         &self,

chalk-ir/src/zip.rs

@@ -148,6 +148,10 @@ macro_rules! eq_zip {
 }
 
 eq_zip!(ItemId);
+eq_zip!(StructId);
+eq_zip!(TraitId);
+eq_zip!(TypeId);
+eq_zip!(TypeKindId);
 eq_zip!(TypeName);
 eq_zip!(Identifier);
 eq_zip!(QuantifierKind);

src/coherence.rs

@@ -2,7 +2,7 @@ use petgraph::prelude::*;
 
 use crate::rust_ir::Program;
 use chalk_ir::ProgramEnvironment;
-use chalk_ir::{self, Identifier, ItemId};
+use chalk_ir::{self, Identifier, ImplId};
 use chalk_solve::solve::SolverChoice;
 use failure::Fallible;
 use std::sync::Arc;
@@ -43,7 +43,7 @@ impl Program {
         &self,
         env: Arc<ProgramEnvironment>,
         solver_choice: SolverChoice,
-    ) -> Fallible<Graph<ItemId, ()>> {
+    ) -> Fallible<Graph<ImplId, ()>> {
         // The forest is returned as a graph but built as a GraphMap; this is
         // so that we never add multiple nodes with the same ItemId.
         let mut forest = DiGraphMap::new();
@@ -59,7 +59,7 @@ impl Program {
     }
 
     // Recursively set priorities for those node and all of its children.
-    fn set_priorities(&mut self, idx: NodeIndex, forest: &Graph<ItemId, ()>, p: usize) {
+    fn set_priorities(&mut self, idx: NodeIndex, forest: &Graph<ImplId, ()>, p: usize) {
         // Get the impl datum recorded at this node and reset its priority
         {
             let impl_id = forest

src/coherence/orphan.rs

@@ -29,7 +29,7 @@ pub(crate) fn perform_orphan_check(
     for impl_datum in local_impls {
         if !solver.orphan_check(impl_datum) {
             let trait_id = impl_datum.binders.value.trait_ref.trait_ref().trait_id;
-            let trait_id = program.type_kinds.get(&trait_id).unwrap().name;
+            let trait_id = program.type_kinds.get(&trait_id.into()).unwrap().name;
             Err(CoherenceError::FailedOrphanCheck(trait_id))?;
         }
     }

src/coherence/solve.rs

@@ -23,7 +23,7 @@ impl Program {
         mut record_specialization: F,
     ) -> Fallible<()>
     where
-        F: FnMut(ItemId, ItemId),
+        F: FnMut(ImplId, ImplId),
     {
         let mut solver = DisjointSolver { env, solver_choice };
 
@@ -53,7 +53,7 @@ impl Program {
 
         // Iterate over every pair of impls for the same trait.
         for (trait_id, impls) in &impl_groupings {
-            let impls: Vec<(&ItemId, &ImplDatum)> = impls.collect();
+            let impls: Vec<(&ImplId, &ImplDatum)> = impls.collect();
 
             for ((&l_id, lhs), (&r_id, rhs)) in impls.into_iter().tuple_combinations() {
                 // Two negative impls never overlap.
@@ -71,7 +71,7 @@ impl Program {
                         (true, false) => record_specialization(l_id, r_id),
                         (false, true) => record_specialization(r_id, l_id),
                         (_, _) => {
-                            let trait_id = self.type_kinds.get(&trait_id).unwrap().name;
+                            let trait_id = self.type_kinds.get(&trait_id.into()).unwrap().name;
                             Err(CoherenceError::OverlappingImpls(trait_id))?;
                         }
                     }

src/rules.rs

@@ -296,7 +296,7 @@ impl AssociatedTyValue {
                 }),
                 conditions: vec![
                     normalize_goal.cast(),
-                    DomainGoal::InScope(impl_trait_ref.trait_id).cast(),
+                    DomainGoal::InScope(impl_trait_ref.trait_id.into()).cast(),
                 ],
             },
         }

src/rules/wf.rs

@@ -55,15 +55,23 @@ fn solve_wf_requirements(
 
     for (id, struct_datum) in &program.struct_data {
         if !solver.verify_struct_decl(struct_datum) {
-            let name = program.type_kinds.get(id).unwrap().name;
+            let name = program
+                .type_kinds
+                .get(&TypeKindId::StructId(*id))
+                .unwrap()
+                .name;
             Err(WfError::IllFormedTypeDecl(name))?;
         }
     }
 
     for impl_datum in program.impl_data.values() {
         if !solver.verify_trait_impl(impl_datum) {
             let trait_ref = impl_datum.binders.value.trait_ref.trait_ref();
-            let name = program.type_kinds.get(&trait_ref.trait_id).unwrap().name;
+            let name = program
+                .type_kinds
+                .get(&trait_ref.trait_id.into())
+                .unwrap()
+                .name;
             Err(WfError::IllFormedTraitImpl(name))?;
         }
     }