Auto merge of #18278 - ShoyuVanilla:never-place, r=Veykril

Do not consider match/let/ref of place that evaluates to ! to diverge, disallow coercions from them too
Resolves#18237

Author: bors

src/tools/rust-analyzer/crates/hir-ty/src/infer.rs

@@ -57,7 +57,7 @@ use crate::{
  db::HirDatabase,
  fold_tys,
  generics::Generics,
- infer::{coerce::CoerceMany, unify::InferenceTable},
+ infer::{coerce::CoerceMany,expr::ExprIsRead,unify::InferenceTable},
  lower::ImplTraitLoweringMode,
  mir::MirSpan,
  to_assoc_type_id,
@@ -1154,6 +1154,7 @@ impl<'a> InferenceContext<'a> {
  _ = self.infer_expr_coerce(
 self.body.body_expr,
 &Expectation::has_type(self.return_ty.clone()),
+ExprIsRead::Yes,
 )
 }
 }

src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs

@@ -5,8 +5,9 @@ use hir_def::{hir::ExprId, AdtId};
 use stdx::never;
 
 usecrate::{
- infer::unify::InferenceTable,Adjustment,Binders,DynTy,InferenceDiagnostic,Interner,
-PlaceholderIndex,QuantifiedWhereClauses,Ty,TyExt,TyKind,TypeFlags,WhereClause,
+ infer::{coerce::CoerceNever, unify::InferenceTable},
+Adjustment,Binders,DynTy,InferenceDiagnostic,Interner,PlaceholderIndex,
+QuantifiedWhereClauses,Ty,TyExt,TyKind,TypeFlags,WhereClause,
 };
 
 #[derive(Debug)]
@@ -128,7 +129,7 @@ impl CastCheck {
 returnOk(());
 }
 
-ifletOk((adj, _)) = table.coerce(&self.expr_ty,&self.cast_ty){
+ifletOk((adj, _)) = table.coerce(&self.expr_ty,&self.cast_ty,CoerceNever::Yes){
 apply_adjustments(self.source_expr, adj);
 set_coercion_cast(self.source_expr);
 returnOk(());
@@ -154,7 +155,8 @@ impl CastCheck {
 let sig = self.expr_ty.callable_sig(table.db).expect("FnDef had no sig");
 let sig = table.normalize_associated_types_in(sig);
 let fn_ptr = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
-ifletOk((adj, _)) = table.coerce(&self.expr_ty,&fn_ptr){
+ifletOk((adj, _)) = table.coerce(&self.expr_ty,&fn_ptr,CoerceNever::Yes)
+{
 apply_adjustments(self.source_expr, adj);
 }else{
 returnErr(CastError::IllegalCast);
@@ -241,7 +243,8 @@ impl CastCheck {
 ifletTyKind::Array(ety, _) = t_expr.kind(Interner){
 // Coerce to a raw pointer so that we generate RawPtr in MIR.
 let array_ptr_type = TyKind::Raw(m_expr, t_expr.clone()).intern(Interner);
-ifletOk((adj, _)) = table.coerce(&self.expr_ty,&array_ptr_type){
+ifletOk((adj, _)) = table.coerce(&self.expr_ty,&array_ptr_type,CoerceNever::Yes)
+{
 apply_adjustments(self.source_expr, adj);
 }else{
 never!(
@@ -253,7 +256,7 @@ impl CastCheck {
 
 // This is a less strict condition than rustc's `demand_eqtype`,
 // but false negative is better than false positive
-if table.coerce(ety, t_cast).is_ok(){
+if table.coerce(ety, t_cast,CoerceNever::Yes).is_ok(){
 returnOk(());
 }
 }

src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs

@@ -29,6 +29,7 @@ use crate::{
  db::{HirDatabase,InternedClosure},
  error_lifetime, from_chalk_trait_id, from_placeholder_idx,
  generics::Generics,
+ infer::coerce::CoerceNever,
  make_binders,
  mir::{BorrowKind,MirSpan,MutBorrowKind,ProjectionElem},
  to_chalk_trait_id,
@@ -65,7 +66,7 @@ impl InferenceContext<'_> {
 }
 
 // Deduction from where-clauses in scope, as well as fn-pointer coercion are handled here.
-let _ = self.coerce(Some(closure_expr), closure_ty,&expected_ty);
+let _ = self.coerce(Some(closure_expr), closure_ty,&expected_ty,CoerceNever::Yes);
 
 // Coroutines are not Fn* so return early.
 ifmatches!(closure_ty.kind(Interner),TyKind::Coroutine(..)){

src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs

@@ -139,8 +139,8 @@ impl CoerceMany {
 };
 ifletSome(sig) = sig {
 let target_ty = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
-let result1 = ctx.table.coerce_inner(self.merged_ty(),&target_ty);
-let result2 = ctx.table.coerce_inner(expr_ty.clone(),&target_ty);
+let result1 = ctx.table.coerce_inner(self.merged_ty(),&target_ty,CoerceNever::Yes);
+let result2 = ctx.table.coerce_inner(expr_ty.clone(),&target_ty,CoerceNever::Yes);
 iflet(Ok(result1),Ok(result2)) = (result1, result2){
  ctx.table.register_infer_ok(InferOk{value:(),goals: result1.goals});
 for&e in&self.expressions{
@@ -159,9 +159,9 @@ impl CoerceMany {
 // type is a type variable and the new one is `!`, trying it the other
 // way around first would mean we make the type variable `!`, instead of
 // just marking it as possibly diverging.
-ifletOk(res) = ctx.coerce(expr,&expr_ty,&self.merged_ty()){
+ifletOk(res) = ctx.coerce(expr,&expr_ty,&self.merged_ty(),CoerceNever::Yes){
 self.final_ty = Some(res);
-}elseifletOk(res) = ctx.coerce(expr,&self.merged_ty(),&expr_ty){
+}elseifletOk(res) = ctx.coerce(expr,&self.merged_ty(),&expr_ty,CoerceNever::Yes){
 self.final_ty = Some(res);
 }else{
 match cause {
@@ -197,7 +197,7 @@ pub(crate) fn coerce(
 let vars = table.fresh_subst(tys.binders.as_slice(Interner));
 let ty1_with_vars = vars.apply(tys.value.0.clone(),Interner);
 let ty2_with_vars = vars.apply(tys.value.1.clone(),Interner);
-let(adjustments, ty) = table.coerce(&ty1_with_vars,&ty2_with_vars)?;
+let(adjustments, ty) = table.coerce(&ty1_with_vars,&ty2_with_vars,CoerceNever::Yes)?;
 // default any type vars that weren't unified back to their original bound vars
 // (kind of hacky)
 let find_var = |iv| {
@@ -219,6 +219,12 @@ pub(crate) fn coerce(
 Ok((adjustments, table.resolve_with_fallback(ty,&fallback)))
 }
 
+#[derive(Clone,Copy,PartialEq,Eq)]
+pub(crate)enumCoerceNever{
+Yes,
+No,
+}
+
 implInferenceContext<'_>{
 /// Unify two types, but may coerce the first one to the second one
 /// using "implicit coercion rules" if needed.
@@ -227,10 +233,16 @@ impl InferenceContext<'_> {
 expr:Option<ExprId>,
 from_ty:&Ty,
 to_ty:&Ty,
+// [Comment from rustc](https://github.com/rust-lang/rust/blob/4cc494bbfe9911d24f3ee521f98d5c6bb7e3ffe8/compiler/rustc_hir_typeck/src/coercion.rs#L85-L89)
+// Whether we allow `NeverToAny` coercions. This is unsound if we're
+// coercing a place expression without it counting as a read in the MIR.
+// This is a side-effect of HIR not really having a great distinction
+// between places and values.
+coerce_never:CoerceNever,
 ) -> Result<Ty,TypeError>{
 let from_ty = self.resolve_ty_shallow(from_ty);
 let to_ty = self.resolve_ty_shallow(to_ty);
-let(adjustments, ty) = self.table.coerce(&from_ty,&to_ty)?;
+let(adjustments, ty) = self.table.coerce(&from_ty,&to_ty, coerce_never)?;
 ifletSome(expr) = expr {
 self.write_expr_adj(expr, adjustments);
 }
@@ -245,10 +257,11 @@ impl InferenceTable<'_> {
 &mutself,
 from_ty:&Ty,
 to_ty:&Ty,
+coerce_never:CoerceNever,
 ) -> Result<(Vec<Adjustment>,Ty),TypeError>{
 let from_ty = self.resolve_ty_shallow(from_ty);
 let to_ty = self.resolve_ty_shallow(to_ty);
-matchself.coerce_inner(from_ty,&to_ty){
+matchself.coerce_inner(from_ty,&to_ty, coerce_never){
 Ok(InferOk{value:(adjustments, ty), goals }) => {
 self.register_infer_ok(InferOk{value:(), goals });
 Ok((adjustments, ty))
@@ -260,19 +273,23 @@ impl InferenceTable<'_> {
 }
 }
 
-fncoerce_inner(&mutself,from_ty:Ty,to_ty:&Ty) -> CoerceResult{
+fncoerce_inner(&mutself,from_ty:Ty,to_ty:&Ty,coerce_never:CoerceNever) -> CoerceResult{
 if from_ty.is_never(){
-// Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound
-// type variable, we want `?T` to fallback to `!` if not
-// otherwise constrained. An example where this arises:
-//
-// let _: Option<?T> = Some({ return; });
-//
-// here, we would coerce from `!` to `?T`.
 ifletTyKind::InferenceVar(tv,TyVariableKind::General) = to_ty.kind(Interner){
 self.set_diverging(*tv,true);
 }
-returnsuccess(simple(Adjust::NeverToAny)(to_ty.clone()), to_ty.clone(),vec![]);
+if coerce_never == CoerceNever::Yes{
+// Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound
+// type variable, we want `?T` to fallback to `!` if not
+// otherwise constrained. An example where this arises:
+//
+// let _: Option<?T> = Some({ return; });
+//
+// here, we would coerce from `!` to `?T`.
+returnsuccess(simple(Adjust::NeverToAny)(to_ty.clone()), to_ty.clone(),vec![]);
+}else{
+returnself.unify_and(&from_ty, to_ty, identity);
+}
 }
 
 // If we are coercing into a TAIT, coerce into its proxy inference var, instead.