[Typed throws] Handle explicitly-specified throws on do..catch in closures

Teach the constraint system to use the same primitives as elsewhere to
determine the type context for a `throw` statement and the caught
error type within a `do..catch` statement. This makes
explicitly-specified `throws` work on `do..catch` that occurs in
closures.

Cleans up some redundant computations for caught error types.

Author: DougGregor

include/swift/AST/AnyFunctionRef.h

@@ -124,24 +124,6 @@ class AnyFunctionRef {
     return TheFunction.get<AbstractClosureExpr *>()->getType();
   }
 
-  Type getThrownErrorType() const {
-    if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
-      if (Type thrownError = AFD->getThrownInterfaceType())
-        return AFD->mapTypeIntoContext(thrownError);
-
-      return Type();
-    }
-
-    Type closureType = TheFunction.get<AbstractClosureExpr *>()->getType();
-    if (!closureType)
-      return Type();
-
-    if (auto closureFnType = closureType->getAs<AnyFunctionType>())
-      return closureFnType->getThrownError();
-
-    return Type();
-  }
-
   Type getBodyResultType() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
       if (auto *FD = dyn_cast<FuncDecl>(AFD))

lib/AST/Decl.cpp

@@ -11702,11 +11702,19 @@ CatchNode::getThrownErrorTypeInContext(DeclContext *dc) const {
     return llvm::None;
   }
 
-  if (auto closure = dyn_cast<AbstractClosureExpr *>()) {
-    if (closure->getType())
-      return closure->getEffectiveThrownType();
+  if (auto abstractClosure = dyn_cast<AbstractClosureExpr *>()) {
+    if (abstractClosure->getType())
+      return abstractClosure->getEffectiveThrownType();
+
+    if (auto closure = llvm::dyn_cast<ClosureExpr>(abstractClosure)) {
+      if (Type thrownType = closure->getExplicitThrownType()) {
+        if (thrownType->isNever())
+          return llvm::None;
+
+        return thrownType;
+      }
+    }
 
-    // FIXME: Should we lazily compute this?
     return llvm::None;
   }
 

lib/Sema/CSSyntacticElement.cpp

@@ -919,16 +919,22 @@ class SyntacticElementConstraintGenerator
   }
 
   void visitThrowStmt(ThrowStmt *throwStmt) {
+    // Look up the catch node for this "throw" to determine the error type.
+    auto dc = context.getAsDeclContext();
+    CatchNode catchNode = ASTScope::lookupCatchNode(
+        dc->getParentModule(), throwStmt->getThrowLoc());
+    Type errorType;
+    if (catchNode) {
+      errorType = catchNode.getThrownErrorTypeInContext(dc).value_or(Type());
+    }
 
-    // Find the thrown type of our current context.
-    Type errType = getContextualThrownErrorType();
-    if (!errType) {
+    if (!errorType) {
       if (!cs.getASTContext().getErrorDecl()) {
         hadError = true;
         return;
       }
 
-      errType = cs.getASTContext().getErrorExistentialType();
+      errorType = cs.getASTContext().getErrorExistentialType();
     }
 
     auto *errorExpr = throwStmt->getSubExpr();
@@ -937,7 +943,7 @@ class SyntacticElementConstraintGenerator
         {makeElement(errorExpr,
                      cs.getConstraintLocator(
                          locator, LocatorPathElt::SyntacticElement(errorExpr)),
-                     {errType, CTP_ThrowStmt})},
+                     {errorType, CTP_ThrowStmt})},
         locator);
   }
 
@@ -1053,8 +1059,12 @@ class SyntacticElementConstraintGenerator
       if (parent.isStmt(StmtKind::Switch)) {
         auto *switchStmt = cast<SwitchStmt>(parent.get<Stmt *>());
         contextualTy = cs.getType(switchStmt->getSubjectExpr());
-      } else if (parent.isStmt(StmtKind::DoCatch)) {
-        contextualTy = cs.getASTContext().getErrorExistentialType();
+      } else if (auto doCatch =
+                     dyn_cast_or_null<DoCatchStmt>(parent.dyn_cast<Stmt *>())) {
+        auto dc = context.getAsDeclContext();
+        contextualTy = doCatch->getExplicitCaughtType(dc);
+        if (!contextualTy)
+          contextualTy = cs.getASTContext().getErrorExistentialType();
       } else {
         hadError = true;
         return;
@@ -1332,18 +1342,6 @@ 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);          \
   }

test/stmt/typed_throws.swift

@@ -176,3 +176,18 @@ func tryBangQuestionMismatchingContext() throws(MyError) {
   try? doHomework()
   try doHomework() // expected-error{{thrown expression type 'HomeworkError' cannot be converted to error type 'MyError'}}
 }
+
+func apply<T, E: Error>(body: () throws(E) -> T) throws(E) -> T {
+  return try body()
+}
+
+func testDoCatchErrorTypedInClosure(cond: Bool) {
+  apply {
+    do throws(MyError) {
+      throw .failed
+    } catch {
+      assert(error == .failed)
+      processMyError(error)
+    }
+  }
+}