fix <rdar://problem/21675896> QoI: [Closure return type inference] Swift cannot find members for the result of inlined lambdas with branches

We previously produced the unhelpful error message:

x.swift:11:7: error: type of expression is ambiguous without more context

we now produce:

error: unable to infer closure return type in current context

which is going in the right direction.

Author: lattner

lib/Sema/CSDiag.cpp

@@ -6304,6 +6304,22 @@ void FailureDiagnosis::diagnoseAmbiguity(Expr *E) {
     return;
   }
 
+  // A very common cause of this diagnostic is a situation where a closure expr
+  // has no inferred type, due to being a multiline closure.  Check to see if
+  // this is the case and (if so), speculatively diagnose that as the problem.
+  bool didDiagnose = false;
+  E->forEachChildExpr([&](Expr *subExpr) -> Expr*{
+    auto closure = dyn_cast<ClosureExpr>(subExpr);
+    if (!didDiagnose && closure)
+      didDiagnose = checkMultistatementClosureForAmbiguity(closure,
+                                                          CS->getTypeChecker());
+    
+    return subExpr;
+  });
+  
+  if (didDiagnose) return;
+  
+
 
   // Attempt to re-type-check the entire expression, allowing ambiguity, but
   // ignoring a contextual type.

test/Constraints/closures.swift

@@ -218,5 +218,16 @@ let things = Thing().map { thing in  // expected-error {{unable to infer closure
 }
 
 
+// <rdar://problem/21675896> QoI: [Closure return type inference] Swift cannot find members for the result of inlined lambdas with branches
+func r21675896(file : String) {
+  let x: String = { // expected-error {{unable to infer closure return type in current context}}
+    if true {
+      return "foo"
+    }
+    else {
+      return file
+    }
+  }().pathExtension
+}
 
 

test/Constraints/diagnostics.swift

@@ -465,9 +465,12 @@ func f20371273() {
 
 
 // <rdar://problem/20921068> Swift fails to compile: [0].map() { _ in let r = (1,2).0; return r }
-// FIXME: Should complain about not having a return type annotation in the closure.
-[0].map { _ in let r =  (1,2).0;  return r }
-// expected-error @-1 {{expression type '[_]' is ambiguous without more context}}
+[0].map {  // expected-error {{unable to infer closure return type in current context}}
+  _ in
+  let r =  (1,2).0
+  return r
+}
+
 
 // <rdar://problem/21078316> Less than useful error message when using map on optional dictionary type
 func rdar21078316() {

test/expr/closure/closures.swift

@@ -259,7 +259,7 @@ Void(0) // expected-error{{argument passed to call that takes no arguments}}
 _ = {0}
 
 // <rdar://problem/22086634> "multi-statement closures require an explicit return type" should be an error not a note
-let samples = {   // expected-error {{type of expression is ambiguous without more context}}
+let samples = {   // expected-error {{unable to infer closure return type in current context}}
   // FIXME: This diagnostic should be improved, we can infer a type for the closure expr from
   // its body (by trying really hard in diagnostic generation) and say that we need an explicit
   // contextual result specified because we don't do cross-statement type inference or something.