Merge pull request #69497 from DougGregor/runtime-normalize-thrown-error

Author: DougGregor

stdlib/public/runtime/Metadata.cpp

@@ -1565,6 +1565,39 @@ swift::swift_getFunctionTypeMetadataGlobalActor(
   return &FunctionTypes.getOrInsert(key).first->Data;
 }
 
+extern "C" const EnumDescriptor NOMINAL_TYPE_DESCR_SYM(s5NeverO);
+extern "C" const ProtocolDescriptor PROTOCOL_DESCR_SYM(s5Error);
+
+namespace {
+  /// Classification for a given thrown error type.
+  enum class ThrownErrorClassification {
+    /// An arbitrary thrown error.
+    Arbitrary,
+    /// 'Never', which means a function type is non-throwing.
+    Never,
+    /// 'any Error', which means the function type uses untyped throws.
+    AnyError,
+  };
+
+  /// Classify a thrown error type.
+  ThrownErrorClassification classifyThrownError(const Metadata *type) {
+    if (auto enumMetadata = dyn_cast<EnumMetadata>(type)) {
+      if (enumMetadata->getDescription() == &NOMINAL_TYPE_DESCR_SYM(s5NeverO))
+        return ThrownErrorClassification::Never;
+    } else if (auto existential = dyn_cast<ExistentialTypeMetadata>(type)) {
+      auto protocols = existential->getProtocols();
+      if (protocols.size() == 1 &&
+          !protocols[0].isObjC() &&
+          protocols[0].getSwiftProtocol() == &PROTOCOL_DESCR_SYM(s5Error) &&
+          !existential->isClassBounded() &&
+          !existential->isObjC())
+        return ThrownErrorClassification::AnyError;
+    }
+
+    return ThrownErrorClassification::Arbitrary;
+  }
+}
+
 const FunctionTypeMetadata *
 swift::swift_getExtendedFunctionTypeMetadata(
     FunctionTypeFlags flags, FunctionMetadataDifferentiabilityKind diffKind,
@@ -1573,6 +1606,31 @@ swift::swift_getExtendedFunctionTypeMetadata(
     ExtendedFunctionTypeFlags extFlags, const Metadata *thrownError) {
   assert(flags.hasExtendedFlags() || extFlags.getIntValue() == 0);
   assert(flags.hasExtendedFlags() || thrownError == nullptr);
+
+  if (thrownError) {
+    // Perform adjustments based on the given thrown error.
+    switch (classifyThrownError(thrownError)){
+    case ThrownErrorClassification::Arbitrary:
+      // Nothing to do.
+      break;
+
+    case ThrownErrorClassification::Never:
+      // The thrown error was 'Never', so make this a non-throwing function
+      flags = flags.withThrows(false);
+
+      // Fall through to clear out the error.
+      SWIFT_FALLTHROUGH;
+
+    case ThrownErrorClassification::AnyError:
+      // Clear out the thrown error and extended flags.
+      thrownError = nullptr;
+      extFlags = extFlags.withTypedThrows(false);
+      if (extFlags.getIntValue() == 0)
+        flags = flags.withExtendedFlags(false);
+      break;
+    }
+  }
+
   FunctionCacheEntry::Key key = {
     flags, diffKind, parameters,
     reinterpret_cast<const ParameterFlags *>(parameterFlags), result,

test/IRGen/typed_throws.sil

@@ -406,12 +406,12 @@ entry(%0: $*T):
 // CHECK: define{{.*}} swiftcc void @apply_closure_generic(ptr %0, ptr %1, ptr %T, ptr %V)
 // CHECK:  [[T0:%.*]] = getelementptr inbounds ptr, ptr %T
 // CHECK:  [[T1:%.*]] = load ptr, ptr [[T0]]
-// CHECK:  [[T2:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[T1]]
+// CHECK:  [[T2:%.*]] = getelementptr inbounds %swift.vwtable{{.*}}
 // CHECK:  [[T3:%.*]] = load i64, ptr [[T2]]
 // CHECK:  [[T4:%.*]] = alloca i8, i64 [[T3]]
 // CHECK:  [[V0:%.*]] = getelementptr inbounds ptr, ptr %V
 // CHECK:  [[V1:%.*]] = load ptr, ptr [[V0]]
-// CHECK:  [[V2:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[V1]]
+// CHECK:  [[V2:%.*]] = getelementptr inbounds %swift.vwtable{{.*}}
 // CHECK:  [[V3:%.*]] = load i64, ptr [[V2]]
 // CHECK:  [[V4:%.*]] = alloca i8, i64 [[V3]]
 // CHECK: call swiftcc void %0(ptr noalias sret(%swift.opaque) [[T4]], ptr swiftself %1, ptr noalias nocapture swifterror dereferenceable(8) %swifterror, ptr [[V4]])

test/Runtime/demangleToMetadata.swift

@@ -526,12 +526,26 @@ enum MyBigError: Error {
   case epicFail
 }
 
+@available(SwiftStdlib 5.11, *)
+func getFnTypeWithThrownError<E: Error>(_: E.Type) -> Any.Type {
+  typealias Fn = (Int) throws(E) -> Void
+  return Fn.self
+}
+
 if #available(SwiftStdlib 5.11, *) {
   DemangleToMetadataTests.test("typed throws") {
     typealias Fn = (Int) throws(MyBigError) -> Void
     expectEqual("ySi4main10MyBigErrorOYKc", _mangledTypeName(Fn.self)!)
-    print("Looking up the typed throws... \(_typeByName("ySi4main10MyBigErrorOYKc"))")
     expectEqual(Fn.self, _typeByName("ySi4main10MyBigErrorOYKc")!)
+
+
+    expectEqual(getFnTypeWithThrownError(MyBigError.self), _typeByName("ySi4main10MyBigErrorOYKc")!)
+
+    // throws(any Error) -> throws
+    expectEqual(getFnTypeWithThrownError((any Error).self), _typeByName("ySiKc")!)
+
+    // throws(Never) -> non-throwing
+    expectEqual(getFnTypeWithThrownError(Never.self), _typeByName("ySic")!)
   }
 }
 

unittests/runtime/Stdlib.cpp

@@ -520,3 +520,11 @@ const long long $ss7KeyPathCMo[1] = {0};
 
 SWIFT_RUNTIME_STDLIB_INTERNAL
 const long long $ss12__SwiftValueCMn[1] = {0};
+
+// Never and Error
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+const long long $ss5NeverOMn[1] = {0};
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+const long long $ss5ErrorMp[1] = {0};