Rollup merge of #145277 - dingxiangfei2009:fold-coercion-into-const, r=nnethercote

Do not materialise X in [X; 0] when X is unsizing a const
Fix#143671
It turns out that MIR builder materialise `X` in `[X; 0]` into a temporary local when `X` is unsizing a `const`. This led to a confusing call to destructor of `X` when such a destructor is declared. [Playground](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2024&gist=8dfc933af89efeb89c881bc77498ba63)
This patch may miss out other cases that we should avoid materialisation in case of `[X; 0]`. Suggestions to include is most welcome!

Author: Zalathar

compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs

@@ -8,6 +8,7 @@ use rustc_middle::middle::region;
 use rustc_middle::mir::interpret::Scalar;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
+use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::cast::{CastTy, mir_cast_kind};
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self,Ty,UpvarArgs};
@@ -656,6 +657,27 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  block.and(rvalue)
 }
 
+/// Recursively inspect a THIR expression and probe through unsizing
+/// operations that can be const-folded today.
+fncheck_constness(&self,mutkind:&'aExprKind<'tcx>) -> bool{
+loop{
+debug!(?kind,"check_constness");
+match kind {
+&ExprKind::ValueTypeAscription{source: eid,user_ty: _,user_ty_span: _ }
+ | &ExprKind::Use{source: eid }
+ | &ExprKind::PointerCoercion{
+cast:PointerCoercion::Unsize,
+source: eid,
+is_from_as_cast: _,
+}
+ | &ExprKind::Scope{region_scope: _,lint_level: _,value: eid } => {
+ kind = &self.thir[eid].kind
+}
+ _ => returnmatches!(Category::of(&kind),Some(Category::Constant)),
+}
+}
+}
+
 fnbuild_zero_repeat(
 &mutself,
 mutblock:BasicBlock,
@@ -666,7 +688,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 let this = self;
 let value_expr = &this.thir[value];
 let elem_ty = value_expr.ty;
-ifletSome(Category::Constant) = Category::of(&value_expr.kind){
+ifthis.check_constness(&value_expr.kind){
 // Repeating a const does nothing
 }else{
 // For a non-const, we may need to generate an appropriate `Drop`

tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs

@@ -0,0 +1,46 @@
+//@ run-pass
+
+#![feature(unsize)]
+#![feature(coerce_unsized)]
+
+use std::fmt::Display;
+use std::marker::Unsize;
+use std::ops::CoerceUnsized;
+use std::rc::Weak;
+
+#[repr(transparent)]
+structX<'a,T: ?Sized>{
+f:&'aT,
+}
+
+impl<'a,T: ?Sized>DropforX<'a,T>{
+fndrop(&mutself){
+panic!()
+}
+}
+
+impl<'a,T: ?Sized + Unsize<U>,U: ?Sized>CoerceUnsized<X<'a,U>>forX<'a,T>where
+&'aT:CoerceUnsized<&'aU>
+{
+}
+
+constY:X<'static,i32> = X{f:&0};
+
+fnmain(){
+let _:[X<'static,dynDisplay>;0] = [Y;0];
+coercion_on_weak_in_const();
+coercion_on_weak_as_cast();
+}
+
+fncoercion_on_weak_in_const(){
+constX:Weak<i32> = Weak::new();
+constY:[Weak<dynSend>;0] = [X;0];
+let _ = Y;
+}
+
+fncoercion_on_weak_as_cast(){
+constY:X<'static,i32> = X{f:&0};
+// What happens in the following code is that
+// a constant is explicitly coerced into
+let _a:[X<'static,dynDisplay>;0] = [YasX<'static,dynDisplay>;0];
+}