Use more robust Swift type names for error domains

getErrorDomainStringForObjC() now includes the parent types in the error domain string. Its implementation does not support generic types or private discriminators, but those types can’t be PrintAsObjC’d anyway, so we should never see them.

Author: beccadax

lib/AST/SwiftNameTranslation.cpp

@@ -54,9 +54,29 @@ getNameForObjC(const ValueDecl *VD, CustomNamesOnly_t customNamesOnly) {
 
 std::string swift::objc_translation::
 getErrorDomainStringForObjC(const EnumDecl *ED) {
+  // Should have already been diagnosed as diag::objc_enum_generic.
+  assert(!ED->isGenericContext() && "Trying to bridge generic enum error to Obj-C");
+
+  // Clang decls have custom domains, but we shouldn't see them here anyway.
+  assert(!ED->getClangDecl() && "clang decls shouldn't be re-exported");
+
+  SmallVector<const NominalTypeDecl *, 4> outerTypes;
+  for (const NominalTypeDecl * D = ED;
+       D != nullptr;
+       D = D->getDeclContext()->getSelfNominalTypeDecl()) {
+    // We don't currently PrintAsObjC any types whose parents are private or
+    // fileprivate.
+    assert(D->getFormalAccess() >= AccessLevel::Internal &&
+            "We don't currently append private discriminators");
+    outerTypes.push_back(D);
+  }
+
   std::string buffer = ED->getParentModule()->getNameStr();
-  buffer += ".";
-  buffer += ED->getNameStr();
+  for (auto D : reversed(outerTypes)) {
+    buffer += ".";
+    buffer += D->getNameStr();
+  }
+
   return buffer;
 }
 

test/stdlib/ErrorBridged.swift

@@ -722,6 +722,17 @@ ErrorBridgingTests.test("Error archetype identity") {
     === nsError)
 }
 
+// SR-9389
+class ParentA: NSObject {
+  @objc(ParentAError) enum Error: Int, Swift.Error {
+    case failed
+  }
+}
+class ParentB: NSObject {
+  @objc(ParentBError) enum Error: Int, Swift.Error {
+    case failed
+  }
+}
 private class NonPrintAsObjCClass: NSObject {
   @objc enum Error: Int, Swift.Error {
     case foo
@@ -731,7 +742,22 @@ private class NonPrintAsObjCClass: NSObject {
   case bar
 }
 
-ErrorBridgingTests.test("@objc enum error domains") {
+ErrorBridgingTests.test("@objc error domains for nested types") {
+  // Domain strings should correspond to Swift types, including parent types.
+  expectEqual(ParentA.Error.failed._domain, "main.ParentA.Error")
+  expectEqual(ParentB.Error.failed._domain, "main.ParentB.Error")
+
+  func makeNSError(like error: Error) -> NSError {
+    return NSError(domain: error._domain, code: error._code)
+  }
+
+  // NSErrors corresponding to Error types with the same name but nested in
+  // different enclosing types should not be castable to the wrong error type.
+  expectTrue(makeNSError(like: ParentA.Error.failed) is ParentA.Error)
+  expectFalse(makeNSError(like: ParentA.Error.failed) is ParentB.Error)
+  expectFalse(makeNSError(like: ParentB.Error.failed) is ParentA.Error)
+  expectTrue(makeNSError(like: ParentB.Error.failed) is ParentB.Error)
+
   // If an @objc enum error is not eligible for PrintAsObjC, we should treat it
   // as though it inherited the default implementation, which calls
   // String(reflecting:).