instantly_dangling_pointer: change wording a bit

Author: GrigorenkoPV

compiler/rustc_lint/messages.ftl

@@ -405,10 +405,10 @@ lint_incomplete_include =
 
 lint_inner_macro_attribute_unstable = inner macro attributes are unstable
 
-lint_instantly_dangling = this pointer will immediately dangle
-    .ptr_label = this pointer will be invalid
-    .temporary_label = this `{$ty}` is deallocated at the end of the statement, bind it to a variable to extend its lifetime
-    .note = pointers do not have a lifetime; when calling `{$method}` the `{$ty}` will be deallocated at the end of the statement because nothing is referencing it as far as the type system is concerned
+lint_instantly_dangling = getting a pointer from a temporary `{$ty}` will result in a dangling pointer
+    .label_ptr = this pointer will immediately be invalid
+    .label_temporary = this `{$ty}` is deallocated at the end of the statement, bind it to a variable to extend its lifetime
+    .note = pointers do not have a lifetime; when calling `{$callee}` the `{$ty}` will be deallocated at the end of the statement because nothing is referencing it as far as the type system is concerned
     .help = for more information, see https://doc.rust-lang.org/reference/destructors.html
 
 lint_invalid_asm_label_binary = avoid using labels containing only the digits `0` and `1` in inline assembly

compiler/rustc_lint/src/dangling.rs

@@ -35,14 +35,15 @@ declare_lint! {
 // FIXME: does not catch UnsafeCell::get
 // FIXME: does not catch getting a ref to a temporary and then converting it to a ptr
 declare_lint! {
+    /// TODO
     pub INSTANTLY_DANGLING_POINTER,
     Warn,
     "detects getting a pointer that will immediately dangle"
 }
 
-declare_lint_pass!(InstantlyDanglingPtr => [TEMPORARY_CSTRING_AS_PTR, INSTANTLY_DANGLING_POINTER]);
+declare_lint_pass!(DanglingPointers => [TEMPORARY_CSTRING_AS_PTR, INSTANTLY_DANGLING_POINTER]);
 
-impl<'tcx> LateLintPass<'tcx> for InstantlyDanglingPtr {
+impl<'tcx> LateLintPass<'tcx> for DanglingPointers {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // We have a method call.
         let ExprKind::MethodCall(method, receiver, _args, _span) = expr.kind else {
@@ -66,9 +67,9 @@ impl<'tcx> LateLintPass<'tcx> for InstantlyDanglingPtr {
             return;
         };
 
-        let span = method.ident.span;
+        let span = method_span;
         let decorator = InstantlyDangling {
-            method: method_name,
+            callee: method_name,
             ty: ty.to_string(),
             ptr_span: method_span,
             temporary_span: receiver.span,
@@ -85,7 +86,7 @@ impl<'tcx> LateLintPass<'tcx> for InstantlyDanglingPtr {
 fn is_temporary_rvalue(expr: &Expr<'_>) -> bool {
     match expr.kind {
         // We are not interested in these
-        ExprKind::Cast(_, _) | ExprKind::Closure(_) | ExprKind::Tup(_) | ExprKind::Lit(_) => false,
+        ExprKind::Cast(_, _) | ExprKind::Closure(_) | ExprKind::Tup(_) => false,
 
         // Const is not temporary.
         ExprKind::ConstBlock(_) | ExprKind::Repeat(_, _) => false,
@@ -109,6 +110,8 @@ fn is_temporary_rvalue(expr: &Expr<'_>) -> bool {
         ExprKind::Field(parent, _) => is_temporary_rvalue(parent),
 
         ExprKind::Struct(_, _, _) => true,
+        // These are 'static
+        ExprKind::Lit(_) => false,
         // False negatives are possible, but arrays get promoted to 'static way too often.
         ExprKind::Array(_) => false,
 

compiler/rustc_lint/src/lib.rs

@@ -223,7 +223,7 @@ late_lint_methods!(
             UngatedAsyncFnTrackCaller: UngatedAsyncFnTrackCaller,
             ShadowedIntoIter: ShadowedIntoIter,
             DropTraitConstraints: DropTraitConstraints,
-            InstantlyDanglingPtr: InstantlyDanglingPtr,
+            DanglingPointers: DanglingPointers,
             NonPanicFmt: NonPanicFmt,
             NoopMethodCall: NoopMethodCall,
             EnumIntrinsicsNonEnums: EnumIntrinsicsNonEnums,

compiler/rustc_lint/src/lints.rs

@@ -1130,11 +1130,11 @@ pub struct IgnoredUnlessCrateSpecified<'a> {
 #[note]
 #[help]
 pub struct InstantlyDangling {
-    pub method: Symbol,
+    pub callee: Symbol,
     pub ty: String,
-    #[label(lint_ptr_label)]
+    #[label(lint_label_ptr)]
     pub ptr_span: Span,
-    #[label(lint_temporary_label)]
+    #[label(lint_label_temporary)]
     pub temporary_span: Span,
 }
 

tests/ui/lint/lint-temporary-cstring-as-param.rs

@@ -7,5 +7,5 @@ fn some_function(data: *const c_char) {}
 
 fn main() {
     some_function(CString::new("").unwrap().as_ptr());
-    //~^ ERROR this pointer will immediately dangle
+    //~^ ERROR getting a pointer from a temporary `CString` will result in a dangling pointer
 }

tests/ui/lint/lint-temporary-cstring-as-param.stderr

@@ -1,8 +1,8 @@
-error: this pointer will immediately dangle
+error: getting a pointer from a temporary `CString` will result in a dangling pointer
   --> $DIR/lint-temporary-cstring-as-param.rs:9:45
    |
 LL |     some_function(CString::new("").unwrap().as_ptr());
-   |                   ------------------------- ^^^^^^ this pointer will be invalid
+   |                   ------------------------- ^^^^^^ this pointer will immediately be invalid
    |                   |
    |                   this `CString` is deallocated at the end of the statement, bind it to a variable to extend its lifetime
    |

tests/ui/lint/lint-temporary-cstring-as-ptr.rs

@@ -6,12 +6,12 @@ use std::ffi::CString;
 macro_rules! mymacro {
     () => {
         let s = CString::new("some text").unwrap().as_ptr();
-        //~^ ERROR this pointer will immediately dangle
+        //~^ ERROR getting a pointer from a temporary `CString` will result in a dangling pointer
     }
 }
 
 fn main() {
     let s = CString::new("some text").unwrap().as_ptr();
-    //~^ ERROR this pointer will immediately dangle
+    //~^ ERROR getting a pointer from a temporary `CString` will result in a dangling pointer
     mymacro!();
 }

tests/ui/lint/lint-temporary-cstring-as-ptr.stderr

@@ -1,8 +1,8 @@
-error: this pointer will immediately dangle
+error: getting a pointer from a temporary `CString` will result in a dangling pointer
   --> $DIR/lint-temporary-cstring-as-ptr.rs:14:48
    |
 LL |     let s = CString::new("some text").unwrap().as_ptr();
-   |             ---------------------------------- ^^^^^^ this pointer will be invalid
+   |             ---------------------------------- ^^^^^^ this pointer will immediately be invalid
    |             |
    |             this `CString` is deallocated at the end of the statement, bind it to a variable to extend its lifetime
    |
@@ -14,11 +14,11 @@ note: the lint level is defined here
 LL | #![deny(temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: this pointer will immediately dangle
+error: getting a pointer from a temporary `CString` will result in a dangling pointer
   --> $DIR/lint-temporary-cstring-as-ptr.rs:8:52
    |
 LL |         let s = CString::new("some text").unwrap().as_ptr();
-   |                 ---------------------------------- ^^^^^^ this pointer will be invalid
+   |                 ---------------------------------- ^^^^^^ this pointer will immediately be invalid
    |                 |
    |                 this `CString` is deallocated at the end of the statement, bind it to a variable to extend its lifetime
 ...