diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 33f0b0282d173..bdd8169b84fe7 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -413,7 +413,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // discriminant. This is sort of a workaround, see note (*) in // `check_pat` for some details. discrim_ty = self.next_ty_var(TypeVariableOrigin::TypeInference(discrim.span)); - self.check_expr_has_type(discrim, discrim_ty); + self.check_expr_has_type_or_error(discrim, discrim_ty); }; // If the discriminant diverges, the match is pointless (e.g., @@ -480,7 +480,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { for (i, (arm, pats_diverge)) in arms.iter().zip(all_arm_pats_diverge).enumerate() { if let Some(ref e) = arm.guard { self.diverges.set(pats_diverge); - self.check_expr_has_type(e, tcx.types.bool); + self.check_expr_has_type_or_error(e, tcx.types.bool); } self.diverges.set(pats_diverge); diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 732b9be81a398..1b6f96cf65137 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -29,7 +29,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { self.demand_suptype_diag(sp, expected, actual).map(|mut e| e.emit()); } - pub fn demand_suptype_diag(&self, sp: Span, + pub fn demand_suptype_diag(&self, + sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) -> Option> { let cause = &self.misc(sp); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 5bba79a176eee..d663d8f0d2b5a 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -345,7 +345,7 @@ impl<'a, 'gcx, 'tcx> Expectation<'tcx> { match self.resolve(fcx) { ExpectHasType(ty) => Some(ty), ExpectIfCondition => Some(fcx.tcx.types.bool), - _ => None + NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None, } } @@ -2647,15 +2647,15 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { self.demand_eqtype(expr.span, expected, ty); } - pub fn check_expr_has_type(&self, - expr: &'gcx hir::Expr, - expected: Ty<'tcx>) -> Ty<'tcx> { - self.check_expr_expect_type(expr, ExpectHasType(expected)) + pub fn check_expr_has_type_or_error(&self, + expr: &'gcx hir::Expr, + expected: Ty<'tcx>) -> Ty<'tcx> { + self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected)) } - fn check_expr_expect_type(&self, - expr: &'gcx hir::Expr, - expected: Expectation<'tcx>) -> Ty<'tcx> { + fn check_expr_meets_expectation_or_error(&self, + expr: &'gcx hir::Expr, + expected: Expectation<'tcx>) -> Ty<'tcx> { let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool); let mut ty = self.check_expr_with_expectation(expr, expected); @@ -2865,7 +2865,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { opt_else_expr: Option<&'gcx hir::Expr>, sp: Span, expected: Expectation<'tcx>) -> Ty<'tcx> { - let cond_ty = self.check_expr_expect_type(cond_expr, ExpectIfCondition); + let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition); let cond_diverges = self.diverges.get(); self.diverges.set(Diverges::Maybe); @@ -3352,7 +3352,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields, base_expr.is_none()); if let &Some(ref base_expr) = base_expr { - self.check_expr_has_type(base_expr, struct_ty); + self.check_expr_has_type_or_error(base_expr, struct_ty); match struct_ty.sty { ty::TyAdt(adt, substs) if adt.is_struct() => { let fru_field_types = adt.struct_variant().fields.iter().map(|f| { @@ -3668,7 +3668,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty); match expected { - ExpectIfCondition => (), + ExpectIfCondition => { + self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\ + expected error elsehwere"); + } _ => { // Only check this if not in an `if` condition, as the // mistyped comparison help is more appropriate. @@ -3704,7 +3707,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { }; self.with_breakable_ctxt(expr.id, ctxt, || { - self.check_expr_has_type(&cond, tcx.types.bool); + self.check_expr_has_type_or_error(&cond, tcx.types.bool); let cond_diverging = self.diverges.get(); self.check_block_no_value(&body); @@ -3842,7 +3845,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { } None => { let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span)); - let element_ty = self.check_expr_has_type(&element, t); + let element_ty = self.check_expr_has_type_or_error(&element, t); (element_ty, t) } }; @@ -4097,7 +4100,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { } hir::StmtExpr(ref expr, _) => { // Check with expected type of () - self.check_expr_has_type(&expr, self.tcx.mk_nil()); + self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil()); } hir::StmtSemi(ref expr, _) => { self.check_expr(&expr); diff --git a/src/test/ui/type-check/issue-17283.rs b/src/test/ui/type-check/assignment-in-if.rs similarity index 93% rename from src/test/ui/type-check/issue-17283.rs rename to src/test/ui/type-check/assignment-in-if.rs index f06888b8ec469..98dc55c666303 100644 --- a/src/test/ui/type-check/issue-17283.rs +++ b/src/test/ui/type-check/assignment-in-if.rs @@ -45,4 +45,8 @@ fn main() { //~| HELP did you mean to compare equality? println!("{}", x); } + if (if true { x = 4 } else { x = 5 }) { + //~^ ERROR mismatched types + println!("{}", x); + } } diff --git a/src/test/ui/type-check/issue-17283.stderr b/src/test/ui/type-check/assignment-in-if.stderr similarity index 73% rename from src/test/ui/type-check/issue-17283.stderr rename to src/test/ui/type-check/assignment-in-if.stderr index f258caecd300e..2943999927322 100644 --- a/src/test/ui/type-check/issue-17283.stderr +++ b/src/test/ui/type-check/assignment-in-if.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/issue-17283.rs:25:8 + --> $DIR/assignment-in-if.rs:25:8 | 25 | if x = x { | ^^^^^ @@ -11,7 +11,7 @@ error[E0308]: mismatched types found type `()` error[E0308]: mismatched types - --> $DIR/issue-17283.rs:31:8 + --> $DIR/assignment-in-if.rs:31:8 | 31 | if (x = x) { | ^^^^^^^ @@ -23,7 +23,7 @@ error[E0308]: mismatched types found type `()` error[E0308]: mismatched types - --> $DIR/issue-17283.rs:37:8 + --> $DIR/assignment-in-if.rs:37:8 | 37 | if y = (Foo { foo: x }) { | ^^^^^^^^^^^^^^^^^^^^ @@ -35,7 +35,7 @@ error[E0308]: mismatched types found type `()` error[E0308]: mismatched types - --> $DIR/issue-17283.rs:43:8 + --> $DIR/assignment-in-if.rs:43:8 | 43 | if 3 = x { | ^^^^^ @@ -46,5 +46,14 @@ error[E0308]: mismatched types = note: expected type `bool` found type `()` +error[E0308]: mismatched types + --> $DIR/assignment-in-if.rs:48:8 + | +48 | if (if true { x = 4 } else { x = 5 }) { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bool, found () + | + = note: expected type `bool` + found type `()` + error: aborting due to previous error(s)