Move the definition of DefId to librustc

src/librustc/ast_map/mod.rs

@@ -14,6 +14,7 @@ use self::MapEntry::*;
 
 use metadata::inline::InlinedItem;
 use metadata::inline::InlinedItem as II;
+use middle::def_id::DefId;
 use syntax::abi;
 use syntax::ast::*;
 use syntax::ast_util;
@@ -378,7 +379,7 @@ impl<'ast> Map<'ast> {
         match self.find_entry(parent) {
             Some(RootInlinedParent(&InlinedParent {ii: II::TraitItem(did, _), ..})) => did,
             Some(RootInlinedParent(&InlinedParent {ii: II::ImplItem(did, _), ..})) => did,
-            _ => ast_util::local_def(parent)
+            _ => DefId::local(parent)
         }
     }
 
@@ -591,7 +592,7 @@ impl<'ast> Map<'ast> {
     }
 
     pub fn def_id_span(&self, def_id: DefId, fallback: Span) -> Span {
-        if def_id.krate == LOCAL_CRATE {
+        if def_id.is_local() {
             self.opt_span(def_id.node).unwrap_or(fallback)
         } else {
             fallback

src/librustc/lib.rs

@@ -118,6 +118,7 @@ pub mod middle {
     pub mod dataflow;
     pub mod dead;
     pub mod def;
+    pub mod def_id;
     pub mod dependency_format;
     pub mod effect;
     pub mod entry;

src/librustc/metadata/csearch.rs

@@ -15,6 +15,7 @@ use metadata::common::*;
 use metadata::cstore;
 use metadata::decoder;
 use metadata::inline::InlinedItem;
+use middle::def_id::DefId;
 use middle::lang_items;
 use middle::ty;
 
@@ -30,11 +31,11 @@ use std::collections::hash_map::HashMap;
 #[derive(Copy, Clone)]
 pub struct MethodInfo {
     pub name: ast::Name,
-    pub def_id: ast::DefId,
+    pub def_id: DefId,
     pub vis: ast::Visibility,
 }
 
-pub fn get_symbol(cstore: &cstore::CStore, def: ast::DefId) -> String {
+pub fn get_symbol(cstore: &cstore::CStore, def: DefId) -> String {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_symbol(cdata.data(), def.node)
 }
@@ -52,7 +53,7 @@ pub fn each_lang_item<F>(cstore: &cstore::CStore,
 
 /// Iterates over each child of the given item.
 pub fn each_child_of_item<F>(cstore: &cstore::CStore,
-                             def_id: ast::DefId,
+                             def_id: DefId,
                              callback: F) where
     F: FnMut(decoder::DefLike, ast::Name, ast::Visibility),
 {
@@ -83,7 +84,7 @@ pub fn each_top_level_item_of_crate<F>(cstore: &cstore::CStore,
                                           callback)
 }
 
-pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem> {
+pub fn get_item_path(tcx: &ty::ctxt, def: DefId) -> Vec<ast_map::PathElem> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     let path = decoder::get_item_path(&*cdata, def.node);
@@ -96,22 +97,22 @@ pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem>
     })
 }
 
-pub fn get_item_name(tcx: &ty::ctxt, def: ast::DefId) -> ast::Name {
+pub fn get_item_name(tcx: &ty::ctxt, def: DefId) -> ast::Name {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_item_name(&cstore.intr, &cdata, def.node)
 }
 
 pub enum FoundAst<'ast> {
     Found(&'ast InlinedItem),
-    FoundParent(ast::DefId, &'ast InlinedItem),
+    FoundParent(DefId, &'ast InlinedItem),
     NotFound,
 }
 
 // Finds the AST for this item in the crate metadata, if any.  If the item was
 // not marked for inlining, then the AST will not be present and hence none
 // will be returned.
-pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId,
+pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId,
                                 decode_inlined_item: decoder::DecodeInlinedItem)
                                 -> FoundAst<'tcx> {
     let cstore = &tcx.sess.cstore;
@@ -120,13 +121,13 @@ pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId,
 }
 
 /// Returns information about the given implementation.
-pub fn get_impl_items(cstore: &cstore::CStore, impl_def_id: ast::DefId)
+pub fn get_impl_items(cstore: &cstore::CStore, impl_def_id: DefId)
                       -> Vec<ty::ImplOrTraitItemId> {
     let cdata = cstore.get_crate_data(impl_def_id.krate);
     decoder::get_impl_items(&*cdata, impl_def_id.node)
 }
 
-pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
+pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId)
                                     -> ty::ImplOrTraitItem<'tcx> {
     let cdata = tcx.sess.cstore.get_crate_data(def.krate);
     decoder::get_impl_or_trait_item(tcx.sess.cstore.intr.clone(),
@@ -135,114 +136,114 @@ pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
                                     tcx)
 }
 
-pub fn get_trait_name(cstore: &cstore::CStore, def: ast::DefId) -> ast::Name {
+pub fn get_trait_name(cstore: &cstore::CStore, def: DefId) -> ast::Name {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_trait_name(cstore.intr.clone(),
                             &*cdata,
                             def.node)
 }
 
-pub fn is_static_method(cstore: &cstore::CStore, def: ast::DefId) -> bool {
+pub fn is_static_method(cstore: &cstore::CStore, def: DefId) -> bool {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::is_static_method(&*cdata, def.node)
 }
 
-pub fn get_trait_item_def_ids(cstore: &cstore::CStore, def: ast::DefId)
+pub fn get_trait_item_def_ids(cstore: &cstore::CStore, def: DefId)
                               -> Vec<ty::ImplOrTraitItemId> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_trait_item_def_ids(&*cdata, def.node)
 }
 
 pub fn get_item_variances(cstore: &cstore::CStore,
-                          def: ast::DefId) -> ty::ItemVariances {
+                          def: DefId) -> ty::ItemVariances {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_item_variances(&*cdata, def.node)
 }
 
 pub fn get_provided_trait_methods<'tcx>(tcx: &ty::ctxt<'tcx>,
-                                        def: ast::DefId)
+                                        def: DefId)
                                         -> Vec<Rc<ty::Method<'tcx>>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.node, tcx)
 }
 
-pub fn get_associated_consts<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
+pub fn get_associated_consts<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId)
                                    -> Vec<Rc<ty::AssociatedConst<'tcx>>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_associated_consts(cstore.intr.clone(), &*cdata, def.node, tcx)
 }
 
-pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: ast::DefId)
+pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: DefId)
                           -> Option<ast::Name> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_type_name_if_impl(&*cdata, def.node)
 }
 
 pub fn get_methods_if_impl(cstore: &cstore::CStore,
-                                  def: ast::DefId)
+                                  def: DefId)
                                -> Option<Vec<MethodInfo> > {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_methods_if_impl(cstore.intr.clone(), &*cdata, def.node)
 }
 
 pub fn get_item_attrs(cstore: &cstore::CStore,
-                      def_id: ast::DefId)
+                      def_id: DefId)
                       -> Vec<ast::Attribute> {
     let cdata = cstore.get_crate_data(def_id.krate);
     decoder::get_item_attrs(&*cdata, def_id.node)
 }
 
-pub fn get_struct_field_names(cstore: &cstore::CStore, def: ast::DefId) -> Vec<ast::Name> {
+pub fn get_struct_field_names(cstore: &cstore::CStore, def: DefId) -> Vec<ast::Name> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_struct_field_names(&cstore.intr, &*cdata, def.node)
 }
 
-pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: ast::DefId) -> HashMap<ast::NodeId,
+pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: DefId) -> HashMap<ast::NodeId,
         Vec<ast::Attribute>> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_struct_field_attrs(&*cdata)
 }
 
 pub fn get_type<'tcx>(tcx: &ty::ctxt<'tcx>,
-                      def: ast::DefId)
+                      def: DefId)
                       -> ty::TypeScheme<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_type(&*cdata, def.node, tcx)
 }
 
-pub fn get_trait_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId) -> ty::TraitDef<'tcx> {
+pub fn get_trait_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_trait_def(&*cdata, def.node, tcx)
 }
 
-pub fn get_adt_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId) -> ty::AdtDefMaster<'tcx> {
+pub fn get_adt_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_adt_def(&cstore.intr, &*cdata, def.node, tcx)
 }
 
-pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
+pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId)
                             -> ty::GenericPredicates<'tcx>
 {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_predicates(&*cdata, def.node, tcx)
 }
 
-pub fn get_super_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
+pub fn get_super_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId)
                                   -> ty::GenericPredicates<'tcx>
 {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_super_predicates(&*cdata, def.node, tcx)
 }
 
-pub fn get_field_type<'tcx>(tcx: &ty::ctxt<'tcx>, class_id: ast::DefId,
-                            def: ast::DefId) -> ty::TypeScheme<'tcx> {
+pub fn get_field_type<'tcx>(tcx: &ty::ctxt<'tcx>, class_id: DefId,
+                            def: DefId) -> ty::TypeScheme<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(class_id.krate);
     let all_items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items);
@@ -267,7 +268,7 @@ pub fn get_field_type<'tcx>(tcx: &ty::ctxt<'tcx>, class_id: ast::DefId,
 }
 
 pub fn get_impl_polarity<'tcx>(tcx: &ty::ctxt<'tcx>,
-                               def: ast::DefId)
+                               def: DefId)
                                -> Option<ast::ImplPolarity>
 {
     let cstore = &tcx.sess.cstore;
@@ -276,7 +277,7 @@ pub fn get_impl_polarity<'tcx>(tcx: &ty::ctxt<'tcx>,
 }
 
 pub fn get_custom_coerce_unsized_kind<'tcx>(tcx: &ty::ctxt<'tcx>,
-                                            def: ast::DefId)
+                                            def: DefId)
                                             -> Option<ty::CustomCoerceUnsized> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
@@ -286,7 +287,7 @@ pub fn get_custom_coerce_unsized_kind<'tcx>(tcx: &ty::ctxt<'tcx>,
 // Given a def_id for an impl, return the trait it implements,
 // if there is one.
 pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>,
-                            def: ast::DefId)
+                            def: DefId)
                             -> Option<ty::TraitRef<'tcx>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
@@ -300,18 +301,18 @@ pub fn get_native_libraries(cstore: &cstore::CStore, crate_num: ast::CrateNum)
 }
 
 pub fn each_inherent_implementation_for_type<F>(cstore: &cstore::CStore,
-                                                def_id: ast::DefId,
+                                                def_id: DefId,
                                                 callback: F) where
-    F: FnMut(ast::DefId),
+    F: FnMut(DefId),
 {
     let cdata = cstore.get_crate_data(def_id.krate);
     decoder::each_inherent_implementation_for_type(&*cdata, def_id.node, callback)
 }
 
 pub fn each_implementation_for_trait<F>(cstore: &cstore::CStore,
-                                        def_id: ast::DefId,
+                                        def_id: DefId,
                                         mut callback: F) where
-    F: FnMut(ast::DefId),
+    F: FnMut(DefId),
 {
     cstore.iter_crate_data(|_, cdata| {
         decoder::each_implementation_for_trait(cdata, def_id, &mut callback)
@@ -322,16 +323,16 @@ pub fn each_implementation_for_trait<F>(cstore: &cstore::CStore,
 /// default method or an implementation of a trait method), returns the ID of
 /// the trait that the method belongs to. Otherwise, returns `None`.
 pub fn get_trait_of_item(cstore: &cstore::CStore,
-                         def_id: ast::DefId,
+                         def_id: DefId,
                          tcx: &ty::ctxt)
-                         -> Option<ast::DefId> {
+                         -> Option<DefId> {
     let cdata = cstore.get_crate_data(def_id.krate);
     decoder::get_trait_of_item(&*cdata, def_id.node, tcx)
 }
 
 pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore,
-                                           def_id: ast::DefId)
-    -> Option<ast::DefId>
+                                           def_id: DefId)
+    -> Option<DefId>
 {
     let cdata = cstore.get_crate_data(def_id.krate);
     decoder::get_tuple_struct_definition_if_ctor(&*cdata, def_id.node)
@@ -352,37 +353,37 @@ pub fn get_missing_lang_items(cstore: &cstore::CStore, cnum: ast::CrateNum)
     decoder::get_missing_lang_items(&*cdata)
 }
 
-pub fn get_method_arg_names(cstore: &cstore::CStore, did: ast::DefId)
+pub fn get_method_arg_names(cstore: &cstore::CStore, did: DefId)
     -> Vec<String>
 {
     let cdata = cstore.get_crate_data(did.krate);
     decoder::get_method_arg_names(&*cdata, did.node)
 }
 
 pub fn get_reachable_ids(cstore: &cstore::CStore, cnum: ast::CrateNum)
-    -> Vec<ast::DefId>
+    -> Vec<DefId>
 {
     let cdata = cstore.get_crate_data(cnum);
     decoder::get_reachable_ids(&*cdata)
 }
 
-pub fn is_typedef(cstore: &cstore::CStore, did: ast::DefId) -> bool {
+pub fn is_typedef(cstore: &cstore::CStore, did: DefId) -> bool {
     let cdata = cstore.get_crate_data(did.krate);
     decoder::is_typedef(&*cdata, did.node)
 }
 
-pub fn is_const_fn(cstore: &cstore::CStore, did: ast::DefId) -> bool {
+pub fn is_const_fn(cstore: &cstore::CStore, did: DefId) -> bool {
     let cdata = cstore.get_crate_data(did.krate);
     decoder::is_const_fn(&*cdata, did.node)
 }
 
-pub fn is_impl(cstore: &cstore::CStore, did: ast::DefId) -> bool {
+pub fn is_impl(cstore: &cstore::CStore, did: DefId) -> bool {
     let cdata = cstore.get_crate_data(did.krate);
     decoder::is_impl(&*cdata, did.node)
 }
 
 pub fn get_stability(cstore: &cstore::CStore,
-                     def: ast::DefId)
+                     def: DefId)
                      -> Option<attr::Stability> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_stability(&*cdata, def.node)
@@ -392,23 +393,23 @@ pub fn is_staged_api(cstore: &cstore::CStore, krate: ast::CrateNum) -> bool {
     cstore.get_crate_data(krate).staged_api
 }
 
-pub fn get_repr_attrs(cstore: &cstore::CStore, def: ast::DefId)
+pub fn get_repr_attrs(cstore: &cstore::CStore, def: DefId)
                       -> Vec<attr::ReprAttr> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_repr_attrs(&*cdata, def.node)
 }
 
-pub fn is_defaulted_trait(cstore: &cstore::CStore, trait_def_id: ast::DefId) -> bool {
+pub fn is_defaulted_trait(cstore: &cstore::CStore, trait_def_id: DefId) -> bool {
     let cdata = cstore.get_crate_data(trait_def_id.krate);
     decoder::is_defaulted_trait(&*cdata, trait_def_id.node)
 }
 
-pub fn is_default_impl(cstore: &cstore::CStore, impl_did: ast::DefId) -> bool {
+pub fn is_default_impl(cstore: &cstore::CStore, impl_did: DefId) -> bool {
     let cdata = cstore.get_crate_data(impl_did.krate);
     decoder::is_default_impl(&*cdata, impl_did.node)
 }
 
-pub fn is_extern_fn(cstore: &cstore::CStore, did: ast::DefId,
+pub fn is_extern_fn(cstore: &cstore::CStore, did: DefId,
                     tcx: &ty::ctxt) -> bool {
     let cdata = cstore.get_crate_data(did.krate);
     decoder::is_extern_fn(&*cdata, did.node, tcx)