collected all the imports and names

Author: DevinR528

clippy_lints/src/macro_use.rs

@@ -1,11 +1,34 @@
 use crate::utils::{snippet, span_lint_and_sugg, in_macro};
 use if_chain::if_chain;
 use rustc_ast::ast;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+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;
+
+const PRELUDE: &[&str] = &[
+    "marker", "ops", "convert", "iter", "option", "result", "borrow", "boxed", "string", "vec",
+    "macros"
+];
+
+pub type SuggFn = Box<dyn FnOnce(EarlyContext<'_>, &'static Lint, Span, &str, &str, String, Applicability)>;
+pub type SaveFn = Box<dyn FnOnce()>;
+
+pub struct ImportData {
+    name: String,
+    path: String,
+}
+
+impl ImportData {
+    pub fn new(name: String, span: Span, ecx: &EarlyContext<'_>) -> Self {
+        let path = ecx.sess.source_map().span_to_filename(span);
+        let path = ecx.sess.source_map().span_to_unmapped_path(span);
+        println!("{:?} {:?}", name, path);
+        Self { name: name.to_string(), path: path.to_string(), }
+    }
+}
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `#[macro_use] use...`.
@@ -27,13 +50,20 @@ declare_clippy_lint! {
 
 #[derive(Default)]
 pub struct MacroUseImport {
-    collected: FxHashSet<Span>,
+    imports: Vec<(String, Span)>,
+    collected: FxHashMap<Span, ImportData>,
+}
+
+impl MacroUseImport {
+    fn import_path_mac(&self, name: &str) -> String {
+        println!("{:?}", name);
+        String::default() 
+    }
 }
 
 impl_lint_pass!(MacroUseImport => [MACRO_USE_IMPORT]);
 
 impl EarlyLintPass for MacroUseImport {
-
     fn check_item(&mut self, ecx: &EarlyContext<'_>, item: &ast::Item) {
         if_chain! {
             if ecx.sess.opts.edition == Edition::Edition2018;
@@ -44,58 +74,77 @@ impl EarlyLintPass for MacroUseImport {
                 .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
             then {
                 let import_path = snippet(ecx, use_tree.span, "_");
-                let mac_names = find_used_macros(ecx, &import_path);
-                let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
-                let help = format!("use {}::<macro name>", import_path);
-                span_lint_and_sugg(
-                    ecx,
-                    MACRO_USE_IMPORT,
-                    mac_attr.span,
-                    msg,
-                    // "remove the attribute and import the macro directly, try",
-                    "",
-                    help,
-                    Applicability::HasPlaceholders,
-                );
+                let span = mac_attr.span.clone();
+                self.imports.push((import_path.to_string(), span));
             }
         }
     }
 
     fn check_expr(&mut self, ecx: &EarlyContext<'_>, expr: &ast::Expr) {
         if in_macro(expr.span) {
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(expr.span.source_callsite(), '!'), "_");
+            let call_site = expr.span.source_callsite();
+            let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = expr.span.source_callee() {
-                if self.collected.insert(callee.def_site) {
-                    println!("EXPR {:#?}", name);
-                }
+                self.collected.entry(call_site)
+                    .or_insert_with(|| {
+                        println!("EXPR {:?}", name);
+                        ImportData::new(name.to_string(), callee.def_site, ecx)
+                    });
             }
         }
     }
     fn check_stmt(&mut self, ecx: &EarlyContext<'_>, stmt: &ast::Stmt) {
         if in_macro(stmt.span) {
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(stmt.span.source_callsite(), '!'), "_");
+            let call_site = stmt.span.source_callsite();
+            let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = stmt.span.source_callee() {
-                println!("EXPR {:#?}", name);
+                self.collected.entry(call_site)
+                    .or_insert_with(|| {
+                        println!("STMT {:?}", name);
+                        ImportData::new(name.to_string(), callee.def_site, ecx)
+                    });
             }
         }
     }
     fn check_pat(&mut self, ecx: &EarlyContext<'_>, pat: &ast::Pat) {
         if in_macro(pat.span) {
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(pat.span.source_callsite(), '!'), "_");
+            let call_site = pat.span.source_callsite();
+            let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = pat.span.source_callee() {
-                println!("EXPR {:#?}", name);
+                self.collected.entry(call_site)
+                    .or_insert_with(|| {
+                        println!("PAT {:?}", name);
+                        ImportData::new(name.to_string(), callee.def_site, ecx)
+                    });
             }
         }
     }
-}
-
-fn find_used_macros(ecx: &EarlyContext<'_>, path: &str) {
-    for it in ecx.krate.module.items.iter() {
-        if in_macro(it.span) {
-            // println!("{:#?}", it)
+    fn check_mac(&mut self, ecx: &EarlyContext<'_>, mac: &ast::Mac) {
+        let call_site = mac.span().source_callsite();
+        let name = snippet(ecx, ecx.sess.source_map().span_until_char(call_site, '!'), "_");
+        if let Some(callee) = mac.span().source_callee() {
+            self.collected.entry(call_site)
+                .or_insert_with(|| {
+                    println!("MAC {:?}", name);
+                    ImportData::new(name.to_string(), callee.def_site, ecx)
+                });
         }
     }
-    for x in ecx.sess.imported_macro_spans.borrow().iter() {
-        // println!("{:?}", x);
+    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);
+            let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
+            let help = format!("use {}::{}", import_path, name);
+            span_lint_and_sugg(
+                ecx,
+                MACRO_USE_IMPORT,
+                *span,
+                msg,
+                // "remove the attribute and import the macro directly, try",
+                "",
+                help,
+                Applicability::HasPlaceholders,
+            )
+        }
     }
 }

tests/ui/macro_use_import.rs

@@ -1,12 +1,30 @@
 // compile-flags: --edition 2018
 #![warn(clippy::macro_use_import)]
+#![feature(rustc_private)]
 
 use std::collections::HashMap;
 #[macro_use]
 use std::prelude;
+#[macro_use]
+extern crate rustc_session;
 
 fn main() {
     let _ = HashMap::<u8, u8>::new();
-    serde_if_integer128!("");
+    here!();
     println!();
+    declare_tool_lint! {
+        pub clippy::TEST_LINT,
+        Warn,
+        "",
+        report_in_external_macro: true
+    }
+}
+
+mod a {
+    #[macro_export]
+    macro_rules! here {
+        () => {
+            ()
+        };
+    }
 }