fix

Author: sgasho

compiler/rustc_hir_typeck/src/_if.rs

@@ -29,6 +29,11 @@ struct IfChain<'tcx> {
     cond_error: Option<ErrorGuaranteed>,
 }
 
+enum IfChainTail<'tcx> {
+    FinalElse(BranchBody<'tcx>),
+    Missing(&'tcx hir::Expr<'tcx>),
+}
+
 const RECENT_BRANCH_HISTORY_LIMIT: usize = 5;
 
 #[derive(Default)]
@@ -57,99 +62,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub(crate) fn check_expr_if(
         &self,
         expr_id: HirId,
-        cond_expr: &'tcx hir::Expr<'tcx>,
-        then_expr: &'tcx hir::Expr<'tcx>,
-        opt_else_expr: Option<&'tcx hir::Expr<'tcx>>,
         sp: Span,
         orig_expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
         let root_if_expr = self.tcx.hir_expect_expr(expr_id);
-        if !self.if_chain_has_final_else(root_if_expr) {
-            let expected = orig_expected.try_structurally_resolve_and_adjust_for_branches(self, sp);
-            return self.evaluate_if_without_final_else(
-                expr_id,
-                cond_expr,
-                then_expr,
-                opt_else_expr,
-                sp,
-                orig_expected,
-                expected,
-            );
-        }
-
         let expected = orig_expected.try_structurally_resolve_and_adjust_for_branches(self, sp);
-        self.evaluate_if_chain_with_final_else(expr_id, root_if_expr, sp, orig_expected, expected)
-    }
-
-    fn evaluate_if_without_final_else(
-        &self,
-        expr_id: HirId,
-        cond_expr: &'tcx hir::Expr<'tcx>,
-        then_expr: &'tcx hir::Expr<'tcx>,
-        opt_else_expr: Option<&'tcx hir::Expr<'tcx>>,
-        sp: Span,
-        orig_expected: Expectation<'tcx>,
-        expected: Expectation<'tcx>,
-    ) -> Ty<'tcx> {
-        let (cond_ty, cond_diverges) = self.check_if_condition(cond_expr, then_expr.span);
-
-        let BranchBody { ty: then_ty, diverges: then_diverges, .. } =
-            self.check_branch_body(then_expr, expected);
-
-        // We've already taken the expected type's preferences
-        // into account when typing the `then` branch. To figure
-        // out the initial shot at a LUB, we thus only consider
-        // `expected` if it represents a *hard* constraint
-        // (`only_has_type`); otherwise, we just go with a
-        // fresh type variable.
-        let coerce_to_ty = expected.coercion_target_type(self, sp);
-        let mut coerce: DynamicCoerceMany<'_> = CoerceMany::new(coerce_to_ty);
-
-        coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
-
-        if let Some(else_expr) = opt_else_expr {
-            let BranchBody { ty: else_ty, diverges: else_diverges, .. } =
-                self.check_branch_body(else_expr, expected);
-
-            let tail_defines_return_position_impl_trait =
-                self.return_position_impl_trait_from_match_expectation(orig_expected);
-            let if_cause =
-                self.if_cause(expr_id, else_expr, tail_defines_return_position_impl_trait);
-
-            coerce.coerce(self, &if_cause, else_expr, else_ty);
-
-            // We won't diverge unless both branches do (or the condition does).
-            self.diverges.set(cond_diverges | then_diverges & else_diverges);
-        } else {
-            self.if_fallback_coercion(sp, cond_expr, then_expr, &mut coerce);
-
-            // If the condition is false we can't diverge.
-            self.diverges.set(cond_diverges);
-        }
-
-        let result_ty = coerce.complete(self);
-        if let Err(guar) = cond_ty.error_reported() {
-            Ty::new_error(self.tcx, guar)
-        } else {
-            result_ty
-        }
-    }
-
-    fn evaluate_if_chain_with_final_else(
-        &self,
-        expr_id: HirId,
-        root_if_expr: &'tcx hir::Expr<'tcx>,
-        sp: Span,
-        orig_expected: Expectation<'tcx>,
-        expected: Expectation<'tcx>,
-    ) -> Ty<'tcx> {
-        let mut chain = IfChain::default();
 
         let initial_diverges = self.diverges.get();
-        let terminal_else = self.collect_if_chain(root_if_expr, expected, &mut chain);
 
-        let Some(else_branch) = terminal_else else {
-            bug!("sequential `if` chain expected a final `else` arm");
+        let (chain, tail) = self.collect_if_chain(root_if_expr, expected);
+
+        let terminal_else_expr = match &tail {
+            IfChainTail::FinalElse(else_branch) => Some(else_branch.expr),
+            IfChainTail::Missing(last_if_expr) => Some(*last_if_expr),
         };
 
         let coerce_to_ty = expected.coercion_target_type(self, sp);
@@ -166,40 +91,72 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
 
             let branch_body = &branch.body;
+            let skip_coercion = matches!(tail, IfChainTail::Missing(_))
+                && chain.branches.len() > 1
+                && idx == chain.branches.len() - 1;
+            if skip_coercion {
+                recent_branch_types.record(branch_body.ty, branch_body.span);
+                continue;
+            }
             let next_else_expr =
-                chain.branches.get(idx + 1).map(|next| next.if_expr).unwrap_or(else_branch.expr);
-            let mut branch_cause = self.if_cause(
-                branch.if_expr.hir_id,
-                next_else_expr,
-                tail_defines_return_position_impl_trait,
-            );
+                chain.branches.get(idx + 1).map(|next| next.if_expr).or(terminal_else_expr);
+            let mut branch_cause = if let Some(next_else_expr) = next_else_expr {
+                let prev_branch = chain.branches.get(idx - 1).unwrap_or(branch);
+                self.if_cause(
+                    prev_branch.if_expr.hir_id,
+                    next_else_expr,
+                    tail_defines_return_position_impl_trait,
+                )
+            } else {
+                self.misc(branch_body.span)
+            };
             let diag_info = recent_branch_types.diagnostic_snapshot();
+            let cause_span =
+                if idx == 0 { Some(root_if_expr.span) } else { Some(branch_body.span) };
+
             self.coerce_if_arm(
                 &mut coerce,
                 &mut branch_cause,
                 branch_body.expr,
                 branch_body.ty,
+                cause_span,
                 branch_body.span,
                 diag_info,
             );
 
             recent_branch_types.record(branch_body.ty, branch_body.span);
         }
 
-        let mut else_cause =
-            self.if_cause(expr_id, else_branch.expr, tail_defines_return_position_impl_trait);
-        let diag_info = recent_branch_types.diagnostic_snapshot();
-        self.coerce_if_arm(
-            &mut coerce,
-            &mut else_cause,
-            else_branch.expr,
-            else_branch.ty,
-            else_branch.span,
-            diag_info,
-        );
-        recent_branch_types.record(else_branch.ty, else_branch.span);
+        let mut tail_diverges = match tail {
+            IfChainTail::FinalElse(else_branch) => {
+                let mut else_cause = self.if_cause(
+                    expr_id,
+                    else_branch.expr,
+                    tail_defines_return_position_impl_trait,
+                );
+                let diag_info = recent_branch_types.diagnostic_snapshot();
+                self.coerce_if_arm(
+                    &mut coerce,
+                    &mut else_cause,
+                    else_branch.expr,
+                    else_branch.ty,
+                    None,
+                    else_branch.span,
+                    diag_info,
+                );
+                recent_branch_types.record(else_branch.ty, else_branch.span);
+
+                else_branch.diverges
+            }
+            IfChainTail::Missing(last_if_expr) => {
+                let hir::ExprKind::If(tail_cond, tail_then, _) = last_if_expr.kind else {
+                    bug!("expected `if` expression, found {:#?}", last_if_expr);
+                };
+                self.if_fallback_coercion(last_if_expr.span, tail_cond, tail_then, &mut coerce);
+                Diverges::Maybe
+            }
+        };
 
-        let mut tail_diverges = else_branch.diverges;
         for branch in chain.branches.iter().rev() {
             tail_diverges = branch.cond_diverges | (branch.body.diverges & tail_diverges);
         }
@@ -229,16 +186,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         cause: &mut traits::ObligationCause<'tcx>,
         expr: &'tcx hir::Expr<'tcx>,
         ty: Ty<'tcx>,
-        span: Span,
+        cause_span: Option<Span>,
+        body_span: Span,
         prior_branches: SmallVec<[(Ty<'tcx>, Span); 4]>,
     ) {
-        cause.span = span;
+        if let Some(span) = cause_span {
+            cause.span = span;
+        }
         coerce.coerce_inner(
             self,
             cause,
             Some(expr),
             ty,
-            move |err| self.explain_if_branch_mismatch(err, span, &prior_branches),
+            move |err| self.explain_if_branch_mismatch(err, body_span, &prior_branches),
             false,
         );
     }
@@ -258,35 +218,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         (cond_ty, cond_diverges)
     }
 
-    fn if_chain_has_final_else(&self, mut current: &'tcx hir::Expr<'tcx>) -> bool {
-        loop {
-            match current.kind {
-                hir::ExprKind::If(_, _, Some(else_expr)) => match else_expr.kind {
-                    hir::ExprKind::If(..) => current = else_expr,
-                    _ => return true,
-                },
-                _ => return false,
-            }
-        }
-    }
-
     fn collect_if_chain(
         &self,
         mut current_if: &'tcx hir::Expr<'tcx>,
         expected: Expectation<'tcx>,
-        chain: &mut IfChain<'tcx>,
-    ) -> Option<BranchBody<'tcx>> {
+    ) -> (IfChain<'tcx>, IfChainTail<'tcx>) {
+        let mut chain: IfChain<'tcx> = IfChain::default();
+
         loop {
-            let Some(else_expr) = self.collect_if_branch(current_if, expected, chain) else {
-                return None;
+            let Some(else_expr) = self.collect_if_branch(current_if, expected, &mut chain) else {
+                return (chain, IfChainTail::Missing(current_if));
             };
 
             if let hir::ExprKind::If(..) = else_expr.kind {
                 current_if = else_expr;
                 continue;
             }
 
-            return Some(self.collect_final_else(else_expr, expected));
+            return (chain, IfChainTail::FinalElse(self.collect_final_else(else_expr, expected)));
         }
     }
 

compiler/rustc_hir_typeck/src/expr.rs

@@ -584,9 +584,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.demand_eqtype(e.span, ascribed_ty, ty);
                 ascribed_ty
             }
-            ExprKind::If(cond, then_expr, opt_else_expr) => {
-                self.check_expr_if(expr.hir_id, cond, then_expr, opt_else_expr, expr.span, expected)
-            }
+            ExprKind::If(..) => self.check_expr_if(expr.hir_id, expr.span, expected),
             ExprKind::DropTemps(e) => self.check_expr_with_expectation(e, expected),
             ExprKind::Array(args) => self.check_expr_array(args, expected, expr),
             ExprKind::ConstBlock(ref block) => self.check_expr_const_block(block, expected),

tests/ui/expr/if/if-else-chain-missing-else.rs

@@ -1,5 +1,10 @@
-enum Cause { Cause1, Cause2 }
-struct MyErr { x: Cause }
+enum Cause {
+    Cause1,
+    Cause2,
+}
+struct MyErr {
+    x: Cause,
+}
 
 fn main() {
     _ = f();
@@ -9,7 +14,7 @@ fn f() -> Result<i32, MyErr> {
     let res = could_fail();
     let x = if let Ok(x) = res {
         x
-    } else if let Err(e) = res { //~ ERROR `if` and `else`
+    } else if let Err(e) = res { //~ ERROR `if` may be missing an `else` clause
         return Err(e);
     };
     Ok(x)

tests/ui/expr/if/if-else-chain-missing-else.stderr

@@ -1,18 +1,15 @@
-error[E0308]: `if` and `else` have incompatible types
-  --> $DIR/if-else-chain-missing-else.rs:12:12
+error[E0317]: `if` may be missing an `else` clause
+  --> $DIR/if-else-chain-missing-else.rs:17:12
    |
-LL |       let x = if let Ok(x) = res {
-   |               ------------------ `if` and `else` have incompatible types
-LL |           x
 LL |       } else if let Err(e) = res {
    |  ____________^
 LL | |         return Err(e);
 LL | |     };
    | |_____^ expected `i32`, found `()`
    |
    = note: `if` expressions without `else` evaluate to `()`
-   = note: consider adding an `else` block that evaluates to the expected type
+   = help: consider adding an `else` block that evaluates to the expected type
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0308`.
+For more information about this error, try `rustc --explain E0317`.

tests/ui/inference/deref-suggestion.rs

@@ -1,5 +1,7 @@
 macro_rules! borrow {
-    ($x:expr) => { &$x }
+    ($x:expr) => {
+        &$x
+    };
 }
 
 fn foo(_: String) {}
@@ -39,15 +41,14 @@ fn main() {
     let u = 3;
     let s = S { u };
     //~^ ERROR mismatched types
-    let s = S { u: u };
+    let s = S { u };
     //~^ ERROR mismatched types
     let i = &4;
     let r = R { i };
     //~^ ERROR mismatched types
-    let r = R { i: i };
+    let r = R { i };
     //~^ ERROR mismatched types
 
-
     let a = &1;
     let b = &2;
     let val: i32 = if true {
@@ -67,8 +68,8 @@ fn main() {
     let val = if true {
         *a
     } else if true {
-    //~^ ERROR incompatible types
         b
+        //~^ ERROR incompatible types
     } else {
         &0
     };
@@ -79,6 +80,6 @@ fn main() {
     let bar = &Foo;
 
     if foo == bar {
-    //~^ ERROR mismatched types
+        //~^ ERROR mismatched types
     }
 }