[Typed throws] Refactor thrown error subtyping check for reuse.

Lift the subtyping check for thrown error types out of the constraint
solver, so we can re-use it elsewhere.

There is a minor diagnostic change, from one that is actively
misleading (it shows a legitimate conversion that's wrong) to one that
is correct, which comes from us not treating "dropping throws" as a
legitimate way to handle equality of function types.

Author: DougGregor

lib/Sema/CSSimplify.cpp

@@ -17,6 +17,7 @@
 
 #include "CSDiagnostics.h"
 #include "TypeCheckConcurrency.h"
+#include "TypeCheckEffects.h"
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/ExistentialLayout.h"
@@ -2945,28 +2946,6 @@ 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;
-  }
-}
-
 /// Match the throwing specifier of the two function types.
 static ConstraintSystem::TypeMatchResult
 matchFunctionThrowing(ConstraintSystem &cs,
@@ -2978,82 +2957,45 @@ 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 neverType = cs.getASTContext().getNeverType();
-  Type thrownError1 = func1->getEffectiveThrownInterfaceType().value_or(neverType);
-  Type thrownError2 = func2->getEffectiveThrownInterfaceType().value_or(neverType);
-  if (!thrownError1 || !thrownError2 || thrownError1->isEqual(thrownError2))
+  Type thrownError1 = getEffectiveThrownErrorTypeOrNever(func1);
+  Type thrownError2 = getEffectiveThrownErrorTypeOrNever(func2);
+  if (!thrownError1 || !thrownError2)
     return cs.getTypeMatchSuccess();
 
-  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) {
+  switch (compareThrownErrorsForSubtyping(thrownError1, thrownError2, cs.DC)) {
+  case ThrownErrorSubtyping::DropsThrows: {
+    // We need to drop 'throws' to make this work.
     if (!cs.shouldAttemptFixes())
       return cs.getTypeMatchFailure(locator);
 
     auto *fix = DropThrowsAttribute::create(cs, func1, func2,
                                             cs.getConstraintLocator(locator));
     if (cs.recordFix(fix))
       return cs.getTypeMatchFailure(locator);
+
+    return cs.getTypeMatchSuccess();
   }
 
-  // If we need to unify the thrown error types, do so now.
-  if (mustUnify) {
+  case ThrownErrorSubtyping::ExactMatch:
+    return cs.getTypeMatchSuccess();
+
+  case ThrownErrorSubtyping::Subtype:
+    // We know this is going to work, but we might still need to generate a
+    // constraint if one of the error types involves type variables.
+    if (thrownError1->hasTypeVariable() || thrownError2->hasTypeVariable()) {
+      // Fall through to the dependent case.
+    } else if (kind < ConstraintKind::Subtype) {
+      // We aren't allowed to have a subtype, so fail here.
+      return cs.getTypeMatchFailure(locator);
+    } else {
+      // We have a subtype. All set!
+      return cs.getTypeMatchSuccess();
+    }
+    LLVM_FALLTHROUGH;
+
+  case ThrownErrorSubtyping::Dependent: {
+    // The presence of type variables in the thrown error types require that
+    // we generate a constraint to unify the thrown error types, so do so now.
     ConstraintKind subKind = (kind < ConstraintKind::Subtype)
         ? ConstraintKind::Equal
         : ConstraintKind::Subtype;
@@ -3064,9 +3006,24 @@ matchFunctionThrowing(ConstraintSystem &cs,
         locator.withPathElement(LocatorPathElt::ThrownErrorType()));
     if (result == ConstraintSystem::SolutionKind::Error)
       return cs.getTypeMatchFailure(locator);
+
+    return cs.getTypeMatchSuccess();
   }
 
-  return cs.getTypeMatchSuccess();
+  case ThrownErrorSubtyping::Mismatch: {
+    auto thrownErrorLocator = cs.getConstraintLocator(
+        locator.withPathElement(LocatorPathElt::ThrownErrorType()));
+    if (!cs.shouldAttemptFixes())
+      return cs.getTypeMatchFailure(thrownErrorLocator);
+
+    auto *fix = IgnoreThrownErrorMismatch::create(
+        cs, thrownError1, thrownError2, thrownErrorLocator);
+    if (cs.recordFix(fix))
+      return cs.getTypeMatchFailure(thrownErrorLocator);
+
+    return cs.getTypeMatchSuccess();
+  }
+  }
 }
 
 ConstraintSystem::TypeMatchResult

lib/Sema/TypeCheckEffects.cpp

@@ -17,6 +17,7 @@
 
 #include "TypeChecker.h"
 #include "TypeCheckConcurrency.h"
+#include "TypeCheckEffects.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/Effects.h"
@@ -3303,3 +3304,129 @@ Type TypeChecker::errorUnion(Type type1, Type type2) {
   // actual union type here.
   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'.
+enum class ThrownErrorClassification {
+  /// The `Never` type, which represents a non-throwing function.
+  Never,
+
+  /// A specific error type that is neither `Never` nor `any Error`.
+  Specific,
+
+  /// A specific error type that depends on a type variable or type parameter,
+  /// and therefore we cannot determine whether it is a subtype of another
+  /// type or not.
+  Dependent,
+
+  /// The type `any Error`, used for untyped throws.
+  AnyError,
+};
+
+}
+
+/// Classify the given thrown error type.
+static ThrownErrorClassification classifyThrownErrorType(Type type) {
+  if (type->isNever())
+    return ThrownErrorClassification::Never;
+
+  if (type->isExistentialType()) {
+    Type anyError = type->getASTContext().getErrorExistentialType();
+    if (anyError->isEqual(type))
+      return ThrownErrorClassification::AnyError;
+  }
+
+  if (type->hasTypeVariable() || type->hasTypeParameter())
+    return ThrownErrorClassification::Dependent;
+
+  return ThrownErrorClassification::Specific;
+}
+
+ThrownErrorSubtyping
+swift::compareThrownErrorsForSubtyping(
+    Type subThrownError, Type superThrownError, DeclContext *dc
+) {
+  // Easy case: exact match.
+  if (superThrownError->isEqual(subThrownError))
+    return ThrownErrorSubtyping::ExactMatch;
+
+  auto superThrownErrorKind = classifyThrownErrorType(superThrownError);
+  auto subThrownErrorKind = classifyThrownErrorType(subThrownError);
+
+  switch (subThrownErrorKind) {
+  case ThrownErrorClassification::Dependent:
+    switch (superThrownErrorKind) {
+    case ThrownErrorClassification::AnyError:
+      // This is a clear subtype relationship, because the supertype throws
+      // anything.
+      return ThrownErrorSubtyping::Subtype;
+
+    case ThrownErrorClassification::Never:
+    case ThrownErrorClassification::Dependent:
+    case ThrownErrorClassification::Specific:
+      // We have to compare the types. Do so below.
+      break;
+    }
+    break;
+
+  case ThrownErrorClassification::Specific:
+    switch (superThrownErrorKind) {
+    case ThrownErrorClassification::AnyError:
+      // This is a clear subtype relationship, because the supertype throws
+      // anything.
+      return ThrownErrorSubtyping::Subtype;
+
+    case ThrownErrorClassification::Never:
+      // The supertype doesn't throw, so this has to drop 'throws' to work.
+      return ThrownErrorSubtyping::DropsThrows;
+
+    case ThrownErrorClassification::Dependent:
+    case ThrownErrorClassification::Specific:
+      // We have to compare the types. Do so below.
+      break;
+    }
+    break;
+
+  case ThrownErrorClassification::Never:
+    // A function type throwing 'Never' is a subtype of all function types.
+    return ThrownErrorSubtyping::Subtype;
+
+  case ThrownErrorClassification::AnyError:
+    switch (superThrownErrorKind) {
+    case ThrownErrorClassification::Dependent:
+    case ThrownErrorClassification::Specific:
+      // We have to compare the types. Do so below.
+      break;
+
+    case ThrownErrorClassification::Never:
+      // We're going to have to drop the "throws" entirely.
+      return ThrownErrorSubtyping::DropsThrows;
+
+    case ThrownErrorClassification::AnyError:
+      llvm_unreachable("The thrown error types should have been equal");
+    }
+    break;
+  }
+
+  // If either of the types was dependent on a type variable or type parameter,
+  // we can't do the comparison at all.
+  if (superThrownErrorKind == ThrownErrorClassification::Dependent ||
+      subThrownErrorKind == ThrownErrorClassification::Dependent)
+    return ThrownErrorSubtyping::Dependent;
+
+  // Check whether the subtype's thrown error type is convertible to the
+  // supertype's thrown error type.
+  if (TypeChecker::isConvertibleTo(subThrownError, superThrownError, dc))
+    return ThrownErrorSubtyping::Subtype;
+
+  // We know it doesn't work.
+  return ThrownErrorSubtyping::Mismatch;
+}

lib/Sema/TypeCheckEffects.h

@@ -0,0 +1,55 @@
+//===--- TypeCheckEffects.h - Effects checking ------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides type checking support for Swift's effect checking, which
+// includes error handling (throws) and asynchronous (async) effects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SEMA_TYPECHECKEFFECTS_H
+#define SWIFT_SEMA_TYPECHECKEFFECTS_H
+
+#include "swift/AST/Type.h"
+
+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 {
+  /// There is no subtyping relationship, and we're trying to convert from a
+  /// throwning type to a non-throwing type.
+  DropsThrows,
+  /// There is no subtyping relationship because the types mismatch.
+  Mismatch,
+  /// The thrown error types exactly match; there is a subtype relationship.
+  ExactMatch,
+  /// The thrown error types are different, but there is an obvious subtype
+  /// relationship.
+  Subtype,
+  /// The thrown error types are different, and the presence of type variables
+  /// or type parameters prevents us from determining now whether there is a
+  /// subtype relationship.
+  Dependent,
+};
+
+/// Compare the thrown error types for the purposes of subtyping.
+ThrownErrorSubtyping compareThrownErrorsForSubtyping(
+    Type subThrownError, Type superThrownError, DeclContext *dc);
+
+}
+
+#endif // SWIFT_SEMA_TYPECHECKEFFECTS_H

lib/Sema/TypeCheckProtocol.cpp

@@ -832,6 +832,8 @@ RequirementMatch swift::matchWitness(
       }
 
       // 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);

test/decl/func/throwing_functions.swift

@@ -70,13 +70,14 @@ func fooT(_ callback: () -> Bool) {}
 
 // Throwing and non-throwing types are not equivalent.
 struct X<T> { }
+// expected-note@-1{{arguments to generic parameter 'T' ('(String) -> Int' and '(String) throws -> Int') are expected to be equal}}
 
 func specializedOnFuncType1(_ x: X<(String) throws -> Int>) { }
 func specializedOnFuncType2(_ x: X<(String) -> Int>) { }
 func testSpecializedOnFuncType(_ xThrows: X<(String) throws -> Int>,
                                xNonThrows: X<(String) -> Int>) {
   specializedOnFuncType1(xThrows) // ok
-  specializedOnFuncType1(xNonThrows) // expected-error{{invalid conversion from throwing function of type '(String) -> Int' to non-throwing function type '(String) throws -> Int'}}
+  specializedOnFuncType1(xNonThrows) // expected-error{{cannot convert value of type 'X<(String) -> Int>' to expected argument type 'X<(String) throws -> Int>'}}
   specializedOnFuncType2(xThrows)  // expected-error{{invalid conversion from throwing function of type '(String) throws -> Int' to non-throwing function type '(String) -> Int'}}
   specializedOnFuncType2(xNonThrows) // ok
 }