Extend the unused macro lint to macros 2.0

src/librustc_resolve/lib.rs

@@ -1200,7 +1200,7 @@ pub struct Resolver<'a> {
     pub found_unresolved_macro: bool,
 
     // List of crate local macros that we need to warn about as being unused.
-    // Right now this only includes macro_rules! macros.
+    // Right now this only includes macro_rules! macros, and 2.0 macros.
     unused_macros: FxHashSet<DefId>,
 
     // Maps the `Mark` of an expansion to its containing module or block.

src/librustc_resolve/macros.rs

@@ -316,6 +316,7 @@ impl<'a> base::Resolver for Resolver<'a> {
         for did in self.unused_macros.iter() {
             let id_span = match *self.macro_map[did] {
                 SyntaxExtension::NormalTT(_, isp, _) => isp,
+                SyntaxExtension::DeclMacro(.., osp) => osp,
                 _ => None,
             };
             if let Some((id, span)) = id_span {
@@ -735,6 +736,9 @@ impl<'a> Resolver<'a> {
             let module = self.current_module;
             let def = Def::Macro(def_id, MacroKind::Bang);
             let vis = self.resolve_visibility(&item.vis);
+            if vis != ty::Visibility::Public {
+                self.unused_macros.insert(def_id);
+            }
             self.define(module, ident, MacroNS, (def, vis, item.span, expansion));
         }
     }

src/libsyntax/ext/base.rs

@@ -552,7 +552,9 @@ pub enum SyntaxExtension {
     BuiltinDerive(BuiltinDeriveFn),
 
     /// A declarative macro, e.g. `macro m() {}`.
-    DeclMacro(Box<TTMacroExpander>, Option<Span> /* definition site span */),
+    ///
+    /// The second element is the definition site span.
+    DeclMacro(Box<TTMacroExpander>, Option<(ast::NodeId, Span)>),
 }
 
 impl SyntaxExtension {

src/libsyntax/ext/expand.rs

@@ -472,8 +472,9 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
 
         let marked_tts = noop_fold_tts(mac.node.stream(), &mut Marker(mark));
         let opt_expanded = match *ext {
-            SyntaxExtension::DeclMacro(ref expand, def_site_span) => {
-                if let Err(msg) = validate_and_set_expn_info(def_site_span, false) {
+            SyntaxExtension::DeclMacro(ref expand, def_span) => {
+                if let Err(msg) = validate_and_set_expn_info(def_span.map(|(_, s)| s),
+                                                             false) {
                     self.cx.span_err(path.span, &msg);
                     return kind.dummy(span);
                 }

src/libsyntax/ext/tt/macro_rules.rs

@@ -266,7 +266,7 @@ pub fn compile(sess: &ParseSess, features: &RefCell<Features>, def: &ast::Item)
         let allow_internal_unstable = attr::contains_name(&def.attrs, "allow_internal_unstable");
         NormalTT(exp, Some((def.id, def.span)), allow_internal_unstable)
     } else {
-        SyntaxExtension::DeclMacro(exp, Some(def.span))
+        SyntaxExtension::DeclMacro(exp, Some((def.id, def.span)))
     }
 }
 

src/test/compile-fail/unused-macro-rules.rs

@@ -0,0 +1,39 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(unused_macros)]
+
+// Most simple case
+macro_rules! unused { //~ ERROR: unused macro definition
+    () => {};
+}
+
+// Test macros created by macros
+macro_rules! create_macro {
+    () => {
+        macro_rules! m { //~ ERROR: unused macro definition
+            () => {};
+        }
+    };
+}
+create_macro!();
+
+#[allow(unused_macros)]
+mod bar {
+    // Test that putting the #[deny] close to the macro's definition
+    // works.
+
+    #[deny(unused_macros)]
+    macro_rules! unused { //~ ERROR: unused macro definition
+        () => {};
+    }
+}
+
+fn main() {}

src/test/compile-fail/unused-macro.rs

@@ -8,31 +8,28 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(decl_macro)]
 #![deny(unused_macros)]
 
 // Most simple case
-macro_rules! unused { //~ ERROR: unused macro definition
-    () => {};
+macro unused { //~ ERROR: unused macro definition
+    () => {}
 }
 
-// Test macros created by macros
-macro_rules! create_macro {
-    () => {
-        macro_rules! m { //~ ERROR: unused macro definition
-            () => {};
-        }
-    };
-}
-create_macro!();
-
 #[allow(unused_macros)]
 mod bar {
     // Test that putting the #[deny] close to the macro's definition
     // works.
 
     #[deny(unused_macros)]
-    macro_rules! unused { //~ ERROR: unused macro definition
-        () => {};
+    macro unused { //~ ERROR: unused macro definition
+        () => {}
+    }
+}
+
+mod boo {
+    pub(crate) macro unused { //~ ERROR: unused macro definition
+        () => {}
     }
 }