[Typed throws] Enable checking of thrown types on closures.

Enable typed throws on explicit closures, either due to contextual
type information or due to explicit specification.

Author: DougGregor

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -54,6 +54,9 @@ SIMPLE_LOCATOR_PATH_ELT(AutoclosureResult)
 /// The result of a closure.
 SIMPLE_LOCATOR_PATH_ELT(ClosureResult)
 
+/// The thrown error of a closure.
+SIMPLE_LOCATOR_PATH_ELT(ClosureThrownError)
+
 /// FIXME: Misleading name: this locator is used only for single-expression
 /// closure returns.
 ///

lib/Sema/CSGen.cpp

@@ -2454,6 +2454,49 @@ namespace {
       auto resultLocator =
           CS.getConstraintLocator(closure, ConstraintLocator::ClosureResult);
 
+      // FIXME: Need a better locator.
+      auto thrownErrorLocator =
+        CS.getConstraintLocator(closure, ConstraintLocator::ClosureThrownError);
+
+      // Determine the thrown error type, when appropriate.
+      Type thrownErrorTy = [&] {
+        // Explicitly-specified thrown type.
+        if (auto thrownTypeRepr = closure->getExplicitThrownTypeRepr()) {
+          Type resolvedTy = resolveTypeReferenceInExpression(
+              thrownTypeRepr, TypeResolverContext::InExpression,
+              thrownErrorLocator);
+          if (resolvedTy)
+            return resolvedTy;
+        }
+
+        // Thrown type inferred from context.
+        if (auto contextualType = CS.getContextualType(
+                closure, /*forConstraint=*/false)) {
+          if (auto fnType = contextualType->getAs<AnyFunctionType>()) {
+            if (Type thrownErrorTy = fnType->getThrownError())
+              return thrownErrorTy;
+          }
+        }
+
+        // We do not try to infer a thrown error type if one isn't immediately
+        // available. We could attempt this in the future.
+        return Type();
+      }();
+
+      if (thrownErrorTy) {
+        // Record the thrown error type in the extended info for the function
+        // type of the closure.
+        extInfo = extInfo.withThrows(true, thrownErrorTy);
+
+        // Ensure that the thrown error type conforms to Error.
+        if (auto errorProto =
+                CS.getASTContext().getProtocol(KnownProtocolKind::Error)) {
+          CS.addConstraint(
+              ConstraintKind::ConformsTo, thrownErrorTy,
+              errorProto->getDeclaredInterfaceType(), thrownErrorLocator);
+        }
+      }
+
       // Closure expressions always have function type. In cases where a
       // parameter or return type is omitted, a fresh type variable is used to
       // stand in for that parameter or return type, allowing it to be inferred

lib/Sema/CSSyntacticElement.cpp

@@ -908,12 +908,18 @@ class SyntacticElementConstraintGenerator
   }
 
   void visitThrowStmt(ThrowStmt *throwStmt) {
-    if (!cs.getASTContext().getErrorDecl()) {
-      hadError = true;
-      return;
+
+    // Find the thrown type of our current context.
+    Type errType = getContextualThrownErrorType();
+    if (!errType) {
+      if (!cs.getASTContext().getErrorDecl()) {
+        hadError = true;
+        return;
+      }
+
+      errType = cs.getASTContext().getErrorExistentialType();
     }
 
-    auto errType = cs.getASTContext().getErrorExistentialType();
     auto *errorExpr = throwStmt->getSubExpr();
 
     createConjunction(
@@ -1300,6 +1306,18 @@ class SyntacticElementConstraintGenerator
     return {funcRef->getBodyResultType(), CTP_ReturnStmt};
   }
 
+  Type getContextualThrownErrorType() const {
+    auto funcRef = AnyFunctionRef::fromDeclContext(context.getAsDeclContext());
+    if (!funcRef)
+      return Type();
+
+    if (auto *closure =
+            getAsExpr<ClosureExpr>(funcRef->getAbstractClosureExpr()))
+      return cs.getClosureType(closure)->getThrownError();
+
+    return funcRef->getThrownErrorType();
+  }
+
 #define UNSUPPORTED_STMT(STMT) void visit##STMT##Stmt(STMT##Stmt *) { \
       llvm_unreachable("Unsupported statement kind " #STMT);          \
   }
@@ -2520,6 +2538,11 @@ SolutionApplicationToFunctionResult ConstraintSystem::applySolution(
     if (llvm::is_contained(solution.preconcurrencyClosures, closure))
       closure->setIsolatedByPreconcurrency();
 
+    // Coerce the thrown type, if it was written explicitly.
+    if (closure->getExplicitThrownType()) {
+      closure->setExplicitThrownType(closureFnType->getThrownError());
+    }
+
     // Coerce the result type, if it was written explicitly.
     if (closure->hasExplicitResultType()) {
       closure->setExplicitResultType(closureFnType->getResult());

lib/Sema/ConstraintLocator.cpp

@@ -45,6 +45,7 @@ unsigned LocatorPathElt::getNewSummaryFlags() const {
   case ConstraintLocator::ApplyFunction:
   case ConstraintLocator::SequenceElementType:
   case ConstraintLocator::ClosureResult:
+  case ConstraintLocator::ClosureThrownError:
   case ConstraintLocator::ClosureBody:
   case ConstraintLocator::ConstructorMember:
   case ConstraintLocator::ConstructorMemberType:
@@ -187,6 +188,10 @@ void LocatorPathElt::dump(raw_ostream &out) const {
     out << "closure result";
     break;
 
+  case ConstraintLocator::ClosureThrownError:
+    out << "closure thrown error";
+    break;
+
   case ConstraintLocator::ClosureBody:
     out << "type of a closure body";
     break;

lib/Sema/ConstraintSystem.cpp

@@ -5811,6 +5811,16 @@ void constraints::simplifyLocator(ASTNode &anchor,
       }
       break;
 
+    case ConstraintLocator::ClosureThrownError:
+      if (auto CE = getAsExpr<ClosureExpr>(anchor)) {
+        if (auto thrownTypeRepr = CE->getExplicitThrownTypeRepr()) {
+          anchor = thrownTypeRepr;
+          path = path.slice(1);
+          break;
+        }
+      }
+      break;
+
     case ConstraintLocator::CoercionOperand: {
       auto *CE = castToExpr<CoerceExpr>(anchor);
       anchor = CE->getSubExpr()->getValueProvidingExpr();

lib/Sema/TypeCheckStmt.cpp

@@ -1195,8 +1195,6 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     // Coerce the operand to the exception type.
     auto E = TS->getSubExpr();
 
-
-
     Type errorType;
     if (auto TheFunc = AnyFunctionRef::fromDeclContext(DC)) {
       errorType = TheFunc->getThrownErrorType();

test/expr/closure/typed_throws.swift

@@ -0,0 +1,35 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature TypedThrows
+
+enum MyError: Error {
+  case fail
+}
+
+enum MyBadError {
+  case fail
+}
+
+func testClosures() {
+  let c1 = { () throws(MyError) in
+    throw .fail
+  }
+
+  let _: () -> Void = c1
+  // expected-error@-1{{invalid conversion from throwing function of type '() throws(MyError) -> ()'}}
+
+  let _: () throws(MyError) -> Void = {
+    throw .fail
+  }
+
+  // FIXME: Terrible diagnostic.
+  // expected-error@+1{{unable to infer closure type without a type annotation}}
+  let _ = { () throws(MyBadError) in
+    throw MyBadError.fail
+  }
+
+  // We do not infer thrown error types from the body, because doing so would
+  // break existing code.
+  let c2 = { throw MyError.fail }
+  let _: Int = c2
+  // expected-error@-1{{cannot convert value of type '() throws -> ()'}}
+}
+