macros: improve reexports

src/librustc/hir/def.rs

@@ -52,6 +52,9 @@ pub enum Def {
  ast::NodeId), // expr node that creates the closure
  Label(ast::NodeId),
 
+ // Macro namespace
+ Macro(DefId),
+
  // Both namespaces
  Err,
 }
@@ -133,7 +136,7 @@ impl Def {
  Def::Variant(id) | Def::VariantCtor(id, ..) | Def::Enum(id) | Def::TyAlias(id) |
  Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) |
  Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) |
- Def::AssociatedConst(id) | Def::Local(id) | Def::Upvar(id, ..) => {
+ Def::AssociatedConst(id) | Def::Local(id) | Def::Upvar(id, ..) | Def::Macro(id) => {
  id
  }
 
@@ -173,6 +176,7 @@ impl Def {
  Def::Upvar(..) => "closure capture",
  Def::Label(..) => "label",
  Def::SelfTy(..) => "self type",
+ Def::Macro(..) => "macro",
  Def::Err => "unresolved item",
  }
  }

src/librustc/hir/def_id.rs

@@ -34,6 +34,10 @@ impl Idx for CrateNum {
 /// LOCAL_CRATE in their DefId.
 pub const LOCAL_CRATE: CrateNum = CrateNum(0);
 
+/// Virtual crate for builtin macros
+// FIXME(jseyfried): this is also used for custom derives until proc-macro crates get `CrateNum`s.
+pub const BUILTIN_MACROS_CRATE: CrateNum = CrateNum(!0);
+
 impl CrateNum {
  pub fn new(x: usize) -> CrateNum {
  assert!(x < (u32::MAX as usize));

src/librustc/hir/map/collector.rs

@@ -226,4 +226,8 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
  fn visit_lifetime(&mut self, lifetime: &'ast Lifetime) {
  self.insert(lifetime.id, NodeLifetime(lifetime));
  }
+
+ fn visit_macro_def(&mut self, macro_def: &'ast MacroDef) {
+ self.insert_entry(macro_def.id, NotPresent);
+ }
 }

src/librustc/middle/cstore.rs

@@ -61,7 +61,18 @@ pub struct LinkMeta {
 pub struct CrateSource {
  pub dylib: Option<(PathBuf, PathKind)>,
  pub rlib: Option<(PathBuf, PathKind)>,
- pub cnum: CrateNum,
+}
+
+#[derive(RustcEncodable, RustcDecodable, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+pub enum DepKind {
+ /// A dependency that is only used for its macros.
+ MacrosOnly,
+ /// A dependency that is always injected into the dependency list and so
+ /// doesn't need to be linked to an rlib, e.g. the injected allocator.
+ Implicit,
+ /// A dependency that is required by an rlib version of this crate.
+ /// Ordinary `extern crate`s result in `Explicit` dependencies.
+ Explicit,
 }
 
 #[derive(Copy, Debug, PartialEq, Clone, RustcEncodable, RustcDecodable)]
@@ -170,10 +181,10 @@ pub trait CrateStore<'tcx> {
  // crate metadata
  fn dylib_dependency_formats(&self, cnum: CrateNum)
  -> Vec<(CrateNum, LinkagePreference)>;
+ fn dep_kind(&self, cnum: CrateNum) -> DepKind;
  fn lang_items(&self, cnum: CrateNum) -> Vec<(DefIndex, usize)>;
  fn missing_lang_items(&self, cnum: CrateNum) -> Vec<lang_items::LangItem>;
  fn is_staged_api(&self, cnum: CrateNum) -> bool;
- fn is_explicitly_linked(&self, cnum: CrateNum) -> bool;
  fn is_allocator(&self, cnum: CrateNum) -> bool;
  fn is_panic_runtime(&self, cnum: CrateNum) -> bool;
  fn is_compiler_builtins(&self, cnum: CrateNum) -> bool;
@@ -200,6 +211,7 @@ pub trait CrateStore<'tcx> {
  fn relative_def_path(&self, def: DefId) -> Option<hir_map::DefPath>;
  fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>;
  fn item_children(&self, did: DefId) -> Vec<def::Export>;
+ fn load_macro(&self, did: DefId, sess: &Session) -> ast::MacroDef;
 
  // misc. metadata
  fn maybe_get_item_ast<'a>(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
@@ -342,7 +354,7 @@ impl<'tcx> CrateStore<'tcx> for DummyCrateStore {
  fn missing_lang_items(&self, cnum: CrateNum) -> Vec<lang_items::LangItem>
  { bug!("missing_lang_items") }
  fn is_staged_api(&self, cnum: CrateNum) -> bool { bug!("is_staged_api") }
- fn is_explicitly_linked(&self, cnum: CrateNum) -> bool { bug!("is_explicitly_linked") }
+ fn dep_kind(&self, cnum: CrateNum) -> DepKind { bug!("is_explicitly_linked") }
  fn is_allocator(&self, cnum: CrateNum) -> bool { bug!("is_allocator") }
  fn is_panic_runtime(&self, cnum: CrateNum) -> bool { bug!("is_panic_runtime") }
  fn is_compiler_builtins(&self, cnum: CrateNum) -> bool { bug!("is_compiler_builtins") }
@@ -371,6 +383,7 @@ impl<'tcx> CrateStore<'tcx> for DummyCrateStore {
  }
  fn struct_field_names(&self, def: DefId) -> Vec<ast::Name> { bug!("struct_field_names") }
  fn item_children(&self, did: DefId) -> Vec<def::Export> { bug!("item_children") }
+ fn load_macro(&self, did: DefId, sess: &Session) -> ast::MacroDef { bug!("load_macro") }
 
  // misc. metadata
  fn maybe_get_item_ast<'a>(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
@@ -410,22 +423,8 @@ impl<'tcx> CrateStore<'tcx> for DummyCrateStore {
  fn metadata_encoding_version(&self) -> &[u8] { bug!("metadata_encoding_version") }
 }
 
-pub enum LoadedMacros {
- MacroRules(Vec<ast::MacroDef>),
- ProcMacros(Vec<(ast::Name, SyntaxExtension)>),
-}
-
-impl LoadedMacros {
- pub fn is_proc_macros(&self) -> bool {
- match *self {
- LoadedMacros::ProcMacros(_) => true,
- _ => false,
- }
- }
-}
-
 pub trait CrateLoader {
  fn process_item(&mut self, item: &ast::Item, defs: &Definitions, load_macros: bool)
- -> Option<LoadedMacros>;
+ -> Vec<(ast::Name, SyntaxExtension)>;
  fn postprocess(&mut self, krate: &ast::Crate);
 }

src/librustc/middle/dependency_format.rs

@@ -65,6 +65,7 @@ use hir::def_id::CrateNum;
 
 use session;
 use session::config;
+use middle::cstore::DepKind;
 use middle::cstore::LinkagePreference::{self, RequireStatic, RequireDynamic};
 use util::nodemap::FxHashMap;
 use rustc_back::PanicStrategy;
@@ -123,6 +124,7 @@ fn calculate_type(sess: &session::Session,
  return v;
  }
  for cnum in sess.cstore.crates() {
+ if sess.cstore.dep_kind(cnum) == DepKind::MacrosOnly { continue }
  let src = sess.cstore.used_crate_source(cnum);
  if src.rlib.is_some() { continue }
  sess.err(&format!("dependency `{}` not found in rlib format",
@@ -155,6 +157,7 @@ fn calculate_type(sess: &session::Session,
  // dependencies, ensuring there are no conflicts. The only valid case for a
  // dependency to be relied upon twice is for both cases to rely on a dylib.
  for cnum in sess.cstore.crates() {
+ if sess.cstore.dep_kind(cnum) == DepKind::MacrosOnly { continue }
  let name = sess.cstore.crate_name(cnum);
  let src = sess.cstore.used_crate_source(cnum);
  if src.dylib.is_some() {
@@ -188,7 +191,7 @@ fn calculate_type(sess: &session::Session,
  let src = sess.cstore.used_crate_source(cnum);
  if src.dylib.is_none() &&
  !formats.contains_key(&cnum) &&
- sess.cstore.is_explicitly_linked(cnum) {
+ sess.cstore.dep_kind(cnum) == DepKind::Explicit {
  assert!(src.rlib.is_some());
  info!("adding staticlib: {}", sess.cstore.crate_name(cnum));
  add_library(sess, cnum, RequireStatic, &mut formats);
@@ -272,7 +275,7 @@ fn attempt_static(sess: &session::Session) -> Option<DependencyList> {
  // everything in explicitly so long as it's actually required.
  let last_crate = sess.cstore.crates().len();
  let mut ret = (1..last_crate+1).map(|cnum| {
- if sess.cstore.is_explicitly_linked(CrateNum::new(cnum)) {
+ if sess.cstore.dep_kind(CrateNum::new(cnum)) == DepKind::Explicit {
  Linkage::Static
  } else {
  Linkage::NotLinked

src/librustc_incremental/calculate_svh/svh_visitor.rs

@@ -834,7 +834,8 @@ impl<'a, 'hash, 'tcx> StrictVersionHashVisitor<'a, 'hash, 'tcx> {
  Def::Const(..) |
  Def::AssociatedConst(..) |
  Def::Local(..) |
- Def::Upvar(..) => {
+ Def::Upvar(..) |
+ Def::Macro(..) => {
  DefHash::SawDefId.hash(self.st);
  self.hash_def_id(def.def_id());
  }

src/librustc_llvm/lib.rs

@@ -29,6 +29,7 @@
 #![feature(staged_api)]
 #![feature(linked_from)]
 #![feature(concat_idents)]
+#![cfg_attr(not(stage0), feature(rustc_private))]
 
 extern crate libc;
 #[macro_use]