WIP auto-applicable suggestion macro-use-imports

clippy_lints/src/lib.rs

@@ -53,6 +53,11 @@ extern crate rustc_target;
 #[allow(unused_extern_crates)]
 extern crate rustc_typeck;
 
+#[allow(unused_extern_crates)]
+extern crate rustc_resolve;
+#[allow(unused_extern_crates)]
+extern crate rustc_codegen_llvm;
+
 use rustc::session::Session;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
@@ -1014,7 +1019,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
     store.register_early_pass(|| box option_env_unwrap::OptionEnvUnwrap);
     store.register_late_pass(|| box wildcard_imports::WildcardImports);
-    store.register_early_pass(|| box macro_use::MacroUseImports::default());
+    // store.register_early_pass(|| box macro_use::MacroUseImports::default());
+    store.register_late_pass(|| box macro_use::MacroUseImports::default());
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),

clippy_lints/src/macro_use.rs

@@ -1,16 +1,15 @@
-use crate::utils::{snippet, span_lint_and_sugg, in_macro};
+use crate::utils::{in_macro, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_ast::ast;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext, Lint};
-use rustc_session::{impl_lint_pass, declare_tool_lint};
-use rustc_span::{edition::Edition, Span};
 use rustc_hir as hir;
+use hir::def::{Res, DefKind};
+use rustc_lint::{LintContext, LateLintPass, LateContext};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{edition::Edition, Span};
 
 const PRELUDE: &[&str] = &[
-    "marker", "ops", "convert", "iter", "option", "result", "borrow", "boxed", "string", "vec",
-    "macros"
+    "marker", "ops", "convert", "iter", "option", "result", "borrow", "boxed", "string", "vec", "macros",
 ];
 const BRACKETS: &[char] = &['<', '>'];
 
@@ -34,14 +33,15 @@ declare_clippy_lint! {
 
 /// MacroRefData includes the name of the macro
 /// and the path from `SourceMap::span_to_filename`.
+#[derive(Debug, Clone)]
 pub struct MacroRefData {
     name: String,
     path: String,
 }
 
 impl MacroRefData {
-    pub fn new(name: String, span: Span, ecx: &EarlyContext<'_>) -> Self {
-        let mut path = ecx.sess.source_map().span_to_filename(span).to_string();
+    pub fn new(name: String, span: Span, ecx: &LateContext<'_, '_>) -> Self {
+        let mut path = ecx.sess().source_map().span_to_filename(span).to_string();
 
         // std lib paths are <::std::module::file type>
         // so remove brackets and space
@@ -51,7 +51,10 @@ impl MacroRefData {
         if path.contains(' ') {
             path = path.split(' ').next().unwrap().to_string();
         }
-        Self { name: name.to_string(), path, }
+        Self {
+            name: name.to_string(),
+            path,
+        }
     }
 }
 
@@ -62,122 +65,144 @@ pub struct MacroUseImports {
     /// the span of the macro reference and the `MacroRefData`
     /// for the use of the macro.
     collected: FxHashMap<Span, MacroRefData>,
+    mac_refs: Vec<(Span, MacroRefData)>,
 }
 
-impl MacroUseImports {
-    fn import_path_mac(&self, use_path: &str) -> String {
-        for mac in self.collected.values() {
-            if paths_match(mac, use_path) {
-                return make_path(mac, use_path)
-            }
-        }
-        format!("{}::<macro name>", use_path)
-    }
-}
-
-fn paths_match(mac: &MacroRefData, use_path: &str) -> bool {
-    let segs = mac.path.split("::")
-        .filter(|s| *s != "")
-        .collect::<Vec<_>>();
+/// This is somewhat of a fallback for imports from `std::prelude` because they
+/// are not recognized by `LateLintPass::check_item` `lcx.tcx.item_children(id)`
+fn make_path(mac: &MacroRefData, use_path: &str) -> String {
+    let segs = mac.path.split("::").filter(|s| *s != "").collect::<Vec<_>>();
 
-    if segs.starts_with(&["std"]) {
-        return PRELUDE.iter().any(|m| segs.contains(m))
+    if segs.starts_with(&["std"]) && PRELUDE.iter().any(|m| segs.contains(m)) {
+        return format!("std::prelude::{} is imported by default, remove `use` statement", mac.name);
     }
-
-    segs.starts_with(&use_path.split("::").collect::<Vec<_>>())
-}
 
-fn make_path(mac: &MacroRefData, use_path: &str) -> String {
     if use_path.split("::").count() == 1 {
         return format!("{}::{}", use_path, mac.name);
     }
 
-    let segs = mac.path.split("::")
-        .filter(|s| *s != "")
-        .collect::<Vec<_>>();
-
-    if segs.starts_with(&["std"]) && PRELUDE.iter().any(|m| segs.contains(m)) {
-        return format!("std::prelude::{}", mac.name);
-    }
-
     mac.path.clone()
 }
 
 impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
 
-impl EarlyLintPass for MacroUseImports {
-    fn check_item(&mut self, ecx: &EarlyContext<'_>, item: &ast::Item) {
+impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
+    fn check_item(&mut self, lcx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
         if_chain! {
-            if ecx.sess.opts.edition == Edition::Edition2018;
-            if let ast::ItemKind::Use(use_tree) = &item.kind;
+            if lcx.sess().opts.edition == Edition::Edition2018;
+            if let hir::ItemKind::Use(path, _kind) = &item.kind;
             if let Some(mac_attr) = item
                 .attrs
                 .iter()
                 .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
+            if let Res::Def(DefKind::Mod, id) = path.res;
             then {
-                let import_path = snippet(ecx, use_tree.span, "_");
-                let span = mac_attr.span.clone();
-                self.imports.push((import_path.to_string(), span));
+                for kid in lcx.tcx.item_children(id).iter() {
+                    if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
+                        let span = mac_attr.span.clone();
+                        println!("{:#?}", lcx.tcx.def_path_str(mac_id));
+                        self.imports.push((lcx.tcx.def_path_str(mac_id), span));
+                    }
+                }
+            } else {
+                if in_macro(item.span) {
+                    let call_site = item.span.source_callsite();
+                    let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+                    if let Some(callee) = item.span.source_callee() {
+                        if !self.collected.contains_key(&call_site) {
+                            let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                            self.mac_refs.push((call_site, mac.clone()));
+                            self.collected.insert(call_site, mac);
+                            // println!("EXPR {:?} {:?}", name, lcx.sess().source_map().span_to_filename(callee.def_site));
+                        }
+                    }
+                }
             }
         }
     }
 
-    fn check_expr(&mut self, ecx: &EarlyContext<'_>, expr: &ast::Expr) {
+    fn check_expr(&mut self, lcx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
         if in_macro(expr.span) {
             let call_site = expr.span.source_callsite();
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = expr.span.source_callee() {
-                self.collected.entry(call_site)
-                    .or_insert_with(|| {
-                        MacroRefData::new(name.to_string(), callee.def_site, ecx)
-                    });
+                if !self.collected.contains_key(&call_site) {
+                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                    // println!("EXPR {:?} {:?}", name, lcx.sess().source_map().span_to_filename(callee.def_site));
+                }
             }
         }
     }
-    fn check_stmt(&mut self, ecx: &EarlyContext<'_>, stmt: &ast::Stmt) {
+    fn check_stmt(&mut self, lcx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>) {
         if in_macro(stmt.span) {
             let call_site = stmt.span.source_callsite();
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = stmt.span.source_callee() {
-                self.collected.entry(call_site)
-                    .or_insert_with(|| {
-                        MacroRefData::new(name.to_string(), callee.def_site, ecx)
-                    });
+                if !self.collected.contains_key(&call_site) {
+                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                    // println!("STMT {:?} {:?}", name, lcx.sess().source_map().span_to_filename(callee.def_site));
+                }
             }
         }
     }
-    fn check_pat(&mut self, ecx: &EarlyContext<'_>, pat: &ast::Pat) {
+    fn check_pat(&mut self, lcx: &LateContext<'_, '_>, pat: &hir::Pat<'_>) {
         if in_macro(pat.span) {
             let call_site = pat.span.source_callsite();
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = pat.span.source_callee() {
-                self.collected.entry(call_site)
-                    .or_insert_with(|| {
-                        MacroRefData::new(name.to_string(), callee.def_site, ecx)
-                    });
+                if !self.collected.contains_key(&call_site) {
+                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                    // println!("PAT {:?} {:?}", name, lcx.sess().source_map().span_to_filename(callee.def_site));
+                }
             }
         }
     }
-    fn check_ty(&mut self, ecx: &EarlyContext<'_>, ty: &ast::Ty) {
+    fn check_ty(&mut self, lcx: &LateContext<'_, '_>, ty: &hir::Ty<'_>) {
         if in_macro(ty.span) {
             let call_site = ty.span.source_callsite();
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = ty.span.source_callee() {
-                self.collected.entry(call_site)
-                    .or_insert_with(|| {
-                        MacroRefData::new(name.to_string(), callee.def_site, ecx)
-                    });
+                if !self.collected.contains_key(&call_site) {
+                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                    // println!("TYPE {:?} {:?}", name, lcx.sess().source_map().span_to_filename(callee.def_site));
+                }
             }
         }
     }
 
-    fn check_crate_post(&mut self, ecx: &EarlyContext<'_>, _krate: &ast::Crate) {
-        for (name, span) in self.imports.iter() {
-            let import_path = self.import_path_mac(&name);
+    fn check_crate_post(&mut self, lcx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
+        for (import, span) in self.imports.iter() {
+
+            let matched = self.mac_refs.iter().find(|(_span, mac)| !import.ends_with(&mac.name)).is_some();
+            if matched {
+                self.mac_refs.retain(|(_span, mac)| !import.ends_with(&mac.name));
+                let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
+                let help = format!("use {}", import);
+                span_lint_and_sugg(
+                    lcx,
+                    MACRO_USE_IMPORTS,
+                    *span,
+                    msg,
+                    "remove the attribute and import the macro directly, try",
+                    help,
+                    Applicability::HasPlaceholders,
+                )
+            }
+        }
+
+        for (span, mac) in self.mac_refs.iter() {
             let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
-            let help = format!("use {}", import_path);
+            let help = make_path(mac, "hello");
             span_lint_and_sugg(
-                ecx,
+                lcx,
                 MACRO_USE_IMPORTS,
                 *span,
                 msg,

tests/ui/auxiliary/macro_use_helper.rs

@@ -0,0 +1,32 @@
+// pub use macro_rules::foofoo;
+// pub use crate::extern_exports::*;
+
+#[macro_export]
+macro_rules! pub_macro {
+    () => {
+        let _ = "hello Mr. Vonnegut";
+    };
+}
+
+
+pub mod inner {
+    #[macro_export]
+        macro_rules! inner_mod {
+            () => {
+                #[allow(dead_code)]
+                pub struct Tardis;
+            };
+        }
+}
+
+mod extern_exports {
+
+    pub(super) mod private_inner {
+        #[macro_export]
+        macro_rules! pub_in_private {
+            ($name:ident) => {
+                let $name = String::from("secrets and lies");
+            };
+        }
+    }
+}

tests/ui/macro_use_imports.rs

@@ -1,21 +1,30 @@
 // compile-flags: --edition 2018
+// aux-build:macro_use_helper.rs
+
+// aux-build:macro_rules.rs
+#![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
 #![feature(rustc_private)]
 
-use std::collections::HashMap;
 #[macro_use]
-use std::{prelude, sync::Mutex};
+extern crate macro_use_helper as mac;
 #[macro_use]
-extern crate rustc_session;
+use std::prelude;
+
+mod a {
+    use std::collections::HashMap;
+    #[macro_use]
+    use mac;
+
+    fn main() {
+        let _ = HashMap::<u8, u8>::new();
+        println!();
+        pub_macro!();
+        inner_mod!();
+        pub_in_private!(_var);
+    }
+}
 
 fn main() {
-    let _ = Mutex::new(8_u8);
-    let _ = HashMap::<u8, u8>::new();
     println!();
-    declare_tool_lint! {
-        pub clippy::TEST_LINT,
-        Warn,
-        "",
-        report_in_external_macro: true
-    }
 }