rustc: use DefKind instead of Def, where possible.

[rust.git] / src / librustc_resolve / macros.rs

diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index 21ca8ea369fd90930c1fcc957bb380e681c8276f..3df09369f89b5effe3c8da623d5ff723a71fc826 100644 (file)
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -8,7 +8,7 @@
 use crate::resolve_imports::ImportResolver;
 use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX, DefIndex,
                          CrateNum, DefIndexAddressSpace};
-use rustc::hir::def::{Def, NonMacroAttrKind};
+use rustc::hir::def::{self, DefKind, NonMacroAttrKind};
 use rustc::hir::map::{self, DefCollector};
 use rustc::{ty, lint};
 use rustc::{bug, span_bug};
@@ -33,6 +33,8 @@
 use std::{mem, ptr};
 use rustc_data_structures::sync::Lrc;
 
+type Def = def::Def<ast::NodeId>;
+
 #[derive(Clone, Debug)]
 pub struct InvocationData<'a> {
     def_index: DefIndex,
@@ -138,7 +140,7 @@ impl<'a> Visitor<'a> for ResolveDollarCrates<'a, '_> {
             fn visit_ident(&mut self, ident: Ident) {
                 if ident.name == keywords::DollarCrate.name() {
                     let name = match self.resolver.resolve_crate_root(ident).kind {
-                        ModuleKind::Def(_, name) if name != keywords::Invalid.name() => name,
+                        ModuleKind::Def(.., name) if name != keywords::Invalid.name() => name,
                         _ => keywords::Crate.name(),
                     };
                     ident.span.ctxt().set_dollar_crate_name(name);
@@ -177,7 +179,7 @@ fn add_builtin(&mut self, ident: ast::Ident, ext: Lrc<SyntaxExtension>) {
         let kind = ext.kind();
         self.macro_map.insert(def_id, ext);
         let binding = self.arenas.alloc_name_binding(NameBinding {
-            kind: NameBindingKind::Def(Def::Macro(def_id, kind), false),
+            kind: NameBindingKind::Def(Def::Def(DefKind::Macro(kind), def_id), false),
             ambiguity: None,
             span: DUMMY_SP,
             vis: ty::Visibility::Public,
@@ -216,7 +218,7 @@ fn resolve_macro_invocation(&mut self, invoc: &Invocation, invoc_id: Mark, force
             Err(determinacy) => return Err(determinacy),
         };
 
-        if let Def::Macro(def_id, _) = def {
+        if let Def::Def(DefKind::Macro(_), def_id) = def {
             if after_derive {
                 self.session.span_err(invoc.span(),
                                       "macro attributes must be placed before `#[derive]`");
@@ -295,7 +297,7 @@ fn resolve_macro_to_def(
         let def = def?;
 
         match def {
-            Def::Macro(def_id, macro_kind) => {
+            Def::Def(DefKind::Macro(macro_kind), def_id) => {
                 self.unused_macros.remove(&def_id);
                 if macro_kind == MacroKind::ProcMacroStub {
                     let msg = "can't use a procedural macro from the same crate that defines it";
@@ -339,7 +341,7 @@ fn resolve_macro_to_def(
             Def::Err => {
                 return Err(Determinacy::Determined);
             }
-            _ => panic!("expected `Def::Macro` or `Def::NonMacroAttr`"),
+            _ => panic!("expected `DefKind::Macro` or `Def::NonMacroAttr`"),
         }
 
         Ok((def, self.get_macro(def)))
@@ -358,8 +360,8 @@ fn report_unknown_attribute(&self, span: Span, name: &str, msg: &str, feature: &
 
         let attr_candidates = BUILTIN_ATTRIBUTES
             .iter()
-            .filter_map(|(name, _, _, gate)| {
-                if name.starts_with("rustc_") && !features.rustc_attrs {
+            .filter_map(|&(name, _, _, ref gate)| {
+                if name.as_str().starts_with("rustc_") && !features.rustc_attrs {
                     return None;
                 }
 
@@ -374,7 +376,6 @@ fn report_unknown_attribute(&self, span: Span, name: &str, msg: &str, feature: &
                     _ => None,
                 }
             })
-            .map(|name| Symbol::intern(name))
             .chain(
                 // Add built-in macro attributes as well.
                 self.builtin_macros.iter().filter_map(|(name, binding)| {
@@ -1027,7 +1028,7 @@ fn suggest_macro_name(&mut self, name: &str, kind: MacroKind,
         // Then check modules.
         }).or_else(|| {
             let is_macro = |def| {
-                if let Def::Macro(_, def_kind) = def {
+                if let Def::Def(DefKind::Macro(def_kind), _) = def {
                     def_kind == kind
                 } else {
                     false
@@ -1106,7 +1107,7 @@ pub fn define_macro(&mut self,
         if def.legacy {
             let ident = ident.modern();
             self.macro_names.insert(ident);
-            let def = Def::Macro(def_id, MacroKind::Bang);
+            let def = Def::Def(DefKind::Macro(MacroKind::Bang), def_id);
             let is_macro_export = attr::contains_name(&item.attrs, "macro_export");
             let vis = if is_macro_export {
                 ty::Visibility::Public
@@ -1132,7 +1133,7 @@ pub fn define_macro(&mut self,
             }
         } else {
             let module = self.current_module;
-            let def = Def::Macro(def_id, MacroKind::Bang);
+            let def = Def::Def(DefKind::Macro(MacroKind::Bang), def_id);
             let vis = self.resolve_visibility(&item.vis);
             if vis != ty::Visibility::Public {
                 self.unused_macros.insert(def_id);