Clang importer: handle CF type renaming in importFullName.

DougGregor · DougGregor · commit 2ea58f93b04c · 2015-12-03T11:50:43.000-08:00
Ensures that the Swift lookup tables get transformed name for imported
CF types, including original name (which is still
available). Otherwise, this is an NFC refactoring that gets the last
of the naming tricks into importFullName.
diff --git a/lib/Basic/StringExtras.cpp b/lib/Basic/StringExtras.cpp
@@ -309,12 +309,18 @@ static bool isKeyword(StringRef identifier) {
 static Optional<StringRef> skipTypeSuffix(StringRef typeName) {
   if (typeName.empty()) return None;
 
+  auto lastWord = camel_case::getLastWord(typeName);
+
   // "Type" suffix.
-  if (camel_case::getLastWord(typeName) == "Type" &&
-      typeName.size() > 4) {
+  if (lastWord == "Type" && typeName.size() > 4) {
     return typeName.drop_back(4);
   }
 
+  // "Ref" suffix.
+  if (lastWord == "Ref" && typeName.size() > 3) {
+    return typeName.drop_back(3);
+  }
+
   // \d+D for dimensionality.
   if (typeName.back() == 'D' && typeName.size() > 1) {
     unsigned firstDigit = typeName.size() - 1;
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -703,8 +703,12 @@ void ClangImporter::Implementation::addEntryToLookupTable(
   if (!suppressDecl) {
     // If we have a name to import as, add this entry to the table.
     clang::DeclContext *effectiveContext;
-    if (DeclName name = importFullName(named, None, &effectiveContext)) {
-      table.addEntry(name, named, effectiveContext);
+    if (auto importedName = importFullName(named, None, &effectiveContext)) {
+      table.addEntry(importedName.Imported, named, effectiveContext);
+
+      // Also add the alias, if needed.
+      if (importedName.Alias)
+        table.addEntry(importedName.Alias, named, effectiveContext);
     }
   }
 
@@ -2321,6 +2325,19 @@ auto ClangImporter::Implementation::importFullName(
     }
   }
 
+  // Typedef declarations might be CF types that will drop the "Ref"
+  // suffix.
+  bool aliasIsFunction = false;
+  bool aliasIsInitializer = false;
+  StringRef aliasBaseName;
+  SmallVector<StringRef, 4> aliasArgumentNames;
+  if (auto typedefNameDecl = dyn_cast<clang::TypedefNameDecl>(D)) {
+    auto swiftName = getCFTypeName(typedefNameDecl, &aliasBaseName);
+    if (!swiftName.empty()) {
+      baseName = swiftName;
+    }
+  }
+
   // Local function to determine whether the given declaration is subject to
   // a swift_private attribute.
   auto hasSwiftPrivate = [this](const clang::NamedDecl *D) {
@@ -2398,32 +2415,58 @@ auto ClangImporter::Implementation::importFullName(
   // If this declaration has the swift_private attribute, prepend "__" to the
   // appropriate place.
   SmallString<16> swiftPrivateScratch;
+  SmallString<16> swiftPrivateAliasScratch;
   if (hasSwiftPrivate(D)) {
-    swiftPrivateScratch = "__";
+    // Make the given name private.
+    //
+    // Returns true if this is not possible.
+    auto makeNamePrivate = [](bool isInitializer,
+                              StringRef &baseName,
+                              SmallVectorImpl<StringRef> &argumentNames,
+                              CtorInitializerKind initKind,
+                              SmallString<16> &scratch) -> bool {
+      scratch = "__";
+
+      if (isInitializer) {
+        // For initializers, prepend "__" to the first argument name.
+        if (argumentNames.empty()) {
+          // FIXME: ... unless it was from a factory method, for historical
+          // reasons.
+          if (initKind == CtorInitializerKind::Factory ||
+              initKind == CtorInitializerKind::ConvenienceFactory)
+            return true;
 
-    if (isInitializer) {
-      // For initializers, prepend "__" to the first argument name.
-      if (argumentNames.empty()) {
-        // FIXME: ... unless it was from a factory method, for historical
-        // reasons.
-        if (result.InitKind == CtorInitializerKind::Factory ||
-            result.InitKind == CtorInitializerKind::ConvenienceFactory)
-          return result;
-
-        // FIXME: Record that we did this.
-        argumentNames.push_back("__");
+          // FIXME: Record that we did this.
+          argumentNames.push_back("__");
+        } else {
+          scratch += argumentNames[0];
+          argumentNames[0] = scratch;
+        }
       } else {
-        swiftPrivateScratch += argumentNames[0];
-        argumentNames[0] = swiftPrivateScratch;
+        // For all other entities, prepend "__" to the base name.
+        scratch += baseName;
+        baseName = scratch;
       }
-    } else {
-      // For all other entities, prepend "__" to the base name.
-      swiftPrivateScratch += baseName;
-      baseName = swiftPrivateScratch;
+
+      return false;
+    };
+
+    // Make the name private.
+    if (makeNamePrivate(isInitializer, baseName, argumentNames,
+                        result.InitKind, swiftPrivateScratch))
+      return result;
+
+    // If we have an alias name, make it private as well.
+    if (!aliasBaseName.empty()) {
+      (void)makeNamePrivate(aliasIsInitializer, aliasBaseName,
+                            aliasArgumentNames, CtorInitializerKind::Designated,
+                            swiftPrivateAliasScratch);
     }
   }
 
   result.Imported = formDeclName(baseName, argumentNames, isFunction);
+  result.Alias = formDeclName(aliasBaseName, aliasArgumentNames,
+                              aliasIsFunction);
   return result;
 }
 
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
@@ -1181,15 +1181,34 @@ static StringRef getImportedCFTypeName(StringRef name) {
 
 bool ClangImporter::Implementation::isCFTypeDecl(
        const clang::TypedefNameDecl *Decl) {
-  if (auto pointee = CFPointeeInfo::classifyTypedef(Decl))
-    return pointee.isValid();
+  if (CFPointeeInfo::classifyTypedef(Decl))
+    return true;
   return false;
 }
 
 StringRef ClangImporter::Implementation::getCFTypeName(
-            const clang::TypedefNameDecl *decl) {
-  if (isCFTypeDecl(decl))
-    return getImportedCFTypeName(decl->getName());
+            const clang::TypedefNameDecl *decl,
+            StringRef *secondaryName) {
+  if (secondaryName) *secondaryName = "";
+
+  if (auto pointee = CFPointeeInfo::classifyTypedef(decl)) {
+    auto name = decl->getName();
+    if (pointee.isRecord()) {
+      auto resultName = getImportedCFTypeName(name);
+      if (secondaryName && name != resultName)
+        *secondaryName = name;
+
+      return resultName;
+    }
+
+    if (pointee.isTypedef() && secondaryName) {
+      StringRef otherName = getImportedCFTypeName(name);
+      if (otherName != name) 
+        *secondaryName = otherName;
+    }
+
+    return name;
+  }
 
   return "";
 }
@@ -1364,11 +1383,7 @@ namespace {
     }
 
     Type importCFClassType(const clang::TypedefNameDecl *decl,
-                           StringRef name, CFPointeeInfo info) {
-      // If the name ends in 'Ref', drop that from the imported class name.
-      StringRef nameWithoutRef = getImportedCFTypeName(name);
-      Identifier className = Impl.SwiftContext.getIdentifier(nameWithoutRef);
-
+                           Identifier className, CFPointeeInfo info) {
       auto dc = Impl.importDeclContextOf(decl);
       if (!dc) return Type();
 
@@ -1426,7 +1441,8 @@ namespace {
     }
 
     Decl *VisitTypedefNameDecl(const clang::TypedefNameDecl *Decl) {
-      auto Name = Impl.importFullName(Decl).Imported.getBaseName();
+      auto importedName = Impl.importFullName(Decl);
+      auto Name = importedName.Imported.getBaseName();
       if (Name.empty())
         return nullptr;
 
@@ -1448,10 +1464,15 @@ namespace {
           if (auto pointee = CFPointeeInfo::classifyTypedef(Decl)) {
             // If the pointee is a record, consider creating a class type.
             if (pointee.isRecord()) {
-              SwiftType = importCFClassType(Decl, Name.str(), pointee);
+              SwiftType = importCFClassType(Decl, Name, pointee);
               if (!SwiftType) return nullptr;
               NameMapping = MappedTypeNameKind::DefineOnly;
 
+              // If there is an alias (i.e., that doesn't have "Ref"),
+              // use that as the name of the typedef later.
+              if (importedName.Alias)
+                Name = importedName.Alias.getBaseName();
+
             // If the pointee is another CF typedef, create an extra typealias
             // for the name without "Ref", but not a separate type.
             } else if (pointee.isTypedef()) {
@@ -1460,7 +1481,6 @@ namespace {
               if (!underlying)
                 return nullptr;
 
-              // Remove one level of "Ref" from the typealias.
               if (auto typealias = dyn_cast<TypeAliasDecl>(underlying)) {
                 Type doublyUnderlyingTy = typealias->getUnderlyingType();
                 if (isa<NameAliasType>(doublyUnderlyingTy.getPointer()))
@@ -1473,20 +1493,24 @@ namespace {
               if (!DC)
                 return nullptr;
 
-              StringRef nameWithoutRef = getImportedCFTypeName(Name.str());
-              Identifier idWithoutRef =
-                Impl.SwiftContext.getIdentifier(nameWithoutRef);
-              auto aliasWithoutRef =
-                Impl.createDeclWithClangNode<TypeAliasDecl>(Decl,
-                                      Impl.importSourceLoc(Decl->getLocStart()),
-                                      idWithoutRef,
-                                      Impl.importSourceLoc(Decl->getLocation()),
-                                      TypeLoc::withoutLoc(SwiftType),
-                                      DC);
-
-              aliasWithoutRef->computeType();
-              SwiftType = aliasWithoutRef->getDeclaredType();
-              NameMapping = MappedTypeNameKind::DefineOnly;
+              // If there is an alias (i.e., that doesn't have "Ref"),
+              // create that separate typedef.
+              if (importedName.Alias) {
+                auto aliasWithoutRef =
+                  Impl.createDeclWithClangNode<TypeAliasDecl>(
+                    Decl,
+                    Impl.importSourceLoc(Decl->getLocStart()),
+                    importedName.Alias.getBaseName(),
+                    Impl.importSourceLoc(Decl->getLocation()),
+                    TypeLoc::withoutLoc(SwiftType),
+                    DC);
+
+                aliasWithoutRef->computeType();
+                SwiftType = aliasWithoutRef->getDeclaredType();
+                NameMapping = MappedTypeNameKind::DefineOnly;
+              } else {
+                NameMapping = MappedTypeNameKind::DefineAndUse;
+              }
 
             // If the pointee is 'const void', 
             // 'CFTypeRef', bring it in specifically as AnyObject.
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
@@ -1967,9 +1967,8 @@ Type ClangImporter::Implementation::importMethodType(
                                allowNSUIntegerAsIntInResult,
                                /*isFullyBridgeable*/true,
                                OptionalityOfReturn);
-
     // Adjust the result type for a throwing function.
-    if (errorInfo) {
+    if (swiftResultTy && errorInfo) {
       origSwiftResultTy = swiftResultTy->getCanonicalType();
       swiftResultTy = adjustResultTypeForThrowingFunction(*errorInfo,
                                                           swiftResultTy);
diff --git a/lib/ClangImporter/ImporterImpl.h b/lib/ClangImporter/ImporterImpl.h
@@ -724,7 +724,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
 
   /// Determine the imported CF type for the given typedef-name, or the empty
   /// string if this is not an imported CF type name.
-  StringRef getCFTypeName(const clang::TypedefNameDecl *decl);
+  StringRef getCFTypeName(const clang::TypedefNameDecl *decl,
+                          StringRef *secondaryName = nullptr);
 
   /// Retrieve the type name of a Clang type for the purposes of
   /// omitting unneeded words.
@@ -765,6 +766,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     /// The imported name.
     DeclName Imported;
 
+    /// An additional alias to the imported name, which should be
+    /// recorded in name lookup tables as well.
+    DeclName Alias;
+
     /// Whether this name was explicitly specified via a Clang
     /// swift_name attribute.
     bool HasCustomName = false;
@@ -775,7 +780,7 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     bool DroppedVariadic = false;
 
     /// For an initializer, the kind of initializer to import.
-    CtorInitializerKind InitKind;
+    CtorInitializerKind InitKind = CtorInitializerKind::Designated;
 
     /// For names that map Objective-C error handling conventions into
     /// throwing Swift methods, describes how the mapping is performed.
diff --git a/test/IDE/Inputs/swift_name_objc.h b/test/IDE/Inputs/swift_name_objc.h
@@ -63,3 +63,6 @@ SWIFT_NAME(SomeProtocol)
 - (nullable instancetype)initAndReturnError:(NSError **)error;
 - (nullable instancetype)initWithFloat:(float)value error:(NSError **)error;
 @end
+
+typedef const void *CFTypeRef __attribute__((objc_bridge(id)));
+typedef const struct __attribute__((objc_bridge(id))) __CCItem *CCItemRef;
diff --git a/test/IDE/dump_swift_lookup_tables_objc.swift b/test/IDE/dump_swift_lookup_tables_objc.swift
@@ -7,6 +7,9 @@
 // REQUIRES: objc_interop
 
 // CHECK:      Base -> full name mappings:
+// CHECK-NEXT:   CCItem --> CCItem
+// CHECK-NEXT:   CCItemRef --> CCItemRef
+// CHECK-NEXT:   CFTypeRef --> CFTypeRef
 // CHECK-NEXT:   NSAccessibility --> NSAccessibility
 // CHECK-NEXT:   NSError --> NSError
 // CHECK-NEXT:   NSErrorImports --> NSErrorImports
@@ -15,6 +18,7 @@
 // CHECK-NEXT:   SomeClass --> SomeClass
 // CHECK-NEXT:   SomeProtocol --> SomeProtocol
 // CHECK-NEXT:   UIActionSheet --> UIActionSheet
+// CHECK-NEXT:   __CCItem --> __CCItem
 // CHECK-NEXT:   accessibilityFloat --> accessibilityFloat()
 // CHECK-NEXT:   categoryMethodWithX --> categoryMethodWithX(_:y:), categoryMethodWithX(_:y:z:)
 // CHECK-NEXT:   doubleProperty --> doubleProperty{{$}}
@@ -28,6 +32,12 @@
 // CHECK-NEXT:   setAccessibilityFloat --> setAccessibilityFloat(_:)
 
 // CHECK:      Full name -> entry mappings:
+// CHECK-NEXT:   CCItem:
+// CHECK-NEXT:     TU: CCItemRef
+// CHECK-NEXT:   CCItemRef:
+// CHECK-NEXT:     TU: CCItemRef
+// CHECK-NEXT:   CFTypeRef:
+// CHECK-NEXT:     TU: CFTypeRef
 // CHECK-NEXT:   NSAccessibility:
 // CHECK-NEXT:     TU: NSAccessibility{{$}}
 // CHECK-NEXT:   NSError:
@@ -44,6 +54,8 @@
 // CHECK-NEXT:     TU: SNSomeProtocol
 // CHECK-NEXT:   UIActionSheet:
 // CHECK-NEXT:     TU: UIActionSheet
+// CHECK-NEXT:   __CCItem:
+// CHECK-NEXT:     TU: __CCItem
 // CHECK-NEXT:   accessibilityFloat():
 // CHECK-NEXT:     NSAccessibility: -[NSAccessibility accessibilityFloat]
 // CHECK-NEXT:   categoryMethodWithX(_:y:):
