[Typed throws] Type-check thrown expressions against the thrown error type

Rather than always type-check the expression in a `throw` statement for
conformance to `Error`, check that it converts to the thrown error type.

Author: DougGregor

include/swift/AST/AnyFunctionRef.h

@@ -124,6 +124,24 @@ 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))

include/swift/AST/DiagnosticsSema.def

@@ -336,7 +336,9 @@ ERROR(cannot_convert_to_return_type_nil,none,
       "'nil' is incompatible with return type %0", (Type))
 
 ERROR(cannot_convert_thrown_type,none,
-      "thrown expression type %0 does not conform to 'Error'", (Type))
+      "thrown expression type %0 %select{cannot be converted to error type %1|"
+      "does not conform to 'Error'}2",
+      (Type, Type, bool))
 ERROR(cannot_throw_error_code,none,
       "thrown error code type %0 does not conform to 'Error'; construct an %1 "
       "instance", (Type, Type))

lib/Sema/CSDiagnostics.cpp

@@ -3136,15 +3136,24 @@ bool ContextualFailure::diagnoseThrowsTypeMismatch() const {
 
   auto anchor = getAnchor();
 
+  auto &Ctx = getASTContext();
+  Type toType = getToType();
+  bool toErrorExistential = false;
+  if (toType->isEqual(Ctx.getErrorExistentialType()))
+    toErrorExistential = true;
+  else if (auto protoType = toType->getAs<ProtocolType>()) {
+    toErrorExistential = protoType->getDecl()->isSpecificProtocol(
+        KnownProtocolKind::Error);
+  }
+
   // If we tried to throw the error code of an error type, suggest object
   // construction.
-  auto &Ctx = getASTContext();
   if (auto errorCodeProtocol =
           Ctx.getProtocol(KnownProtocolKind::ErrorCodeProtocol)) {
     Type errorCodeType = getFromType();
     auto conformance = TypeChecker::conformsToProtocol(
         errorCodeType, errorCodeProtocol, getParentModule());
-    if (conformance) {
+    if (conformance && toErrorExistential) {
       Type errorType =
           conformance
               .getTypeWitnessByName(errorCodeType, getASTContext().Id_ErrorType)
@@ -3164,8 +3173,10 @@ bool ContextualFailure::diagnoseThrowsTypeMismatch() const {
   // The conversion destination of throw is always ErrorType (at the moment)
   // if this ever expands, this should be a specific form like () is for
   // return.
-  emitDiagnostic(diag::cannot_convert_thrown_type, getFromType())
-      .highlight(getSourceRange());
+  emitDiagnostic(
+      diag::cannot_convert_thrown_type, getFromType(), toType,
+      toErrorExistential)
+        .highlight(getSourceRange());
   return true;
 }
 

lib/Sema/TypeCheckStmt.cpp

@@ -1195,10 +1195,20 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     // Coerce the operand to the exception type.
     auto E = TS->getSubExpr();
 
-    if (!getASTContext().getErrorDecl())
+
+
+    Type errorType;
+    if (auto TheFunc = AnyFunctionRef::fromDeclContext(DC)) {
+      errorType = TheFunc->getThrownErrorType();
+    }
+
+    if (!errorType) {
+      errorType = getASTContext().getErrorExistentialType();
+    }
+
+    if (!errorType)
       return TS;
 
-    Type errorType = getASTContext().getErrorExistentialType();
     TypeChecker::typeCheckExpression(E, DC, {errorType, CTP_ThrowStmt});
     TS->setSubExpr(E);
 

test/decl/func/typed_throws.swift

@@ -4,6 +4,10 @@ enum MyError: Error {
   case fail
 }
 
+enum MyOtherError: Error {
+  case fail
+}
+
 enum MyBadError {
   case epicFail
 }
@@ -37,4 +41,22 @@ func throwsUnusedInSignature<T: Error>() throws(T) { }
 func testSubstitutedType() {
   let _: (_: MyError.Type) -> Void = throwsGeneric
   // expected-error@-1{{invalid conversion from throwing function of type '(MyError.Type) throws(MyError) -> ()'}}
+
+  let _: (_: (any Error).Type) -> Void = throwsGeneric
+  // expected-error@-1{{invalid conversion from throwing function of type '((any Error).Type) throws((any Error)) -> ()' to non-throwing function type}}
+
+  let _: (_: Never.Type) -> Void = throwsGeneric
+  // FIXME wrong: expected-error@-1{{invalid conversion from throwing function of type '(Never.Type) throws(Never) -> ()'}}
+}
+
+
+func testThrowingInFunction(cond: Bool, cond2: Bool) throws(MyError) {
+  if cond {
+    throw MyError.fail
+  } else if cond2 {
+    throw .fail
+  } else {
+    throw MyBadError.epicFail
+    // expected-error@-1{{thrown expression type 'MyBadError' cannot be converted to error type 'MyError'}}
+  }
 }