Change desugaring of let-else to ensure temporary is dropped earlier

compiler/rustc_ast_lowering/src/block.rs

@@ -159,6 +159,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  span,
  kind: hir::ExprKind::If(let_expr, then_expr, Some(else_expr)),
  });
+ let drop_temps = self.expr_drop_temps(span, if_expr, AttrVec::new());
  if !self.sess.features_untracked().let_else {
  feature_err(
  &self.sess.parse_sess,
@@ -168,6 +169,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  )
  .emit();
  }
- if_expr
+ drop_temps
  }
 }

compiler/rustc_typeck/src/check/expr.rs

@@ -225,6 +225,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  | ExprKind::If(..)
  | ExprKind::Let(..)
  | ExprKind::Loop(..)
+ | ExprKind::DropTemps(..)
  | ExprKind::Match(..) => {}
  // If `expr` is a result of desugaring the try block and is an ok-wrapped
  // diverging expression (e.g. it arose from desugaring of `try { return }`),

src/test/ui/let-else/let-else-allow-unused.rs

@@ -1,14 +1,15 @@
-// check-pass
 // issue #89807
 
 #![feature(let_else)]
 
 #[deny(unused_variables)]
 
 fn main() {
- let value = Some(String::new());
+ let value = Some(5);
  #[allow(unused)]
  let banana = 1;
  #[allow(unused)]
  let Some(chaenomeles) = value else { return }; // OK
+ let Some(unused) = value else { return };
+ //~^ ERROR unused variable: `unused`
 }

src/test/ui/let-else/let-else-allow-unused.stderr

@@ -0,0 +1,14 @@
+error: unused variable: `unused`
+ --> $DIR/let-else-allow-unused.rs:13:14
+ |
+LL | let Some(unused) = value else { return };
+ | ^^^^^^ help: if this is intentional, prefix it with an underscore: `_unused`
+ |
+note: the lint level is defined here
+ --> $DIR/let-else-allow-unused.rs:5:8
+ |
+LL | #[deny(unused_variables)]
+ | ^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+

src/test/ui/let-else/let-else-temp-borrowck.rs

@@ -0,0 +1,26 @@
+// check-pass
+//
+// from issue #93951, where borrowck complained the temporary that `foo(&x)` was stored in was to
+// be dropped sometime after `x` was. It then suggested adding a semicolon that was already there.
+
+#![feature(let_else)]
+use std::fmt::Debug;
+
+fn foo<'a>(x: &'a str) -> Result<impl Debug + 'a, ()> {
+ Ok(x)
+}
+
+fn let_else() {
+ let x = String::from("Hey");
+ let Ok(_) = foo(&x) else { return };
+}
+
+fn if_let() {
+ let x = String::from("Hey");
+ let _ = if let Ok(s) = foo(&x) { s } else { return };
+}
+
+fn main() {
+ let_else();
+ if_let();
+}

src/test/ui/let-else/let-else-then-diverge.rs

@@ -0,0 +1,20 @@
+// popped up in in #94012, where an alternative desugaring was
+// causing unreachable code errors, and also we needed to check
+// that the desugaring's generated lints weren't applying to
+// the whole else block.
+
+#![feature(let_else)]
+#![deny(unused_variables)]
+#![deny(unreachable_code)]
+
+fn let_else_diverge() -> bool {
+ let Some(_) = Some("test") else {
+ let x = 5; //~ ERROR unused variable: `x`
+ return false;
+ };
+ return true;
+}
+
+fn main() {
+ let_else_diverge();
+}

src/test/ui/let-else/let-else-then-diverge.stderr

@@ -0,0 +1,14 @@
+error: unused variable: `x`
+ --> $DIR/let-else-then-diverge.rs:12:13
+ |
+LL | let x = 5;
+ | ^ help: if this is intentional, prefix it with an underscore: `_x`
+ |
+note: the lint level is defined here
+ --> $DIR/let-else-then-diverge.rs:7:9
+ |
+LL | #![deny(unused_variables)]
+ | ^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+