Used a constraint system, not typeCheckExpression.

Author: nate-chandler

lib/Sema/TypeCheckStmt.cpp

@@ -17,6 +17,7 @@
 #include "TypeChecker.h"
 #include "TypeCheckType.h"
 #include "MiscDiagnostics.h"
+#include "ConstraintSystem.h"
 #include "swift/Subsystems.h"
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/ASTWalker.h"
@@ -1923,7 +1924,8 @@ bool TypeChecker::typeCheckFunctionBodyUntil(FuncDecl *FD,
   // FIXME: FIXME_NOW: DETERMINE: What is the appropriate place for this code to
   //        live?
   if (FD->hasSingleExpressionBody()) {
-    auto fnType = FD->getBodyResultTypeLoc().getType();
+    auto fnTypeLoc = FD->getBodyResultTypeLoc();
+    auto fnType = fnTypeLoc.getType();
     auto returnStmt = cast<ReturnStmt>(BS->getElement(0).get<Stmt *>());
     auto E = returnStmt->getResult();
 
@@ -1935,7 +1937,7 @@ bool TypeChecker::typeCheckFunctionBodyUntil(FuncDecl *FD,
     //             FD->setSingleExpressionBody(E);
     //           }
 
-    if (FD->getBodyResultTypeLoc().isNull() || fnType->isVoid()) {
+    if (fnTypeLoc.isNull() || fnType->isVoid()) {
       auto voidExpr = TupleExpr::createEmpty(Context,
                                              E->getStartLoc(),
                                              E->getEndLoc(),
@@ -1949,15 +1951,23 @@ bool TypeChecker::typeCheckFunctionBodyUntil(FuncDecl *FD,
     } else {
       // FIXME: FIXME_NOW: DETERMINE: Is this the appropriate mechanism to use
       //        to divine the type of E?
-      auto exprTy = typeCheckExpression(E, FD, TypeLoc(),
-                                        CTP_ReturnStmt);
-      if (!exprTy.isNull() && exprTy->isUninhabited() &&
-          exprTy->getCanonicalType() != fnType->getCanonicalType()) {
-        BS = BraceStmt::create(Context,
-                               BS->getStartLoc(),
-                               { E },
-                               BS->getEndLoc(),
-                               /*implicit=*/true);
+      preCheckExpression(E, FD);
+      constraints::ConstraintSystem cs(*this, FD, 
+                                       constraints::ConstraintSystemFlags::SuppressDiagnostics);
+      SmallVector<constraints::Solution, 4> viable;
+      if(!cs.solve(E, /*convertType*/Type(), nullptr, viable,
+                   FreeTypeVariableBinding::Disallow)) {
+        auto &solution = viable[0];
+        auto &solutionCS = solution.getConstraintSystem();
+        Type exprType = solution.simplifyType(solutionCS.getType(E));
+        if (!exprType.isNull() && exprType->isUninhabited() &&
+            exprType->getCanonicalType() != fnType->getCanonicalType()) {
+          BS = BraceStmt::create(Context,
+                                 BS->getStartLoc(),
+                                 { E },
+                                 BS->getEndLoc(),
+                                 /*implicit=*/true);
+        }
       }
     }
   }

test/Parse/omit_return.swift

@@ -34,6 +34,23 @@ func myOwnFatalError() -> MyOwnNever { fatalError() }
 
 func identity<T>(_ t: T) -> T { t }
 
+internal func _fatalErrorFlags() -> UInt32 {
+    return 0
+}
+internal func _assertionFailure(
+  _ prefix: StaticString, _ message: String,
+  flags: UInt32
+) -> Never {
+    fatalError()
+} 
+internal func _diagnoseUnexpectedEnumCaseValue<SwitchedValue, RawValue>(
+  type: SwitchedValue.Type,
+  rawValue: RawValue
+) -> Never {
+  _assertionFailure("Fatal error",
+                    "unexpected enum case '\(type)(rawValue: \(rawValue))'",
+                    flags: _fatalErrorFlags())
+}
 
 
 // MARK: - Free Functions
@@ -62,6 +79,22 @@ func ff_implicitClosure() -> () -> Void {
     { print("howdy") }
 }
 
+func ff_explicitMultilineClosure() -> () -> String {
+    return {
+        let one = "big a"
+        let two = "little a"
+        return "\(one) + \(two)"
+    }
+}
+
+func ff_implicitMultilineClosure() -> () -> String {
+    {
+        let one = "big a"
+        let two = "little a"
+        return "\(one) + \(two)"
+    }
+}
+
 func ff_implicitWrong() -> String {
     17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
 }
@@ -242,6 +275,22 @@ var fv_implicitClosure: () -> Void {
     { print("howdy") }
 }
 
+var fv_explicitMultilineClosure: () -> String {
+    return {
+        let one = "big a"
+        let two = "little a"
+        return "\(one) + \(two)"
+    }
+}
+
+var fv_implicitMultilineClosure: () -> String {
+    {
+        let one = "big a"
+        let two = "little a"
+        return "\(one) + \(two)"
+    }
+}
+
 var fv_implicitWrong: String {
     17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
 }
@@ -400,6 +449,26 @@ var fvg_implicitClosure: () -> Void {
     }
 }
 
+var fvg_explicitMultilineClosure: () -> String {
+    get {
+        return {
+            let one = "big a"
+            let two = "little a"
+            return "\(one) + \(two)"
+        }
+    }
+}
+
+var fvg_implicitMultilineClosure: () -> String {
+    get {
+        {
+            let one = "big a"
+            let two = "little a"
+            return "\(one) + \(two)"
+        }
+    }
+}
+
 var fvg_implicitWrong: String {
     get {
         17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
@@ -726,6 +795,26 @@ enum S_implicitClosure {
     }
 }
 
+enum S_explicitMultilineClosure {
+   subscript() -> () -> String {
+        return {
+            let one = "big a"
+            let two = "little a"
+            return "\(one) + \(two)"
+        }
+    }
+}
+
+enum S_implicitMultilineClosure {
+    subscript() -> () -> String {
+        {
+            let one = "big a"
+            let two = "little a"
+            return "\(one) + \(two)"
+        }
+    }
+}
+
 enum S_implicitWrong {
     subscript() -> String {
         17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
@@ -932,6 +1021,30 @@ enum SRO_implicitClosure {
     }
 }
 
+enum SRO_explicitMultilineClosure {
+   subscript() -> () -> String {
+        get {
+            return {
+                let one = "big a"
+                let two = "little a"
+                return "\(one) + \(two)"
+            }
+        }
+    }
+}
+
+enum SRO_implicitMultilineClosure {
+    subscript() -> () -> String {
+        get {
+            {
+                let one = "big a"
+                let two = "little a"
+                return "\(one) + \(two)"
+            }
+        }
+    }
+}
+
 enum SRO_implicitWrong {
     subscript() -> String {
         get {