SIL: AbstractionPattern support for typed throws

Author: slavapestov

include/swift/SIL/AbstractionPattern.h

@@ -1521,6 +1521,22 @@ class AbstractionPattern {
   /// abstraction pattern for its result type.
   AbstractionPattern getFunctionResultType() const;
 
+  /// Given that the value being abstracted is a function, return the
+  /// abstraction pattern for its thrown error type.
+  llvm::Optional<AbstractionPattern> getFunctionThrownErrorType() const;
+
+  /// Utility method to adjust a thrown error pattern and thrown error type
+  /// to account for some quirks in type lowering.
+  ///
+  /// When lowered with an opaque pattern,
+  ///
+  /// - () -> () becomes () -> (),
+  /// - () throws(any Error) -> () becomes () -> (@error any Error),
+  ///
+  /// *not* () -> (@error_indirect Never) or () -> (@error_indirect any Error).
+  llvm::Optional<std::pair<AbstractionPattern, CanType>>
+  getFunctionThrownErrorType(CanAnyFunctionType substFnInterfaceType) const;
+
   /// Given that the value being abstracted is a function type, return
   /// the abstraction pattern for one of its parameter types.
   AbstractionPattern getFunctionParamType(unsigned index) const;
@@ -1611,15 +1627,19 @@ class AbstractionPattern {
   /// Given that this is a pack expansion, do the pack elements need to be
   /// passed indirectly?
   bool arePackElementsPassedIndirectly(TypeConverter &TC) const;
-  
+
   /// If this abstraction pattern appears in function return position, how is
   /// the corresponding value returned?
   CallingConventionKind getResultConvention(TypeConverter &TC) const;
-  
+
   /// If this abstraction pattern appears in function parameter position, how
   /// is the corresponding value passed?
   CallingConventionKind getParameterConvention(TypeConverter &TC) const;
-  
+
+  /// If this abstraction pattern appears in function thrown error position, how
+  /// is the corresponding value passed?
+  CallingConventionKind getErrorConvention(TypeConverter &TC) const;
+
   /// Generate the abstraction pattern for lowering the substituted SIL
   /// function type for a function type matching this abstraction pattern.
   ///

include/swift/SIL/SILFunctionConventions.h

@@ -78,6 +78,8 @@ class SILModuleConventions {
 public:
   static bool isPassedIndirectlyInSIL(SILType type, SILModule &M);
 
+  static bool isThrownIndirectlyInSIL(SILType type, SILModule &M);
+
   static bool isReturnedIndirectlyInSIL(SILType type, SILModule &M);
 
   static SILModuleConventions getLoweredAddressConventions(SILModule &M) {

include/swift/SIL/SILType.h

@@ -340,6 +340,13 @@ class SILType {
     return isAddressOnly(type, tc, sig, TypeExpansionContext::minimal());
   }
 
+  /// Return true if this type must be thrown indirectly.
+  static bool isFormallyThrownIndirectly(CanType type,
+                                         Lowering::TypeConverter &tc,
+                                         CanGenericSignature sig) {
+    return isAddressOnly(type, tc, sig, TypeExpansionContext::minimal());
+  }
+
   /// True if the type, or the referenced type of an address type, is loadable.
   /// This is the opposite of isAddressOnly.
   bool isLoadable(const SILFunction &F) const {

lib/SIL/IR/AbstractionPattern.cpp

@@ -1214,6 +1214,78 @@ AbstractionPattern AbstractionPattern::getFunctionResultType() const {
   llvm_unreachable("bad kind");
 }
 
+llvm::Optional<AbstractionPattern>
+AbstractionPattern::getFunctionThrownErrorType() const {
+  switch (getKind()) {
+  case Kind::Invalid:
+    llvm_unreachable("querying invalid abstraction pattern!");
+  case Kind::ObjCCompletionHandlerArgumentsType:
+  case Kind::Tuple:
+    llvm_unreachable("abstraction pattern for tuple cannot be function");
+  case Kind::Opaque:
+    return *this;
+  case Kind::Type: {
+    if (isTypeParameterOrOpaqueArchetype())
+      return getOpaque();
+
+    if (auto errorType = cast<AnyFunctionType>(getType())->getEffectiveThrownErrorType()) {
+      return AbstractionPattern(getGenericSubstitutions(),
+                                getGenericSignatureForFunctionComponent(),
+                                (*errorType)->getCanonicalType());
+    }
+
+    return llvm::None;
+  }
+  case Kind::Discard:
+    llvm_unreachable("don't need to discard function abstractions yet");
+  case Kind::ClangType:
+  case Kind::CFunctionAsMethodType:
+  case Kind::PartialCurriedCFunctionAsMethodType:
+  case Kind::CXXMethodType:
+  case Kind::PartialCurriedCXXMethodType:
+  case Kind::CurriedObjCMethodType:
+  case Kind::CurriedCFunctionAsMethodType:
+  case Kind::CurriedCXXMethodType:
+  case Kind::PartialCurriedObjCMethodType:
+  case Kind::ObjCMethodType:
+    llvm_unreachable("implement me");
+  case Kind::OpaqueFunction:
+  case Kind::OpaqueDerivativeFunction:
+    return llvm::None;
+  }
+  llvm_unreachable("bad kind");
+}
+
+llvm::Optional<std::pair<AbstractionPattern, CanType>>
+AbstractionPattern::getFunctionThrownErrorType(
+    CanAnyFunctionType substFnInterfaceType) const {
+  auto optOrigErrorType = getFunctionThrownErrorType();
+  if (!optOrigErrorType)
+    return llvm::None;
+
+  auto &ctx = substFnInterfaceType->getASTContext();
+  auto optErrorType = substFnInterfaceType->getEffectiveThrownErrorType();
+
+  if (isTypeParameterOrOpaqueArchetype()) {
+    if (!optErrorType)
+      return llvm::None;
+
+    if (!(*optErrorType)->isEqual(ctx.getErrorExistentialType())) {
+      llvm::errs() << "unsupported reabstraction\n";
+      abort();
+    }
+
+    return std::make_pair(AbstractionPattern(*optErrorType),
+                          (*optErrorType)->getCanonicalType());
+  }
+
+  if (!optErrorType)
+    optErrorType = ctx.getErrorExistentialType();
+
+  return std::make_pair(*optOrigErrorType,
+                        (*optErrorType)->getCanonicalType());
+}
+
 AbstractionPattern
 AbstractionPattern::getObjCMethodAsyncCompletionHandlerType(
                                      CanType swiftCompletionHandlerType) const {
@@ -1939,7 +2011,7 @@ AbstractionPattern::getParameterConvention(TypeConverter &TC) const {
   case Kind::Opaque:
     // Maximally abstracted values are always passed indirectly.
     return Indirect;
-  
+
   case Kind::OpaqueFunction:
   case Kind::OpaqueDerivativeFunction:
   case Kind::PartialCurriedObjCMethodType:
@@ -1953,16 +2025,57 @@ AbstractionPattern::getParameterConvention(TypeConverter &TC) const {
   case Kind::PartialCurriedCXXMethodType:
     // Function types are always passed directly
     return Direct;
-      
+
   case Kind::ClangType:
   case Kind::Type:
   case Kind::Discard:
     // Pass according to the formal type.
     return SILType::isFormallyPassedIndirectly(getType(),
-                                                 TC,
-                                                 getGenericSignatureOrNull())
+                                               TC,
+                                               getGenericSignatureOrNull())
       ? Indirect : Direct;
-  
+
+  case Kind::Invalid:
+  case Kind::Tuple:
+  case Kind::ObjCCompletionHandlerArgumentsType:
+    llvm_unreachable("should not get here");
+  }
+}
+
+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::OpaqueFunction:
+  case Kind::OpaqueDerivativeFunction:
+  case Kind::PartialCurriedObjCMethodType:
+  case Kind::CurriedObjCMethodType:
+  case Kind::PartialCurriedCFunctionAsMethodType:
+  case Kind::CurriedCFunctionAsMethodType:
+  case Kind::CFunctionAsMethodType:
+  case Kind::ObjCMethodType:
+  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:
@@ -2562,7 +2675,7 @@ const {
   auto substTy = visitor.handleUnabstractedFunctionType(substType, *this,
                                                         substYieldType,
                                                         origYieldType);
-  
+
   auto substSig = buildGenericSignature(TC.Context, GenericSignature(),
                                         std::move(visitor.substGenericParams),
                                         std::move(visitor.substRequirements))

lib/SIL/IR/SILType.cpp

@@ -713,6 +713,15 @@ bool SILModuleConventions::isPassedIndirectlyInSIL(SILType type, SILModule &M) {
   return false;
 }
 
+bool SILModuleConventions::isThrownIndirectlyInSIL(SILType type, SILModule &M) {
+  if (SILModuleConventions(M).loweredAddresses) {
+    return M.Types.getTypeLowering(type, TypeExpansionContext::minimal())
+        .isAddressOnly();
+  }
+
+  return false;
+}
+
 bool SILFunctionType::isNoReturnFunction(SILModule &M,
                                          TypeExpansionContext context) const {
   for (unsigned i = 0, e = getNumResults(); i < e; ++i) {