temporary_as_ptr: fixes

1. Fix `is_temporary_rvalue` for:
   - Unary operations (such as dereference)
   - `yield`
   - Literals, array literals, repeat array literals
   - `DropTemps`
2. Fix typecheck to account for `T` in `Box<T>`

Author: GrigorenkoPV

compiler/rustc_lint/src/methods.rs

@@ -1,5 +1,5 @@
 use rustc_hir::{Expr, ExprKind, LangItem};
-use rustc_middle::ty;
+use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::symbol::{sym, Ident};
 
@@ -36,7 +36,7 @@ declare_lint! {
     /// TODO
     pub TEMPORARY_AS_PTR,
     Warn,
-    "TODO"
+    "detects getting the inner pointer of a temporary container"
 }
 
 declare_lint_pass!(TemporaryCStringAsPtr => [TEMPORARY_CSTRING_AS_PTR, TEMPORARY_AS_PTR]);
@@ -57,33 +57,15 @@ impl<'tcx> LateLintPass<'tcx> for TemporaryCStringAsPtr {
 
         // It is called on a temporary rvalue.
         let is_temp = is_temporary_rvalue(receiver);
-        tracing::debug!(?receiver, ?is_temp);
+        tracing::debug!(receiver = ?receiver.kind, ?is_temp);
         if !is_temp {
             return;
         }
 
         // The temporary value's type is array, box, Vec, String, or CString
         let ty = cx.typeck_results().expr_ty(receiver);
         tracing::debug!(?ty);
-
-        // None => not a container
-        // Some(true) => CString
-        // Some(false) => String, Vec, box, array
-        let lint_is_cstring = match ty.kind() {
-            ty::Array(_, _) => Some(false),
-            ty::Adt(def, _) if def.is_box() => Some(false),
-            ty::Adt(def, _) if cx.tcx.lang_items().get(LangItem::String) == Some(def.did()) => {
-                Some(false)
-            }
-            ty::Adt(def, _) => match cx.tcx.get_diagnostic_name(def.did()) {
-                Some(sym::Vec) => Some(false),
-                Some(sym::cstring_type) => Some(true),
-                _ => None,
-            },
-            _ => None,
-        };
-        tracing::debug!(?lint_is_cstring);
-        let Some(is_cstring) = lint_is_cstring else {
+        let Some(is_cstring) = as_container(cx, ty) else {
             return;
         };
 
@@ -106,10 +88,10 @@ impl<'tcx> LateLintPass<'tcx> for TemporaryCStringAsPtr {
 fn is_temporary_rvalue(expr: &Expr<'_>) -> bool {
     match expr.kind {
         // We are not interested in these
-        ExprKind::Cast(_, _) | ExprKind::Closure(_) | ExprKind::Tup(_) => false,
+        ExprKind::Cast(_, _) | ExprKind::Closure(_) | ExprKind::Tup(_) | ExprKind::Lit(_) => false,
 
         // Const is not temporary.
-        ExprKind::ConstBlock(_) => false,
+        ExprKind::ConstBlock(_) | ExprKind::Repeat(_, _) => false,
 
         // This is literally lvalue.
         ExprKind::Path(_) => false,
@@ -120,39 +102,65 @@ fn is_temporary_rvalue(expr: &Expr<'_>) -> bool {
         | ExprKind::Index(_, _, _)
         | ExprKind::Binary(_, _, _) => true,
 
-        // TODO: Check if x: &String, *(x).as_ptr() gets triggered
-        ExprKind::Unary(_, _) => true,
+        // This is likely a dereference.
+        ExprKind::Unary(_, _) => false,
 
         // Inner blocks are rvalues.
         ExprKind::If(_, _, _)
         | ExprKind::Loop(_, _, _, _)
         | ExprKind::Match(_, _, _)
         | ExprKind::Block(_, _) => true,
 
+        ExprKind::DropTemps(inner) => is_temporary_rvalue(inner),
         ExprKind::Field(parent, _) => is_temporary_rvalue(parent),
 
-        // FIXME: some of these get promoted to const/'static ?
-        ExprKind::Struct(_, _, _)
-        | ExprKind::Array(_)
-        | ExprKind::Repeat(_, _)
-        | ExprKind::Lit(_) => true,
+        ExprKind::Struct(_, _, _) => true,
+        // False negatives are possible, but arrays get promoted to 'static way too often.
+        ExprKind::Array(_) => false,
 
         // These typecheck to `!`
         ExprKind::Break(_, _) | ExprKind::Continue(_) | ExprKind::Ret(_) | ExprKind::Become(_) => {
             false
         }
 
         // These typecheck to `()`
-        ExprKind::Assign(_, _, _) | ExprKind::AssignOp(_, _, _) => false,
+        ExprKind::Assign(_, _, _) | ExprKind::AssignOp(_, _, _) | ExprKind::Yield(_, _) => false,
 
         // Not applicable
         ExprKind::Type(_, _) | ExprKind::Err(_) | ExprKind::Let(_) => false,
 
         // These are compiler-magic macros
         ExprKind::AddrOf(_, _, _) | ExprKind::OffsetOf(_, _) | ExprKind::InlineAsm(_) => false,
+    }
+}
 
-        // TODO: WTF are these
-        ExprKind::DropTemps(_) => todo!(),
-        ExprKind::Yield(_, _) => todo!(),
+// None => not a container
+// Some(true) => CString
+// Some(false) => String, Vec, box, array
+fn as_container(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<bool> {
+    if ty.is_array() {
+        Some(false)
+    } else if ty.is_box() {
+        let inner = ty.boxed_ty();
+        // We only care about Box<[..]>, Box<str>, Box<CStr>,
+        // or Box<T> iff T is another type we care about
+        if inner.is_slice()
+            || inner.is_str()
+            || inner.ty_adt_def().is_some_and(|def| cx.tcx.is_lang_item(def.did(), LangItem::CStr))
+            || as_container(cx, inner).is_some()
+        {
+            Some(false)
+        } else {
+            None
+        }
+    } else if let Some(def) = ty.ty_adt_def() {
+        match cx.tcx.get_diagnostic_name(def.did()) {
+            Some(sym::cstring_type) => Some(true),
+            Some(sym::Vec) => Some(false),
+            _ if cx.tcx.is_lang_item(def.did(), LangItem::String) => Some(false),
+            _ => None,
+        }
+    } else {
+        None
     }
 }