[clang][extract-api] Use dedicated API to check for macro equality

[zixuw]

LGTM

clang/lib/ExtractAPI/ExtractAPIConsumer.cpp

 
 private:
   ExtractAPIVisitor Visitor;
   std::unique_ptr<LocationFileChecker> LCF;
 };
 
 class MacroCallback : public PPCallbacks {
 public:
-  MacroCallback(const SourceManager &SM, LocationFileChecker &LCF, APISet &API)
-      : SM(SM), LCF(LCF), API(API) {}
+  MacroCallback(const SourceManager &SM, LocationFileChecker &LCF, APISet &API,
+                Preprocessor &PP)
+      : SM(SM), LCF(LCF), API(API), PP(PP) {}
 
   void MacroDefined(const Token &MacroNameToken,
                     const MacroDirective *MD) override {
     auto *MacroInfo = MD->getMacroInfo();
 
     if (MacroInfo->isBuiltinMacro())
       return;
 
public:
   // macro definition for it.
   void MacroUndefined(const Token &MacroNameToken, const MacroDefinition &MD,
                       const MacroDirective *Undef) override {
     // If this macro wasn't previously defined we don't need to do anything
     // here.
     if (!Undef)
       return;
 
-    llvm::erase_if(PendingMacros, [&MD](const PendingMacro &PM) {
-      return MD.getMacroInfo()->getDefinitionLoc() ==
-             PM.MD->getMacroInfo()->getDefinitionLoc();
+    llvm::erase_if(PendingMacros, [&MD, this](const PendingMacro &PM) {
+      return MD.getMacroInfo()->isIdenticalTo(*PM.MD->getMacroInfo(), PP,
+                                              /*Syntactically*/ false);
     });
   }
 
   void EndOfMainFile() override {
     for (auto &PM : PendingMacros) {
       // `isUsedForHeaderGuard` is only set when the preprocessor leaves the
       // file so check for it here.
       if (PM.MD->getMacroInfo()->isUsedForHeaderGuard())
struct PendingMacro {
 
     PendingMacro(const Token &MacroNameToken, const MacroDirective *MD)
         : MacroNameToken(MacroNameToken), MD(MD) {}
   };
 
   const SourceManager &SM;
   LocationFileChecker &LCF;
   APISet &API;
+  Preprocessor &PP;
   llvm::SmallVector<PendingMacro> PendingMacros;
 };
 
 } // namespace
 
 std::unique_ptr<ASTConsumer>
 ExtractAPIAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   OS = CreateOutputFile(CI, InFile);
   if (!OS)
     return nullptr;
 
   ProductName = CI.getFrontendOpts().ProductName;
 
   // Now that we have enough information about the language options and the
   // target triple, let's create the APISet before anyone uses it.
   API = std::make_unique<APISet>(
       CI.getTarget().getTriple(),
       CI.getFrontendOpts().Inputs.back().getKind().getLanguage());
 
   auto LCF = std::make_unique<LocationFileChecker>(CI.getSourceManager(),
                                                    KnownInputFiles);
 
-  // Register preprocessor callbacks that will add macro definitions to API.
-  CI.getPreprocessor().addPPCallbacks(
-      std::make_unique<MacroCallback>(CI.getSourceManager(), *LCF, *API));
+  CI.getPreprocessor().addPPCallbacks(std::make_unique<MacroCallback>(
+      CI.getSourceManager(), *LCF, *API, CI.getPreprocessor()));
 
   return std::make_unique<ExtractAPIConsumer>(CI.getASTContext(),
                                               std::move(LCF), *API);
 }
 
 bool ExtractAPIAction::PrepareToExecuteAction(CompilerInstance &CI) {
   auto &Inputs = CI.getFrontendOpts().Inputs;
   if (Inputs.empty())