how to compare macro to import path

Author: DevinR528

clippy_lints/src/lib.rs

@@ -1049,14 +1049,13 @@ 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);
     store.register_late_pass(|| box verbose_file_reads::VerboseFileReads);
     store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
     store.register_late_pass(|| box unnamed_address::UnnamedAddress);
     store.register_late_pass(|| box dereference::Dereferencing);
     store.register_late_pass(|| box future_not_send::FutureNotSend);
     store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
-    store.register_late_pass(|| box if_let_mutex::IfLetMutex);
+    store.register_early_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

@@ -50,21 +50,21 @@ declare_clippy_lint! {
     /// #[macro_use]
     /// use lazy_static;
     /// ```
-    pub MACRO_USE_IMPORT,
+    pub MACRO_USE_IMPORTS,
     pedantic,
     "#[macro_use] is no longer needed"
 }
 
 #[derive(Default)]
-pub struct MacroUseImport {
+pub struct MacroUseImports {
     /// the actual import path used and its span.
     imports: Vec<(String, Span)>,
     /// the span of the macro reference and the `MacroRefData`
     /// for the use of the macro.
     collected: FxHashMap<Span, MacroRefData>,
 }
 
-impl MacroUseImport {
+impl MacroUseImports {
     fn import_path_mac(&self, use_path: &str) -> String {
         println!("END {:?}", use_path);
 
@@ -79,12 +79,16 @@ impl MacroUseImport {
 
 fn paths_match(mac: &MacroRefData, use_path: &str) -> bool {
     let segs = mac.path.split("::")
-        .filter(|s| *s == "")
+        .filter(|s| *s != "")
         .collect::<Vec<_>>();
+
+    println!("{:?}", segs);
+    
     if segs.starts_with(&["std"]) {
         return PRELUDE.iter().any(|m| segs.contains(m))
     }
-    false
+    
+    segs.starts_with(&use_path.split("::").collect::<Vec<_>>())
 }
 
 fn make_path(mac: &MacroRefData, use_path: &str) -> String {
@@ -98,9 +102,9 @@ fn make_path(mac: &MacroRefData, use_path: &str) -> String {
     res
 }
 
-impl_lint_pass!(MacroUseImport => [MACRO_USE_IMPORT]);
+impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
 
-impl EarlyLintPass for MacroUseImport {
+impl EarlyLintPass for MacroUseImports {
     fn check_item(&mut self, ecx: &EarlyContext<'_>, item: &ast::Item) {
         if_chain! {
             if ecx.sess.opts.edition == Edition::Edition2018;
@@ -175,7 +179,7 @@ impl EarlyLintPass for MacroUseImport {
             let help = format!("use {}", import_path);
             span_lint_and_sugg(
                 ecx,
-                MACRO_USE_IMPORT,
+                MACRO_USE_IMPORTS,
                 *span,
                 msg,
                 // "remove the attribute and import the macro directly, try",

tests/ui/macro_use_import.rs

@@ -1,11 +1,21 @@
 // edition:2018
 #![warn(clippy::macro_use_imports)]
+#![feature(rustc_private)]
 
 use std::collections::HashMap;
 #[macro_use]
-use std::prelude;
+use std::{prelude, sync::Mutex};
+#[macro_use]
+extern crate rustc_session;
 
 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
+    }
 }