[swift_newtype] Handle un-audited CF types

Special case logic for CF types, which may be coming in as
unmanaged. In this case, we will use audit information if present to
import with the new type, otherwise we have to fall back to
Unmanaged<CF...>.

We still import global variables that must be unmanaged onto the new
type, though they keep their unmanaged types. This helps to
consolidate the definitions, as well as make future migration easier
if they get audited.

Test cases included.

Author: milseman

lib/ClangImporter/ImportDecl.cpp

@@ -1334,6 +1334,16 @@ namespace {
           isInSystemModule(dc), decl->getUnderlyingType()->isBlockPointerType(),
           OTK_None);
 
+      // If the type is Unmanaged, that is it is not CF ARC audited,
+      // we will store the underlying type and leave it up to the use site
+      // to determine whether to use this new_type, or an Unmanaged<CF...> type.
+      if (auto genericType = storedUnderlyingType->getAs<BoundGenericType>()) {
+        if (genericType->getDecl() == Impl.SwiftContext.getUnmanagedDecl()) {
+          assert(genericType->getGenericArgs().size() == 1 && "other args?");
+          storedUnderlyingType = genericType->getGenericArgs()[0];
+        }
+      }
+
       // Find a bridged type, which may be different
       auto computedPropertyUnderlyingType = Impl.importType(
           decl->getUnderlyingType(), ImportTypeKind::Property,

lib/ClangImporter/ImportType.cpp

@@ -90,6 +90,11 @@ namespace {
 
       /// The source type created a new Swift type, using swift_newtype
       SwiftNewtype,
+
+      /// The source type created a new Swift type, using swift_newtype, of an
+      /// original underlying CFPointer. This distinction is necessary to
+      /// trigger audit-checking.
+      SwiftNewtypeFromCFPointer,
     };
 
     ImportHintKind Kind;
@@ -121,7 +126,6 @@ namespace {
     case ImportHint::NSUInteger:
     case ImportHint::Reference:
     case ImportHint::Void:
-    case ImportHint::SwiftNewtype:
       return false;
 
     case ImportHint::Block:
@@ -130,6 +134,8 @@ namespace {
     case ImportHint::ObjCPointer:
     case ImportHint::CFunctionPointer:
     case ImportHint::OtherPointer:
+    case ImportHint::SwiftNewtype:
+    case ImportHint::SwiftNewtypeFromCFPointer:
       return true;
     }
   }
@@ -555,8 +561,10 @@ namespace {
       ImportHint hint = ImportHint::None;
 
       if (Impl.getSwiftNewtypeAttr(type->getDecl(), /*useSwift2Name=*/false)) {
-        hint = ImportHint::SwiftNewtype;
-
+        if (ClangImporter::Implementation::isCFTypeDecl(type->getDecl()))
+          hint = ImportHint::SwiftNewtypeFromCFPointer;
+        else
+          hint = ImportHint::SwiftNewtype;
       // For certain special typedefs, we don't want to use the imported type.
       } else if (auto specialKind = Impl.getSpecialTypedefKind(type->getDecl())) {
         switch (specialKind.getValue()) {
@@ -997,6 +1005,21 @@ static bool isNSString(Type type) {
   return false;
 }
 
+static Type findNewtypeUnderlyingType(Type newtype) {
+  auto structDecl = newtype->getStructOrBoundGenericStruct();
+  assert(structDecl && structDecl->getClangNode() &&
+         structDecl->getClangNode().getAsDecl() &&
+         structDecl->getClangNode()
+             .castAsDecl()
+             ->getAttr<clang::SwiftNewtypeAttr>() &&
+         "Called on a non-swift_newtype decl");
+  for (auto member : structDecl->getMembers())
+    if (auto varDecl = dyn_cast<VarDecl>(member))
+      if (varDecl->getName().str() == "rawValue")
+        return varDecl->getType();
+  assert(0 && "no rawValue variable member");
+}
+
 static Type adjustTypeForConcreteImport(ClangImporter::Implementation &impl,
                                         clang::QualType clangType,
                                         Type importedType,
@@ -1178,6 +1201,15 @@ static Type adjustTypeForConcreteImport(ClangImporter::Implementation &impl,
     importedType = getUnmanagedType(impl, importedType);
   }
 
+  // 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
+  if (hint == ImportHint::SwiftNewtypeFromCFPointer &&
+      !isCFAudited(importKind)) {
+    auto underlyingType = findNewtypeUnderlyingType(importedType);
+    if (underlyingType)
+      importedType = getUnmanagedType(impl, underlyingType);
+  }
+
   // If we have a bridged Objective-C type and we are allowed to
   // bridge, do so.
   if (hint == ImportHint::ObjCBridged && canBridgeTypes(importKind) &&

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

@@ -50,3 +50,16 @@ extern const NSString *Notification;
 extern const NSString *kSNNotification
     __attribute((swift_name("swiftNamedNotification")));
 
+// Test CFStringRef
+typedef CFStringRef CFNewType __attribute((swift_newtype(struct)));
+
+// CF audited
+_Pragma("clang arc_cf_code_audited begin")
+extern const CFNewType MyCFNewTypeValue;
+CFNewType FooAudited(void);
+_Pragma("clang arc_cf_code_audited end")
+extern const CFNewType MyCFNewTypeValueUnauditedButConst;
+
+// un-audited CFStringRef
+extern CFNewType MyCFNewTypeValueUnaudited;
+CFNewType FooUnaudited(void);

test/IDE/newtype.swift

@@ -3,6 +3,7 @@
 // RUN: %build-clang-importer-objc-overlays
 // RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk-nosource) -I %t -I %S/Inputs/custom-modules -enable-swift-newtype -print-module -source-filename %s -module-to-print=Newtype > %t.printed.A.txt
 // RUN: FileCheck %s -check-prefix=PRINT -strict-whitespace < %t.printed.A.txt
+// RUN: %target-parse-verify-swift -sdk %clang-importer-sdk -I %S/Inputs/custom-modules -enable-swift-newtype -I %t
 // REQUIRES: objc_interop
 
 // PRINT-LABEL: struct ErrorDomain : RawRepresentable, _SwiftNewtypeWrapper, Equatable, Hashable, Comparable, _ObjectiveCBridgeable {
@@ -48,6 +49,7 @@
 // PRINT-NEXT:    static let PI: MyFloat
 // PRINT-NEXT:    static let version: MyFloat
 // PRINT-NEXT:  }
+//
 // PRINT-LABEL: extension NSURLResourceKey {
 // PRINT-NEXT:    static let isRegularFileKey: NSURLResourceKey
 // PRINT-NEXT:    static let isDirectoryKey: NSURLResourceKey
@@ -61,8 +63,18 @@
 // PRINT-NEXT:  let kNotification: String
 // PRINT-NEXT:  let Notification: String
 // PRINT-NEXT:  let swiftNamedNotification: String
-
-// RUN: %target-parse-verify-swift -sdk %clang-importer-sdk -I %S/Inputs/custom-modules -enable-swift-newtype -I %t
+//
+// PRINT-LABEL: struct CFNewType : RawRepresentable, _SwiftNewtypeWrapper {
+// PRINT-NEXT:    init(rawValue: CFString)
+// PRINT-NEXT:    let rawValue: CFString
+// PRINT-NEXT:  }
+// PRINT-NEXT:  extension CFNewType {
+// PRINT-NEXT:    static let MyCFNewTypeValue: CFNewType
+// PRINT-NEXT:    static let MyCFNewTypeValueUnauditedButConst: CFNewType
+// PRINT-NEXT:    static var MyCFNewTypeValueUnaudited: Unmanaged<CFString>
+// PRINT-NEXT:  }
+// PRINT-NEXT:  func FooAudited() -> CFNewType
+// PRINT-NEXT:  func FooUnaudited() -> Unmanaged<CFString>
 import Newtype
 
 func tests() {
@@ -73,7 +85,7 @@ func tests() {
 	fooErr.process()
 	Foo().process() // expected-error{{value of type 'Foo' 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'}}
 
@@ -82,6 +94,10 @@ func tests() {
 
 	let _ = NSNotificationName.Foo
 	let _ = NSNotificationName.bar
+	let _ : CFNewType = CFNewType.MyCFNewTypeValue
+	let _ : CFNewType = CFNewType.MyCFNewTypeValueUnauditedButConst
+	let _ : CFNewType = CFNewType.MyCFNewTypeValueUnaudited
+	  // expected-error@-1{{cannot convert value of type 'Unmanaged<CFString>!' to specified type 'CFNewType'}}
 }
 
 func acceptSwiftNewtypeWrapper<T : _SwiftNewtypeWrapper>(_ t: T) { }

test/IRGen/newtype.swift

@@ -33,3 +33,27 @@ public func getGlobalNotification(_ x: Int) -> String {
   }
 // CHECK: ret
 }
+
+// CHECK-LABEL: _TF7newtype17getCFNewTypeValueFT6useVarSb_VSC9CFNewType
+public func getCFNewTypeValue(useVar: Bool) -> CFNewType {
+  if (useVar) {
+    return CFNewType.MyCFNewTypeValue
+    // CHECK: load {{.*}} @MyCFNewTypeValue
+  } else {
+    return FooAudited()
+    // CHECK: call {{.*}} @FooAudited()
+  }
+  // CHECK: ret
+}
+
+// CHECK-LABEL: _TF7newtype21getUnmanagedCFNewTypeFT6useVarSb_GVs9UnmanagedCSo8CFString_
+public func getUnmanagedCFNewType(useVar: Bool) -> Unmanaged<CFString> {
+  if (useVar) {
+    return CFNewType.MyCFNewTypeValueUnaudited
+    // CHECK: load {{.*}} @MyCFNewTypeValueUnaudited
+  } else {
+    return FooUnaudited()
+    // CHECK: call {{.*}} @FooUnaudited()
+  }
+  // CHECK: ret
+}