Optional swift_newtype types are @objc if the raw type would be @objc.

lib/AST/Decl.cpp

@@ -4935,17 +4935,14 @@ Type TypeBase::getSwiftNewtypeUnderlyingType() {
     return {};
 
   // Make sure the clang node has swift_newtype attribute
-  if (!structDecl->getClangNode())
-    return {};
-  auto clangNode = structDecl->getClangNode();
-  if (!clangNode.getAsDecl() ||
-      !clangNode.castAsDecl()->getAttr<clang::SwiftNewtypeAttr>())
+  auto clangNode = structDecl->getClangDecl();
+  if (!clangNode || !clangNode->hasAttr<clang::SwiftNewtypeAttr>())
     return {};
 
   // Underlying type is the type of rawValue
   for (auto member : structDecl->getMembers())
     if (auto varDecl = dyn_cast<VarDecl>(member))
-      if (varDecl->getName().str() == "rawValue")
+      if (varDecl->getName() == getASTContext().Id_rawValue)
         return varDecl->getType();
 
   return {};

lib/AST/Type.cpp

@@ -2230,12 +2230,19 @@ getForeignRepresentable(Type type, ForeignLanguage language,
     case ForeignLanguage::ObjectiveC:
       if (isa<StructDecl>(nominal) || isa<EnumDecl>(nominal)) {
         // Optional structs are not representable in (Objective-)C if they
-        // originally came from C, whether or not they are bridged. If they
-        // are defined in Swift, they are only representable if they are
-        // bridged (checked below).
+        // originally came from C, whether or not they are bridged, unless they
+        // came from swift_newtype. If they are defined in Swift, they are only
+        // representable if they are bridged (checked below).
         if (wasOptional) {
-          if (nominal->hasClangNode())
+          if (nominal->hasClangNode()) {
+            Type underlyingType =
+                nominal->getDeclaredType()->getSwiftNewtypeUnderlyingType();
+            if (underlyingType) {
+              return getForeignRepresentable(OptionalType::get(underlyingType),
+                                             language, dc);
+            }
             return failure();
+          }
           break;
         }
       }

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

@@ -0,0 +1,4 @@
+@import Foundation;
+
+typedef NSString *__nonnull SNTErrorDomain __attribute((swift_newtype(struct)));
+typedef NSInteger MyInt __attribute((swift_newtype(struct)));

test/ClangModules/Inputs/custom-modules/module.map

@@ -69,6 +69,10 @@ module MissingHeader {
   header "this-header-does-not-exist.h"
 }
 
+module Newtype {
+  header "Newtype.h"
+}
+
 module ObjCIRExtras {
   header "ObjCIRExtras.h"
   export *

test/ClangModules/objc_parse.swift

@@ -5,6 +5,7 @@
 import AppKit
 import AVFoundation
 
+import Newtype
 import objc_ext
 import TestProtocols
 
@@ -599,3 +600,10 @@ func testNSUInteger(_ obj: NSUIntegerTests, uint: UInt, int: Int) {
   let _: String = num.uintValue // expected-error {{cannot convert value of type 'UInt' to specified type 'String'}}
 }
 
+class NewtypeUser {
+  @objc func stringNewtype(a: SNTErrorDomain) {}
+  @objc func stringNewtypeOptional(a: SNTErrorDomain?) {}
+  @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}}
+}
+

test/IRGen/newtype.swift

@@ -130,3 +130,31 @@ public func compareInits() -> Bool {
 public func anchor() -> Bool {
   return false
 }
+
+class ObjCTest {
+  // CHECK-LABEL: define hidden %0* @_TToFC7newtype8ObjCTest19optionalPassThroughfGSqVSC11ErrorDomain_GSqS1__
+  // CHECK: [[CASTED:%.+]] = ptrtoint %0* %2 to i{{32|64}}
+  // CHECK: [[RESULT:%.+]] = call i{{32|64}} @_TFC7newtype8ObjCTest19optionalPassThroughfGSqVSC11ErrorDomain_GSqS1__(i{{32|64}} [[CASTED]], %C7newtype8ObjCTest* {{%.+}})
+  // CHECK: [[OPAQUE_RESULT:%.+]] = inttoptr i{{32|64}} [[RESULT]] to %0*
+  // CHECK: ret %0* [[OPAQUE_RESULT]]
+  // CHECK: {{^}$}}
+
+  // OPT-LABEL: define hidden %0* @_TToFC7newtype8ObjCTest19optionalPassThroughfGSqVSC11ErrorDomain_GSqS1__
+  // OPT: ret %0* %2
+  // OPT: {{^}$}}
+  @objc func optionalPassThrough(_ ed: ErrorDomain?) -> ErrorDomain? {
+    return ed
+  }
+
+  // CHECK-LABEL: define hidden i32 @_TToFC7newtype8ObjCTest18integerPassThroughfVSC5MyIntS1_
+  // CHECK: [[RESULT:%.+]] = call i32 @_TFC7newtype8ObjCTest18integerPassThroughfVSC5MyIntS1_(i32 %2, %C7newtype8ObjCTest* {{%.+}})
+  // CHECK: ret i32 [[RESULT]]
+  // CHECK: {{^}$}}
+
+  // OPT-LABEL: define hidden i32 @_TToFC7newtype8ObjCTest18integerPassThroughfVSC5MyIntS1_
+  // OPT: ret i32 %2
+  // OPT: {{^}$}}
+  @objc func integerPassThrough(_ num: MyInt) -> MyInt {
+    return num
+  }
+}

test/PrintAsObjC/newtype.swift

@@ -28,6 +28,8 @@ class TestEnumLike : NSObject {
   func takesNewtypeArray(_ a: [EnumLikeStringWrapper]) {}
   // CHECK: - (void)takesNewtypeDictionary:(NSDictionary<EnumLikeStringWrapper, EnumLikeStringWrapper> * _Nonnull)a;
   func takesNewtypeDictionary(_ a: [EnumLikeStringWrapper: EnumLikeStringWrapper]) {}
+  // CHECK: - (void)takesNewtypeOptional:(EnumLikeStringWrapper _Nullable)a;
+  func takesNewtypeOptional(_ a: EnumLikeStringWrapper?) {}
 }
 // CHECK: @end
 
@@ -39,6 +41,8 @@ class TestStructLike : NSObject {
   func takesNewtypeArray(_ a: [StructLikeStringWrapper]) {}
   // CHECK: - (void)takesNewtypeDictionary:(NSDictionary<StructLikeStringWrapper, StructLikeStringWrapper> * _Nonnull)a;
   func takesNewtypeDictionary(_ a: [StructLikeStringWrapper: StructLikeStringWrapper]) {}
+  // CHECK: - (void)takesNewtypeOptional:(StructLikeStringWrapper _Nullable)a;
+  func takesNewtypeOptional(_ a: StructLikeStringWrapper?) {}
 }
 // CHECK: @end
 

test/SILGen/Inputs/usr/include/newtype.h

@@ -5,3 +5,5 @@ __attribute((swift_name("ErrorDomain")));
 extern const SNTErrorDomain SNTErrTwo;
 extern const SNTErrorDomain SNTErrorDomainThree;
 extern const SNTErrorDomain SNTFourErrorDomain;
+
+typedef NSInteger MyInt __attribute((swift_newtype(struct)));

test/SILGen/newtype.swift

@@ -39,3 +39,17 @@ func getRawValue(ed: ErrorDomain) -> String {
 // CHECK-RAW: [[STRING_RESULT:%[0-9]+]] = load [[STRING_RESULT_ADDR]]
 // CHECK-RAW: return [[STRING_RESULT]]
 
+class ObjCTest {
+  // CHECK-RAW-LABEL: sil hidden @_TFC7newtype8ObjCTest19optionalPassThroughfGSqVSC11ErrorDomain_GSqS1__ : $@convention(method) (@owned Optional<ErrorDomain>, @guaranteed ObjCTest) -> @owned Optional<ErrorDomain> {
+  // CHECK-RAW: sil hidden [thunk] @_TToFC7newtype8ObjCTest19optionalPassThroughfGSqVSC11ErrorDomain_GSqS1__ : $@convention(objc_method) (Optional<ErrorDomain>, ObjCTest) -> Optional<ErrorDomain> {
+  @objc func optionalPassThrough(_ ed: ErrorDomain?) -> ErrorDomain? {
+    return ed
+  }  
+
+  // CHECK-RAW-LABEL: sil hidden @_TFC7newtype8ObjCTest18integerPassThroughfVSC5MyIntS1_ : $@convention(method) (MyInt, @guaranteed ObjCTest) -> MyInt {
+  // CHECK-RAW: sil hidden [thunk] @_TToFC7newtype8ObjCTest18integerPassThroughfVSC5MyIntS1_ : $@convention(objc_method) (MyInt, ObjCTest) -> MyInt {
+  @objc func integerPassThrough(_ ed: MyInt) -> MyInt {
+    return ed
+  }  
+}
+