[Clang importer] Factor mapping of macro names into a single location. NFC

Author: DougGregor

include/swift/ClangImporter/ClangImporter.h

@@ -231,9 +231,6 @@ class ClangImporter final : public ClangModuleLoader {
   /// Otherwise, return nullptr.
   Decl *importDeclCached(const clang::NamedDecl *ClangDecl);
 
-  /// Returns true if it is expected that the macro is ignored.
-  bool shouldIgnoreMacro(StringRef Name, const clang::MacroInfo *Macro);
-
   /// Returns the name of the given enum element as it would be imported into
   /// Swift.
   ///

lib/ClangImporter/ClangImporter.cpp

@@ -740,10 +740,6 @@ void ClangImporter::Implementation::addMacrosToLookupTable(
     clang::MacroDirective *MD = pp.getLocalMacroDirectiveHistory(macro.first);
     if (!MD) continue;
 
-    // Import the name.
-    auto name = importIdentifier(macro.first);
-    if (name.empty()) continue;
-
     // Walk the history.
     for (; MD; MD = MD->getPrevious()) {
       // Check whether we have a macro defined in this module.
@@ -766,6 +762,8 @@ void ClangImporter::Implementation::addMacrosToLookupTable(
         break;
 
       // Add this entry.
+      auto name = importMacroName(macro.first, info);
+      if (name.empty()) continue;
       table.addEntry(name, info, clangCtx.getTranslationUnitDecl());
     }
   }
@@ -2020,6 +2018,44 @@ static bool canStripModulePrefix(StringRef name) {
   return true;
 }
 
+/// Returns true if it is expected that the macro is ignored.
+static bool shouldIgnoreMacro(const clang::IdentifierInfo *identifier,
+                              const clang::MacroInfo *macro) {
+  // Ignore include guards.
+  if (macro->isUsedForHeaderGuard())
+    return true;
+
+  // If there are no tokens, there is nothing to convert.
+  if (macro->tokens_empty())
+    return true;
+
+  // Currently we only convert non-function-like macros.
+  if (macro->isFunctionLike())
+    return nullptr;
+
+  // Consult the blacklist of macros to suppress.
+  auto suppressMacro =
+    llvm::StringSwitch<bool>(identifier->getName())
+#define SUPPRESS_MACRO(NAME) .Case(#NAME, true)
+#include "MacroTable.def"
+    .Default(false);
+
+  if (suppressMacro)
+    return true;
+
+  return false;
+}
+
+Identifier ClangImporter::Implementation::importMacroName(
+             const clang::IdentifierInfo *clangIdentifier,
+             const clang::MacroInfo *macro) {
+  // If we're supposed to ignore this macro, return an empty identifier.
+  if (shouldIgnoreMacro(clangIdentifier, macro)) return Identifier();
+
+  // Import the identifier.
+  return importIdentifier(clangIdentifier);
+}
+
 auto ClangImporter::Implementation::importFullName(
        const clang::NamedDecl *D,
        ImportNameOptions options,
@@ -3439,12 +3475,11 @@ void ClangImporter::lookupBridgingHeaderDecls(
       }
     }
   }
-  ASTContext &Ctx = Impl.SwiftContext;
   auto &ClangPP = Impl.getClangPreprocessor();
   for (clang::IdentifierInfo *II : Impl.BridgeHeaderMacros) {
     if (auto *MI = ClangPP.getMacroInfo(II)) {
       if (filter(MI)) {
-        Identifier Name = Ctx.getIdentifier(II->getName());
+        Identifier Name = Impl.importMacroName(II, MI);
         if (Decl *imported = Impl.importMacro(Name, MI))
           receiver(imported);
       }
@@ -3460,7 +3495,6 @@ bool ClangImporter::lookupDeclsFromHeader(StringRef Filename,
   if (!File)
     return true;
 
-  ASTContext &Ctx = Impl.SwiftContext;
   auto &ClangCtx = getClangASTContext();
   auto &ClangSM = ClangCtx.getSourceManager();
   auto &ClangPP = getClangPreprocessor();
@@ -3522,7 +3556,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 = Ctx.getIdentifier(II->getName());
+              Identifier Name = Impl.importMacroName(II, MI);
               if (Decl *imported = Impl.importMacro(Name, MI))
                 receiver(imported);
             }
@@ -3937,11 +3971,6 @@ Decl *ClangImporter::importDeclCached(const clang::NamedDecl *ClangDecl) {
   return Impl.importDeclCached(ClangDecl);
 }
 
-bool ClangImporter::shouldIgnoreMacro(StringRef Name,
-                                      const clang::MacroInfo *Macro) {
-  return Impl.shouldIgnoreMacro(Name, Macro);
-}
-
 void ClangImporter::printStatistics() const {
   Impl.Instance->getModuleManager()->PrintStats();
 }

lib/ClangImporter/ImportMacro.cpp

@@ -225,40 +225,12 @@ static bool isSignToken(const clang::Token &tok) {
          tok.is(clang::tok::tilde);
 }
 
-/// Returns true if it is expected that the macro is ignored.
-bool ClangImporter::Implementation::shouldIgnoreMacro(StringRef name,
-                                                const clang::MacroInfo *macro) {
-  // Ignore include guards.
-  if (macro->isUsedForHeaderGuard())
-    return true;
-
-  if (macro->tokens_empty())
-    return true;
-
-  // Consult the blacklist of macros to suppress.
-  auto suppressMacro =
-    llvm::StringSwitch<bool>(name)
-#define SUPPRESS_MACRO(NAME) .Case(#NAME, true)
-#include "MacroTable.def"
-    .Default(false);
-
-  if (suppressMacro)
-    return true;
-
-  return false;
-}
-
 static ValueDecl *importMacro(ClangImporter::Implementation &impl,
                               DeclContext *DC,
                               Identifier name,
                               const clang::MacroInfo *macro,
                               const clang::MacroInfo *ClangN) {
-  if (impl.shouldIgnoreMacro(name.str(), macro))
-    return nullptr;
-
-  // Currently we only convert non-function-like macros.
-  if (macro->isFunctionLike())
-    return nullptr;
+  if (name.empty()) return nullptr;
 
   auto numTokens = macro->getNumTokens();
   auto tokenI = macro->tokens_begin(), tokenE = macro->tokens_end();

lib/ClangImporter/ImporterImpl.h

@@ -872,6 +872,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
                               clang::DeclContext **effectiveContext = nullptr,
                               clang::Sema *clangSemaOverride = nullptr);
 
+  /// Imports the name of the given Clang macro into Swift.
+  Identifier importMacroName(const clang::IdentifierInfo *clangIdentifier,
+                             const clang::MacroInfo *macro);
+
   /// \brief Import the given Clang identifier into Swift.
   ///
   /// \param identifier The Clang identifier to map into Swift.
@@ -906,9 +910,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// translated into Swift.
   ValueDecl *importMacro(Identifier name, clang::MacroInfo *macro);
 
-  /// Returns true if it is expected that the macro is ignored.
-  bool shouldIgnoreMacro(StringRef name, const clang::MacroInfo *macro);
-
   /// \brief Classify the given Clang enumeration type to describe how it
   /// should be imported 
   static EnumKind classifyEnum(clang::Preprocessor &pp,