Clang importer: teach importFullName to map init methods to initializers.

We're only using this in the Swift lookup tables at the moment.

Author: DougGregor

lib/ClangImporter/ClangImporter.cpp

@@ -1655,8 +1655,10 @@ DeclName ClangImporter::Implementation::importFullName(
 
   /// Whether the result is a function name.
   bool isFunction = false;
+  bool isInitializer = false;
   StringRef baseName;
   SmallVector<StringRef, 4> argumentNames;
+  SmallString<16> selectorSplitScratch;
   switch (D->getDeclName().getNameKind()) {
   case clang::DeclarationName::CXXConstructorName:
   case clang::DeclarationName::CXXConversionFunctionName:
@@ -1675,15 +1677,55 @@ DeclName ClangImporter::Implementation::importFullName(
   case clang::DeclarationName::ObjCMultiArgSelector:
   case clang::DeclarationName::ObjCOneArgSelector:
   case clang::DeclarationName::ObjCZeroArgSelector: {
+    auto objcMethod = cast<clang::ObjCMethodDecl>(D);
+    isInitializer = isInitMethod(objcMethod);
+
     // Map the Objective-C selector directly.
     auto selector = D->getDeclName().getObjCSelector();
-    baseName = selector.getNameForSlot(0);
+    if (isInitializer)
+      baseName = "init";
+    else
+      baseName = selector.getNameForSlot(0);
     for (unsigned index = 0, numArgs = selector.getNumArgs(); index != numArgs;
          ++index) {
-      if (index == 0)
-        argumentNames.push_back("");
-      else
+      if (index == 0) {
+        argumentNames.push_back(StringRef());
+      } else {
         argumentNames.push_back(selector.getNameForSlot(index));
+      }
+    }
+
+    // For initializers, compute the first argument name.
+    if (isInitializer) {
+      // Skip over the 'init'.
+      auto argName = selector.getNameForSlot(0).substr(4);
+
+      // Drop "With" if present after the "init".
+      bool droppedWith = false;
+      if (argName.startswith("With")) {
+        argName = argName.substr(4);
+        droppedWith = true;
+      }
+
+      // Lowercase the remaining argument name.
+      argName = camel_case::toLowercaseWord(argName, selectorSplitScratch);
+
+      // If we dropped "with" and ended up with a reserved name,
+      // put "with" back.
+      if (droppedWith && isSwiftReservedName(argName)) {
+        selectorSplitScratch = "with";
+        selectorSplitScratch += selector.getNameForSlot(0).substr(8);
+        argName = selectorSplitScratch;
+      }
+
+      // Set the first argument name to be the name we computed. If
+      // there is no first argument, create one for this purpose.
+      if (argumentNames.empty() && !argName.empty()) {
+        // FIXME: Record what happened here for the caller?
+        argumentNames.push_back(argName);
+      } else {
+        argumentNames[0] = argName;
+      }
     }
 
     isFunction = true;
@@ -1825,17 +1867,15 @@ DeclName ClangImporter::Implementation::importFullName(
   if (hasSwiftPrivate(D)) {
     swiftPrivateScratch = "__";
 
-    if (baseName == "init") {
+    if (isInitializer) {
       // For initializers, prepend "__" to the first argument name.
       if (argumentNames.empty()) {
-        // swift_private cannot actually do anything here. Just drop the
-        // declaration.
-        // FIXME: Diagnose this?
-        return { };
+        // FIXME: Record that we did this.
+        argumentNames.push_back("__");
+      } else {
+        swiftPrivateScratch += argumentNames[0];
+        argumentNames[0] = swiftPrivateScratch;
       }
-
-      swiftPrivateScratch += argumentNames[0];
-      argumentNames[0] = swiftPrivateScratch;
     } else {
       // For all other entities, prepend "__" to the base name.
       swiftPrivateScratch += baseName;
@@ -2572,6 +2612,19 @@ ClangImporter::Implementation::isAccessibilityDecl(const clang::Decl *decl) {
   return false;
 }
 
+bool ClangImporter::Implementation::isInitMethod(
+       const clang::ObjCMethodDecl *method) {
+  // init methods are always instance methods.
+  if (!method->isInstanceMethod()) return false;
+
+  // init methods must be classified as such by Clang.
+  if (method->getMethodFamily() != clang::OMF_init) return false;
+
+  // Swift restriction: init methods must start with the word "init".
+  auto selector = method->getSelector();
+  return camel_case::getFirstWord(selector.getNameForSlot(0)) == "init";
+}
+
 #pragma mark Name lookup
 void ClangImporter::lookupValue(Identifier name, VisibleDeclConsumer &consumer){
   auto &pp = Impl.Instance->getPreprocessor();

lib/ClangImporter/ImportDecl.cpp

@@ -2879,8 +2879,7 @@ namespace {
                               DeclContext *dc,
                               bool forceClassMethod = false) {
       // If we have an init method, import it as an initializer.
-      if (decl->getMethodFamily() == clang::OMF_init &&
-          isReallyInitMethod(decl)) {
+      if (Impl.isInitMethod(decl)) {
         // Cannot force initializers into class methods.
         if (forceClassMethod)
           return nullptr;
@@ -3069,27 +3068,6 @@ namespace {
       return result;
     }
 
-  private:
-    /// Check whether the given name starts with the given word.
-    static bool startsWithWord(StringRef name, StringRef word) {
-      if (name.size() < word.size()) return false;
-      return ((name.size() == word.size() || !islower(name[word.size()])) &&
-              name.startswith(word));
-    }
-
-    /// Determine whether the given Objective-C method, which Clang classifies
-    /// as an init method, is considered an init method in Swift.
-    static bool isReallyInitMethod(const clang::ObjCMethodDecl *method) {
-      if (!method->isInstanceMethod())
-        return false;
-
-      auto selector = method->getSelector();
-      auto first = selector.getIdentifierInfoForSlot(0);
-      if (!first) return false;
-
-      return startsWithWord(first->getName(), "init");
-    }
-
   public:
     /// \brief Given an imported method, try to import it as some kind of
     /// special declaration, e.g., a constructor or subscript.
@@ -3241,9 +3219,7 @@ namespace {
                                        Optional<CtorInitializerKind> kind,
                                        bool required) {
       // Only methods in the 'init' family can become constructors.
-      assert(objcMethod->getMethodFamily() == clang::OMF_init &&
-             "Not an init method");
-      assert(isReallyInitMethod(objcMethod) && "Not a real init method");
+      assert(Impl.isInitMethod(objcMethod) && "Not a real init method");
 
       // Check whether we've already created the constructor.
       auto known = Impl.Constructors.find({objcMethod, dc});
@@ -4552,8 +4528,7 @@ namespace {
             continue;
 
           // When mirroring an initializer, make it designated and required.
-          if (objcMethod->getMethodFamily() == clang::OMF_init &&
-              isReallyInitMethod(objcMethod)) {
+          if (Impl.isInitMethod(objcMethod)) {
             // Import the constructor.
             if (auto imported = importConstructor(
                                   objcMethod, dc, /*implicit=*/true,

lib/ClangImporter/ImporterImpl.h

@@ -426,6 +426,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// imported as methods into Swift.
   bool isAccessibilityDecl(const clang::Decl *objCMethodOrProp);
 
+  /// Determine whether this method is an Objective-C "init" method
+  /// that will be imported as a Swift initializer.
+  bool isInitMethod(const clang::ObjCMethodDecl *method);
+
 private:
   /// \brief Generation number that is used for crude versioning.
   ///

test/IDE/Inputs/swift_name_objc.h

@@ -16,6 +16,7 @@
 SWIFT_NAME(SomeClass)
 @interface SNSomeClass : NSObject
 - (instancetype)initWithFloat:(float)f;
+- (instancetype)initWithDefault;
 - (void)instanceMethodWithX:(float)x y:(float)y z:(float)z;
 + (instancetype)someClassWithDouble:(double)d;
 

test/IDE/dump_swift_lookup_tables_objc.swift

@@ -14,7 +14,7 @@
 // CHECK-NEXT:   doubleProperty --> doubleProperty{{$}}
 // CHECK-NEXT:   extensionMethodWithX --> extensionMethodWithX(_:y:)
 // CHECK-NEXT:   floatProperty --> floatProperty{{$}}
-// CHECK-NEXT:   initWithFloat --> initWithFloat(_:)
+// CHECK-NEXT:   init --> init(float:), init(withDefault:)
 // CHECK-NEXT:   instanceMethodWithX --> instanceMethodWithX(_:y:z:)
 // CHECK-NEXT:   protoInstanceMethodWithX --> protoInstanceMethodWithX(_:y:)
 // CHECK-NEXT:   setAccessibilityFloat --> setAccessibilityFloat(_:)
@@ -43,8 +43,10 @@
 // CHECK-NEXT:     SNSomeClass: -[SNSomeClass extensionMethodWithX:y:]
 // CHECK-NEXT:   floatProperty:
 // CHECK-NEXT:     SNSomeClass: SNSomeClass.floatProperty
-// CHECK-NEXT:   initWithFloat(_:):
+// CHECK-NEXT:   init(float:):
 // CHECK-NEXT:     SNSomeClass: -[SNSomeClass initWithFloat:]
+// CHECK-NEXT:   init(withDefault:):
+// CHECK-NEXT:     SNSomeClass: -[SNSomeClass initWithDefault]
 // CHECK-NEXT:   instanceMethodWithX(_:y:z:):
 // CHECK-NEXT:     SNSomeClass: -[SNSomeClass instanceMethodWithX:y:z:]
 // CHECK-NEXT:   protoInstanceMethodWithX(_:y:):