[Typed throws] Teach witness matching to check typed throws.

Author: DougGregor

lib/Sema/TypeCheckProtocol.cpp

@@ -22,6 +22,7 @@
 #include "TypeCheckAvailability.h"
 #include "TypeCheckConcurrency.h"
 #include "TypeCheckDistributed.h"
+#include "TypeCheckEffects.h"
 #include "TypeCheckObjC.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -589,6 +590,8 @@ RequirementMatch swift::matchWitness(
   // Perform basic matching of the requirement and witness.
   bool decomposeFunctionType = false;
   bool ignoreReturnType = false;
+  Type reqThrownError;
+  Type witnessThrownError;
   if (isa<FuncDecl>(req) && isa<FuncDecl>(witness)) {
     auto funcReq = cast<FuncDecl>(req);
     auto funcWitness = cast<FuncDecl>(witness);
@@ -681,12 +684,36 @@ RequirementMatch swift::matchWitness(
                                 MatchKind::MutatingConflict);
     }
 
+    // Check for async mismatches.
+    if (!witnessASD->isLessEffectfulThan(reqASD, EffectKind::Async)) {
+      return RequirementMatch(
+          getStandinForAccessor(witnessASD, AccessorKind::Get),
+          MatchKind::AsyncConflict);
+    }
+
     // Check that the witness has no more effects than the requirement.
     if (auto problem = checkEffects(witnessASD, reqASD))
       return problem.value();
 
     // Decompose the parameters for subscript declarations.
     decomposeFunctionType = isa<SubscriptDecl>(req);
+
+    // Dig out the thrown error types from the getter so we can compare them
+    // later.
+    auto getThrownErrorType = [](AbstractStorageDecl *asd) -> Type {
+      if (auto getter = asd->getEffectfulGetAccessor()) {
+        if (Type thrownErrorType = getter->getThrownInterfaceType()) {
+          return thrownErrorType;
+        } else if (getter->hasThrows()) {
+          return asd->getASTContext().getAnyExistentialType();
+        }
+      }
+
+      return asd->getASTContext().getNeverType();
+    };
+
+    reqThrownError = getThrownErrorType(reqASD);
+    witnessThrownError = getThrownErrorType(witnessASD);
   } else if (isa<ConstructorDecl>(witness)) {
     decomposeFunctionType = true;
     ignoreReturnType = true;
@@ -831,12 +858,11 @@ RequirementMatch swift::matchWitness(
         return RequirementMatch(witness, MatchKind::AsyncConflict);
       }
 
-      // If the witness is 'throws', the requirement must be.
-      // FIXME: We need the same matching we do in the constraint solver,
-      // with the same fast paths for obvious throws/nonthrows cases.
-      if (witnessFnType->getExtInfo().isThrowing() &&
-          !reqFnType->getExtInfo().isThrowing()) {
-        return RequirementMatch(witness, MatchKind::ThrowsConflict);
+      if (!reqThrownError) {
+        // Save the thrown error types of the requirement and witness so we
+        // can check them later.
+        reqThrownError = getEffectiveThrownErrorTypeOrNever(reqFnType);
+        witnessThrownError = getEffectiveThrownErrorTypeOrNever(witnessFnType);
       }
     }
   } else {
@@ -859,6 +885,35 @@ RequirementMatch swift::matchWitness(
     }
   }
 
+  // Check the thrown error types. This includes 'any Error' and 'Never' for
+  // untyped throws and non-throwing cases as well.
+  if (reqThrownError && witnessThrownError) {
+    auto thrownErrorTypes = getTypesToCompare(
+        req, reqThrownError, false, witnessThrownError, false,
+        VarianceKind::None);
+
+    Type reqThrownError = std::get<0>(thrownErrorTypes);
+    Type witnessThrownError = std::get<1>(thrownErrorTypes);
+    switch (compareThrownErrorsForSubtyping(witnessThrownError, reqThrownError,
+                                            dc)) {
+    case ThrownErrorSubtyping::DropsThrows:
+    case ThrownErrorSubtyping::Mismatch:
+      return RequirementMatch(witness, MatchKind::ThrowsConflict);
+
+    case ThrownErrorSubtyping::ExactMatch:
+    case ThrownErrorSubtyping::Subtype:
+      // All is well.
+      break;
+
+    case ThrownErrorSubtyping::Dependent:
+      // We need to perform type matching
+      if (auto result = matchTypes(witnessThrownError, reqThrownError)) {
+        return std::move(result.value());
+      }
+      break;
+    }
+  }
+
   // Now finalize the match.
   auto result = finalize(anyRenaming, optionalAdjustments);
   // Check if the requirement's `@differentiable` attributes are satisfied by

test/decl/protocol/conforms/typed_throws.swift

@@ -0,0 +1,40 @@
+// RUN: %target-typecheck-verify-swift -parse-as-library -enable-experimental-feature TypedThrows
+
+enum MyError: Error {
+case failed
+}
+
+enum HomeworkError: Error {
+case dogAteIt
+}
+
+class SuperError: Error { }
+class SubError: SuperError { }
+
+protocol VeryThrowing {
+  func f() throws
+  func g() throws(MyError)
+  func h() throws(HomeworkError) // expected-note{{protocol requires function 'h()' with type '() throws(HomeworkError) -> ()'}}
+  func i() throws(SuperError)
+
+  var prop1: Int { get throws }
+  var prop2: Int { get throws(MyError) }
+  var prop3: Int { get throws(HomeworkError) } // expected-note{{protocol requires property 'prop3' with type 'Int'; add a stub for conformance}}
+                                               // FIXME: poor diagnostic above
+  var prop4: Int { get throws(SuperError) }
+}
+
+// expected-error@+1{{type 'ConformingToVeryThrowing' does not conform to protocol 'VeryThrowing'}}
+struct ConformingToVeryThrowing: VeryThrowing {
+  func f() throws(MyError) { } // okay to make type more specific
+  func g() { } // okay to be non-throwing
+  func h() throws(MyError) { } // expected-note{{candidate throws, but protocol does not allow it}}
+                               // FIXME: Diagnostic above should be better
+  func i() throws(SubError) { } // okay to have a subtype
+
+  var prop1: Int { get throws(MyError) { 0 } }
+  var prop2: Int { 0 } // okay to be non-throwing
+  var prop3: Int { get throws(MyError) { 0 } } // expected-note{{candidate throws, but protocol does not allow it}}
+                               // FIXME: Diagnostic above should be better
+  var prop4: Int { get throws(SubError) { 0 } }
+}