Point at return type always when type mismatch against it

estebank · estebank · commit d96f9d47ac35 · 2017-07-25T22:11:15.000-07:00
Before this, the diagnostic errors would only point at the return type when changing it would be a possible solution to a type error. Add a label to the return type without a suggestion to change in order to make the source of the expected type obvious. Follow up to #42850, fixes #25133, fixes #41897.
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -664,7 +664,7 @@ impl<'hir> Map<'hir> {
             match *node {
                 NodeExpr(ref expr) => {
                     match expr.node {
-                        ExprWhile(..) | ExprLoop(..) => true,
+                        ExprWhile(..) | ExprLoop(..) | ExprIf(..) => true,
                         _ => false,
                     }
                 }
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -488,6 +488,7 @@ impl<'tcx> TyS<'tcx> {
             TypeVariants::TyFnPtr(..) |
             TypeVariants::TyDynamic(..) |
             TypeVariants::TyClosure(..) |
+            TypeVariants::TyInfer(..) |
             TypeVariants::TyProjection(..) => false,
             _ => true,
         }
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -4187,8 +4187,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         ty
     }
 
-    /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether it is
-    /// `fn main` if it is a method, `None` otherwise.
+    /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
+    /// suggetion can be made, `None` otherwise.
     pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
         // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
         // `while` before reaching it, as block tail returns are not available in them.
@@ -4199,14 +4199,23 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 name, node: hir::ItemFn(ref decl, ..), ..
             }) = parent {
                 decl.clone().and_then(|decl| {
-                    // This is less than ideal, it will not present the return type span on any
-                    // method called `main`, regardless of whether it is actually the entry point.
-                    Some((decl, name == Symbol::intern("main")))
+                    // This is less than ideal, it will not suggest a return type span on any
+                    // method called `main`, regardless of whether it is actually the entry point,
+                    // but it will still present it as the reason for the expected type.
+                    Some((decl, name != Symbol::intern("main")))
                 })
             } else if let Node::NodeTraitItem(&hir::TraitItem {
                 node: hir::TraitItemKind::Method(hir::MethodSig {
                     ref decl, ..
                 }, ..), ..
+            }) = parent {
+                decl.clone().and_then(|decl| {
+                    Some((decl, true))
+                })
+            } else if let Node::NodeImplItem(&hir::ImplItem {
+                node: hir::ImplItemKind::Method(hir::MethodSig {
+                    ref decl, ..
+                }, ..), ..
             }) = parent {
                 decl.clone().and_then(|decl| {
                     Some((decl, false))
@@ -4233,11 +4242,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                             blk_id: ast::NodeId) {
         self.suggest_missing_semicolon(err, expression, expected, cause_span);
 
-        if let Some((fn_decl, is_main)) = self.get_fn_decl(blk_id) {
-            // `fn main()` must return `()`, do not suggest changing return type
-            if !is_main {
-                self.suggest_missing_return_type(err, &fn_decl, found);
-            }
+        if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
+            self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
         }
     }
 
@@ -4293,20 +4299,31 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
     fn suggest_missing_return_type(&self,
                                    err: &mut DiagnosticBuilder<'tcx>,
                                    fn_decl: &hir::FnDecl,
-                                   ty: Ty<'tcx>) {
+                                   expected: Ty<'tcx>,
+                                   found: Ty<'tcx>,
+                                   can_suggest: bool) {
 
-        // Only recommend changing the return type for methods that
+        // Only suggest changing the return type for methods that
         // haven't set a return type at all (and aren't `fn main()` or an impl).
-        if let &hir::FnDecl {
-            output: hir::FunctionRetTy::DefaultReturn(span), ..
-        } = fn_decl {
-            if ty.is_suggestable() {
+        match (&fn_decl.output, found.is_suggestable(), can_suggest) {
+            (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
                 err.span_suggestion(span,
                                     "try adding a return type",
-                                    format!("-> {} ", ty));
-            } else {
+                                    format!("-> {} ", found));
+            }
+            (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
                 err.span_label(span, "possibly return type missing here?");
             }
+            (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
+                // `fn main()` must return `()`, do not suggest changing return type
+                err.span_label(span, "expected `()` because of default return type");
+            }
+            (&hir::FunctionRetTy::Return(ref ty), _, _) => {
+                // Only point to return type if the expected type is the return type, as if they
+                // are not, the expectation must have been caused by something else.
+                err.span_label(ty.span,
+                               format!("expected `{}` because of return type", expected));
+            }
         }
     }
 
diff --git a/src/test/compile-fail/struct-path-self-type-mismatch.rs b/src/test/compile-fail/struct-path-self-type-mismatch.rs
@@ -20,17 +20,15 @@ impl Bar for Foo<i32> {
 }
 
 impl<T> Foo<T> {
-    fn new<U>(u: U) -> Foo<U> {
+    fn new<U>(u: U) -> Foo<U> { //~ NOTE expected `Foo<U>` because of return type
         Self {
         //~^ ERROR mismatched types
-        //~| expected type parameter, found a different type parameter
-        //~| expected type `Foo<U>`
-        //~| found type `Foo<T>`
+        //~| NOTE expected type parameter, found a different type parameter
+        //~| NOTE expected type `Foo<U>`
             inner: u
             //~^ ERROR mismatched types
-            //~| expected type parameter, found a different type parameter
-            //~| expected type `T`
-            //~| found type `U`
+            //~| NOTE expected type parameter, found a different type parameter
+            //~| NOTE expected type `T`
         }
     }
 }
diff --git a/src/test/ui/block-result/block-must-not-have-result-res.stderr b/src/test/ui/block-result/block-must-not-have-result-res.stderr
@@ -1,6 +1,8 @@
 error[E0308]: mismatched types
   --> $DIR/block-must-not-have-result-res.rs:15:9
    |
+14 |     fn drop(&mut self) {
+   |                        - expected `()` because of default return type
 15 |         true //~  ERROR mismatched types
    |         ^^^^ expected (), found bool
    |
diff --git a/src/test/ui/block-result/issue-13624.stderr b/src/test/ui/block-result/issue-13624.stderr
@@ -1,6 +1,8 @@
 error[E0308]: mismatched types
   --> $DIR/issue-13624.rs:17:5
    |
+16 |   pub fn get_enum_struct_variant() -> () {
+   |                                       -- expected `()` because of return type
 17 |     Enum::EnumStructVariant { x: 1, y: 2, z: 3 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), found enum `a::Enum`
    |
diff --git a/src/test/ui/block-result/issue-22645.stderr b/src/test/ui/block-result/issue-22645.stderr
@@ -11,6 +11,9 @@ error[E0277]: the trait bound `{integer}: Scalar` is not satisfied
 error[E0308]: mismatched types
   --> $DIR/issue-22645.rs:25:3
    |
+23 | fn main() {
+   |           - expected `()` because of default return type
+24 |   let b = Bob + 3.5;
 25 |   b + 3 //~ ERROR E0277
    |   ^^^^^ expected (), found struct `Bob`
    |
diff --git a/src/test/ui/block-result/issue-5500.stderr b/src/test/ui/block-result/issue-5500.stderr
@@ -1,6 +1,8 @@
 error[E0308]: mismatched types
   --> $DIR/issue-5500.rs:12:5
    |
+11 | fn main() {
+   |           - expected `()` because of default return type
 12 |     &panic!()
    |     ^^^^^^^^^ expected (), found reference
    |
diff --git a/src/test/ui/impl-trait/equality.stderr b/src/test/ui/impl-trait/equality.stderr
@@ -1,6 +1,9 @@
 error[E0308]: mismatched types
   --> $DIR/equality.rs:25:5
    |
+21 | fn two(x: bool) -> impl Foo {
+   |                    -------- expected `_` because of return type
+...
 25 |     0_u32
    |     ^^^^^ expected i32, found u32
    |
diff --git a/src/test/ui/mismatched_types/abridged.stderr b/src/test/ui/mismatched_types/abridged.stderr
@@ -1,6 +1,8 @@
 error[E0308]: mismatched types
   --> $DIR/abridged.rs:26:5
    |
+25 | fn a() -> Foo {
+   |           --- expected `Foo` because of return type
 26 |     Some(Foo { bar: 1 })
    |     ^^^^^^^^^^^^^^^^^^^^ expected struct `Foo`, found enum `std::option::Option`
    |
@@ -10,6 +12,8 @@ error[E0308]: mismatched types
 error[E0308]: mismatched types
   --> $DIR/abridged.rs:30:5
    |
+29 | fn a2() -> Foo {
+   |            --- expected `Foo` because of return type
 30 |     Ok(Foo { bar: 1})
    |     ^^^^^^^^^^^^^^^^^ expected struct `Foo`, found enum `std::result::Result`
    |
@@ -19,6 +23,8 @@ error[E0308]: mismatched types
 error[E0308]: mismatched types
   --> $DIR/abridged.rs:34:5
    |
+33 | fn b() -> Option<Foo> {
+   |           ----------- expected `std::option::Option<Foo>` because of return type
 34 |     Foo { bar: 1 }
    |     ^^^^^^^^^^^^^^ expected enum `std::option::Option`, found struct `Foo`
    |
@@ -28,6 +34,8 @@ error[E0308]: mismatched types
 error[E0308]: mismatched types
   --> $DIR/abridged.rs:38:5
    |
+37 | fn c() -> Result<Foo, Bar> {
+   |           ---------------- expected `std::result::Result<Foo, Bar>` because of return type
 38 |     Foo { bar: 1 }
    |     ^^^^^^^^^^^^^^ expected enum `std::result::Result`, found struct `Foo`
    |
@@ -37,6 +45,9 @@ error[E0308]: mismatched types
 error[E0308]: mismatched types
   --> $DIR/abridged.rs:49:5
    |
+41 | fn d() -> X<X<String, String>, String> {
+   |           ---------------------------- expected `X<X<std::string::String, std::string::String>, std::string::String>` because of return type
+...
 49 |     x
    |     ^ expected struct `std::string::String`, found integral variable
    |
@@ -46,6 +57,9 @@ error[E0308]: mismatched types
 error[E0308]: mismatched types
   --> $DIR/abridged.rs:60:5
    |
+52 | fn e() -> X<X<String, String>, String> {
+   |           ---------------------------- expected `X<X<std::string::String, std::string::String>, std::string::String>` because of return type
+...
 60 |     x
    |     ^ expected struct `std::string::String`, found integral variable
    |

Original file line number	Diff line number	Diff line change
`@@ -664,7 +664,7 @@ impl<'hir> Map<'hir> {`
`664`	`664`	`match *node {`
`665`	`665`	`NodeExpr(ref expr) => {`
`666`	`666`	`match expr.node {`
`667`		`- ExprWhile(..) \| ExprLoop(..) => true,`
	`667`	`+ ExprWhile(..) \| ExprLoop(..) \| ExprIf(..) => true,`
`668`	`668`	`_ => false,`
`669`	`669`	`}`
`670`	`670`	`}`
Original file line number	Diff line number	Diff line change
`@@ -488,6 +488,7 @@ impl<'tcx> TyS<'tcx> {`
`488`	`488`	`TypeVariants::TyFnPtr(..) \|`
`489`	`489`	`TypeVariants::TyDynamic(..) \|`
`490`	`490`	`TypeVariants::TyClosure(..) \|`
	`491`	`+ TypeVariants::TyInfer(..) \|`
`491`	`492`	`TypeVariants::TyProjection(..) => false,`
`492`	`493`	`_ => true,`
`493`	`494`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,17 +20,15 @@ impl Bar for Foo<i32> {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`impl<T> Foo<T> {`
`23`		`- fn new<U>(u: U) -> Foo<U> {`
	`23`	+ fn new<U>(u: U) -> Foo<U> { //~ NOTE expected `Foo<U>` because of return type
`24`	`24`	`Self {`
`25`	`25`	`//~^ ERROR mismatched types`
`26`		`- //~\| expected type parameter, found a different type parameter`
`27`		- //~\| expected type `Foo<U>`
`28`		- //~\| found type `Foo<T>`
	`26`	`+ //~\| NOTE expected type parameter, found a different type parameter`
	`27`	+ //~\| NOTE expected type `Foo<U>`
`29`	`28`	`inner: u`
`30`	`29`	`//~^ ERROR mismatched types`
`31`		`- //~\| expected type parameter, found a different type parameter`
`32`		- //~\| expected type `T`
`33`		- //~\| found type `U`
	`30`	`+ //~\| NOTE expected type parameter, found a different type parameter`
	`31`	+ //~\| NOTE expected type `T`
`34`	`32`	`}`
`35`	`33`	`}`
`36`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`error[E0308]: mismatched types`
`2`	`2`	`--> $DIR/block-must-not-have-result-res.rs:15:9`
`3`	`3`	`\|`
	`4`	`+14 \| fn drop(&mut self) {`
	`5`	+ \| - expected `()` because of default return type
`4`	`6`	`15 \| true //~ ERROR mismatched types`
`5`	`7`	`\| ^^^^ expected (), found bool`
`6`	`8`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`error[E0308]: mismatched types`
`2`	`2`	`--> $DIR/issue-13624.rs:17:5`
`3`	`3`	`\|`
	`4`	`+16 \| pub fn get_enum_struct_variant() -> () {`
	`5`	+ \| -- expected `()` because of return type
`4`	`6`	`17 \| Enum::EnumStructVariant { x: 1, y: 2, z: 3 }`
`5`	`7`	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), found enum `a::Enum`
`6`	`8`	`\|`
Original file line number	Diff line number	Diff line change
@@ -11,6 +11,9 @@ error[E0277]: the trait bound `{integer}: Scalar` is not satisfied
`11`	`11`	`error[E0308]: mismatched types`
`12`	`12`	`--> $DIR/issue-22645.rs:25:3`
`13`	`13`	`\|`
	`14`	`+23 \| fn main() {`
	`15`	+ \| - expected `()` because of default return type
	`16`	`+24 \| let b = Bob + 3.5;`
`14`	`17`	`25 \| b + 3 //~ ERROR E0277`
`15`	`18`	\| ^^^^^ expected (), found struct `Bob`
`16`	`19`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`error[E0308]: mismatched types`
`2`	`2`	`--> $DIR/issue-5500.rs:12:5`
`3`	`3`	`\|`
	`4`	`+11 \| fn main() {`
	`5`	+ \| - expected `()` because of default return type
`4`	`6`	`12 \| &panic!()`
`5`	`7`	`\| ^^^^^^^^^ expected (), found reference`
`6`	`8`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,9 @@`
`1`	`1`	`error[E0308]: mismatched types`
`2`	`2`	`--> $DIR/equality.rs:25:5`
`3`	`3`	`\|`
	`4`	`+21 \| fn two(x: bool) -> impl Foo {`
	`5`	+ \| -------- expected `_` because of return type
	`6`	`+...`
`4`	`7`	`25 \| 0_u32`
`5`	`8`	`\| ^^^^^ expected i32, found u32`
`6`	`9`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`error[E0308]: mismatched types`
`2`	`2`	`--> $DIR/abridged.rs:26:5`
`3`	`3`	`\|`
	`4`	`+25 \| fn a() -> Foo {`
	`5`	+ \| --- expected `Foo` because of return type
`4`	`6`	`26 \| Some(Foo { bar: 1 })`
`5`	`7`	\| ^^^^^^^^^^^^^^^^^^^^ expected struct `Foo`, found enum `std::option::Option`
`6`	`8`	`\|`
`@@ -10,6 +12,8 @@ error[E0308]: mismatched types`
`10`	`12`	`error[E0308]: mismatched types`
`11`	`13`	`--> $DIR/abridged.rs:30:5`
`12`	`14`	`\|`
	`15`	`+29 \| fn a2() -> Foo {`
	`16`	+ \| --- expected `Foo` because of return type
`13`	`17`	`30 \| Ok(Foo { bar: 1})`
`14`	`18`	\| ^^^^^^^^^^^^^^^^^ expected struct `Foo`, found enum `std::result::Result`
`15`	`19`	`\|`
`@@ -19,6 +23,8 @@ error[E0308]: mismatched types`
`19`	`23`	`error[E0308]: mismatched types`
`20`	`24`	`--> $DIR/abridged.rs:34:5`
`21`	`25`	`\|`
	`26`	`+33 \| fn b() -> Option<Foo> {`
	`27`	+ \| ----------- expected `std::option::Option<Foo>` because of return type
`22`	`28`	`34 \| Foo { bar: 1 }`
`23`	`29`	\| ^^^^^^^^^^^^^^ expected enum `std::option::Option`, found struct `Foo`
`24`	`30`	`\|`
`@@ -28,6 +34,8 @@ error[E0308]: mismatched types`
`28`	`34`	`error[E0308]: mismatched types`
`29`	`35`	`--> $DIR/abridged.rs:38:5`
`30`	`36`	`\|`
	`37`	`+37 \| fn c() -> Result<Foo, Bar> {`
	`38`	+ \| ---------------- expected `std::result::Result<Foo, Bar>` because of return type
`31`	`39`	`38 \| Foo { bar: 1 }`
`32`	`40`	\| ^^^^^^^^^^^^^^ expected enum `std::result::Result`, found struct `Foo`
`33`	`41`	`\|`
`@@ -37,6 +45,9 @@ error[E0308]: mismatched types`
`37`	`45`	`error[E0308]: mismatched types`
`38`	`46`	`--> $DIR/abridged.rs:49:5`
`39`	`47`	`\|`
	`48`	`+41 \| fn d() -> X<X<String, String>, String> {`
	`49`	+ \| ---------------------------- expected `X<X<std::string::String, std::string::String>, std::string::String>` because of return type
	`50`	`+...`
`40`	`51`	`49 \| x`
`41`	`52`	\| ^ expected struct `std::string::String`, found integral variable
`42`	`53`	`\|`
`@@ -46,6 +57,9 @@ error[E0308]: mismatched types`
`46`	`57`	`error[E0308]: mismatched types`
`47`	`58`	`--> $DIR/abridged.rs:60:5`
`48`	`59`	`\|`
	`60`	`+52 \| fn e() -> X<X<String, String>, String> {`
	`61`	+ \| ---------------------------- expected `X<X<std::string::String, std::string::String>, std::string::String>` because of return type
	`62`	`+...`
`49`	`63`	`60 \| x`
`50`	`64`	\| ^ expected struct `std::string::String`, found integral variable
`51`	`65`	`\|`