Always make ptr->ptr casts explicit in THIR

THIR building doesn't produce `ExprKind::Cast` for trivial casts.

This is all fine and good on its own but causes problems with raw pointers.
Region-unaware HIR typeck considers casting `*const Foo<'short>` to
`*const Foo<'long>` to be a trivial cast because they're the same type
modulo regions, but borrowck disagrees, emitting errors.

We now force all raw pointer casts to go through `ExprKind::Cast`, which
allows MIR building to pick the right casts that make borrowck blissfully
unaware of our lifetime crimes.

Author: Noratrieb

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -172,21 +172,28 @@ impl<'tcx> Cx<'tcx> {
 
     /// Lowers a cast expression.
     ///
-    /// Dealing with user type annotations is left to the caller.
+    /// Dealing with user type annotations is left to the caller,
+    /// but this method does look at the inferred target type.
     fn mirror_expr_cast(
         &mut self,
         source: &'tcx hir::Expr<'tcx>,
         temp_lifetime: Option<Scope>,
         span: Span,
+        target_ty: Ty<'tcx>,
     ) -> ExprKind<'tcx> {
         let tcx = self.tcx;
-
-        // Check to see if this cast is a "coercion cast", where the cast is actually done
-        // using a coercion (or is a no-op).
-        if self.typeck_results().is_coercion_cast(source.hir_id) {
+        let source_ty = self.typeck_results().expr_ty(source);
+
+        // Raw pointer to raw pointer casts should always be explicit because they can change
+        // regions, which HIR typeck cannot know, see #113257.
+        if source_ty.is_unsafe_ptr() && target_ty.is_unsafe_ptr() {
+            ExprKind::Cast { source: self.mirror_expr(source) }
+        } else if self.typeck_results().is_coercion_cast(source.hir_id) {
+            // Check to see if this cast is a "coercion cast", where the cast is actually done
+            // using a coercion (or is a no-op).
             // Convert the lexpr to a vexpr.
             ExprKind::Use { source: self.mirror_expr(source) }
-        } else if self.typeck_results().expr_ty(source).is_ref() {
+        } else if source_ty.is_ref() {
             // Special cased so that we can type check that the element
             // type of the source matches the pointed to type of the
             // destination.
@@ -755,7 +762,7 @@ impl<'tcx> Cx<'tcx> {
                     expr, cast_ty.hir_id, user_ty,
                 );
 
-                let cast = self.mirror_expr_cast(*source, temp_lifetime, expr.span);
+                let cast = self.mirror_expr_cast(*source, temp_lifetime, expr.span, expr_ty);
 
                 if let Some(user_ty) = user_ty {
                     // NOTE: Creating a new Expr and wrapping a Cast inside of it may be

tests/mir-opt/casts.redundant.InstSimplify.diff

@@ -6,18 +6,23 @@
       let mut _0: *const &u8;
       let mut _2: *const &u8;
       let mut _3: *const &u8;
+      let mut _4: *const &u8;
       scope 1 (inlined generic_cast::<&u8, &u8>) {
-          debug x => _3;
+          debug x => _4;
       }
 
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
--         _2 = _3 as *const &u8 (PtrToPtr);
-+         _2 = _3;
-          StorageDead(_3);
+          StorageLive(_4);
+          _4 = _1;
+-         _3 = _4 as *const &u8 (PtrToPtr);
++         _3 = _4;
+          StorageDead(_4);
+-         _2 = move _3 as *const &u8 (PtrToPtr);
++         _2 = move _3;
           _0 = _2;
+          StorageDead(_3);
           StorageDead(_2);
           return;
       }

tests/ui/cast/ptr-to-ptr-different-regions.rs

@@ -0,0 +1,16 @@
+// check-pass
+
+// https://github.com/rust-lang/rust/issues/113257
+
+struct Foo<'a> { a: &'a () }
+
+fn extend_lifetime_very_very_safely<'a>(v: *const Foo<'a>) -> *const Foo<'static> {
+    // This should pass because raw pointer casts can do anything they want.
+    v as *const Foo<'static>
+}
+
+fn main() {
+    let unit = ();
+    let foo = Foo { a: &unit };
+    let _long: *const Foo<'static> = extend_lifetime_very_very_safely(&foo);
+}