[PrintAsObjC] Handle imported swift_newtype typedefs.

A typedef with the swift_newtype attribute is imported as a struct
wrapping the underlying type instead of just a typealias. If the
underlying type is a bridged type (like String), the newtype struct
is bridged as well. However, we don't want to use that type when
bridging back to Objective-C, because

(1) Objective-C header generation is done too late to fill out the
    _ObjectiveCBridgeable conformance for the type, so if it wasn't
    type-checked then the conformance won't have the original type
    in it.
(2) There's a perfectly good typedef we should be using anyway.

Just use the type as written in Objective-C (instead of crashing).

Finishes rdar://problem/26372925.

Author: jrose-apple

lib/PrintAsObjC/PrintAsObjC.cpp

@@ -25,6 +25,7 @@
 #include "swift/Frontend/PrintingDiagnosticConsumer.h"
 #include "swift/IDE/CommentConversion.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/Module.h"
@@ -786,6 +787,10 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
   bool printIfObjCBridgeable(const NominalTypeDecl *nominal,
                              ArrayRef<Type> typeArgs,
                              Optional<OptionalTypeKind> optionalKind) {
+    // Print imported bridgeable decls as their unbridged type.
+    if (nominal->hasClangNode())
+      return false;
+
     auto &ctx = nominal->getASTContext();
 
     // Dig out the ObjectiveCBridgeable protocol.
@@ -956,7 +961,8 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     ASTContext &ctx = M.getASTContext();
     auto &clangASTContext = ctx.getClangModuleLoader()->getClangASTContext();
     clang::QualType clangTy = clangASTContext.getTypeDeclType(clangTypeDecl);
-    return clangTy->isPointerType();
+    return clangTy->isPointerType() || clangTy->isBlockPointerType() ||
+      clangTy->isObjCObjectPointerType();
   }
 
   void visitNameAliasType(NameAliasType *aliasTy,
@@ -971,10 +977,8 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
       auto *clangTypeDecl = cast<clang::TypeDecl>(alias->getClangDecl());
       os << clangTypeDecl->getName();
 
-      if (aliasTy->hasReferenceSemantics() ||
-          isClangPointerType(clangTypeDecl)) {
+      if (isClangPointerType(clangTypeDecl))
         printNullability(optionalKind);
-      }
       return;
     }
 
@@ -1022,6 +1026,11 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
 
     maybePrintTagKeyword(SD);
     os << getNameForObjC(SD);
+
+    // Handle swift_newtype applied to a pointer type.
+    if (auto *clangDecl = cast_or_null<clang::TypeDecl>(SD->getClangDecl()))
+      if (isClangPointerType(clangDecl))
+        printNullability(optionalKind);
   }
 
   /// Print a collection element type using Objective-C generics syntax.
@@ -1030,12 +1039,22 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
   void printCollectionElement(Type ty) {
     ASTContext &ctx = M.getASTContext();
 
+    auto isSwiftNewtype = [&ctx](const StructDecl *SD) -> bool {
+      if (!SD)
+        return false;
+      auto *clangDecl = SD->getClangDecl();
+      if (!clangDecl)
+        return false;
+      return clangDecl->hasAttr<clang::SwiftNewtypeAttr>();
+    };
+
     // Use the type as bridged to Objective-C unless the element type is itself
-    // a collection.
+    // an imported type or a collection.
     const StructDecl *SD = ty->getStructOrBoundGenericStruct();
     if (SD != ctx.getArrayDecl() &&
         SD != ctx.getDictionaryDecl() &&
-        SD != ctx.getSetDecl()) {
+        SD != ctx.getSetDecl() &&
+        !isSwiftNewtype(SD)) {
       ty = *ctx.getBridgedToObjC(&M, ty, /*resolver*/nullptr);
     }
 

test/PrintAsObjC/Inputs/newtype.h

@@ -0,0 +1,5 @@
+// This file is meant to be used with the mock SDK, not the real one.
+#import <Foundation.h>
+
+typedef NSString *StructLikeStringWrapper __attribute__((swift_newtype(struct)));
+typedef NSString *EnumLikeStringWrapper __attribute__((swift_newtype(enum)));

test/PrintAsObjC/newtype.swift

@@ -0,0 +1,44 @@
+// Please keep this file in alphabetical order!
+
+// REQUIRES: objc_interop
+
+// RUN: rm -rf %t && mkdir %t
+
+// FIXME: BEGIN -enable-source-import hackaround
+// RUN:  %target-swift-frontend(mock-sdk: -sdk %S/../Inputs/clang-importer-sdk -I %t) -emit-module -o %t %S/../Inputs/clang-importer-sdk/swift-modules/ObjectiveC.swift
+// RUN:  %target-swift-frontend(mock-sdk: -sdk %S/../Inputs/clang-importer-sdk -I %t) -emit-module -o %t  %S/../Inputs/clang-importer-sdk/swift-modules/CoreGraphics.swift
+// RUN:  %target-swift-frontend(mock-sdk: -sdk %S/../Inputs/clang-importer-sdk -I %t) -emit-module -o %t  %S/../Inputs/clang-importer-sdk/swift-modules/Foundation.swift
+// FIXME: END -enable-source-import hackaround
+
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/../Inputs/clang-importer-sdk -I %t) -import-objc-header %S/Inputs/newtype.h -enable-swift-newtype -emit-module -o %t %s
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/../Inputs/clang-importer-sdk -I %t) -import-objc-header %S/Inputs/newtype.h -enable-swift-newtype -parse-as-library %t/newtype.swiftmodule -parse -emit-objc-header-path %t/newtype.h
+
+// RUN: FileCheck %s < %t/newtype.h
+
+// RUN: %check-in-clang %t/newtype.h
+// RUN: %check-in-clang -fno-modules -Qunused-arguments %t/newtype.h
+
+import Foundation
+
+// CHECK-LABEL: @interface TestEnumLike : NSObject
+class TestEnumLike : NSObject {
+  // CHECK: - (void)takesNewtype:(EnumLikeStringWrapper _Nonnull)a;
+  func takesNewtype(_ a: EnumLikeStringWrapper) {}
+  // CHECK: - (void)takesNewtypeArray:(NSArray<EnumLikeStringWrapper> * _Nonnull)a;
+  func takesNewtypeArray(_ a: [EnumLikeStringWrapper]) {}
+  // CHECK: - (void)takesNewtypeDictionary:(NSDictionary<EnumLikeStringWrapper, EnumLikeStringWrapper> * _Nonnull)a;
+  func takesNewtypeDictionary(_ a: [EnumLikeStringWrapper: EnumLikeStringWrapper]) {}
+}
+// CHECK: @end
+
+// CHECK-LABEL: @interface TestStructLike : NSObject
+class TestStructLike : NSObject {
+  // CHECK: - (void)takesNewtype:(StructLikeStringWrapper _Nonnull)a;
+  func takesNewtype(_ a: StructLikeStringWrapper) {}
+  // CHECK: - (void)takesNewtypeArray:(NSArray<StructLikeStringWrapper> * _Nonnull)a;
+  func takesNewtypeArray(_ a: [StructLikeStringWrapper]) {}
+  // CHECK: - (void)takesNewtypeDictionary:(NSDictionary<StructLikeStringWrapper, StructLikeStringWrapper> * _Nonnull)a;
+  func takesNewtypeDictionary(_ a: [StructLikeStringWrapper: StructLikeStringWrapper]) {}
+}
+// CHECK: @end
+