Merge pull request #69474 from slavapestov/typed-throws-wip-2

A couple more typed throws fixes

Author: slavapestov

include/swift/AST/TypeMatcher.h

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

lib/AST/RequirementMachine/TypeDifference.cpp

@@ -348,13 +348,13 @@ swift::rewriting::buildTypeDifference(
   auto resultSymbol = [&]() {
     switch (symbol.getKind()) {
     case Symbol::Kind::Superclass:
-      return Symbol::forSuperclass(CanType(resultType),
+      return Symbol::forSuperclass(resultType->getCanonicalType(),
                                    resultSubstitutions, ctx);
     case Symbol::Kind::ConcreteType:
-      return Symbol::forConcreteType(CanType(resultType),
+      return Symbol::forConcreteType(resultType->getCanonicalType(),
                                      resultSubstitutions, ctx);
     case Symbol::Kind::ConcreteConformance:
-      return Symbol::forConcreteConformance(CanType(resultType),
+      return Symbol::forConcreteConformance(resultType->getCanonicalType(),
                                             resultSubstitutions,
                                             symbol.getProtocol(),
                                             ctx);

lib/SIL/IR/AbstractionPattern.cpp

@@ -2044,15 +2044,21 @@ AbstractionPattern::getParameterConvention(TypeConverter &TC) const {
 
 AbstractionPattern::CallingConventionKind
 AbstractionPattern::getErrorConvention(TypeConverter &TC) const {
-  // Tuples should be destructured.
-  if (isTuple()) {
-    return Destructured;
-  }
   switch (getKind()) {
   case Kind::Opaque:
     // Maximally abstracted values are always thrown indirectly.
     return Indirect;
 
+  case Kind::ClangType:
+  case Kind::Type:
+  case Kind::Discard:
+    // Pass according to the formal type.
+    return SILType::isFormallyThrownIndirectly(getType(),
+                                               TC,
+                                               getGenericSignatureOrNull())
+      ? Indirect : Direct;
+
+  case Kind::Tuple:
   case Kind::OpaqueFunction:
   case Kind::OpaqueDerivativeFunction:
   case Kind::PartialCurriedObjCMethodType:
@@ -2064,20 +2070,7 @@ AbstractionPattern::getErrorConvention(TypeConverter &TC) const {
   case Kind::CXXMethodType:
   case Kind::CurriedCXXMethodType:
   case Kind::PartialCurriedCXXMethodType:
-    // Function types are always thrown directly
-    return Direct;
-
-  case Kind::ClangType:
-  case Kind::Type:
-  case Kind::Discard:
-    // Pass according to the formal type.
-    return SILType::isFormallyThrownIndirectly(getType(),
-                                               TC,
-                                               getGenericSignatureOrNull())
-      ? Indirect : Direct;
-
   case Kind::Invalid:
-  case Kind::Tuple:
   case Kind::ObjCCompletionHandlerArgumentsType:
     llvm_unreachable("should not get here");
   }

lib/Sema/TypeCheckProtocolInference.cpp

@@ -752,10 +752,6 @@ 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/Generics/typed_throws.swift

@@ -0,0 +1,26 @@
+// RUN: %target-typecheck-verify-swift -debug-generic-signatures -enable-experimental-feature TypedThrows 2>&1 | %FileCheck %s
+
+protocol P1 {
+  associatedtype A
+}
+
+// CHECK-LABEL: typed_throws.(file).f1@
+// CHECK-NEXT: Generic signature: <T where T : P1, T.[P1]A == Never>
+func f1<T: P1>(_: T) where () throws(T.A) -> () == () -> () {}
+
+// CHECK-LABEL: typed_throws.(file).f2@
+// CHECK-NEXT: Generic signature: <T where T : P1, T.[P1]A == any Error>
+func f2<T: P1>(_: T) where () throws(T.A) -> () == () throws -> () {}
+
+protocol P2 {
+  associatedtype A where A == () throws(E) -> ()
+  associatedtype E
+}
+
+// CHECK-LABEL: typed_throws.(file).f3@
+// CHECK-NEXT: Generic signature: <T where T : P2, T.[P2]E == Never>
+func f3<T: P2>(_: T) where T.A == () -> () {}
+
+// CHECK-LABEL: typed_throws.(file).f4@
+// CHECK-NEXT: Generic signature: <T where T : P2, T.[P2]E == any Error>
+func f4<T: P2>(_: T) where T.A == () throws -> () {}