emit lints in check_crate_post for useless_vec

Author: ericwu17

clippy_lints/src/lib.rs

@@ -50,6 +50,8 @@ extern crate clippy_utils;
 #[macro_use]
 extern crate declare_clippy_lint;
 
+use std::collections::{BTreeMap, BTreeSet};
+
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
 
@@ -722,6 +724,8 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         Box::new(vec::UselessVec {
             too_large_for_stack,
             msrv: msrv(),
+            span_to_lint_map: BTreeMap::new(),
+            spans_sure_to_lint: BTreeSet::new(),
         })
     });
     store.register_late_pass(|_| Box::new(panic_unimplemented::PanicUnimplemented));

clippy_lints/src/vec.rs

@@ -1,3 +1,4 @@
+use std::collections::{BTreeMap, BTreeSet};
 use std::ops::ControlFlow;
 
 use clippy_config::msrvs::{self, Msrv};
@@ -20,6 +21,8 @@ use rustc_span::{sym, Span};
 pub struct UselessVec {
     pub too_large_for_stack: u64,
     pub msrv: Msrv,
+    pub span_to_lint_map: BTreeMap<Span, Option<(SuggestedType, String, Applicability)>>,
+    pub spans_sure_to_lint: BTreeSet<Span>,
 }
 
 declare_clippy_lint! {
@@ -70,9 +73,7 @@ pub fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 impl<'tcx> LateLintPass<'tcx> for UselessVec {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // search for `&vec![_]` or `vec![_]` expressions where the adjusted type is `&[_]`
-        if adjusts_to_slice(cx, expr)
-            && let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows())
-        {
+        if let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows()) {
             let (suggest_slice, span) = if let ExprKind::AddrOf(BorrowKind::Ref, mutability, _) = expr.kind {
                 // `expr` is `&vec![_]`, so suggest `&[_]` (or `&mut[_]` resp.)
                 (SuggestedType::SliceRef(mutability), expr.span)
@@ -82,7 +83,11 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                 (SuggestedType::Array, expr.span.ctxt().outer_expn_data().call_site)
             };
 
-            self.check_vec_macro(cx, &vec_args, span, suggest_slice);
+            if adjusts_to_slice(cx, expr) {
+                self.check_vec_macro(cx, &vec_args, span, suggest_slice);
+            } else if !self.spans_sure_to_lint.contains(&span) {
+                self.span_to_lint_map.insert(span, None);
+            }
         }
 
         // search for `let foo = vec![_]` expressions where all uses of `foo`
@@ -110,12 +115,9 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
             .is_continue();
 
             if only_slice_uses {
-                self.check_vec_macro(
-                    cx,
-                    &vec_args,
-                    expr.span.ctxt().outer_expn_data().call_site,
-                    SuggestedType::Array,
-                );
+                let span = expr.span.ctxt().outer_expn_data().call_site;
+                self.spans_sure_to_lint.insert(span);
+                self.check_vec_macro(cx, &vec_args, span, SuggestedType::Array);
             }
         }
 
@@ -126,15 +128,38 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
         {
             // report the error around the `vec!` not inside `<std macros>:`
             let span = arg.span.ctxt().outer_expn_data().call_site;
+            self.spans_sure_to_lint.insert(span);
             self.check_vec_macro(cx, &vec_args, span, SuggestedType::Array);
         }
     }
 
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        for (span, lint_opt) in self.span_to_lint_map.clone() {
+            if let Some((suggest_slice, snippet, applicability)) = lint_opt {
+                span_lint_and_sugg(
+                    cx,
+                    USELESS_VEC,
+                    span,
+                    "useless use of `vec!`",
+                    &format!(
+                        "you can use {} directly",
+                        match suggest_slice {
+                            SuggestedType::SliceRef(_) => "a slice",
+                            SuggestedType::Array => "an array",
+                        }
+                    ),
+                    snippet,
+                    applicability,
+                );
+            }
+        }
+    }
+
     extract_msrv_attr!(LateContext);
 }
 
 #[derive(Copy, Clone)]
-enum SuggestedType {
+pub enum SuggestedType {
     /// Suggest using a slice `&[..]` / `&mut [..]`
     SliceRef(Mutability),
     /// Suggest using an array: `[..]`
@@ -204,21 +229,10 @@ impl UselessVec {
             },
         };
 
-        span_lint_and_sugg(
-            cx,
-            USELESS_VEC,
-            span,
-            "useless use of `vec!`",
-            &format!(
-                "you can use {} directly",
-                match suggest_slice {
-                    SuggestedType::SliceRef(_) => "a slice",
-                    SuggestedType::Array => "an array",
-                }
-            ),
-            snippet,
-            applicability,
-        );
+        if !self.span_to_lint_map.contains_key(&span) || self.spans_sure_to_lint.contains(&span) {
+            self.span_to_lint_map
+                .insert(span, Some((suggest_slice, snippet, applicability)));
+        }
     }
 }