[Typed throws] Teach associated type inference to infer from thrown errors

When comparing a requirement that uses typed throws and uses an
associated type for the thrown error type against a potential witness,
infer the associated type from the thrown error of the
witness---whether explicitly specified, untyped throws (`any Error`),
or non-throwing (`Never`).

Author: DougGregor

include/swift/AST/Decl.h

@@ -7123,7 +7123,7 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   ///
   /// Functions with untyped throws will produce "any Error", functions that
   /// cannot throw or are specified to throw "Never" will return llvm::None.
-  llvm::Optional<Type> getEffectiveThrownInterfaceType() const;
+  llvm::Optional<Type> getEffectiveThrownErrorType() const;
 
   /// Returns if the function throws or is async.
   bool hasEffect(EffectKind kind) const;

include/swift/AST/TypeMatcher.h

@@ -397,6 +397,15 @@ class TypeMatcher {
             return false;
         }
 
+        // If requested, compare the thrown error types.
+        Type thrownError1 = firstFunc->getEffectiveThrownErrorTypeOrNever();
+        Type thrownError2 = secondFunc->getEffectiveThrownErrorTypeOrNever();
+        if (Matcher.asDerived().considerThrownErrorTypes(thrownError1,
+                                                         thrownError2) &&
+            !this->visit(thrownError1->getCanonicalType(),
+                         thrownError2, thrownError1))
+          return false;
+
         return this->visit(firstFunc.getResult(), secondFunc->getResult(),
                            sugaredFirstFunc->getResult());
       }
@@ -558,6 +567,10 @@ class TypeMatcher {
     return MatchVisitor(*this).visit(first->getCanonicalType(), second,
                                      first);
   }
+
+  bool considerThrownErrorTypes(Type errorType1, Type errorType2) const {
+    return false;
+  }
 };
 
 } // end namespace swift

include/swift/AST/Types.h

@@ -3391,8 +3391,15 @@ class AnyFunctionType : public TypeBase {
   ///
   /// Functions with untyped throws will produce "any Error", functions that
   /// cannot throw or are specified to throw "Never" will return llvm::None.
-  llvm::Optional<Type> getEffectiveThrownInterfaceType() const;
-  
+  llvm::Optional<Type> getEffectiveThrownErrorType() const;
+
+  /// Retrieve the "effective" thrown interface type, or `Never` if
+  /// this function cannot throw.
+  ///
+  /// Functions with untyped throws will produce `any Error`, functions that
+  /// cannot throw or are specified to throw `Never` will return `Never`.
+  Type getEffectiveThrownErrorTypeOrNever() const;
+
   /// Returns true if the function type stores a Clang type that cannot
   /// be derived from its Swift type. Returns false otherwise, including if
   /// the function type is not @convention(c) or @convention(block).

lib/AST/Decl.cpp

@@ -953,15 +953,15 @@ Type AbstractFunctionDecl::getThrownInterfaceType() const {
 }
 
 llvm::Optional<Type> 
-AbstractFunctionDecl::getEffectiveThrownInterfaceType() const {
+AbstractFunctionDecl::getEffectiveThrownErrorType() const {
   Type interfaceType = getInterfaceType();
   if (hasImplicitSelfDecl()) {
     if (auto fnType = interfaceType->getAs<AnyFunctionType>())
       interfaceType = fnType->getResult();
   }
 
   return interfaceType->castTo<AnyFunctionType>()
-      ->getEffectiveThrownInterfaceType();
+      ->getEffectiveThrownErrorType();
 }
 
 Expr *AbstractFunctionDecl::getSingleExpressionBody() const {

lib/AST/Expr.cpp

@@ -1937,7 +1937,7 @@ Type AbstractClosureExpr::getResultType(
 
 llvm::Optional<Type> AbstractClosureExpr::getEffectiveThrownType() const {
   return getType()->castTo<AnyFunctionType>()
-      ->getEffectiveThrownInterfaceType();
+      ->getEffectiveThrownErrorType();
 }
 
 bool AbstractClosureExpr::isBodyThrowing() const {

lib/AST/Type.cpp

@@ -5419,7 +5419,7 @@ AnyFunctionType *AnyFunctionType::getWithoutThrowing() const {
   return withExtInfo(info);
 }
 
-llvm::Optional<Type> AnyFunctionType::getEffectiveThrownInterfaceType() const {
+llvm::Optional<Type> AnyFunctionType::getEffectiveThrownErrorType() const {
   // A non-throwing function... has no thrown interface type.
   if (!isThrowing())
     return llvm::None;
@@ -5437,6 +5437,13 @@ llvm::Optional<Type> AnyFunctionType::getEffectiveThrownInterfaceType() const {
   return thrownError;
 }
 
+Type AnyFunctionType::getEffectiveThrownErrorTypeOrNever() const {
+  if (auto thrown = getEffectiveThrownErrorType())
+    return *thrown;
+
+  return getASTContext().getNeverType();
+}
+
 llvm::Optional<TangentSpace>
 TypeBase::getAutoDiffTangentSpace(LookupConformanceFn lookupConformance) {
   assert(lookupConformance);

lib/SILGen/SILGenBackDeploy.cpp

@@ -238,7 +238,7 @@ void SILGenFunction::emitBackDeploymentThunk(SILDeclRef thunk) {
   }
 
   prepareEpilog(getResultInterfaceType(AFD),
-                AFD->getEffectiveThrownInterfaceType(),
+                AFD->getEffectiveThrownErrorType(),
                 CleanupLocation(AFD));
 
   SILBasicBlock *availableBB = createBasicBlock("availableBB");

lib/SILGen/SILGenConstructor.cpp

@@ -680,7 +680,7 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   // Create a basic block to jump to for the implicit 'self' return.
   // We won't emit this until after we've emitted the body.
   // The epilog takes a void return because the return of 'self' is implicit.
-  prepareEpilog(llvm::None, ctor->getEffectiveThrownInterfaceType(),
+  prepareEpilog(llvm::None, ctor->getEffectiveThrownErrorType(),
                 CleanupLocation(ctor));
 
   // If the constructor can fail, set up an alternative epilog for constructor
@@ -1185,7 +1185,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
 
   // Create a basic block to jump to for the implicit 'self' return.
   // We won't emit the block until after we've emitted the body.
-  prepareEpilog(llvm::None, ctor->getEffectiveThrownInterfaceType(),
+  prepareEpilog(llvm::None, ctor->getEffectiveThrownErrorType(),
                 CleanupLocation(endOfInitLoc));
 
   auto resultType = ctor->mapTypeIntoContext(ctor->getResultInterfaceType());
@@ -1751,7 +1751,7 @@ void SILGenFunction::emitInitAccessor(AccessorDecl *accessor) {
   }
 
   prepareEpilog(accessor->getResultInterfaceType(),
-                accessor->getEffectiveThrownInterfaceType(),
+                accessor->getEffectiveThrownErrorType(),
                 CleanupLocation(accessor));
 
   emitProfilerIncrement(accessor->getTypecheckedBody());

lib/SILGen/SILGenFunction.cpp

@@ -1051,7 +1051,7 @@ void SILGenFunction::emitFunction(FuncDecl *fd) {
     emitDistributedActorFactory(fd);
   } else {
     prepareEpilog(fd->getResultInterfaceType(),
-                  fd->getEffectiveThrownInterfaceType(), CleanupLocation(fd));
+                  fd->getEffectiveThrownErrorType(), CleanupLocation(fd));
 
     if (fd->requiresUnavailableDeclABICompatibilityStubs())
       emitApplyOfUnavailableCodeReached();

lib/Sema/CSSimplify.cpp

@@ -2957,8 +2957,8 @@ matchFunctionThrowing(ConstraintSystem &cs,
   // that throws error type E2 when E1 is a subtype of E2. For the purpose
   // of this comparison, a non-throwing function has thrown error type 'Never',
   // and an untyped throwing function has thrown error type 'any Error'.
-  Type thrownError1 = getEffectiveThrownErrorTypeOrNever(func1);
-  Type thrownError2 = getEffectiveThrownErrorTypeOrNever(func2);
+  Type thrownError1 = func1->getEffectiveThrownErrorTypeOrNever();
+  Type thrownError2 = func2->getEffectiveThrownErrorTypeOrNever();
   if (!thrownError1 || !thrownError2)
     return cs.getTypeMatchSuccess();
 

lib/Sema/TypeCheckEffects.cpp

@@ -762,7 +762,7 @@ class Classification {
 
       if (considerThrows) {
         if (auto thrownInterfaceType =
-                func->getEffectiveThrownInterfaceType()) {
+                func->getEffectiveThrownErrorType()) {
           Type thrownType =
               thrownInterfaceType->subst(declRef.getSubstitutions());
           result.merge(Classification::forThrows(thrownType,
@@ -1660,7 +1660,7 @@ class ApplyClassifier {
         return Classification();
 
       case EffectKind::Throws:
-        if (auto thrownError = fnType->getEffectiveThrownInterfaceType())
+        if (auto thrownError = fnType->getEffectiveThrownErrorType())
           return Classification::forThrows(*thrownError, conditional, reason);
 
         return Classification();
@@ -3305,13 +3305,6 @@ Type TypeChecker::errorUnion(Type type1, Type type2) {
   return type1->getASTContext().getErrorExistentialType();
 }
 
-Type swift::getEffectiveThrownErrorTypeOrNever(AnyFunctionType *func) {
-  if (auto thrownError = func->getEffectiveThrownInterfaceType())
-    return *thrownError;
-
-  return func->getASTContext().getNeverType();
-}
-
 namespace {
 
 /// Classifies a thrown error kind as Never, a specific type, or 'any Error'.

lib/Sema/TypeCheckEffects.h

@@ -22,11 +22,6 @@
 
 namespace swift {
 
-/// Retrieve the effective thrown error type for the given function type, which
-/// is the thrown error type (is specified), `any Error` if untyped throwing, or
-/// `Never` if non-throwing.
-Type getEffectiveThrownErrorTypeOrNever(AnyFunctionType *func);
-
 /// Classifies the result of a subtyping comparison between two thrown error
 /// types.
 enum class ThrownErrorSubtyping {

lib/Sema/TypeCheckProtocol.cpp

@@ -861,8 +861,8 @@ RequirementMatch swift::matchWitness(
       if (!reqThrownError) {
         // Save the thrown error types of the requirement and witness so we
         // can check them later.
-        reqThrownError = getEffectiveThrownErrorTypeOrNever(reqFnType);
-        witnessThrownError = getEffectiveThrownErrorTypeOrNever(witnessFnType);
+        reqThrownError = reqFnType->getEffectiveThrownErrorTypeOrNever();
+        witnessThrownError = witnessFnType->getEffectiveThrownErrorTypeOrNever();
       }
     }
   } else {
@@ -901,13 +901,19 @@ RequirementMatch swift::matchWitness(
       return RequirementMatch(witness, MatchKind::ThrowsConflict);
 
     case ThrownErrorSubtyping::ExactMatch:
-    case ThrownErrorSubtyping::Subtype:
       // All is well.
       break;
 
+    case ThrownErrorSubtyping::Subtype:
+      // If there were no type parameters, we're done.
+      if (!reqThrownError->hasTypeParameter())
+        break;
+
+      LLVM_FALLTHROUGH;
+
     case ThrownErrorSubtyping::Dependent:
       // We need to perform type matching
-      if (auto result = matchTypes(witnessThrownError, reqThrownError)) {
+      if (auto result = matchTypes(reqThrownError, witnessThrownError)) {
         return std::move(result.value());
       }
       break;

lib/Sema/TypeCheckProtocolInference.cpp

@@ -751,6 +751,10 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitness(ValueDecl *req,
                   TypeBase *secondType, Type sugaredFirstType) {
       return true;
     }
+
+    bool considerThrownErrorTypes(Type errorType1, Type errorType2) const {
+      return errorType1->hasTypeParameter();
+    }
   };
 
   // Match a requirement and witness type.

test/decl/protocol/conforms/typed_throws.swift

@@ -38,3 +38,34 @@ struct ConformingToVeryThrowing: VeryThrowing {
                                // FIXME: Diagnostic above should be better
   var prop4: Int { get throws(SubError) { 0 } }
 }
+
+// Associated type inference.
+protocol FailureAssociatedType {
+  associatedtype Failure: Error
+
+  func f() throws(Failure)
+}
+
+struct S1: FailureAssociatedType {
+  func f() throws(MyError) { }
+}
+
+struct S2: FailureAssociatedType {
+  func f() throws { }
+}
+
+struct S3: FailureAssociatedType {
+  func f() { }
+}
+
+func testAssociatedTypes() {
+  let _ = S1.Failure() // expected-error{{'S1.Failure' (aka 'MyError') cannot be constructed because it has no accessible initializers}}
+  let _ = S2.Failure() // expected-error{{'S2.Failure' (aka 'any Error') cannot be constructed because it has no accessible initializers}}
+  let _: Int = S3.Failure() // expected-error{{cannot convert value of type 'S3.Failure' (aka 'Never') to specified type 'Int'}}
+  // expected-error@-1{{missing argument for parameter 'from' in call}}
+}
+
+// Make sure we can throw the generic failure type.
+func assocFailureType<T: FailureAssociatedType>(_ value: T, _ error: T.Failure) throws(T.Failure) {
+  throw error
+}