Merge #11842

11842: Fix duplicate type mismatches with blocks r=flodiebold a=flodiebold E.g. when there's a type mismatch on the return value of a function. To fix this, we have to return the expected type as the type of the block when there's a mismatch. That meant some IDE code that expected otherwise had to be adapted, in particular the "add return type" assist. For the "wrap in Ok/Some" quickfix, this sadly means it usually can't be applied in all branches of an if expression at the same time anymore, because there's a type mismatch for each branch that has the wrong type. Co-authored-by: Florian Diebold <flodiebold@gmail.com>

Author: bors[bot]

crates/hir_ty/src/infer/expr.rs

@@ -69,12 +69,11 @@ impl<'a> InferenceContext<'a> {
  match self.coerce(Some(expr), &ty, &target) {
  Ok(res) => res,
  Err(_) => {
- self.result
- .type_mismatches
- .insert(expr.into(), TypeMismatch { expected: target, actual: ty.clone() });
- // Return actual type when type mismatch.
- // This is needed for diagnostic when return type mismatch.
- ty
+ self.result.type_mismatches.insert(
+ expr.into(),
+ TypeMismatch { expected: target.clone(), actual: ty.clone() },
+ );
+ target
  }
  }
  } else {
@@ -914,9 +913,16 @@ impl<'a> InferenceContext<'a> {
  self.table.new_maybe_never_var()
  } else {
  if let Some(t) = expected.only_has_type(&mut self.table) {
- let _ = self.coerce(Some(expr), &TyBuilder::unit(), &t);
+ if self.coerce(Some(expr), &TyBuilder::unit(), &t).is_err() {
+ self.result.type_mismatches.insert(
+ expr.into(),
+ TypeMismatch { expected: t.clone(), actual: TyBuilder::unit() },
+ );
+ }
+ t
+ } else {
+ TyBuilder::unit()
  }
- TyBuilder::unit()
  }
  }
  }

crates/hir_ty/src/tests.rs

@@ -8,6 +8,7 @@ mod method_resolution;
 mod macros;
 mod display_source_code;
 mod incremental;
+mod diagnostics;
 
 use std::{collections::HashMap, env, sync::Arc};
 

crates/hir_ty/src/tests/coercion.rs

@@ -2,12 +2,10 @@ use super::{check, check_no_mismatches, check_types};
 
 #[test]
 fn block_expr_type_mismatch() {
- // FIXME fix double type mismatch
  check(
  r"
 fn test() {
  let a: i32 = { 1i64 };
- // ^^^^^^^^ expected i32, got i64
  // ^^^^ expected i32, got i64
 }
  ",

crates/hir_ty/src/tests/diagnostics.rs

@@ -0,0 +1,75 @@
+use super::check;
+
+#[test]
+fn function_return_type_mismatch_1() {
+ check(
+ r#"
+fn test() -> &'static str {
+ 5
+ //^ expected &str, got i32
+}
+"#,
+ );
+}
+
+#[test]
+fn function_return_type_mismatch_2() {
+ check(
+ r#"
+fn test(x: bool) -> &'static str {
+ if x {
+ return 1;
+ //^ expected &str, got i32
+ }
+ "ok"
+}
+"#,
+ );
+}
+
+#[test]
+fn function_return_type_mismatch_3() {
+ check(
+ r#"
+fn test(x: bool) -> &'static str {
+ if x {
+ return "ok";
+ }
+ 1
+ //^ expected &str, got i32
+}
+"#,
+ );
+}
+
+#[test]
+fn function_return_type_mismatch_4() {
+ check(
+ r#"
+fn test(x: bool) -> &'static str {
+ if x {
+ "ok"
+ } else {
+ 1
+ //^ expected &str, got i32
+ }
+}
+"#,
+ );
+}
+
+#[test]
+fn function_return_type_mismatch_5() {
+ check(
+ r#"
+fn test(x: bool) -> &'static str {
+ if x {
+ 1
+ //^ expected &str, got i32
+ } else {
+ "ok"
+ }
+}
+"#,
+ );
+}

crates/hir_ty/src/tests/never_type.rs

@@ -314,11 +314,10 @@ fn diverging_expression_2() {
  expect![[r#"
  11..84 '{ ..." }; }': ()
  54..55 'x': u32
- 63..81 '{ loop...foo" }': &str
+ 63..81 '{ loop...foo" }': u32
  65..72 'loop {}': !
  70..72 '{}': ()
  74..79 '"foo"': &str
- 63..81: expected u32, got &str
  74..79: expected u32, got &str
  "#]],
  );
@@ -350,31 +349,30 @@ fn diverging_expression_3_break() {
  let x: u32 = { while true { return; }; };
  }
  ",
- expect![[r"
+ expect![[r#"
  11..85 '{ ...} }; }': ()
  54..55 'x': u32
- 63..82 '{ loop...k; } }': ()
+ 63..82 '{ loop...k; } }': u32
  65..80 'loop { break; }': ()
  70..80 '{ break; }': ()
  72..77 'break': !
- 63..82: expected u32, got ()
  65..80: expected u32, got ()
  97..343 '{ ...; }; }': ()
  140..141 'x': u32
- 149..175 '{ for ...; }; }': ()
+ 149..175 '{ for ...; }; }': u32
  151..172 'for a ...eak; }': ()
  155..156 'a': {unknown}
  160..161 'b': {unknown}
  162..172 '{ break; }': ()
  164..169 'break': !
  226..227 'x': u32
- 235..253 '{ for ... {}; }': ()
+ 235..253 '{ for ... {}; }': u32
  237..250 'for a in b {}': ()
  241..242 'a': {unknown}
  246..247 'b': {unknown}
  248..250 '{}': ()
  304..305 'x': u32
- 313..340 '{ for ...; }; }': ()
+ 313..340 '{ for ...; }; }': u32
  315..337 'for a ...urn; }': ()
  319..320 'a': {unknown}
  324..325 'b': {unknown}
@@ -385,26 +383,26 @@ fn diverging_expression_3_break() {
  313..340: expected u32, got ()
  355..654 '{ ...; }; }': ()
  398..399 'x': u32
- 407..433 '{ whil...; }; }': ()
+ 407..433 '{ whil...; }; }': u32
  409..430 'while ...eak; }': ()
  415..419 'true': bool
  420..430 '{ break; }': ()
  422..427 'break': !
  537..538 'x': u32
- 546..564 '{ whil... {}; }': ()
+ 546..564 '{ whil... {}; }': u32
  548..561 'while true {}': ()
  554..558 'true': bool
  559..561 '{}': ()
  615..616 'x': u32
- 624..651 '{ whil...; }; }': ()
+ 624..651 '{ whil...; }; }': u32
  626..648 'while ...urn; }': ()
  632..636 'true': bool
  637..648 '{ return; }': ()
  639..645 'return': !
  407..433: expected u32, got ()
  546..564: expected u32, got ()
  624..651: expected u32, got ()
- "]],
+ "#]],
  );
 }
 
@@ -438,7 +436,7 @@ fn let_else_must_diverge() {
  17..18 '1': i32
  17..18 '1': i32
  21..22 '2': i32
- 28..30 '{}': ()
+ 28..30 '{}': !
  28..30: expected !, got ()
  "#]],
  );

crates/hir_ty/src/tests/regression.rs

@@ -367,7 +367,7 @@ fn bug_1030() {
  }
  "#,
  expect![[r#"
- 143..145 '{}': ()
+ 143..145 '{}': HashSet<T, H>
  168..197 '{ ...t(); }': ()
  174..192 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<{unknown}, FxHasher>
  174..194 'FxHash...ault()': HashSet<{unknown}, FxHasher>
@@ -831,7 +831,7 @@ fn issue_4966() {
  "#,
  expect![[r#"
  225..229 'iter': T
- 244..246 '{}': ()
+ 244..246 '{}': Vec<A>
  258..402 '{ ...r(); }': ()
  268..273 'inner': Map<|&f64| -> f64>
  276..300 'Map { ... 0.0 }': Map<|&f64| -> f64>
@@ -914,7 +914,7 @@ fn flush(&self) {
 "#,
  expect![[r#"
  123..127 'self': &Mutex<T>
- 150..152 '{}': ()
+ 150..152 '{}': MutexGuard<T>
  234..238 'self': &{unknown}
  240..290 '{ ...()); }': ()
  250..251 'w': &Mutex<BufWriter>
@@ -1039,18 +1039,18 @@ fn cfg_tail() {
  }
  "#,
  expect![[r#"
- 14..53 '{ ...)] 9 }': &str
- 20..31 '{ "first" }': &str
+ 14..53 '{ ...)] 9 }': ()
+ 20..31 '{ "first" }': ()
  22..29 '"first"': &str
- 72..190 '{ ...] 13 }': &str
+ 72..190 '{ ...] 13 }': ()
  78..88 '{ "fake" }': &str
  80..86 '"fake"': &str
  93..103 '{ "fake" }': &str
  95..101 '"fake"': &str
- 108..120 '{ "second" }': &str
+ 108..120 '{ "second" }': ()
  110..118 '"second"': &str
- 210..273 '{ ... 15; }': &str
- 216..227 '{ "third" }': &str
+ 210..273 '{ ... 15; }': ()
+ 216..227 '{ "third" }': ()
  218..225 '"third"': &str
  293..357 '{ ...] 15 }': ()
  299..311 '{ "fourth" }': &str

crates/hir_ty/src/tests/simple.rs

@@ -996,9 +996,9 @@ fn main(foo: Foo) {
  50..106 'if tru... }': ()
  53..57 'true': bool
  58..66 '{ }': ()
- 72..106 'if fal... }': i32
+ 72..106 'if fal... }': ()
  75..80 'false': bool
- 81..106 '{ ... }': i32
+ 81..106 '{ ... }': ()
  91..94 'foo': Foo
  91..100 'foo.field': i32
  "#]],
@@ -1094,10 +1094,10 @@ fn infer_inherent_method() {
  expect![[r#"
  31..35 'self': A
  37..38 'x': u32
- 52..54 '{}': ()
+ 52..54 '{}': i32
  106..110 'self': &A
  112..113 'x': u64
- 127..129 '{}': ()
+ 127..129 '{}': i64
  147..148 'a': A
  153..201 '{ ...(1); }': ()
  159..160 'a': A
@@ -1129,7 +1129,7 @@ fn infer_inherent_method_str() {
  "#,
  expect![[r#"
  39..43 'self': &str
- 52..54 '{}': ()
+ 52..54 '{}': i32
  68..88 '{ ...o(); }': ()
  74..79 '"foo"': &str
  74..85 '"foo".foo()': i32
@@ -1419,7 +1419,7 @@ fn infer_impl_generics_basic() {
  206..210 'self': A<X, Y>
  206..212 'self.y': Y
  214..215 't': T
- 244..341 '{ ...(1); }': ()
+ 244..341 '{ ...(1); }': i128
  254..255 'a': A<u64, i64>
  258..280 'A { x:...1i64 }': A<u64, i64>
  265..269 '1u64': u64
@@ -1456,7 +1456,7 @@ fn infer_impl_generics_with_autoderef() {
  "#,
  expect![[r#"
  77..81 'self': &Option<T>
- 97..99 '{}': ()
+ 97..99 '{}': Option<&T>
  110..111 'o': Option<u32>
  126..164 '{ ...f(); }': ()
  132..145 '(&o).as_ref()': Option<&u32>
@@ -1852,7 +1852,7 @@ fn closure_return() {
  }
  "#,
  expect![[r#"
- 16..58 '{ ...; }; }': ()
+ 16..58 '{ ...; }; }': u32
  26..27 'x': || -> usize
  30..55 '|| -> ...n 1; }': || -> usize
  42..55 '{ return 1; }': usize
@@ -1871,7 +1871,7 @@ fn closure_return_unit() {
  }
  "#,
  expect![[r#"
- 16..47 '{ ...; }; }': ()
+ 16..47 '{ ...; }; }': u32
  26..27 'x': || -> ()
  30..44 '|| { return; }': || -> ()
  33..44 '{ return; }': ()
@@ -1889,7 +1889,7 @@ fn closure_return_inferred() {
  }
  "#,
  expect![[r#"
- 16..46 '{ ..." }; }': ()
+ 16..46 '{ ..." }; }': u32
  26..27 'x': || -> &str
  30..43 '|| { "test" }': || -> &str
  33..43 '{ "test" }': &str
@@ -2628,11 +2628,11 @@ fn main() {
  expect![[r#"
  104..108 'self': &Box<T>
  188..192 'self': &Box<Foo<T>>
- 218..220 '{}': ()
+ 218..220 '{}': &T
  242..246 'self': &Box<Foo<T>>
- 275..277 '{}': ()
+ 275..277 '{}': &Foo<T>
  297..301 'self': Box<Foo<T>>
- 322..324 '{}': ()
+ 322..324 '{}': Foo<T>
  338..559 '{ ...r(); }': ()
  348..353 'boxed': Box<Foo<i32>>
  356..359 'Box': Box<Foo<i32>>(Foo<i32>) -> Box<Foo<i32>>