Make NS_TYPED_ENUMS ObjectiveCBridgeable when they wrap an object (#15270)

This allows them to be used in generic arguments for NSArray et al.
We already do this for the ones that wrap bridged values (like
NSString/String), but failed to do it for objects that /weren't/
bridged to Swift values (class instances and protocol compositions),
or for Error-which-is-special.

In addition to this being a sensible thing to do, /not/ doing this led
to IRGen getting very confused (i.e. crashing) when we imported a
Objective-C protocol that actually used an NS_TYPED_ENUM in this way.

(We actually shouldn't be using Swift's IRGen logic to emit protocol
descriptors for imported protocols at all, because it's possible we
weren't able to import all the requirements. But that's a separate
issue.)

https://bugs.swift.org/browse/SR-6844

Author: jrose-apple

lib/ClangImporter/ImportDecl.cpp

@@ -5358,8 +5358,37 @@ SwiftDeclConverter::importSwiftNewtype(const clang::TypedefNameDecl *decl,
   // implementation in the standard library.
   transferKnown(KnownProtocolKind::Equatable);
   transferKnown(KnownProtocolKind::Hashable);
-  bool transferredObjCBridgeable =
-    transferKnown(KnownProtocolKind::ObjectiveCBridgeable);
+  bool hasObjCBridgeable =
+      transferKnown(KnownProtocolKind::ObjectiveCBridgeable);
+  bool wantsObjCBridgeableTypealias = hasObjCBridgeable && isBridged;
+
+  // Wrappers around ObjC classes and protocols are also bridgeable.
+  if (!hasObjCBridgeable) {
+    if (isBridged) {
+      if (auto *proto = dyn_cast_or_null<ProtocolDecl>(computedNominal))
+        if (proto->getKnownProtocolKind() == KnownProtocolKind::Error)
+          hasObjCBridgeable = true;
+    } else {
+      if (auto *objcClass = dyn_cast_or_null<ClassDecl>(computedNominal)) {
+        switch (objcClass->getForeignClassKind()) {
+        case ClassDecl::ForeignKind::Normal:
+        case ClassDecl::ForeignKind::RuntimeOnly:
+          if (objcClass->hasClangNode())
+            hasObjCBridgeable = true;
+          break;
+        case ClassDecl::ForeignKind::CFType:
+          break;
+        }
+      } else if (storedUnderlyingType->isObjCExistentialType()) {
+        hasObjCBridgeable = true;
+      }
+    }
+
+    if (hasObjCBridgeable) {
+      addKnown(KnownProtocolKind::ObjectiveCBridgeable);
+      wantsObjCBridgeableTypealias = true;
+    }
+  }
 
   if (!isBridged) {
     // Simple, our stored type is equivalent to our computed
@@ -5377,10 +5406,11 @@ SwiftDeclConverter::importSwiftNewtype(const clang::TypedefNameDecl *decl,
                                   computedPropertyUnderlyingType,
                                   synthesizedProtocols,
                                   /*makeUnlabeledValueInit=*/unlabeledCtor);
+  }
 
-    if (transferredObjCBridgeable)
-      addSynthesizedTypealias(structDecl, ctx.Id_ObjectiveCType,
-                              storedUnderlyingType);
+  if (wantsObjCBridgeableTypealias) {
+    addSynthesizedTypealias(structDecl, ctx.Id_ObjectiveCType,
+                            storedUnderlyingType);
   }
 
   Impl.ImportedDecls[{decl->getCanonicalDecl(), getVersion()}] = structDecl;

stdlib/public/SDK/Foundation/NSError.swift

@@ -526,6 +526,38 @@ extension _BridgedStoredNSError {
   }
 }
 
+extension _SwiftNewtypeWrapper where Self.RawValue == Error {
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _bridgeToObjectiveC() -> NSError {
+    return rawValue as NSError
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _forceBridgeFromObjectiveC(
+    _ source: NSError,
+    result: inout Self?
+  ) {
+    result = Self(rawValue: source)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _conditionallyBridgeFromObjectiveC(
+    _ source: NSError,
+    result: inout Self?
+  ) -> Bool {
+    result = Self(rawValue: source)
+    return result != nil
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _unconditionallyBridgeFromObjectiveC(
+    _ source: NSError?
+  ) -> Self {
+    return Self(rawValue: _convertNSErrorToError(source))!
+  }
+}
+
+
 @available(*, unavailable, renamed: "CocoaError")
 public typealias NSCocoaError = CocoaError
 
@@ -3219,6 +3251,7 @@ extension MachError {
 }
 
 public struct ErrorUserInfoKey : RawRepresentable, _SwiftNewtypeWrapper, Equatable, Hashable, _ObjectiveCBridgeable {
+  public typealias _ObjectiveCType = NSString
   public init(rawValue: String) { self.rawValue = rawValue }
   public var rawValue: String
 }

stdlib/public/core/NewtypeWrapper.swift

@@ -24,6 +24,9 @@ extension _SwiftNewtypeWrapper where Self.RawValue : Hashable {
 
 #if _runtime(_ObjC)
 extension _SwiftNewtypeWrapper where Self.RawValue : _ObjectiveCBridgeable {
+  // Note: This is the only default typealias for _ObjectiveCType, because
+  // constrained extensions aren't allowed to define types in different ways.
+  // Fortunately the others don't need it.
   public typealias _ObjectiveCType = Self.RawValue._ObjectiveCType
 
   @_inlineable // FIXME(sil-serialize-all)
@@ -61,5 +64,36 @@ extension _SwiftNewtypeWrapper where Self.RawValue : _ObjectiveCBridgeable {
       rawValue: Self.RawValue._unconditionallyBridgeFromObjectiveC(source))!
   }
 }
+
+extension _SwiftNewtypeWrapper where Self.RawValue: AnyObject {
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _bridgeToObjectiveC() -> Self.RawValue {
+    return rawValue
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _forceBridgeFromObjectiveC(
+    _ source: Self.RawValue,
+    result: inout Self?
+  ) {
+    result = Self(rawValue: source)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _conditionallyBridgeFromObjectiveC(
+    _ source: Self.RawValue,
+    result: inout Self?
+  ) -> Bool {
+    result = Self(rawValue: source)
+    return result != nil
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _unconditionallyBridgeFromObjectiveC(
+    _ source: Self.RawValue?
+  ) -> Self {
+    return Self(rawValue: source!)!
+  }
+}
 #endif
 

test/ClangImporter/Inputs/custom-modules/Newtype.h

@@ -102,3 +102,8 @@ __attribute((swift_name("NSSomeContext.Name")));
 
 extern const NSSomeContextName NSMyContextName;
 
+
+typedef NSError *ErrorNewType __attribute((swift_newtype(struct)));
+
+void testErrorDictionary(NSDictionary<NSError *, NSString *> * _Nonnull);
+void testErrorDictionaryNewtype(NSDictionary<ErrorNewType, NSString *> * _Nonnull);

test/ClangImporter/objc_parse.swift

@@ -651,6 +651,10 @@ class NewtypeUser {
   @objc func stringNewtypeOptional(a: SNTErrorDomain?) {} // expected-error {{'SNTErrorDomain' has been renamed to 'ErrorDomain'}}{{39-53=ErrorDomain}}
   @objc func intNewtype(a: MyInt) {}
   @objc func intNewtypeOptional(a: MyInt?) {} // expected-error {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
+  @objc func intNewtypeArray(a: [MyInt]) {} // expected-error {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
+  @objc func intNewtypeDictionary(a: [MyInt: NSObject]) {} // expected-error {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
+  @objc func cfNewtype(a: CFNewType) {}
+  @objc func cfNewtypeArray(a: [CFNewType]) {} // expected-error {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
 }
 
 func testTypeAndValue() {
@@ -676,4 +680,14 @@ func testNonTrivialStructs() {
   _ = NonTrivialToCopy() // expected-error {{use of unresolved identifier 'NonTrivialToCopy'}}
   _ = NonTrivialToCopyWrapper() // expected-error {{use of unresolved identifier 'NonTrivialToCopyWrapper'}}
   _ = TrivialToCopy() // okay
-}
+}
+
+func testErrorNewtype() {
+  _ = ErrorNewType(3) // expected-error {{argument type 'Int' does not conform to expected type 'Error'}}
+
+  // Since we import NSError as Error, and Error is not Hashable...we end up
+  // losing the types for these functions, even though the above assignment 
+  // works.
+  testErrorDictionary(3) // expected-error {{cannot convert value of type 'Int' to expected argument type '[AnyHashable : String]'}}
+  testErrorDictionaryNewtype(3) // expected-error {{cannot convert value of type 'Int' to expected argument type '[AnyHashable : String]'}}
+}

test/IDE/print_omit_needless_words.swift

@@ -46,7 +46,7 @@
 // CHECK-FOUNDATION: func copy(with: NSZone? = nil) -> Any!
 
 // Note: Objective-C type parameter names.
-// CHECK-FOUNDATION: func object(forKey: NSCopying) -> Any?
+// CHECK-FOUNDATION: func object(forKey: Any) -> Any?
 // CHECK-FOUNDATION: func removeObject(forKey: NSCopying)
 
 // Note: Don't drop the name of the first parameter in an initializer entirely.

test/Inputs/clang-importer-sdk/swift-modules-without-ns/Foundation.swift

@@ -184,3 +184,34 @@ public func _convertErrorToNSError(_ error: Error) -> NSError {
   return error as NSError
 }
 
+extension _SwiftNewtypeWrapper where Self.RawValue == Error {
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _bridgeToObjectiveC() -> NSError {
+    return rawValue as NSError
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _forceBridgeFromObjectiveC(
+    _ source: NSError,
+    result: inout Self?
+  ) {
+    result = Self(rawValue: source)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _conditionallyBridgeFromObjectiveC(
+    _ source: NSError,
+    result: inout Self?
+  ) -> Bool {
+    result = Self(rawValue: source)
+    return result != nil
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _unconditionallyBridgeFromObjectiveC(
+    _ source: NSError?
+  ) -> Self {
+    return Self(rawValue: _convertNSErrorToError(source))!
+  }
+}
+

test/Inputs/clang-importer-sdk/swift-modules/Foundation.swift

@@ -245,6 +245,38 @@ public func _convertErrorToNSError(_ x: Error) -> NSError {
   return x as NSError
 }
 
+extension _SwiftNewtypeWrapper where Self.RawValue == Error {
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _bridgeToObjectiveC() -> NSError {
+    return rawValue as NSError
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _forceBridgeFromObjectiveC(
+    _ source: NSError,
+    result: inout Self?
+  ) {
+    result = Self(rawValue: source)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _conditionallyBridgeFromObjectiveC(
+    _ source: NSError,
+    result: inout Self?
+  ) -> Bool {
+    result = Self(rawValue: source)
+    return result != nil
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public static func _unconditionallyBridgeFromObjectiveC(
+    _ source: NSError?
+  ) -> Self {
+    return Self(rawValue: _convertNSErrorToError(source))!
+  }
+}
+
+
 
 extension NSArray {
   @objc(methodIntroducedInOverlay) public func introducedInOverlay() { }

test/Inputs/clang-importer-sdk/usr/include/Foundation.h

@@ -150,7 +150,7 @@ __attribute__((availability(ios,introduced=8.0)))
 - (id)copyWithZone:(nullable NSZone *)zone;
 @end
 
-@interface NSDictionary<KeyType : id<NSCopying>, ObjectType> : NSObject /*<NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration>*/
+@interface NSDictionary<KeyType, ObjectType> : NSObject /*<NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration>*/
 @property (readonly) NSUInteger count;
 - (nullable ObjectType)objectForKey:(nonnull KeyType)aKey;
 - (nonnull NSEnumerator *)keyEnumerator;

test/Interpreter/SDK/Inputs/objc_bridge_cast_newtype.h

@@ -0,0 +1,80 @@
+@import Foundation;
+
+#define GET_UNTYPED_AND_OPAQUE(Name) \
+  static NSArray * _Nonnull getUntypedNSArrayOf##Name##s() { \
+    return getTypedNSArrayOf##Name##Wrappers(); \
+  } \
+  static id _Nonnull getOpaqueNSArrayOf##Name##s() { \
+    return getTypedNSArrayOf##Name##Wrappers(); \
+  }
+#define CHECK_UNTYPED_AND_OPAQUE(Name) \
+  static BOOL checkUntypedNSArrayOf##Name##s(NSArray * _Nonnull array) { \
+    return checkTypedNSArrayOf##Name##Wrappers(array); \
+  } \
+  static BOOL checkOpaqueNSArrayOf##Name##s(id _Nonnull array) { \
+    return checkTypedNSArrayOf##Name##Wrappers(array); \
+  }
+
+typedef NSString *StringWrapper NS_TYPED_EXTENSIBLE_ENUM;
+static NSArray<StringWrapper> * _Nonnull getTypedNSArrayOfStringWrappers() {
+  return @[@"abc", @"def"];
+}
+static BOOL
+checkTypedNSArrayOfStringWrappers(NSArray<StringWrapper> * _Nonnull array) {
+  return [array isEqual:getTypedNSArrayOfStringWrappers()];
+}
+GET_UNTYPED_AND_OPAQUE(String)
+CHECK_UNTYPED_AND_OPAQUE(String)
+
+
+typedef id <NSCopying, NSCoding> CopyingAndCodingWrapper
+    NS_TYPED_EXTENSIBLE_ENUM;
+static NSArray<CopyingAndCodingWrapper> * _Nonnull
+getTypedNSArrayOfCopyingAndCodingWrappers() {
+  return @[@"abc", @[]];
+}
+static BOOL checkTypedNSArrayOfCopyingAndCodingWrappers(
+    NSArray<CopyingAndCodingWrapper> * _Nonnull array) {
+  return [array isEqual:getTypedNSArrayOfCopyingAndCodingWrappers()];
+}
+GET_UNTYPED_AND_OPAQUE(CopyingAndCoding)
+CHECK_UNTYPED_AND_OPAQUE(CopyingAndCoding)
+
+typedef id <NSCopying> CopyingWrapper NS_TYPED_EXTENSIBLE_ENUM;
+static NSArray<CopyingWrapper> * _Nonnull getTypedNSArrayOfCopyingWrappers() {
+  return getTypedNSArrayOfCopyingAndCodingWrappers();
+}
+static BOOL
+checkTypedNSArrayOfCopyingWrappers(NSArray<CopyingWrapper> * _Nonnull array) {
+  return [array isEqual:getTypedNSArrayOfCopyingWrappers()];
+}
+GET_UNTYPED_AND_OPAQUE(Copying)
+CHECK_UNTYPED_AND_OPAQUE(Copying)
+
+typedef NSObject *ObjectWrapper NS_TYPED_EXTENSIBLE_ENUM;
+static NSArray<ObjectWrapper> * _Nonnull getTypedNSArrayOfObjectWrappers() {
+  return (NSArray<ObjectWrapper> *)getTypedNSArrayOfCopyingAndCodingWrappers();
+}
+static BOOL
+checkTypedNSArrayOfObjectWrappers(NSArray<ObjectWrapper> * _Nonnull array) {
+  return [array isEqual:getTypedNSArrayOfObjectWrappers()];
+}
+GET_UNTYPED_AND_OPAQUE(Object)
+CHECK_UNTYPED_AND_OPAQUE(Object)
+
+typedef NSError *ErrorWrapper NS_TYPED_EXTENSIBLE_ENUM;
+static NSArray<ErrorWrapper> * _Nonnull getTypedNSArrayOfErrorWrappers() {
+  return @[[NSError errorWithDomain:@"x" code:11 userInfo:nil],
+           [NSError errorWithDomain:@"x" code:22 userInfo:nil]];
+}
+static BOOL
+checkTypedNSArrayOfErrorWrappers(NSArray<ErrorWrapper> * _Nonnull array) {
+  return [[array valueForKey:@"code"] isEqual:@[@11, @22]] &&
+         NSNotFound == [array indexOfObjectPassingTest:^BOOL(ErrorWrapper error,
+                                                             NSUInteger idx,
+                                                             BOOL *stop) {
+    return ![error isKindOfClass:[NSError class]];
+  }];
+}
+GET_UNTYPED_AND_OPAQUE(Error)
+CHECK_UNTYPED_AND_OPAQUE(Error)