Let lint_forgetting_references give the suggestion if possible

Author: surechen

compiler/rustc_lint/messages.ftl

@@ -230,6 +230,7 @@ lint_forgetting_copy_types = calls to `std::mem::forget` with a value that imple
 lint_forgetting_references = calls to `std::mem::forget` with a reference instead of an owned value does nothing
     .label = argument has type `{$arg_ty}`
     .note = use `let _ = ...` to ignore the expression or result
+    .suggestion = use `let _ = ...` to ignore the expression or result
 
 lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label}
     .label = this {$label} contains {$count ->

compiler/rustc_lint/src/drop_forget_useless.rs

@@ -4,8 +4,8 @@ use rustc_span::sym;
 
 use crate::{
     lints::{
-        DropCopyDiag, DropRefDiag, ForgetCopyDiag, ForgetRefDiag, IgnoreDropSuggestion,
-        UndroppedManuallyDropsDiag, UndroppedManuallyDropsSuggestion,
+        DropCopyDiag, DropRefDiag, ForgetCopyDiag, ForgetRefDiag, UndroppedManuallyDropsDiag,
+        UndroppedManuallyDropsSuggestion, UseLetUnderscoreIgnoreSuggestion,
     },
     LateContext, LateLintPass, LintContext,
 };
@@ -152,12 +152,12 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetUseless {
                 && let StmtKind::Semi(e) = stmt.kind
                 && e.hir_id == expr.hir_id
             {
-                IgnoreDropSuggestion::Suggestion {
+                UseLetUnderscoreIgnoreSuggestion::Suggestion {
                     start_span: expr.span.shrink_to_lo().until(arg.span),
                     end_span: arg.span.shrink_to_hi().until(expr.span.shrink_to_hi()),
                 }
             } else {
-                IgnoreDropSuggestion::Note
+                UseLetUnderscoreIgnoreSuggestion::Note
             };
             match fn_name {
                 sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => {
@@ -171,7 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetUseless {
                     cx.emit_span_lint(
                         FORGETTING_REFERENCES,
                         expr.span,
-                        ForgetRefDiag { arg_ty, label: arg.span },
+                        ForgetRefDiag { arg_ty, label: arg.span, sugg },
                     );
                 }
                 sym::mem_drop if is_copy && !drop_is_single_call_in_arm => {

compiler/rustc_lint/src/lints.rs

@@ -658,7 +658,7 @@ pub struct ForLoopsOverFalliblesSuggestion<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum IgnoreDropSuggestion {
+pub enum UseLetUnderscoreIgnoreSuggestion {
     #[note(lint_note)]
     Note,
     #[multipart_suggestion(lint_suggestion, style = "verbose", applicability = "maybe-incorrect")]
@@ -678,7 +678,7 @@ pub struct DropRefDiag<'a> {
     #[label]
     pub label: Span,
     #[subdiagnostic]
-    pub sugg: IgnoreDropSuggestion,
+    pub sugg: UseLetUnderscoreIgnoreSuggestion,
 }
 
 #[derive(LintDiagnostic)]
@@ -692,11 +692,12 @@ pub struct DropCopyDiag<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_forgetting_references)]
-#[note]
 pub struct ForgetRefDiag<'a> {
     pub arg_ty: Ty<'a>,
     #[label]
     pub label: Span,
+    #[subdiagnostic]
+    pub sugg: UseLetUnderscoreIgnoreSuggestion,
 }
 
 #[derive(LintDiagnostic)]
@@ -706,7 +707,7 @@ pub struct ForgetCopyDiag<'a> {
     #[label]
     pub label: Span,
     #[subdiagnostic]
-    pub sugg: IgnoreDropSuggestion,
+    pub sugg: UseLetUnderscoreIgnoreSuggestion,
 }
 
 #[derive(LintDiagnostic)]

tests/ui/lint/dropping_copy_types.stderr

@@ -31,8 +31,12 @@ LL |     drop(s3);
    |          |
    |          argument has type `&SomeStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
    = note: `#[warn(dropping_references)]` on by default
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     drop(s3);
+LL +     let _ = s3;
+   |
 
 warning: calls to `std::mem::drop` with a value that implements `Copy` does nothing
   --> $DIR/dropping_copy_types.rs:37:5
@@ -52,7 +56,11 @@ LL |     drop(s5);
    |          |
    |          argument has type `&SomeStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     drop(s5);
+LL +     let _ = s5;
+   |
 
 warning: calls to `std::mem::drop` with a reference instead of an owned value does nothing
   --> $DIR/dropping_copy_types.rs:50:5
@@ -62,7 +70,11 @@ LL |     drop(a2);
    |          |
    |          argument has type `&AnotherStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     drop(a2);
+LL +     let _ = a2;
+   |
 
 warning: calls to `std::mem::drop` with a reference instead of an owned value does nothing
   --> $DIR/dropping_copy_types.rs:52:5
@@ -72,7 +84,11 @@ LL |     drop(a4);
    |          |
    |          argument has type `&AnotherStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     drop(a4);
+LL +     let _ = a4;
+   |
 
 warning: calls to `std::mem::drop` with a value that implements `Copy` does nothing
   --> $DIR/dropping_copy_types.rs:71:13

tests/ui/lint/forgetting_copy_types.stderr

@@ -39,8 +39,12 @@ LL |     forget(s3);
    |            |
    |            argument has type `&SomeStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
    = note: `#[warn(forgetting_references)]` on by default
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     forget(s3);
+LL +     let _ = s3;
+   |
 
 warning: calls to `std::mem::forget` with a value that implements `Copy` does nothing
   --> $DIR/forgetting_copy_types.rs:37:5
@@ -64,7 +68,11 @@ LL |     forget(s5);
    |            |
    |            argument has type `&SomeStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     forget(s5);
+LL +     let _ = s5;
+   |
 
 warning: calls to `std::mem::forget` with a reference instead of an owned value does nothing
   --> $DIR/forgetting_copy_types.rs:50:5
@@ -74,7 +82,11 @@ LL |     forget(a2);
    |            |
    |            argument has type `&AnotherStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     forget(a2);
+LL +     let _ = a2;
+   |
 
 warning: calls to `std::mem::forget` with a reference instead of an owned value does nothing
   --> $DIR/forgetting_copy_types.rs:52:5
@@ -84,7 +96,11 @@ LL |     forget(a3);
    |            |
    |            argument has type `&AnotherStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     forget(a3);
+LL +     let _ = a3;
+   |
 
 warning: calls to `std::mem::forget` with a reference instead of an owned value does nothing
   --> $DIR/forgetting_copy_types.rs:53:5
@@ -94,7 +110,11 @@ LL |     forget(a4);
    |            |
    |            argument has type `&AnotherStruct`
    |
-   = note: use `let _ = ...` to ignore the expression or result
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     forget(a4);
+LL +     let _ = a4;
+   |
 
 warning: 8 warnings emitted
 

tests/ui/lint/forgetting_references-can-fixed.fixed

@@ -0,0 +1,40 @@
+//@ check-fail
+//@ run-rustfix
+
+#![deny(forgetting_references)]
+
+use std::mem::forget;
+
+struct SomeStruct;
+
+fn main() {
+    let _ = &SomeStruct; //~ ERROR calls to `std::mem::forget`
+
+    let mut owned = SomeStruct;
+    let _ = &owned; //~ ERROR calls to `std::mem::forget`
+    let _ = &&owned; //~ ERROR calls to `std::mem::forget`
+    let _ = &mut owned; //~ ERROR calls to `std::mem::forget`
+    forget(owned);
+
+    let reference1 = &SomeStruct;
+    let _ = &*reference1; //~ ERROR calls to `std::mem::forget`
+
+    let reference2 = &mut SomeStruct;
+    let _ = reference2; //~ ERROR calls to `std::mem::forget`
+
+    let ref reference3 = SomeStruct;
+    let _ = reference3; //~ ERROR calls to `std::mem::forget`
+}
+
+#[allow(dead_code)]
+fn test_generic_fn_forget<T>(val: T) {
+    let _ = &val; //~ ERROR calls to `std::mem::forget`
+    forget(val);
+}
+
+#[allow(dead_code)]
+fn test_similarly_named_function() {
+    fn forget<T>(_val: T) {}
+    forget(&SomeStruct); //OK; call to unrelated function which happens to have the same name
+    let _ = &SomeStruct; //~ ERROR calls to `std::mem::forget`
+}

tests/ui/lint/forgetting_references-can-fixed.rs

@@ -0,0 +1,40 @@
+//@ check-fail
+//@ run-rustfix
+
+#![deny(forgetting_references)]
+
+use std::mem::forget;
+
+struct SomeStruct;
+
+fn main() {
+    forget(&SomeStruct); //~ ERROR calls to `std::mem::forget`
+
+    let mut owned = SomeStruct;
+    forget(&owned); //~ ERROR calls to `std::mem::forget`
+    forget(&&owned); //~ ERROR calls to `std::mem::forget`
+    forget(&mut owned); //~ ERROR calls to `std::mem::forget`
+    forget(owned);
+
+    let reference1 = &SomeStruct;
+    forget(&*reference1); //~ ERROR calls to `std::mem::forget`
+
+    let reference2 = &mut SomeStruct;
+    forget(reference2); //~ ERROR calls to `std::mem::forget`
+
+    let ref reference3 = SomeStruct;
+    forget(reference3); //~ ERROR calls to `std::mem::forget`
+}
+
+#[allow(dead_code)]
+fn test_generic_fn_forget<T>(val: T) {
+    forget(&val); //~ ERROR calls to `std::mem::forget`
+    forget(val);
+}
+
+#[allow(dead_code)]
+fn test_similarly_named_function() {
+    fn forget<T>(_val: T) {}
+    forget(&SomeStruct); //OK; call to unrelated function which happens to have the same name
+    std::mem::forget(&SomeStruct); //~ ERROR calls to `std::mem::forget`
+}