[Typed throws] Handle function conversions involving different thrown errors

Teach the constraint solver about the subtyping rule that permits
converting one function type to another when the effective thrown error
type of one is a subtype of the effective thrown error type of the
other, using `any Error` for untyped throws and `Never` for
non-throwing.

With minor other fixes, this allows us to use typed throws for generic
functions that carry a typed error from their arguments through to
themselves, which is in effect a typed `rethrows`:

```swift
func mapArray<T, U, E: Error>(_ array: [T], body: (T) throws(E) -> U)
throws(E) -> [U] {
  var resultArray: [U] = .init()
  for value in array {
    resultArray.append(try body(value))
  }
  return resultArray
}
```

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -615,6 +615,9 @@ ERROR(throws_functiontype_mismatch,none,
       "invalid conversion from throwing function of type %0 to "
       "non-throwing function type %1", (Type, Type))
 
+ERROR(thrown_error_type_mismatch,none,
+      "invalid conversion of thrown error type %0 to %1", (Type, Type))
+
 ERROR(async_functiontype_mismatch,none,
       "invalid conversion from 'async' function of type %0 to "
       "synchronous function type %1", (Type, Type))

include/swift/Sema/CSFix.h

@@ -375,6 +375,9 @@ enum class FixKind : uint8_t {
   /// `throws` attribute from the source function.
   DropThrowsAttribute,
 
+  /// Ignore a mismatch in the thrown error type.
+  IgnoreThrownErrorMismatch,
+
   /// Fix conversion from async to sync function by removing explicit
   /// `async` attribute from the source function.
   DropAsyncAttribute,
@@ -1005,7 +1008,6 @@ class DropThrowsAttribute final : public ContextualMismatch {
                       FunctionType *toType, ConstraintLocator *locator)
       : ContextualMismatch(cs, FixKind::DropThrowsAttribute, fromType, toType,
                            locator) {
-    assert(fromType->isThrowing() != toType->isThrowing());
   }
 
 public:
@@ -1023,6 +1025,30 @@ class DropThrowsAttribute final : public ContextualMismatch {
   }
 };
 
+/// This is a contextual mismatch between the thrown error types of two
+/// function types, which could be repaired by fixing one of the types.
+class IgnoreThrownErrorMismatch final : public ContextualMismatch {
+  IgnoreThrownErrorMismatch(ConstraintSystem &cs, Type fromErrorType,
+                            Type toErrorType, ConstraintLocator *locator)
+      : ContextualMismatch(cs, FixKind::IgnoreThrownErrorMismatch,
+                           fromErrorType, toErrorType, locator) {
+    assert(!fromErrorType->isEqual(toErrorType));
+  }
+
+public:
+  std::string getName() const override { return "drop 'throws' attribute"; }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static IgnoreThrownErrorMismatch *create(ConstraintSystem &cs,
+                                           Type fromErrorType,
+                                           Type toErrorType,
+                                           ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::IgnoreThrownErrorMismatch;
+  }
+};
 /// This is a contextual mismatch between async and non-async
 /// function types, repair it by dropping `async` attribute.
 class DropAsyncAttribute final : public ContextualMismatch {

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -275,6 +275,9 @@ ABSTRACT_LOCATOR_PATH_ELT(PatternDecl)
 /// A function type global actor.
 SIMPLE_LOCATOR_PATH_ELT(GlobalActorType)
 
+/// The thrown error of a function type.
+SIMPLE_LOCATOR_PATH_ELT(ThrownErrorType)
+
 /// A type coercion operand.
 SIMPLE_LOCATOR_PATH_ELT(CoercionOperand)
 

lib/AST/TypeWalker.cpp

@@ -115,6 +115,11 @@ class Traversal : public TypeVisitor<Traversal, bool>
         return true;
     }
 
+    if (Type thrownError = ty->getThrownError()) {
+      if (doIt(thrownError))
+        return true;
+    }
+
     return doIt(ty->getResult());
   }
 

lib/Sema/CSDiagnostics.cpp

@@ -7096,6 +7096,12 @@ bool ThrowingFunctionConversionFailure::diagnoseAsError() {
   return true;
 }
 
+bool ThrownErrorTypeConversionFailure::diagnoseAsError() {
+  emitDiagnostic(diag::thrown_error_type_mismatch, getFromType(),
+                 getToType());
+  return true;
+}
+
 bool AsyncFunctionConversionFailure::diagnoseAsError() {
   auto *locator = getLocator();
 

lib/Sema/CSDiagnostics.h

@@ -933,6 +933,24 @@ class ThrowingFunctionConversionFailure final : public ContextualFailure {
   bool diagnoseAsError() override;
 };
 
+/// Diagnose failures related to conversion between the thrown error type
+/// of two function types, e.g.,
+///
+/// ```swift
+/// func foo<T>(_ t: T) throws(MyError) -> Void {}
+/// let _: (Int) throws (OtherError)-> Void = foo
+///   // `MyError` can't be implicitly converted to `OtherError`
+/// ```
+class ThrownErrorTypeConversionFailure final : public ContextualFailure {
+public:
+  ThrownErrorTypeConversionFailure(const Solution &solution, Type fromType,
+                                    Type toType, ConstraintLocator *locator)
+      : ContextualFailure(solution, fromType, toType, locator) {
+  }
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnose failures related to conversion between 'async' function type
 /// and a synchronous one e.g.
 ///

lib/Sema/CSFix.cpp

@@ -1627,6 +1627,21 @@ DropThrowsAttribute *DropThrowsAttribute::create(ConstraintSystem &cs,
       DropThrowsAttribute(cs, fromType, toType, locator);
 }
 
+bool IgnoreThrownErrorMismatch::diagnose(const Solution &solution,
+                                   bool asNote) const {
+  ThrownErrorTypeConversionFailure failure(solution, getFromType(),
+                                           getToType(), getLocator());
+  return failure.diagnose(asNote);
+}
+
+IgnoreThrownErrorMismatch *IgnoreThrownErrorMismatch::create(ConstraintSystem &cs,
+                                                 Type fromErrorType,
+                                                 Type toErrorType,
+                                                 ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      IgnoreThrownErrorMismatch(cs, fromErrorType, toErrorType, locator);
+}
+
 bool DropAsyncAttribute::diagnose(const Solution &solution,
                                    bool asNote) const {
   AsyncFunctionConversionFailure failure(solution, getFromType(),

lib/Sema/CSGen.cpp

@@ -2453,7 +2453,6 @@ namespace {
       auto resultLocator =
           CS.getConstraintLocator(closure, ConstraintLocator::ClosureResult);
 
-      // FIXME: Need a better locator.
       auto thrownErrorLocator =
         CS.getConstraintLocator(closure, ConstraintLocator::ClosureThrownError);
 

lib/Sema/CSSimplify.cpp

@@ -2945,14 +2945,99 @@ bool ConstraintSystem::hasPreconcurrencyCallee(
   return calleeOverload->choice.getDecl()->preconcurrency();
 }
 
+namespace {
+  /// Classifies a thrown error kind as Never, a specific type, or 'any Error'.
+  enum class ThrownErrorKind {
+    Never,
+    Specific,
+    AnyError,
+  };
+
+  ThrownErrorKind getThrownErrorKind(Type type) {
+    if (type->isNever())
+      return ThrownErrorKind::Never;
+
+    if (type->isExistentialType()) {
+      Type anyError = type->getASTContext().getErrorExistentialType();
+      if (anyError->isEqual(type))
+        return ThrownErrorKind::AnyError;
+    }
+
+    return ThrownErrorKind::Specific;
+  }
+}
+
 ConstraintSystem::TypeMatchResult
 ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
                                      ConstraintKind kind, TypeMatchOptions flags,
                                      ConstraintLocatorBuilder locator) {
-  // A non-throwing function can be a subtype of a throwing function.
-  if (func1->isThrowing() != func2->isThrowing()) {
-    // Cannot drop 'throws'.
-    if (func1->isThrowing() || kind < ConstraintKind::Subtype) {
+  // A function type that throws the error type E1 is a subtype of a function
+  // 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 neverType = getASTContext().getNeverType();
+  Type thrownError1 = func1->getEffectiveThrownInterfaceType().value_or(neverType);
+  Type thrownError2 = func2->getEffectiveThrownInterfaceType().value_or(neverType);
+  if (!thrownError1->isEqual(thrownError2)) {
+    auto thrownErrorKind1 = getThrownErrorKind(thrownError1);
+    auto thrownErrorKind2 = getThrownErrorKind(thrownError2);
+
+    bool mustUnify = false;
+    bool dropThrows = false;
+
+    switch (thrownErrorKind1) {
+    case ThrownErrorKind::Specific:
+      // If the specific thrown error contains no type variables and we're
+      // going to try to convert it to \c Never, treat this as dropping throws.
+      if (thrownErrorKind2 == ThrownErrorKind::Never &&
+          !thrownError1->hasTypeVariable()) {
+        dropThrows = true;
+      } else {
+        // We need to unify the thrown error types.
+        mustUnify = true;
+      }
+      break;
+
+    case ThrownErrorKind::Never:
+      switch (thrownErrorKind2) {
+      case ThrownErrorKind::Specific:
+        // We need to unify the thrown error types.
+        mustUnify = true;
+        break;
+
+      case ThrownErrorKind::Never:
+        llvm_unreachable("The thrown error types should have been equal");
+        break;
+
+      case ThrownErrorKind::AnyError:
+        // We have a subtype. If we're not allowed to do the subtype,
+        // then we need to drop "throws".
+        if (kind < ConstraintKind::Subtype)
+          dropThrows = true;
+        break;
+      }
+      break;
+
+    case ThrownErrorKind::AnyError:
+      switch (thrownErrorKind2) {
+      case ThrownErrorKind::Specific:
+        // We need to unify the thrown error types.
+        mustUnify = true;
+        break;
+
+      case ThrownErrorKind::Never:
+        // We're going to have to drop the "throws" entirely.
+        dropThrows = true;
+        break;
+
+      case ThrownErrorKind::AnyError:
+        llvm_unreachable("The thrown error types should have been equal");
+      }
+      break;
+    }
+
+    // If we know we need to drop 'throws', try it now.
+    if (dropThrows) {
       if (!shouldAttemptFixes())
         return getTypeMatchFailure(locator);
 
@@ -2961,6 +3046,20 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
       if (recordFix(fix))
         return getTypeMatchFailure(locator);
     }
+
+    // If we need to unify the thrown error types, do so now.
+    if (mustUnify) {
+      ConstraintKind subKind = (kind < ConstraintKind::Subtype)
+          ? ConstraintKind::Equal
+          : ConstraintKind::Subtype;
+      const auto subflags = getDefaultDecompositionOptions(flags);
+      auto result = matchTypes(
+          thrownError1, thrownError2,
+          subKind, subflags,
+          locator.withPathElement(LocatorPathElt::ThrownErrorType()));
+      if (result == SolutionKind::Error)
+        return getTypeMatchFailure(locator);
+    }
   }
 
   // A synchronous function can be a subtype of an 'async' function.
@@ -5152,6 +5251,13 @@ bool ConstraintSystem::repairFailures(
                                          getConstraintLocator(locator)))
     return true;
 
+  if (locator.endsWith<LocatorPathElt::ThrownErrorType>()) {
+    conversionsOrFixes.push_back(
+        IgnoreThrownErrorMismatch::create(*this, lhs, rhs,
+                                          getConstraintLocator(locator)));
+    return true;
+  }
+
   if (path.empty()) {
     if (!anchor)
       return false;
@@ -14999,6 +15105,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowAssociatedValueMismatch:
   case FixKind::GenericArgumentsMismatch:
   case FixKind::AllowConcreteTypeSpecialization:
+  case FixKind::IgnoreThrownErrorMismatch:
   case FixKind::IgnoreGenericSpecializationArityMismatch: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }

lib/Sema/ConstraintLocator.cpp

@@ -109,6 +109,7 @@ unsigned LocatorPathElt::getNewSummaryFlags() const {
   case ConstraintLocator::GlobalActorType:
   case ConstraintLocator::CoercionOperand:
   case ConstraintLocator::PackExpansionType:
+  case ConstraintLocator::ThrownErrorType:
     return 0;
 
   case ConstraintLocator::FunctionArgument:
@@ -519,6 +520,10 @@ void LocatorPathElt::dump(raw_ostream &out) const {
         << expansionElt.getOpenedType()->getString(PO) << ")";
     break;
   }
+  case ConstraintLocator::ThrownErrorType: {
+    out << "thrown error type";
+    break;
+  }
   }
 }