wip

Author: phansch

clippy_lints/src/lib.rs

@@ -165,6 +165,11 @@ macro_rules! declare_clippy_lint {
             $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
         }
     };
+    { $(#[$attr:meta])* pub $name:tt, internal_collector, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
 }
 
 mod consts;
@@ -855,6 +860,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
         &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
         &utils::internal_lints::PRODUCE_ICE,
+        &utils::internal_lints::LINT_COLLECTOR,
         &vec::USELESS_VEC,
         &vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
         &verbose_file_reads::VERBOSE_FILE_READS,
@@ -878,6 +884,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
     store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
     store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
+    store.register_late_pass(|| box utils::internal_lints::ClippyLintCollector);
     store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
     store.register_late_pass(|| box utils::author::Author);
     let vec_box_size_threshold = conf.vec_box_size_threshold;

clippy_lints/src/utils/internal_lints.rs

@@ -1,7 +1,7 @@
 use crate::utils::SpanlessEq;
 use crate::utils::{
-    is_expn_of, match_def_path, match_qpath, match_type, method_calls, paths, run_lints, snippet, span_lint,
-    span_lint_and_help, span_lint_and_sugg, walk_ptrs_ty,
+    is_expn_of, match_def_path, match_qpath, match_type, method_calls, paths, snippet, span_lint, span_lint_and_help,
+    span_lint_and_sugg, walk_ptrs_ty, last_path_segment, match_function_call
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
@@ -656,3 +656,76 @@ fn suggest_note(
         Applicability::MachineApplicable,
     );
 }
+
+declare_clippy_lint! {
+    /// **What it does:** Collects data about all our lints into a JSON file
+    ///
+    ///
+    ///
+    /// **Why is this bad?** TODO
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:** TODO
+    pub LINT_COLLECTOR,
+    // Don't want to run this as part of the dogfood tests, so separate lint group
+    internal_collector,
+    "not a lint. collects all lints into a JSON file"
+}
+
+declare_lint_pass!(ClippyLintCollector => [LINT_COLLECTOR]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ClippyLintCollector {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let Some(args) = match_function_call(cx, expr, &["clippy_lints", "utils", "diagnostics", "span_lint_and_sugg"]);
+            let (lint_name, applicability) = lint_of_diagnostic_emission(cx, args);
+
+            then {
+                // dbg!(&lint_name);
+                // dbg!(&applicability);
+
+                span_lint(cx, LINT_COLLECTOR, expr.span, &format!("here: span_lint_and_sugg"));
+            }
+        }
+    }
+}
+
+/// Iterate over the arguments of e.g. `span_lint_and_sugg` and find the lint
+fn lint_of_diagnostic_emission<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    args: &[hir::Expr<'_>],
+) -> (Option<Symbol>, Option<Symbol>) {
+    let mut lint_name: Option<Symbol> = None;
+    let mut applicability: Option<Symbol> = None;
+    for arg in args {
+        let arg_ty = walk_ptrs_ty(cx.tables.expr_ty(&arg));
+
+        if match_type(cx, arg_ty, &paths::LINT) {
+            // If we found the lint arg, extract the lint name
+            if let ExprKind::Path(ref lint_path) = arg.kind {
+                lint_name = Some(last_path_segment(lint_path).ident.name)
+            }
+        }
+        if match_type(cx, arg_ty, &paths::APPLICABILITY) {
+            if let ExprKind::Path(ref path) = arg.kind {
+                // TODO: handle variables of Applicability
+                dbg!(&arg.kind);
+                dbg!(&arg_ty);
+                // dbg!(&path);
+                applicability = Some(last_path_segment(path).ident.name)
+            }
+        }
+    }
+    (lint_name, applicability)
+}
+// todo: re-use `declared_lints` somehow
+// - check for Applicability::MachineApplicable
+// - start with span_lint_and_sugg
+
+// first todo:
+// find span_lint_and_sugg calls with Applicability::MachineApplicable
+// and print the name of the lint
+
+// todo: `args[1]` is brittle. might be better to check each arg:
+// let lint_ty = cx.tables.expr_ty(&args[i]);

clippy_lints/src/utils/mod.rs

@@ -285,6 +285,7 @@ pub fn path_to_res(cx: &LateContext<'_, '_>, path: &[&str]) -> Option<def::Res>
     }
 }
 
+/// A wrapper around `TypeckTables.qpath_res` that returns `Res::Err` instead of panicking
 pub fn qpath_res(cx: &LateContext<'_, '_>, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res {
     match qpath {
         hir::QPath::Resolved(_, path) => path.res,

clippy_lints/src/utils/paths.rs

@@ -57,6 +57,7 @@ pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator
 pub const LATE_CONTEXT: [&str; 4] = ["rustc", "lint", "context", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
 pub const LINT: [&str; 3] = ["rustc_session", "lint", "Lint"];
+pub const APPLICABILITY: [&str; 2] = ["rustc_errors", "Applicability"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
 pub const MEM_FORGET: [&str; 3] = ["core", "mem", "forget"];
 pub const MEM_MAYBEUNINIT: [&str; 4] = ["core", "mem", "maybe_uninit", "MaybeUninit"];