replace temporary_cstring_as_ptr with dangling_pointers_from_temporaries

Author: GrigorenkoPV

compiler/rustc_lint/src/dangling.rs

@@ -1,37 +1,11 @@
 use rustc_hir::{Expr, ExprKind, LangItem};
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::{Ty, TyCtxt};
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::symbol::sym;
 
 use crate::lints::InstantlyDangling;
 use crate::{LateContext, LateLintPass, LintContext};
 
-declare_lint! {
-    /// The `temporary_cstring_as_ptr` lint detects getting the inner pointer of
-    /// a temporary `CString`.
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// # #![allow(unused)]
-    /// # use std::ffi::CString;
-    /// let c_str = CString::new("foo").unwrap().as_ptr();
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// The inner pointer of a `CString` lives only as long as the `CString` it
-    /// points to. Getting the inner pointer of a *temporary* `CString` allows the `CString`
-    /// to be dropped at the end of the statement, as it is not being referenced as far as the
-    /// typesystem is concerned. This means outside of the statement the pointer will point to
-    /// freed memory, which causes undefined behavior if the pointer is later dereferenced.
-    pub TEMPORARY_CSTRING_AS_PTR,
-    Warn,
-    "detects getting the inner pointer of a temporary `CString`"
-}
-
 // 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! {
@@ -68,34 +42,10 @@ declare_lint! {
     "detects getting a pointer from a temporary"
 }
 
-declare_lint_pass!(DanglingPointers => [TEMPORARY_CSTRING_AS_PTR, DANGLING_POINTERS_FROM_TEMPORARIES]);
+declare_lint_pass!(DanglingPointers => [DANGLING_POINTERS_FROM_TEMPORARIES]);
 
 impl<'tcx> LateLintPass<'tcx> for DanglingPointers {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(as_ptr_path, as_ptr_receiver, ..) = expr.kind
-            && as_ptr_path.ident.name == sym::as_ptr
-            && let ExprKind::MethodCall(unwrap_path, unwrap_receiver, ..) = as_ptr_receiver.kind
-            && (unwrap_path.ident.name == sym::unwrap || unwrap_path.ident.name == sym::expect)
-            && let source_type = cx.typeck_results().expr_ty(unwrap_receiver)
-            && let ty::Adt(def, args) = source_type.kind()
-            && cx.tcx.is_diagnostic_item(sym::Result, def.did())
-            && let ty = args.type_at(0)
-            && let ty::Adt(adt, _) = ty.kind()
-            && cx.tcx.is_diagnostic_item(sym::cstring_type, adt.did())
-        {
-            cx.emit_span_lint(
-                TEMPORARY_CSTRING_AS_PTR,
-                as_ptr_path.ident.span,
-                InstantlyDangling {
-                    callee: as_ptr_path.ident.name,
-                    ty,
-                    ptr_span: as_ptr_path.ident.span,
-                    temporary_span: as_ptr_receiver.span,
-                },
-            );
-            return; // One lint is enough
-        }
-
         if let ExprKind::MethodCall(method, receiver, _args, _span) = expr.kind
             && matches!(method.ident.name, sym::as_ptr | sym::as_mut_ptr)
             && is_temporary_rvalue(receiver)

compiler/rustc_lint/src/lib.rs

@@ -346,6 +346,7 @@ fn register_builtins(store: &mut LintStore) {
     store.register_renamed("non_fmt_panic", "non_fmt_panics");
     store.register_renamed("unused_tuple_struct_fields", "dead_code");
     store.register_renamed("static_mut_ref", "static_mut_refs");
+    store.register_renamed("temporary_cstring_as_ptr", "dangling_pointers_from_temporaries");
 
     // These were moved to tool lints, but rustc still sees them when compiling normally, before
     // tool lints are registered, so `check_tool_name_for_backwards_compat` doesn't work. Use

tests/ui/lint/dangling-ptr/allow.rs renamed to tests/ui/lint/dangling-pointers-from-temporaries/allow.rs

@@ -1,4 +1,5 @@
 #![deny(temporary_cstring_as_ptr)]
+//~^ [renamed_and_removed_lints]
 
 use std::ffi::CString;
 use std::os::raw::c_char;

tests/ui/lint/dangling-ptr/cstring-as-param.rs renamed to tests/ui/lint/dangling-pointers-from-temporaries/cstring-as-param.rs

@@ -1,5 +1,13 @@
+warning: lint `temporary_cstring_as_ptr` has been renamed to `dangling_pointers_from_temporaries`
+  --> $DIR/cstring-as-param.rs:1:9
+   |
+LL | #![deny(temporary_cstring_as_ptr)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `dangling_pointers_from_temporaries`
+   |
+   = note: `#[warn(renamed_and_removed_lints)]` on by default
+
 error: getting a pointer from a temporary `CString` will result in a dangling pointer
-  --> $DIR/cstring-as-param.rs:9:45
+  --> $DIR/cstring-as-param.rs:10:45
    |
 LL |     some_function(CString::new("").unwrap().as_ptr());
    |                   ------------------------- ^^^^^^ this pointer will immediately be invalid
@@ -14,5 +22,5 @@ note: the lint level is defined here
 LL | #![deny(temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 1 previous error
+error: aborting due to 1 previous error; 1 warning emitted
 

tests/ui/lint/dangling-ptr/cstring-as-param.stderr renamed to tests/ui/lint/dangling-pointers-from-temporaries/cstring-as-param.stderr

@@ -1,5 +1,6 @@
 // this program is not technically incorrect, but is an obscure enough style to be worth linting
 #![deny(temporary_cstring_as_ptr)]
+//~^ [renamed_and_removed_lints]
 
 use std::ffi::CString;
 

tests/ui/lint/dangling-ptr/cstring-as-ptr.rs renamed to tests/ui/lint/dangling-pointers-from-temporaries/cstring-as-ptr.rs

@@ -1,5 +1,13 @@
+warning: lint `temporary_cstring_as_ptr` has been renamed to `dangling_pointers_from_temporaries`
+  --> $DIR/cstring-as-ptr.rs:2:9
+   |
+LL | #![deny(temporary_cstring_as_ptr)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `dangling_pointers_from_temporaries`
+   |
+   = note: `#[warn(renamed_and_removed_lints)]` on by default
+
 error: getting a pointer from a temporary `CString` will result in a dangling pointer
-  --> $DIR/cstring-as-ptr.rs:14:48
+  --> $DIR/cstring-as-ptr.rs:15:48
    |
 LL |     let s = CString::new("some text").unwrap().as_ptr();
    |             ---------------------------------- ^^^^^^ this pointer will immediately be invalid
@@ -15,7 +23,7 @@ LL | #![deny(temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: getting a pointer from a temporary `CString` will result in a dangling pointer
-  --> $DIR/cstring-as-ptr.rs:8:52
+  --> $DIR/cstring-as-ptr.rs:9:52
    |
 LL |         let s = CString::new("some text").unwrap().as_ptr();
    |                 ---------------------------------- ^^^^^^ this pointer will immediately be invalid
@@ -29,5 +37,5 @@ LL |     mymacro!();
    = help: for more information, see https://doc.rust-lang.org/reference/destructors.html
    = note: this error originates in the macro `mymacro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 2 previous errors
+error: aborting due to 2 previous errors; 1 warning emitted