redundant_allocation: add note to Box<&T>,Box<Box<T>>

Author: lengyijun

clippy_lints/src/types/redundant_allocation.rs

@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item};
 use rustc_errors::Applicability;
@@ -21,14 +21,23 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
 
     if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
         let mut applicability = Applicability::MaybeIncorrect;
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             REDUNDANT_ALLOCATION,
             hir_ty.span,
             &format!("usage of `{}<&T>`", outer_sym),
-            "try",
-            snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
-            applicability,
+            |diag| {
+                diag.span_suggestion(
+                    hir_ty.span,
+                    "try",
+                    format!("{}", snippet_with_applicability(cx, span, "..", &mut applicability)),
+                    applicability,
+                );
+                diag.note(&format!(
+                    "`&T` is already a pointer, `{}<&T>` allocate a pointer on heap",
+                    outer_sym,
+                ));
+            },
         );
         return true;
     }
@@ -53,18 +62,27 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     };
     if inner_sym == outer_sym {
         let mut applicability = Applicability::MaybeIncorrect;
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             REDUNDANT_ALLOCATION,
             hir_ty.span,
             &format!("usage of `{}<{}<T>>`", outer_sym, inner_sym),
-            "try",
-            format!(
-                "{}<{}>",
-                outer_sym,
-                snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-            ),
-            applicability,
+            |diag| {
+                diag.span_suggestion(
+                    hir_ty.span,
+                    "try",
+                    format!(
+                        "{}<{}>",
+                        outer_sym,
+                        snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                    ),
+                    applicability,
+                );
+                diag.note(&format!(
+                    "`{}<T>` is already on the heap, `{}<{}<T>>` makes an extra allocation",
+                    inner_sym, outer_sym, inner_sym,
+                ));
+            },
         );
     } else {
         span_lint_and_then(

tests/ui/redundant_allocation_fixable.stderr

@@ -5,72 +5,95 @@ LL |     pub fn box_test1<T>(foo: Box<&T>) {}
    |                              ^^^^^^^ help: try: `&T`
    |
    = note: `-D clippy::redundant-allocation` implied by `-D warnings`
+   = note: `&T` is already a pointer, `Box<&T>` allocate a pointer on heap
 
 error: usage of `Box<&T>`
   --> $DIR/redundant_allocation_fixable.rs:28:27
    |
 LL |     pub fn box_test2(foo: Box<&MyStruct>) {}
    |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
+   |
+   = note: `&T` is already a pointer, `Box<&T>` allocate a pointer on heap
 
 error: usage of `Box<&T>`
   --> $DIR/redundant_allocation_fixable.rs:30:27
    |
 LL |     pub fn box_test3(foo: Box<&MyEnum>) {}
    |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
+   |
+   = note: `&T` is already a pointer, `Box<&T>` allocate a pointer on heap
 
 error: usage of `Box<Box<T>>`
   --> $DIR/redundant_allocation_fixable.rs:34:30
    |
 LL |     pub fn box_test5<T>(foo: Box<Box<T>>) {}
    |                              ^^^^^^^^^^^ help: try: `Box<T>`
+   |
+   = note: `Box<T>` is already on the heap, `Box<Box<T>>` makes an extra allocation
 
 error: usage of `Rc<&T>`
   --> $DIR/redundant_allocation_fixable.rs:45:29
    |
 LL |     pub fn rc_test1<T>(foo: Rc<&T>) {}
    |                             ^^^^^^ help: try: `&T`
+   |
+   = note: `&T` is already a pointer, `Rc<&T>` allocate a pointer on heap
 
 error: usage of `Rc<&T>`
   --> $DIR/redundant_allocation_fixable.rs:47:26
    |
 LL |     pub fn rc_test2(foo: Rc<&MyStruct>) {}
    |                          ^^^^^^^^^^^^^ help: try: `&MyStruct`
+   |
+   = note: `&T` is already a pointer, `Rc<&T>` allocate a pointer on heap
 
 error: usage of `Rc<&T>`
   --> $DIR/redundant_allocation_fixable.rs:49:26
    |
 LL |     pub fn rc_test3(foo: Rc<&MyEnum>) {}
    |                          ^^^^^^^^^^^ help: try: `&MyEnum`
+   |
+   = note: `&T` is already a pointer, `Rc<&T>` allocate a pointer on heap
 
 error: usage of `Rc<Rc<T>>`
   --> $DIR/redundant_allocation_fixable.rs:53:24
    |
 LL |     pub fn rc_test6(a: Rc<Rc<bool>>) {}
    |                        ^^^^^^^^^^^^ help: try: `Rc<bool>`
+   |
+   = note: `Rc<T>` is already on the heap, `Rc<Rc<T>>` makes an extra allocation
 
 error: usage of `Arc<&T>`
   --> $DIR/redundant_allocation_fixable.rs:64:30
    |
 LL |     pub fn arc_test1<T>(foo: Arc<&T>) {}
    |                              ^^^^^^^ help: try: `&T`
+   |
+   = note: `&T` is already a pointer, `Arc<&T>` allocate a pointer on heap
 
 error: usage of `Arc<&T>`
   --> $DIR/redundant_allocation_fixable.rs:66:27
    |
 LL |     pub fn arc_test2(foo: Arc<&MyStruct>) {}
    |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
+   |
+   = note: `&T` is already a pointer, `Arc<&T>` allocate a pointer on heap
 
 error: usage of `Arc<&T>`
   --> $DIR/redundant_allocation_fixable.rs:68:27
    |
 LL |     pub fn arc_test3(foo: Arc<&MyEnum>) {}
    |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
+   |
+   = note: `&T` is already a pointer, `Arc<&T>` allocate a pointer on heap
 
 error: usage of `Arc<Arc<T>>`
   --> $DIR/redundant_allocation_fixable.rs:72:25
    |
 LL |     pub fn arc_test7(a: Arc<Arc<bool>>) {}
    |                         ^^^^^^^^^^^^^^ help: try: `Arc<bool>`
+   |
+   = note: `Arc<T>` is already on the heap, `Arc<Arc<T>>` makes an extra allocation
 
 error: aborting due to 12 previous errors