[Clang importer] swift_newtype'd types are bridged when their underlying types are.

A swift_wrapper/swift_newtype'd type can wrap a bridged type. In such
cases, we need to report both the unbridged type (which is the
unbridged underlying type) and the bridged type (which is the
importer-created wrapper type). This fixes a problem where Objective-C
generic specializations would use the wrapper types on type parameters
with "AnyObject" constraints, which... doesn't work.

Fixes rdar://problem/26340353.

Author: DougGregor

lib/ClangImporter/ImportType.cpp

@@ -63,7 +63,7 @@ namespace {
       /// The source type is 'Boolean'.
       Boolean,
 
-      /// The source type an Objective-C class type bridged to a Swift
+      /// The source type is an Objective-C class type bridged to a Swift
       /// type.
       ObjCBridged,
 
@@ -565,6 +565,15 @@ namespace {
           hint = ImportHint::SwiftNewtypeFromCFPointer;
         else
           hint = ImportHint::SwiftNewtype;
+
+        // If the underlying type was bridged, the wrapper type is
+        // only useful in bridged cases.
+        auto underlying = Visit(type->getDecl()->getUnderlyingType());
+        if (underlying.Hint == ImportHint::ObjCBridged) {
+          return { underlying.AbstractType,
+                   ImportHint(ImportHint::ObjCBridged, mappedType) };
+        }
+
       // For certain special typedefs, we don't want to use the imported type.
       } else if (auto specialKind = Impl.getSpecialTypedefKind(type->getDecl())) {
         switch (specialKind.getValue()) {
@@ -1187,7 +1196,7 @@ static Type adjustTypeForConcreteImport(ClangImporter::Implementation &impl,
   }
 
   // For types we import as new types in Swift, if the use is CF un-audited,
-  // then we have to for it to be unmanaged
+  // then we have to force it to be unmanaged
   if (hint == ImportHint::SwiftNewtypeFromCFPointer &&
       !isCFAudited(importKind)) {
     auto underlyingType = importedType->getSwiftNewtypeUnderlyingType();

test/IDE/Inputs/custom-modules/NewtypeObjC.h

@@ -0,0 +1,16 @@
+@import Foundation;
+
+typedef NSString *_Nonnull SNTClosedEnum __attribute((swift_newtype(enum)))
+__attribute((swift_name("ClosedEnum")));
+
+extern const SNTClosedEnum SNTFirstClosedEntryEnum;
+extern const SNTClosedEnum SNTSecondEntry;
+extern const SNTClosedEnum SNTClosedEnumThirdEntry;
+
+@interface GenericClassA<T> : NSObject
+@end
+
+@interface UsesGenericClassA : NSObject
+-(void)takeEnumValues:(nonnull GenericClassA<SNTClosedEnum> *)values;
+-(void)takeEnumValuesArray:(nonnull NSArray<SNTClosedEnum> *)values;
+@end

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

@@ -16,6 +16,11 @@ module Newtype {
   header "Newtype.h"
 }
 
+module NewtypeObjC {
+  header "NewtypeObjC.h"
+  export *
+}
+
 module ImportAsMember {
   export *
 

test/IDE/newtype.swift

@@ -85,7 +85,7 @@ func tests() {
 	fooErr.process()
 	Food().process() // expected-error{{value of type 'Food' has no member 'process'}}
 
-	let thirdEnum = ClosedEnum.thirdEntry!
+	let thirdEnum = ClosedEnum.thirdEntry
 	thirdEnum.process()
 	  // expected-error@-1{{value of type 'ClosedEnum' has no member 'process'}}
 

test/IDE/newtype_objc.swift

@@ -0,0 +1,21 @@
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: %build-clang-importer-objc-overlays
+
+// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk-nosource) -I %t -I %S/Inputs/custom-modules -print-module -source-filename %s -module-to-print=NewtypeObjC -enable-swift-newtype > %t.printed.NewtypeObjC.txt
+// RUN: FileCheck %s -check-prefix=PRINT -strict-whitespace < %t.printed.NewtypeObjC.txt
+// RUN: %target-parse-verify-swift -sdk %clang-importer-sdk -I %S/Inputs/custom-modules -I %t -enable-swift-newtype %s
+
+// REQUIRES: objc_interop
+
+// PRINT: class UsesGenericClassA : NSObject {
+// PRINT:   func takeEnumValues(_ values: GenericClassA<NSString>)
+// PRINT:   func takeEnumValuesArray(_ values: [ClosedEnum])
+// PRINT: }
+
+import NewtypeObjC
+
+func useSpecializationOverNewtypes(a: UsesGenericClassA) {
+  let gca = GenericClassA<NSString>()
+  a.takeEnumValues(gca)
+}