[Clang importer] Strip "NS" prefix from macro names, too

Author: DougGregor

lib/ClangImporter/ClangImporter.cpp

@@ -762,7 +762,7 @@ void ClangImporter::Implementation::addMacrosToLookupTable(
         break;
 
       // Add this entry.
-      auto name = importMacroName(macro.first, info);
+      auto name = importMacroName(macro.first, info, clangCtx);
       if (name.empty()) continue;
       table.addEntry(name, info, clangCtx.getTranslationUnitDecl());
     }
@@ -2088,13 +2088,42 @@ bool ClangImporter::shouldIgnoreMacro(StringRef Name,
 
 Identifier ClangImporter::Implementation::importMacroName(
              const clang::IdentifierInfo *clangIdentifier,
-             const clang::MacroInfo *macro) {
+             const clang::MacroInfo *macro,
+             clang::ASTContext &clangCtx) {
   // If we're supposed to ignore this macro, return an empty identifier.
   if (::shouldIgnoreMacro(clangIdentifier->getName(), macro))
     return Identifier();
 
-  // Import the identifier.
-  return importIdentifier(clangIdentifier);
+  // If we aren't omitting needless words, no transformation is applied to the
+  // name.
+  StringRef name = clangIdentifier->getName();
+  if (!OmitNeedlessWords) return SwiftContext.getIdentifier(name);
+
+  // Determine which module defines this macro.
+  StringRef moduleName;
+  if (auto moduleID = macro->getOwningModuleID()) {
+    if (auto module = clangCtx.getExternalSource()->getModule(moduleID))
+      moduleName = module->getTopLevelModuleName();
+  }
+
+  if (moduleName.empty())
+    moduleName = clangCtx.getLangOpts().CurrentModule;
+
+  // Check whether we have a prefix to strip.
+  unsigned prefixLen = stripModulePrefixLength(ModulePrefixes, moduleName,
+                                               name);
+  if (prefixLen == 0) return SwiftContext.getIdentifier(name);
+
+  // Strip the prefix.
+  name = name.substr(prefixLen);
+
+  // If we should lowercase, do so.
+  StringScratchSpace scratch;
+  if (shouldLowercaseValueName(name))
+    name = camel_case::toLowercaseInitialisms(name, scratch);
+
+  // We're done.
+  return SwiftContext.getIdentifier(name);
 }
 
 auto ClangImporter::Implementation::importFullName(
@@ -3516,11 +3545,13 @@ void ClangImporter::lookupBridgingHeaderDecls(
       }
     }
   }
+
+  auto &ClangCtx = Impl.getClangASTContext();
   auto &ClangPP = Impl.getClangPreprocessor();
   for (clang::IdentifierInfo *II : Impl.BridgeHeaderMacros) {
     if (auto *MI = ClangPP.getMacroInfo(II)) {
       if (filter(MI)) {
-        Identifier Name = Impl.importMacroName(II, MI);
+        Identifier Name = Impl.importMacroName(II, MI, ClangCtx);
         if (Decl *imported = Impl.importMacro(Name, MI))
           receiver(imported);
       }
@@ -3597,7 +3628,7 @@ bool ClangImporter::lookupDeclsFromHeader(StringRef Filename,
           auto *II = const_cast<clang::IdentifierInfo*>(MD->getName());
           if (auto *MI = ClangPP.getMacroInfo(II)) {
             if (filter(MI)) {
-              Identifier Name = Impl.importMacroName(II, MI);
+              Identifier Name = Impl.importMacroName(II, MI, ClangCtx);
               if (Decl *imported = Impl.importMacro(Name, MI))
                 receiver(imported);
             }
@@ -4360,7 +4391,7 @@ SwiftLookupTable *ClangImporter::Implementation::findLookupTable(
 ///
 /// FIXME: this is an elaborate hack to badly reflect Clang's
 /// submodule visibility into Swift.
-static bool isVisibleClangEntry(clang::Preprocessor &pp,
+static bool isVisibleClangEntry(clang::ASTContext &ctx,
                                 StringRef name,
                                 SwiftLookupTable::SingleEntry entry) {
   if (auto clangDecl = entry.dyn_cast<clang::NamedDecl *>()) {
@@ -4376,20 +4407,25 @@ static bool isVisibleClangEntry(clang::Preprocessor &pp,
   }
 
   // Check whether the macro is defined.
-  // FIXME: We could get the wrong macro definition here.
-  return pp.isMacroDefined(name);
+  auto clangMacro = entry.get<clang::MacroInfo *>();
+  if (auto moduleID = clangMacro->getOwningModuleID()) {
+    if (auto module = ctx.getExternalSource()->getModule(moduleID)) 
+      return module->NameVisibility == clang::Module::AllVisible;
+  }
+
+  return true;
 }
 
 void ClangImporter::Implementation::lookupValue(
        SwiftLookupTable &table, DeclName name,
        VisibleDeclConsumer &consumer) {
-  auto clangTU = getClangASTContext().getTranslationUnitDecl();
-  auto &clangPP = getClangPreprocessor();
+  auto &clangCtx = getClangASTContext();
+  auto clangTU = clangCtx.getTranslationUnitDecl();
   auto baseName = name.getBaseName().str();
 
   for (auto entry : table.lookup(name.getBaseName().str(), clangTU)) {
     // If the entry is not visible, skip it.
-    if (!isVisibleClangEntry(clangPP, baseName, entry)) continue;
+    if (!isVisibleClangEntry(clangCtx, baseName, entry)) continue;
 
     ValueDecl *decl;
 
@@ -4442,12 +4478,12 @@ void ClangImporter::Implementation::lookupObjCMembers(
        SwiftLookupTable &table,
        DeclName name,
        VisibleDeclConsumer &consumer) {
-  auto &clangPP = getClangPreprocessor();
+  auto &clangCtx = getClangASTContext();
   auto baseName = name.getBaseName().str();
 
   for (auto clangDecl : table.lookupObjCMembers(baseName)) {
     // If the entry is not visible, skip it.
-    if (!isVisibleClangEntry(clangPP, baseName, clangDecl)) continue;
+    if (!isVisibleClangEntry(clangCtx, baseName, clangDecl)) continue;
 
     // Import the declaration.
     auto decl = cast_or_null<ValueDecl>(importDeclReal(clangDecl));

lib/ClangImporter/ImporterImpl.h

@@ -874,7 +874,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
 
   /// Imports the name of the given Clang macro into Swift.
   Identifier importMacroName(const clang::IdentifierInfo *clangIdentifier,
-                             const clang::MacroInfo *macro);
+                             const clang::MacroInfo *macro,
+                             clang::ASTContext &clangCtx);
 
   /// \brief Import the given Clang identifier into Swift.
   ///

lib/ClangImporter/SwiftLookupTable.h

@@ -51,7 +51,7 @@ const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MAJOR = 1;
 /// Lookup table minor version number.
 ///
 /// When the format changes IN ANY WAY, this number should be incremented.
-const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MINOR = 2;
+const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MINOR = 6;
 
 /// A lookup table that maps Swift names to the set of Clang
 /// declarations with that particular name.

test/IDE/dump_swift_lookup_tables_objc.swift

@@ -7,6 +7,8 @@
 // REQUIRES: objc_interop
 
 // CHECK-LABEL: <<Foundation lookup table>>
+// CHECK:   NSTimeIntervalSince1970:
+// CHECK:     TU: Macro
 // CHECK: Categories:{{.*}}NSValue(NSValueCreation){{.*}}
 
 // CHECK-LABEL: <<ObjectiveC lookup table>>
@@ -80,6 +82,10 @@
 
 // CHECK: Categories: SNSomeClass(), SNSomeClass(Category1)
 
+// CHECK-OMIT-NEEDLESS-WORDS-LABEL: <<Foundation lookup table>>
+// CHECK-OMIT-NEEDLESS-WORDS:   timeIntervalSince1970:
+// CHECK-OMIT-NEEDLESS-WORDS:     TU: Macro
+
 // CHECK-OMIT-NEEDLESS-WORDS: <<ObjectiveC lookup table>>
 // CHECK-OMIT-NEEDLESS-WORDS-NOT: lookup table
 // CHECK-OMIT-NEEDLESS-WORDS: respondsTo:

test/IDE/print_omit_needless_words.swift

@@ -178,6 +178,10 @@
 // Lowercasing initialisms with plurals.
 // CHECK-FOUNDATION: var urlsInText: [URL] { get }
 
+// Prefix stripping for macro names.
+// CHECK-FOUNDATION: var timeIntervalSince1970: Double { get }
+// CHECK-FOUNDATION: var DO_SOMETHING: Int
+
 // Note: class method name stripping context type.
 // CHECK-APPKIT: class func red() -> NSColor
 

test/Inputs/clang-importer-sdk/usr/include/Foundation.h

@@ -1005,3 +1005,6 @@ extern NSString *NSHTTPRequestKey;
 @interface NSObject (Selectors)
 -(void)messageSomeObject:(nonnull id)object selector:(SEL)selector;
 @end
+
+#define NSTimeIntervalSince1970  978307200.0
+#define NS_DO_SOMETHING 17