[clang][lex] Pass hash location to more PPCallbacks methods

[KyleFromKitware]

WIP - currently updating the tests for pp-trace and in the process debugging an issue with the location of the #endif hash.

[KyleFromKitware]

Added Introducer parameter to Pragma callbacks.

[dang]

LGTM for the ExtractAPI changes.

[KyleFromKitware]

Rebased onto main for D141000.

clang-tools-extra/clang-include-fixer/find-all-symbols/FindAllMacros.h

                          HeaderMapCollector *Collector = nullptr)
       : Reporter(Reporter), SM(SM), Collector(Collector) {}
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override;
 
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override;
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override;
 
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override;
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override;
 
   void EndOfMainFile() override;
 

clang-tools-extra/clang-include-fixer/find-all-symbols/FindAllMacros.cpp

                     SymbolInfo::SymbolKind::Macro, FilePath, {});
 }
 
-void FindAllMacros::MacroDefined(const Token &MacroNameTok,
+void FindAllMacros::MacroDefined(SourceLocation HashLoc,
+                                 const Token &MacroNameTok,
                                  const MacroDirective *MD) {
   if (auto Symbol = CreateMacroSymbol(MacroNameTok, MD->getMacroInfo()))
     ++FileSymbols[*Symbol].Seen;

   MacroUsed(MacroNameTok, MD);
 }
 
-void FindAllMacros::Ifdef(SourceLocation Loc, const Token &MacroNameTok,
+void FindAllMacros::Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+                          const Token &MacroNameTok,
                           const MacroDefinition &MD) {
   MacroUsed(MacroNameTok, MD);
 }
 
-void FindAllMacros::Ifndef(SourceLocation Loc, const Token &MacroNameTok,
+void FindAllMacros::Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+                           const Token &MacroNameTok,
                            const MacroDefinition &MD) {
   MacroUsed(MacroNameTok, MD);
 }

clang-tools-extra/clang-tidy/ExpandModularHeadersPPCallbacks.h

   void PragmaAssumeNonNullEnd(SourceLocation Loc) override;
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &,
                     SourceRange Range, const MacroArgs *) override;
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override;
-  void MacroUndefined(const Token &, const MacroDefinition &,
+  void MacroUndefined(SourceLocation HashLoc, const Token &,
+                      const MacroDefinition &,
                       const MacroDirective *Undef) override;
   void Defined(const Token &MacroNameTok, const MacroDefinition &,
                SourceRange Range) override;
   void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;
-  void If(SourceLocation Loc, SourceRange, ConditionValueKind) override;
-  void Elif(SourceLocation Loc, SourceRange, ConditionValueKind,
-            SourceLocation) override;
-  void Ifdef(SourceLocation Loc, const Token &,
+  void If(SourceLocation HashLoc, SourceLocation Loc, SourceRange,
+          ConditionValueKind) override;
+  void Elif(SourceLocation HashLoc, SourceLocation Loc, SourceRange,
+            ConditionValueKind, SourceLocation) override;
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc, const Token &,
              const MacroDefinition &) override;
-  void Ifndef(SourceLocation Loc, const Token &,
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc, const Token &,
               const MacroDefinition &) override;
-  void Else(SourceLocation Loc, SourceLocation) override;
-  void Endif(SourceLocation Loc, SourceLocation) override;
+  void Else(SourceLocation HashLoc, SourceLocation Loc,
+            SourceLocation) override;
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation) override;
 
   std::unique_ptr<FileRecorder> Recorder;
   // Set of all the modules visited. Avoids processing a module more than once.

clang-tools-extra/clang-tidy/ExpandModularHeadersPPCallbacks.cpp

   // FIXME: Figure out whether it's the right location to parse to.
   parseToLocation(Range.getBegin());
 }
-void ExpandModularHeadersPPCallbacks::MacroDefined(const Token &MacroNameTok,
+void ExpandModularHeadersPPCallbacks::MacroDefined(SourceLocation HashLoc,
+                                                   const Token &MacroNameTok,
                                                    const MacroDirective *MD) {
   parseToLocation(MD->getLocation());
 }
 void ExpandModularHeadersPPCallbacks::MacroUndefined(
-    const Token &, const MacroDefinition &, const MacroDirective *Undef) {
+    SourceLocation HashLoc, const Token &, const MacroDefinition &,
+    const MacroDirective *Undef) {
   if (Undef)
     parseToLocation(Undef->getLocation());
 }

   // FIXME: Figure out whether it's the right location to parse to.
   parseToLocation(EndifLoc);
 }
-void ExpandModularHeadersPPCallbacks::If(SourceLocation Loc, SourceRange,
+void ExpandModularHeadersPPCallbacks::If(SourceLocation HashLoc,
+                                         SourceLocation Loc, SourceRange,
                                          ConditionValueKind) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::Elif(SourceLocation Loc, SourceRange,
+void ExpandModularHeadersPPCallbacks::Elif(SourceLocation HashLoc,
+                                           SourceLocation Loc, SourceRange,
                                            ConditionValueKind, SourceLocation) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::Ifdef(SourceLocation Loc, const Token &,
+void ExpandModularHeadersPPCallbacks::Ifdef(SourceLocation HashLoc,
+                                            SourceLocation Loc, const Token &,
                                             const MacroDefinition &) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::Ifndef(SourceLocation Loc, const Token &,
+void ExpandModularHeadersPPCallbacks::Ifndef(SourceLocation HashLoc,
+                                             SourceLocation Loc, const Token &,
                                              const MacroDefinition &) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::Else(SourceLocation Loc, SourceLocation) {
+void ExpandModularHeadersPPCallbacks::Else(SourceLocation HashLoc,
+                                           SourceLocation Loc, SourceLocation) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::Endif(SourceLocation Loc,
+void ExpandModularHeadersPPCallbacks::Endif(SourceLocation HashLoc,
+                                            SourceLocation Loc,
                                             SourceLocation) {
   parseToLocation(Loc);
 }

clang-tools-extra/clang-tidy/bugprone/MacroParenthesesCheck.cpp

   MacroParenthesesPPCallbacks(Preprocessor *PP, MacroParenthesesCheck *Check)
       : PP(PP), Check(Check) {}
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     replacementList(MacroNameTok, MD->getMacroInfo());
     argument(MacroNameTok, MD->getMacroInfo());

clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.cpp

                       bool IgnoreCommandLine)
       : Check(Check), SM(SM), RegExp(RegExpStr), CheckCapsOnly(CapsOnly),
         IgnoreCommandLineMacros(IgnoreCommandLine) {}
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     if (SM.isWrittenInBuiltinFile(MD->getLocation()) ||
         MD->getMacroInfo()->isUsedForHeaderGuard() ||

clang-tools-extra/clang-tidy/google/UpgradeGoogletestCaseCheck.cpp

     macroUsed(MacroNameTok, MD, Range.getBegin(), CheckAction::Rename);
   }
 
-  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
+                      const MacroDefinition &MD,
                       const MacroDirective *Undef) override {
     if (Undef != nullptr)
       macroUsed(MacroNameTok, MD, Undef->getLocation(), CheckAction::Warn);
   }
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     if (!ReplacementFound && MD != nullptr) {
       // We check if the newly defined macro is one of the target replacements.

     macroUsed(MacroNameTok, MD, Range.getBegin(), CheckAction::Warn);
   }
 
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override {
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override {
     macroUsed(MacroNameTok, MD, Loc, CheckAction::Warn);
   }
 
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override {
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override {
     macroUsed(MacroNameTok, MD, Loc, CheckAction::Warn);
   }
 

clang-tools-extra/clang-tidy/modernize/MacroToEnumCheck.cpp

   }
 
   // Keep track of macro definitions that look like enums.
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
   // Undefining an enum-like macro results in the enum set being dropped.
-  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
+                      const MacroDefinition &MD,
                       const MacroDirective *Undef) override;
 
   // Conditional compilation clears any adjacent enum-like macros.

   //   #if !defined(GUARD)
   // or
   //   #ifndef GUARD
-  void If(SourceLocation Loc, SourceRange ConditionRange,
+  void If(SourceLocation HashLoc, SourceLocation Loc,
+          SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override {
     conditionStart(Loc);
     checkCondition(ConditionRange);
   }
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override {
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override {
     conditionStart(Loc);
     checkName(MacroNameTok);
   }
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override {
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override {
     conditionStart(Loc);
     checkName(MacroNameTok);
   }
-  void Elif(SourceLocation Loc, SourceRange ConditionRange,
-            ConditionValueKind ConditionValue, SourceLocation IfLoc) override {
+  void Elif(SourceLocation HashLoc, SourceLocation Loc,
+            SourceRange ConditionRange, ConditionValueKind ConditionValue,
+            SourceLocation IfLoc) override {
     checkCondition(ConditionRange);
   }
-  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
-               const MacroDefinition &MD) override {
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               const Token &MacroNameTok, const MacroDefinition &MD) override {
     checkName(MacroNameTok);
   }
-  void Elifdef(SourceLocation Loc, SourceRange ConditionRange,
-      SourceLocation IfLoc) override {
-    PPCallbacks::Elifdef(Loc, ConditionRange, IfLoc);
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               SourceRange ConditionRange, SourceLocation IfLoc) override {
+    PPCallbacks::Elifdef(HashLoc, Loc, ConditionRange, IfLoc);
   }
-  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
-                const MacroDefinition &MD) override {
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                const Token &MacroNameTok, const MacroDefinition &MD) override {
     checkName(MacroNameTok);
   }
-  void Elifndef(SourceLocation Loc, SourceRange ConditionRange,
-      SourceLocation IfLoc) override {
-    PPCallbacks::Elifndef(Loc, ConditionRange, IfLoc);
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                SourceRange ConditionRange, SourceLocation IfLoc) override {
+    PPCallbacks::Elifndef(HashLoc, Loc, ConditionRange, IfLoc);
   }
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override;
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation IfLoc) override;
   void PragmaDirective(SourceLocation Loc,
                        PragmaIntroducerKind Introducer) override;
 

 
 // Any defined but rejected macro is scanned for identifiers that
 // are to be excluded as enums.
-void MacroToEnumCallbacks::MacroDefined(const Token &MacroNameTok,
+void MacroToEnumCallbacks::MacroDefined(SourceLocation HashLoc,
+                                        const Token &MacroNameTok,
                                         const MacroDirective *MD) {
   // Include guards are never candidates for becoming an enum.
   if (CurrentFile->GuardScanner == IncludeGuard::IfGuard) {

 
 // Any macro that is undefined removes all adjacent macros from consideration as
 // an enum and starts a new enum scan.
-void MacroToEnumCallbacks::MacroUndefined(const Token &MacroNameTok,
+void MacroToEnumCallbacks::MacroUndefined(SourceLocation HashLoc,
+                                          const Token &MacroNameTok,
                                           const MacroDefinition &MD,
                                           const MacroDirective *Undef) {
   rememberExpressionName(MacroNameTok);

   CurrentFile->GuardScanner = IncludeGuard::None;
 }
 
-void MacroToEnumCallbacks::Endif(SourceLocation Loc, SourceLocation IfLoc) {
+void MacroToEnumCallbacks::Endif(SourceLocation HashLoc, SourceLocation Loc,
+                                 SourceLocation IfLoc) {
   // The if directive for the include guard isn't counted in the
   // ConditionScopes.
   if (CurrentFile->ConditionScopes == 0 &&

clang-tools-extra/clang-tidy/readability/DuplicateIncludeCheck.cpp

                           StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
-  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
+                      const MacroDefinition &MD,
                       const MacroDirective *Undef) override;
 
 private:

     Files.back().push_back(FileName);
 }
 
-void DuplicateIncludeCallbacks::MacroDefined(const Token &MacroNameTok,
+void DuplicateIncludeCallbacks::MacroDefined(SourceLocation HashLoc,
+                                             const Token &MacroNameTok,
                                              const MacroDirective *MD) {
   Files.back().clear();
 }
 
-void DuplicateIncludeCallbacks::MacroUndefined(const Token &MacroNameTok,
+void DuplicateIncludeCallbacks::MacroUndefined(SourceLocation HashLoc,
+                                               const Token &MacroNameTok,
                                                const MacroDefinition &MD,
                                                const MacroDirective *Undef) {
   Files.back().clear();

clang-tools-extra/clang-tidy/readability/ElseAfterReturnCheck.cpp

       ElseAfterReturnCheck::ConditionalBranchMap &Collections,
       const SourceManager &SM)
       : Collections(Collections), SM(SM) {}
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation IfLoc) override {
     if (!SM.isWrittenInSameFile(Loc, IfLoc))
       return;
     SmallVectorImpl<SourceRange> &Collection = Collections[SM.getFileID(Loc)];

clang-tools-extra/clang-tidy/readability/RedundantPreprocessorCheck.cpp

                                           Preprocessor &PP)
       : Check(Check), PP(PP) {}
 
-  void If(SourceLocation Loc, SourceRange ConditionRange,
+  void If(SourceLocation HashLoc, SourceLocation Loc,
+          SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override {
     StringRef Condition =
         Lexer::getSourceText(CharSourceRange::getTokenRange(ConditionRange),

     checkMacroRedundancy(Loc, Condition, IfStack, DK_If, DK_If, true);
   }
 
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok,
              const MacroDefinition &MacroDefinition) override {
     std::string MacroName = PP.getSpelling(MacroNameTok);
     checkMacroRedundancy(Loc, MacroName, IfdefStack, DK_Ifdef, DK_Ifdef, true);

                          false);
   }
 
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok,
               const MacroDefinition &MacroDefinition) override {
     std::string MacroName = PP.getSpelling(MacroNameTok);
     checkMacroRedundancy(Loc, MacroName, IfndefStack, DK_Ifndef, DK_Ifndef,

                          false);
   }
 
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation IfLoc) override {
     if (!IfStack.empty() && IfLoc == IfStack.back().Loc)
       IfStack.pop_back();
     if (!IfdefStack.empty() && IfLoc == IfdefStack.back().Loc)

clang-tools-extra/clang-tidy/utils/HeaderGuard.cpp

     }
   }
 
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override {
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (MD)
       return;
 

         std::make_pair(Loc, MacroNameTok.getLocation());
   }
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     // Record all defined macros. We store the whole token to get info on the
     // name later.
     Macros.emplace_back(MacroNameTok, MD->getMacroInfo());
   }
 
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation IfLoc) override {
     // Record all #endif and the corresponding #ifs (including #ifndefs).
     EndIfs[IfLoc] = Loc;
   }

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

       : PP(PP), Check(Check) {}
 
   /// MacroDefined calls checkMacro for macros in the main file
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     if (MD->getMacroInfo()->isBuiltinMacro())
       return;

clang-tools-extra/clangd/CollectMacros.h

     InMainFile = isInsideMainFile(Loc, SM);
   }
 
-  void MacroDefined(const Token &MacroName, const MacroDirective *MD) override {
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroName,
+                    const MacroDirective *MD) override {
     add(MacroName, MD->getMacroInfo(), /*IsDefinition=*/true);
   }
 

     add(MacroName, MD.getMacroInfo());
   }
 
-  void MacroUndefined(const clang::Token &MacroName,
+  void MacroUndefined(SourceLocation HashLoc, const clang::Token &MacroName,
                       const clang::MacroDefinition &MD,
                       const clang::MacroDirective *Undef) override {
     add(MacroName, MD.getMacroInfo());
   }
 
-  void Ifdef(SourceLocation Loc, const Token &MacroName,
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc, const Token &MacroName,
              const MacroDefinition &MD) override {
     add(MacroName, MD.getMacroInfo());
   }
 
-  void Ifndef(SourceLocation Loc, const Token &MacroName,
-              const MacroDefinition &MD) override {
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroName, const MacroDefinition &MD) override {
     add(MacroName, MD.getMacroInfo());
   }
 

clang-tools-extra/clangd/Preamble.cpp

     InMainFile = SM.isWrittenInMainFile(Loc);
   }
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     if (!InMainFile)
       return;

clang-tools-extra/include-cleaner/lib/Record.cpp

     recordMacroRef(MacroName, *MD.getMacroInfo());
   }
 
-  void MacroDefined(const Token &MacroName, const MacroDirective *MD) override {
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroName,
+                    const MacroDirective *MD) override {
     if (!Active)
       return;
 

     }
   }
 
-  void MacroUndefined(const Token &MacroName, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroName,
+                      const MacroDefinition &MD,
                       const MacroDirective *) override {
     if (!Active)
       return;

       recordMacroRef(MacroName, *MI);
   }
 
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override {
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!Active)
       return;
     if (const auto *MI = MD.getMacroInfo())
       recordMacroRef(MacroNameTok, *MI, RefType::Ambiguous);
   }
 
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override {
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!Active)
       return;
     if (const auto *MI = MD.getMacroInfo())

 
   using PPCallbacks::Elifdef;
   using PPCallbacks::Elifndef;
-  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
-               const MacroDefinition &MD) override {
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!Active)
       return;
     if (const auto *MI = MD.getMacroInfo())
       recordMacroRef(MacroNameTok, *MI, RefType::Ambiguous);
   }
-  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
-                const MacroDefinition &MD) override {
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!Active)
       return;
     if (const auto *MI = MD.getMacroInfo())

clang-tools-extra/modularize/PreprocessorTracker.cpp

   void Defined(const clang::Token &MacroNameTok,
                const clang::MacroDefinition &MD,
                clang::SourceRange Range) override;
-  void If(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
+  void If(clang::SourceLocation HashLoc, clang::SourceLocation Loc,
+          clang::SourceRange ConditionRange,
           clang::PPCallbacks::ConditionValueKind ConditionResult) override;
-  void Elif(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
+  void Elif(clang::SourceLocation HashLoc, clang::SourceLocation Loc,
+            clang::SourceRange ConditionRange,
             clang::PPCallbacks::ConditionValueKind ConditionResult,
             clang::SourceLocation IfLoc) override;
-  void Ifdef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
+  void Ifdef(clang::SourceLocation HashLoc, clang::SourceLocation Loc,
+             const clang::Token &MacroNameTok,
              const clang::MacroDefinition &MD) override;
-  void Ifndef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
+  void Ifndef(clang::SourceLocation HashLoc, clang::SourceLocation Loc,
+              const clang::Token &MacroNameTok,
               const clang::MacroDefinition &MD) override;
 
 private:

       (MI ? "true" : "false"), PPTracker.getCurrentInclusionPathHandle());
 }
 
-void PreprocessorCallbacks::If(clang::SourceLocation Loc,
-                               clang::SourceRange ConditionRange,
-                               clang::PPCallbacks::ConditionValueKind ConditionResult) {
+void PreprocessorCallbacks::If(
+    clang::SourceLocation HashLoc, clang::SourceLocation Loc,
+    clang::SourceRange ConditionRange,
+    clang::PPCallbacks::ConditionValueKind ConditionResult) {
   std::string Unexpanded(getSourceString(PP, ConditionRange));
   PPTracker.addConditionalExpansionInstance(
       PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_if,
       ConditionResult, Unexpanded, PPTracker.getCurrentInclusionPathHandle());
 }
 
-void PreprocessorCallbacks::Elif(clang::SourceLocation Loc,
-                                 clang::SourceRange ConditionRange,
-                                 clang::PPCallbacks::ConditionValueKind ConditionResult,
-                                 clang::SourceLocation IfLoc) {
+void PreprocessorCallbacks::Elif(
+    clang::SourceLocation HashLoc, clang::SourceLocation Loc,
+    clang::SourceRange ConditionRange,
+    clang::PPCallbacks::ConditionValueKind ConditionResult,
+    clang::SourceLocation IfLoc) {
   std::string Unexpanded(getSourceString(PP, ConditionRange));
   PPTracker.addConditionalExpansionInstance(
       PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_elif,
       ConditionResult, Unexpanded, PPTracker.getCurrentInclusionPathHandle());
 }
 
-void PreprocessorCallbacks::Ifdef(clang::SourceLocation Loc,
+void PreprocessorCallbacks::Ifdef(clang::SourceLocation HashLoc,
+                                  clang::SourceLocation Loc,
                                   const clang::Token &MacroNameTok,
                                   const clang::MacroDefinition &MD) {
   clang::PPCallbacks::ConditionValueKind IsDefined =

       PPTracker.getCurrentInclusionPathHandle());
 }
 
-void PreprocessorCallbacks::Ifndef(clang::SourceLocation Loc,
+void PreprocessorCallbacks::Ifndef(clang::SourceLocation HashLoc,
+                                   clang::SourceLocation Loc,
                                    const clang::Token &MacroNameTok,
                                    const clang::MacroDefinition &MD) {
   clang::PPCallbacks::ConditionValueKind IsNotDefined =

clang-tools-extra/pp-trace/PPCallbacksTracker.h

   void PragmaExecCharsetPop(SourceLocation Loc) override;
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override;
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override;
-  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
+                      const MacroDefinition &MD,
                       const MacroDirective *Undef) override;
   void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                SourceRange Range) override;
   void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;
-  void If(SourceLocation Loc, SourceRange ConditionRange,
+  void If(SourceLocation HashLoc, SourceLocation Loc,
+          SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override;
-  void Elif(SourceLocation Loc, SourceRange ConditionRange,
-            ConditionValueKind ConditionValue, SourceLocation IfLoc) override;
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override;
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override;
-  void Else(SourceLocation Loc, SourceLocation IfLoc) override;
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override;
+  void Elif(SourceLocation HashLoc, SourceLocation Loc,
+            SourceRange ConditionRange, ConditionValueKind ConditionValue,
+            SourceLocation IfLoc) override;
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override;
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override;
+  void Else(SourceLocation HashLoc, SourceLocation Loc,
+            SourceLocation IfLoc) override;
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation IfLoc) override;
 
   // Helper functions.
 

clang-tools-extra/pp-trace/PPCallbacksTracker.cpp

 }
 
 // Hook called whenever a macro definition is seen.
-void PPCallbacksTracker::MacroDefined(const Token &MacroNameTok,
+void PPCallbacksTracker::MacroDefined(SourceLocation HashLoc,
+                                      const Token &MacroNameTok,
                                       const MacroDirective *MacroDirective) {
   beginCallback("MacroDefined");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("MacroNameTok", MacroNameTok);
   appendArgument("MacroDirective", MacroDirective);
 }
 
 // Hook called whenever a macro #undef is seen.
-void PPCallbacksTracker::MacroUndefined(const Token &MacroNameTok,
+void PPCallbacksTracker::MacroUndefined(SourceLocation HashLoc,
+                                        const Token &MacroNameTok,
                                         const MacroDefinition &MacroDefinition,
                                         const MacroDirective *Undef) {
   beginCallback("MacroUndefined");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("MacroNameTok", MacroNameTok);
   appendArgument("MacroDefinition", MacroDefinition);
 }

 }
 
 // Hook called whenever an #if is seen.
-void PPCallbacksTracker::If(SourceLocation Loc, SourceRange ConditionRange,
+void PPCallbacksTracker::If(SourceLocation HashLoc, SourceLocation Loc,
+                            SourceRange ConditionRange,
                             ConditionValueKind ConditionValue) {
   beginCallback("If");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("Loc", Loc);
   appendArgument("ConditionRange", ConditionRange);
   appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);
 }
 
 // Hook called whenever an #elif is seen.
-void PPCallbacksTracker::Elif(SourceLocation Loc, SourceRange ConditionRange,
+void PPCallbacksTracker::Elif(SourceLocation HashLoc, SourceLocation Loc,
+                              SourceRange ConditionRange,
                               ConditionValueKind ConditionValue,
                               SourceLocation IfLoc) {
   beginCallback("Elif");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("Loc", Loc);
   appendArgument("ConditionRange", ConditionRange);
   appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);

 }
 
 // Hook called whenever an #ifdef is seen.
-void PPCallbacksTracker::Ifdef(SourceLocation Loc, const Token &MacroNameTok,
+void PPCallbacksTracker::Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+                               const Token &MacroNameTok,
                                const MacroDefinition &MacroDefinition) {
   beginCallback("Ifdef");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("Loc", Loc);
   appendArgument("MacroNameTok", MacroNameTok);
   appendArgument("MacroDefinition", MacroDefinition);
 }
 
 // Hook called whenever an #ifndef is seen.
-void PPCallbacksTracker::Ifndef(SourceLocation Loc, const Token &MacroNameTok,
+void PPCallbacksTracker::Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+                                const Token &MacroNameTok,
                                 const MacroDefinition &MacroDefinition) {
   beginCallback("Ifndef");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("Loc", Loc);
   appendArgument("MacroNameTok", MacroNameTok);
   appendArgument("MacroDefinition", MacroDefinition);
 }
 
 // Hook called whenever an #else is seen.
-void PPCallbacksTracker::Else(SourceLocation Loc, SourceLocation IfLoc) {
+void PPCallbacksTracker::Else(SourceLocation HashLoc, SourceLocation Loc,
+                              SourceLocation IfLoc) {
   beginCallback("Else");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("Loc", Loc);
   appendArgument("IfLoc", IfLoc);
 }
 
 // Hook called whenever an #endif is seen.
-void PPCallbacksTracker::Endif(SourceLocation Loc, SourceLocation IfLoc) {
+void PPCallbacksTracker::Endif(SourceLocation HashLoc, SourceLocation Loc,
+                               SourceLocation IfLoc) {
   beginCallback("Endif");
+  appendArgument("HashLoc", HashLoc);
   appendArgument("Loc", Loc);
   appendArgument("IfLoc", IfLoc);
 }

clang/include/clang/Lex/PPCallbacks.h

                             const MacroArgs *Args) {}
 
   /// Hook called whenever a macro definition is seen.
-  virtual void MacroDefined(const Token &MacroNameTok,
-                            const MacroDirective *MD) {
-  }
+  virtual void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
+                            const MacroDirective *MD) {}
 
   /// Hook called whenever a macro \#undef is seen.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param MacroNameTok The active Token
   /// \param MD A MacroDefinition for the named macro.
   /// \param Undef New MacroDirective if the macro was defined, null otherwise.
   ///
   /// MD is released immediately following this callback.
-  virtual void MacroUndefined(const Token &MacroNameTok,
+  virtual void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
                               const MacroDefinition &MD,
-                              const MacroDirective *Undef) {
-  }
+                              const MacroDirective *Undef) {}
 
   /// Hook called whenever the 'defined' operator is seen.
   /// \param MD The MacroDirective if the name was a macro, null otherwise.

   };
 
   /// Hook called whenever an \#if is seen.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param ConditionRange The SourceRange of the expression being tested.
   /// \param ConditionValue The evaluated value of the condition.
   ///
   // FIXME: better to pass in a list (or tree!) of Tokens.
-  virtual void If(SourceLocation Loc, SourceRange ConditionRange,
-                  ConditionValueKind ConditionValue) {
-  }
+  virtual void If(SourceLocation HashLoc, SourceLocation Loc,
+                  SourceRange ConditionRange,
+                  ConditionValueKind ConditionValue) {}
 
   /// Hook called whenever an \#elif is seen.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param ConditionRange The SourceRange of the expression being tested.
   /// \param ConditionValue The evaluated value of the condition.
   /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
   // FIXME: better to pass in a list (or tree!) of Tokens.
-  virtual void Elif(SourceLocation Loc, SourceRange ConditionRange,
-                    ConditionValueKind ConditionValue, SourceLocation IfLoc) {
-  }
+  virtual void Elif(SourceLocation HashLoc, SourceLocation Loc,
+                    SourceRange ConditionRange,
+                    ConditionValueKind ConditionValue, SourceLocation IfLoc) {}
 
   /// Hook called whenever an \#ifdef is seen.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param MacroNameTok Information on the token being tested.
   /// \param MD The MacroDefinition if the name was a macro, null otherwise.
-  virtual void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-                     const MacroDefinition &MD) {
-  }
+  virtual void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+                     const Token &MacroNameTok, const MacroDefinition &MD) {}
 
   /// Hook called whenever an \#elifdef branch is taken.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param MacroNameTok Information on the token being tested.
   /// \param MD The MacroDefinition if the name was a macro, null otherwise.
-  virtual void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
-                       const MacroDefinition &MD) {
-  }
+  virtual void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+                       const Token &MacroNameTok, const MacroDefinition &MD) {}
   /// Hook called whenever an \#elifdef is skipped.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param ConditionRange The SourceRange of the expression being tested.
   /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
   // FIXME: better to pass in a list (or tree!) of Tokens.
-  virtual void Elifdef(SourceLocation Loc, SourceRange ConditionRange,
-                       SourceLocation IfLoc) {
-  }
+  virtual void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+                       SourceRange ConditionRange, SourceLocation IfLoc) {}
 
   /// Hook called whenever an \#ifndef is seen.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param MacroNameTok Information on the token being tested.
   /// \param MD The MacroDefiniton if the name was a macro, null otherwise.
-  virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-                      const MacroDefinition &MD) {
-  }
+  virtual void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+                      const Token &MacroNameTok, const MacroDefinition &MD) {}
 
   /// Hook called whenever an \#elifndef branch is taken.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param MacroNameTok Information on the token being tested.
   /// \param MD The MacroDefinition if the name was a macro, null otherwise.
-  virtual void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
-                        const MacroDefinition &MD) {
-  }
+  virtual void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                        const Token &MacroNameTok, const MacroDefinition &MD) {}
   /// Hook called whenever an \#elifndef is skipped.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param ConditionRange The SourceRange of the expression being tested.
   /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
   // FIXME: better to pass in a list (or tree!) of Tokens.
-  virtual void Elifndef(SourceLocation Loc, SourceRange ConditionRange,
-                        SourceLocation IfLoc) {
-  }
+  virtual void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                        SourceRange ConditionRange, SourceLocation IfLoc) {}
 
   /// Hook called whenever an \#else is seen.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
-  virtual void Else(SourceLocation Loc, SourceLocation IfLoc) {
-  }
+  virtual void Else(SourceLocation HashLoc, SourceLocation Loc,
+                    SourceLocation IfLoc) {}
 
   /// Hook called whenever an \#endif is seen.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc the source location of the directive.
   /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
-  virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) {
-  }
+  virtual void Endif(SourceLocation HashLoc, SourceLocation Loc,
+                     SourceLocation IfLoc) {}
 };
 
 /// Simple wrapper class for chaining callbacks.

     Second->MacroExpands(MacroNameTok, MD, Range, Args);
   }
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
-    First->MacroDefined(MacroNameTok, MD);
-    Second->MacroDefined(MacroNameTok, MD);
+    First->MacroDefined(HashLoc, MacroNameTok, MD);
+    Second->MacroDefined(HashLoc, MacroNameTok, MD);
   }
 
-  void MacroUndefined(const Token &MacroNameTok,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
                       const MacroDefinition &MD,
                       const MacroDirective *Undef) override {
-    First->MacroUndefined(MacroNameTok, MD, Undef);
-    Second->MacroUndefined(MacroNameTok, MD, Undef);
+    First->MacroUndefined(HashLoc, MacroNameTok, MD, Undef);
+    Second->MacroUndefined(HashLoc, MacroNameTok, MD, Undef);
   }
 
   void Defined(const Token &MacroNameTok, const MacroDefinition &MD,

   }
 
   /// Hook called whenever an \#if is seen.
-  void If(SourceLocation Loc, SourceRange ConditionRange,
+  void If(SourceLocation HashLoc, SourceLocation Loc,
+          SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override {
-    First->If(Loc, ConditionRange, ConditionValue);
-    Second->If(Loc, ConditionRange, ConditionValue);
+    First->If(HashLoc, Loc, ConditionRange, ConditionValue);
+    Second->If(HashLoc, Loc, ConditionRange, ConditionValue);
   }
 
   /// Hook called whenever an \#elif is seen.
-  void Elif(SourceLocation Loc, SourceRange ConditionRange,
-            ConditionValueKind ConditionValue, SourceLocation IfLoc) override {
-    First->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
-    Second->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
+  void Elif(SourceLocation HashLoc, SourceLocation Loc,
+            SourceRange ConditionRange, ConditionValueKind ConditionValue,
+            SourceLocation IfLoc) override {
+    First->Elif(HashLoc, Loc, ConditionRange, ConditionValue, IfLoc);
+    Second->Elif(HashLoc, Loc, ConditionRange, ConditionValue, IfLoc);
   }
 
   /// Hook called whenever an \#ifdef is seen.
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override {
-    First->Ifdef(Loc, MacroNameTok, MD);
-    Second->Ifdef(Loc, MacroNameTok, MD);
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override {
+    First->Ifdef(HashLoc, Loc, MacroNameTok, MD);
+    Second->Ifdef(HashLoc, Loc, MacroNameTok, MD);
   }
 
   /// Hook called whenever an \#elifdef is taken.
-  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
-               const MacroDefinition &MD) override {
-    First->Elifdef(Loc, MacroNameTok, MD);
-    Second->Elifdef(Loc, MacroNameTok, MD);
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               const Token &MacroNameTok, const MacroDefinition &MD) override {
+    First->Elifdef(HashLoc, Loc, MacroNameTok, MD);
+    Second->Elifdef(HashLoc, Loc, MacroNameTok, MD);
   }
   /// Hook called whenever an \#elifdef is skipped.
-  void Elifdef(SourceLocation Loc, SourceRange ConditionRange,
-               SourceLocation IfLoc) override {
-    First->Elifdef(Loc, ConditionRange, IfLoc);
-    Second->Elifdef(Loc, ConditionRange, IfLoc);
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               SourceRange ConditionRange, SourceLocation IfLoc) override {
+    First->Elifdef(HashLoc, Loc, ConditionRange, IfLoc);
+    Second->Elifdef(HashLoc, Loc, ConditionRange, IfLoc);
   }
 
   /// Hook called whenever an \#ifndef is seen.
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override {
-    First->Ifndef(Loc, MacroNameTok, MD);
-    Second->Ifndef(Loc, MacroNameTok, MD);
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override {
+    First->Ifndef(HashLoc, Loc, MacroNameTok, MD);
+    Second->Ifndef(HashLoc, Loc, MacroNameTok, MD);
   }
 
   /// Hook called whenever an \#elifndef is taken.
-  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
-                const MacroDefinition &MD) override {
-    First->Elifndef(Loc, MacroNameTok, MD);
-    Second->Elifndef(Loc, MacroNameTok, MD);
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                const Token &MacroNameTok, const MacroDefinition &MD) override {
+    First->Elifndef(HashLoc, Loc, MacroNameTok, MD);
+    Second->Elifndef(HashLoc, Loc, MacroNameTok, MD);
   }
   /// Hook called whenever an \#elifndef is skipped.
-  void Elifndef(SourceLocation Loc, SourceRange ConditionRange,
-               SourceLocation IfLoc) override {
-    First->Elifndef(Loc, ConditionRange, IfLoc);
-    Second->Elifndef(Loc, ConditionRange, IfLoc);
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                SourceRange ConditionRange, SourceLocation IfLoc) override {
+    First->Elifndef(HashLoc, Loc, ConditionRange, IfLoc);
+    Second->Elifndef(HashLoc, Loc, ConditionRange, IfLoc);
   }
 
   /// Hook called whenever an \#else is seen.
-  void Else(SourceLocation Loc, SourceLocation IfLoc) override {
-    First->Else(Loc, IfLoc);
-    Second->Else(Loc, IfLoc);
+  void Else(SourceLocation HashLoc, SourceLocation Loc,
+            SourceLocation IfLoc) override {
+    First->Else(HashLoc, Loc, IfLoc);
+    Second->Else(HashLoc, Loc, IfLoc);
   }
 
   /// Hook called whenever an \#endif is seen.
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
-    First->Endif(Loc, IfLoc);
-    Second->Endif(Loc, IfLoc);
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation IfLoc) override {
+    First->Endif(HashLoc, Loc, IfLoc);
+    Second->Endif(HashLoc, Loc, IfLoc);
   }
 };
 

clang/include/clang/Lex/PPConditionalDirectiveRecord.h

   SourceLocation findConditionalDirectiveRegionLoc(SourceLocation Loc) const;
 
 private:
-  void If(SourceLocation Loc, SourceRange ConditionRange,
+  void If(SourceLocation HashLoc, SourceLocation Loc,
+          SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override;
-  void Elif(SourceLocation Loc, SourceRange ConditionRange,
-            ConditionValueKind ConditionValue, SourceLocation IfLoc) override;
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override;
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override;
-  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
-               const MacroDefinition &MD) override;
-  void Elifdef(SourceLocation Loc, SourceRange ConditionRange,
-               SourceLocation IfLoc) override;
-  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
-                const MacroDefinition &MD) override;
-  void Elifndef(SourceLocation Loc, SourceRange ConditionRange,
-                SourceLocation IfLoc) override;
-  void Else(SourceLocation Loc, SourceLocation IfLoc) override;
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override;
+  void Elif(SourceLocation HashLoc, SourceLocation Loc,
+            SourceRange ConditionRange, ConditionValueKind ConditionValue,
+            SourceLocation IfLoc) override;
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override;
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override;
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               const Token &MacroNameTok, const MacroDefinition &MD) override;
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               SourceRange ConditionRange, SourceLocation IfLoc) override;
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                const Token &MacroNameTok, const MacroDefinition &MD) override;
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                SourceRange ConditionRange, SourceLocation IfLoc) override;
+  void Else(SourceLocation HashLoc, SourceLocation Loc,
+            SourceLocation IfLoc) override;
+  void Endif(SourceLocation HashLoc, SourceLocation Loc,
+             SourceLocation IfLoc) override;
 };
 
 } // end namespace clang

clang/include/clang/Lex/PreprocessingRecord.h

 
     void MacroExpands(const Token &Id, const MacroDefinition &MD,
                       SourceRange Range, const MacroArgs *Args) override;
-    void MacroDefined(const Token &Id, const MacroDirective *MD) override;
-    void MacroUndefined(const Token &Id, const MacroDefinition &MD,
+    void MacroDefined(SourceLocation HashLoc, const Token &Id,
+                      const MacroDirective *MD) override;
+    void MacroUndefined(SourceLocation HashLoc, const Token &Id,
+                        const MacroDefinition &MD,
                         const MacroDirective *Undef) override;
     void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                             StringRef FileName, bool IsAngled,

                             OptionalFileEntryRef File, StringRef SearchPath,
                             StringRef RelativePath, const Module *Imported,
                             SrcMgr::CharacteristicKind FileType) override;
-    void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-               const MacroDefinition &MD) override;
-    void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-                const MacroDefinition &MD) override;
+    void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+               const Token &MacroNameTok, const MacroDefinition &MD) override;
+    void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+                const Token &MacroNameTok, const MacroDefinition &MD) override;
 
     using PPCallbacks::Elifdef;
     using PPCallbacks::Elifndef;
-    void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
-                 const MacroDefinition &MD) override;
-    void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
+    void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+                 const Token &MacroNameTok, const MacroDefinition &MD) override;
+    void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                  const Token &MacroNameTok,
                   const MacroDefinition &MD) override;
 
     /// Hook called whenever the 'defined' operator is seen.

clang/include/clang/Lex/Preprocessor.h

   void replayPreambleConditionalStack();
 
   // Macro handling.
-  void HandleDefineDirective(Token &Tok, bool ImmediatelyAfterHeaderGuard);
-  void HandleUndefDirective();
+  void HandleDefineDirective(SourceLocation HashLoc, Token &Tok,
+                             bool ImmediatelyAfterHeaderGuard);
+  void HandleUndefDirective(SourceLocation HashLoc);
 
   // Conditional Inclusion.
   void HandleIfdefDirective(Token &Result, const Token &HashToken,
                             bool isIfndef, bool ReadAnyTokensBeforeDirective);
   void HandleIfDirective(Token &IfToken, const Token &HashToken,
                          bool ReadAnyTokensBeforeDirective);
-  void HandleEndifDirective(Token &EndifToken);
+  void HandleEndifDirective(Token &EndifToken, const Token &HashToken);
   void HandleElseDirective(Token &Result, const Token &HashToken);
   void HandleElifFamilyDirective(Token &ElifToken, const Token &HashToken,
                                  tok::PPKeywordKind Kind);

clang/lib/CodeGen/MacroPPCallbacks.h

                           SrcMgr::CharacteristicKind FileType) override;
 
   /// Hook called whenever a macro definition is seen.
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
   /// Hook called whenever a macro \#undef is seen.
   ///
   /// MD is released immediately following this callback.
-  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
+                      const MacroDefinition &MD,
                       const MacroDirective *Undef) override;
 };
 

clang/lib/CodeGen/MacroPPCallbacks.cpp

   LastHashLoc = HashLoc;
 }
 
-void MacroPPCallbacks::MacroDefined(const Token &MacroNameTok,
+void MacroPPCallbacks::MacroDefined(SourceLocation HashLoc,
+                                    const Token &MacroNameTok,
                                     const MacroDirective *MD) {
   IdentifierInfo *Id = MacroNameTok.getIdentifierInfo();
   SourceLocation location = getCorrectLocation(MacroNameTok.getLocation());

                                      Name.str(), Value.str());
 }
 
-void MacroPPCallbacks::MacroUndefined(const Token &MacroNameTok,
+void MacroPPCallbacks::MacroUndefined(SourceLocation HashLoc,
+                                      const Token &MacroNameTok,
                                       const MacroDefinition &MD,
                                       const MacroDirective *Undef) {
   IdentifierInfo *Id = MacroNameTok.getIdentifierInfo();

clang/lib/ExtractAPI/ExtractAPIConsumer.cpp

                 Preprocessor &PP)
       : SM(SM), LCF(LCF), API(API), PP(PP) {}
 
-  void MacroDefined(const Token &MacroNameToken,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameToken,
                     const MacroDirective *MD) override {
     auto *MacroInfo = MD->getMacroInfo();
 

   // If a macro gets undefined at some point during preprocessing of the inputs
   // it means that it isn't an exposed API and we should therefore not add a
   // macro definition for it.
-  void MacroUndefined(const Token &MacroNameToken, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, 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.

clang/lib/Frontend/ASTUnit.cpp

 public:
   explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) {}
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     AddDefinedMacroToHash(MacroNameTok, Hash);
   }

clang/lib/Frontend/PrintPreprocessedOutput.cpp

   void HandleNewlinesInToken(const char *TokStr, unsigned Len);
 
   /// MacroDefined - This hook is called whenever a macro definition is seen.
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
   /// MacroUndefined - This hook is called whenever a macro #undef is seen.
-  void MacroUndefined(const Token &MacroNameTok,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
                       const MacroDefinition &MD,
                       const MacroDirective *Undef) override;
 

 }
 
 /// MacroDefined - This hook is called whenever a macro definition is seen.
-void PrintPPOutputPPCallbacks::MacroDefined(const Token &MacroNameTok,
+void PrintPPOutputPPCallbacks::MacroDefined(SourceLocation HashLoc,
+                                            const Token &MacroNameTok,
                                             const MacroDirective *MD) {
   const MacroInfo *MI = MD->getMacroInfo();
   // Print out macro definitions in -dD mode and when we have -fdirectives-only

   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::MacroUndefined(const Token &MacroNameTok,
+void PrintPPOutputPPCallbacks::MacroUndefined(SourceLocation HashLoc,
+                                              const Token &MacroNameTok,
                                               const MacroDefinition &MD,
                                               const MacroDirective *Undef) {
   // Print out macro definitions in -dD mode and when we have -fdirectives-only

clang/lib/Frontend/Rewrite/InclusionRewriter.cpp

                           OptionalFileEntryRef File, StringRef SearchPath,
                           StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
-  void If(SourceLocation Loc, SourceRange ConditionRange,
+  void If(SourceLocation HashLoc, SourceLocation Loc,
+          SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override;
-  void Elif(SourceLocation Loc, SourceRange ConditionRange,
-            ConditionValueKind ConditionValue, SourceLocation IfLoc) override;
+  void Elif(SourceLocation HashLoc, SourceLocation Loc,
+            SourceRange ConditionRange, ConditionValueKind ConditionValue,
+            SourceLocation IfLoc) override;
   void WriteLineInfo(StringRef Filename, int Line,
                      SrcMgr::CharacteristicKind FileType,
                      StringRef Extra = StringRef());

     LastInclusionLocation = HashLoc;
 }
 
-void InclusionRewriter::If(SourceLocation Loc, SourceRange ConditionRange,
+void InclusionRewriter::If(SourceLocation HashLoc, SourceLocation Loc,
+                           SourceRange ConditionRange,
                            ConditionValueKind ConditionValue) {
   auto P = IfConditions.insert(std::make_pair(Loc, ConditionValue == CVK_True));
   (void)P;
   assert(P.second && "Unexpected revisitation of the same if directive");
 }
 
-void InclusionRewriter::Elif(SourceLocation Loc, SourceRange ConditionRange,
+void InclusionRewriter::Elif(SourceLocation HashLoc, SourceLocation Loc,
+                             SourceRange ConditionRange,
                              ConditionValueKind ConditionValue,
                              SourceLocation IfLoc) {
   auto P = IfConditions.insert(std::make_pair(Loc, ConditionValue == CVK_True));

clang/lib/Index/IndexingAction.cpp

                                    Range.getBegin(), *MD.getMacroInfo());
   }
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     IndexCtx->handleMacroDefined(*MacroNameTok.getIdentifierInfo(),
                                  MacroNameTok.getLocation(),
                                  *MD->getMacroInfo());
   }
 
-  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
+                      const MacroDefinition &MD,
                       const MacroDirective *Undef) override {
     if (!MD.getMacroInfo())  // Ignore noop #undef.
       return;

                                    MacroNameTok.getLocation(),
                                    *MD.getMacroInfo());
   }
-  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
-             const MacroDefinition &MD) override {
+  void Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+             const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!MD.getMacroInfo()) // Ignore non-existent macro.
       return;
     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
                                    MacroNameTok.getLocation(),
                                    *MD.getMacroInfo());
   }
-  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-              const MacroDefinition &MD) override {
+  void Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+              const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!MD.getMacroInfo()) // Ignore nonexistent macro.
       return;
     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),

 
   using PPCallbacks::Elifdef;
   using PPCallbacks::Elifndef;
-  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
-               const MacroDefinition &MD) override {
+  void Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+               const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!MD.getMacroInfo()) // Ignore non-existent macro.
       return;
     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
                                    MacroNameTok.getLocation(),
                                    *MD.getMacroInfo());
   }
-  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
-                const MacroDefinition &MD) override {
+  void Elifndef(SourceLocation HashLoc, SourceLocation Loc,
+                const Token &MacroNameTok, const MacroDefinition &MD) override {
     if (!MD.getMacroInfo()) // Ignore non-existent macro.
       return;
     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),

clang/lib/Lex/PPConditionalDirectiveRecord.cpp

   CondDirectiveLocs.push_back(DirLoc);
 }
 
-void PPConditionalDirectiveRecord::If(SourceLocation Loc,
+void PPConditionalDirectiveRecord::If(SourceLocation HashLoc,
+                                      SourceLocation Loc,
                                       SourceRange ConditionRange,
                                       ConditionValueKind ConditionValue) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.push_back(Loc);
 }
 
-void PPConditionalDirectiveRecord::Ifdef(SourceLocation Loc,
+void PPConditionalDirectiveRecord::Ifdef(SourceLocation HashLoc,
+                                         SourceLocation Loc,
                                          const Token &MacroNameTok,
                                          const MacroDefinition &MD) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.push_back(Loc);
 }
 
-void PPConditionalDirectiveRecord::Ifndef(SourceLocation Loc,
+void PPConditionalDirectiveRecord::Ifndef(SourceLocation HashLoc,
+                                          SourceLocation Loc,
                                           const Token &MacroNameTok,
                                           const MacroDefinition &MD) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.push_back(Loc);
 }
 
-void PPConditionalDirectiveRecord::Elif(SourceLocation Loc,
+void PPConditionalDirectiveRecord::Elif(SourceLocation HashLoc,
+                                        SourceLocation Loc,
                                         SourceRange ConditionRange,
                                         ConditionValueKind ConditionValue,
                                         SourceLocation IfLoc) {

   CondDirectiveStack.back() = Loc;
 }
 
-void PPConditionalDirectiveRecord::Elifdef(SourceLocation Loc, const Token &,
+void PPConditionalDirectiveRecord::Elifdef(SourceLocation HashLoc,
+                                           SourceLocation Loc, const Token &,
                                            const MacroDefinition &) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.back() = Loc;
 }
-void PPConditionalDirectiveRecord::Elifdef(SourceLocation Loc, SourceRange,
+void PPConditionalDirectiveRecord::Elifdef(SourceLocation HashLoc,
+                                           SourceLocation Loc, SourceRange,
                                            SourceLocation) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.back() = Loc;
 }
 
-void PPConditionalDirectiveRecord::Elifndef(SourceLocation Loc, const Token &,
+void PPConditionalDirectiveRecord::Elifndef(SourceLocation HashLoc,
+                                            SourceLocation Loc, const Token &,
                                             const MacroDefinition &) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.back() = Loc;
 }
-void PPConditionalDirectiveRecord::Elifndef(SourceLocation Loc, SourceRange,
+void PPConditionalDirectiveRecord::Elifndef(SourceLocation HashLoc,
+                                            SourceLocation Loc, SourceRange,
                                             SourceLocation) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.back() = Loc;
 }
 
-void PPConditionalDirectiveRecord::Else(SourceLocation Loc,
+void PPConditionalDirectiveRecord::Else(SourceLocation HashLoc,
+                                        SourceLocation Loc,
                                         SourceLocation IfLoc) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.back() = Loc;
 }
 
-void PPConditionalDirectiveRecord::Endif(SourceLocation Loc,
+void PPConditionalDirectiveRecord::Endif(SourceLocation HashLoc,
+                                         SourceLocation Loc,
                                          SourceLocation IfLoc) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   assert(!CondDirectiveStack.empty());

clang/lib/Lex/PPDirectives.cpp

           endLoc = CheckEndOfDirective("endif");
           CurPPLexer->LexingRawMode = true;
           if (Callbacks)
-            Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
+            Callbacks->Endif(HashTokenLoc, Tok.getLocation(), CondInfo.IfLoc);
           break;
         } else {
           DiscardUntilEndOfDirective();

           endLoc = CheckEndOfDirective("else");
           CurPPLexer->LexingRawMode = true;
           if (Callbacks)
-            Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
+            Callbacks->Else(HashTokenLoc, Tok.getLocation(), CondInfo.IfLoc);
           break;
         } else {
           DiscardUntilEndOfDirective();  // C99 6.10p4.

           CurPPLexer->LexingRawMode = true;
           if (Callbacks) {
             Callbacks->Elif(
-                Tok.getLocation(), DER.ExprRange,
+                HashTokenLoc, Tok.getLocation(), DER.ExprRange,
                 (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False),
                 CondInfo.IfLoc);
           }

 
           if (Callbacks) {
             if (IsElifDef) {
-              Callbacks->Elifdef(DirectiveToken.getLocation(), MacroNameTok,
-                                 MD);
+              Callbacks->Elifdef(HashTokenLoc, DirectiveToken.getLocation(),
+                                 MacroNameTok, MD);
             } else {
-              Callbacks->Elifndef(DirectiveToken.getLocation(), MacroNameTok,
-                                  MD);
+              Callbacks->Elifndef(HashTokenLoc, DirectiveToken.getLocation(),
+                                  MacroNameTok, MD);
             }
           }
           // If this condition is true, enter it!

                                                        SourceLocation HashLoc) {
   if (const IdentifierInfo *II = Result.getIdentifierInfo()) {
     if (II->getPPKeywordID() == tok::pp_define) {
-      return HandleDefineDirective(Result,
+      return HandleDefineDirective(HashLoc, Result,
                                    /*ImmediatelyAfterHeaderGuard=*/false);
     }
     if (SkippingUntilPCHThroughHeader &&

     case tok::pp_else:
       return HandleElseDirective(Result, SavedHash);
     case tok::pp_endif:
-      return HandleEndifDirective(Result);
+      return HandleEndifDirective(Result, SavedHash);
 
     // C99 6.10.2 - Source File Inclusion.
     case tok::pp_include:

 
     // C99 6.10.3 - Macro Replacement.
     case tok::pp_define:
-      return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);
+      return HandleDefineDirective(SavedHash.getLocation(), Result,
+                                   ImmediatelyAfterTopLevelIfndef);
     case tok::pp_undef:
-      return HandleUndefDirective();
+      return HandleUndefDirective(SavedHash.getLocation());
 
     // C99 6.10.4 - Line Control.
     case tok::pp_line:

 /// HandleDefineDirective - Implements \#define.  This consumes the entire macro
 /// line then lets the caller lex the next real token.
 void Preprocessor::HandleDefineDirective(
-    Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) {
+    SourceLocation HashLoc, Token &DefineTok,
+    const bool ImmediatelyAfterHeaderGuard) {
   ++NumDefined;
 
   Token MacroNameTok;

 
   // If the callbacks want to know, tell them about the macro definition.
   if (Callbacks)
-    Callbacks->MacroDefined(MacroNameTok, MD);
+    Callbacks->MacroDefined(HashLoc, MacroNameTok, MD);
 
   // If we're in MS compatibility mode and the macro being defined is the
   // assert macro, implicitly add a macro definition for static_assert to work

 
 /// HandleUndefDirective - Implements \#undef.
 ///
-void Preprocessor::HandleUndefDirective() {
+void Preprocessor::HandleUndefDirective(SourceLocation HashLoc) {
   ++NumUndefined;
 
   Token MacroNameTok;

   // If the callbacks want to know, tell them about the macro #undef.
   // Note: no matter if the macro was defined or not.
   if (Callbacks)
-    Callbacks->MacroUndefined(MacroNameTok, MD, Undef);
+    Callbacks->MacroUndefined(HashLoc, MacroNameTok, MD, Undef);
 
   if (Undef)
     appendMacroDirective(II, Undef);

 
   if (Callbacks) {
     if (isIfndef)
-      Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
+      Callbacks->Ifndef(HashToken.getLocation(), DirectiveTok.getLocation(),
+                        MacroNameTok, MD);
     else
-      Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
+      Callbacks->Ifdef(HashToken.getLocation(), DirectiveTok.getLocation(),
+                       MacroNameTok, MD);
   }
 
   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&

 
   if (Callbacks)
     Callbacks->If(
-        IfToken.getLocation(), DER.ExprRange,
+        HashToken.getLocation(), IfToken.getLocation(), DER.ExprRange,
         (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));
 
   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&

 
 /// HandleEndifDirective - Implements the \#endif directive.
 ///
-void Preprocessor::HandleEndifDirective(Token &EndifToken) {
+void Preprocessor::HandleEndifDirective(Token &EndifToken,
+                                        const Token &HashToken) {
   ++NumEndif;
 
   // Check that this is the whole directive.

          "This code should only be reachable in the non-skipping case!");
 
   if (Callbacks)
-    Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);
+    Callbacks->Endif(HashToken.getLocation(), EndifToken.getLocation(),
+                     CondInfo.IfLoc);
 }
 
 /// HandleElseDirective - Implements the \#else directive.

   if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
 
   if (Callbacks)
-    Callbacks->Else(Result.getLocation(), CI.IfLoc);
+    Callbacks->Else(HashToken.getLocation(), Result.getLocation(), CI.IfLoc);
 
   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
     getSourceManager().isInMainFile(Result.getLocation());

   if (Callbacks) {
     switch (Kind) {
     case tok::pp_elif:
-      Callbacks->Elif(ElifToken.getLocation(), ConditionRange,
-                      PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
+      Callbacks->Elif(HashToken.getLocation(), ElifToken.getLocation(),
+                      ConditionRange, PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
       break;
     case tok::pp_elifdef:
-      Callbacks->Elifdef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);
+      Callbacks->Elifdef(HashToken.getLocation(), ElifToken.getLocation(),
+                         ConditionRange, CI.IfLoc);
       break;
     case tok::pp_elifndef:
-      Callbacks->Elifndef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);
+      Callbacks->Elifndef(HashToken.getLocation(), ElifToken.getLocation(),
+                          ConditionRange, CI.IfLoc);
       break;
     default:
       assert(false && "unexpected directive kind");

clang/lib/Lex/PreprocessingRecord.cpp

     addPreprocessedEntity(new (*this) MacroExpansion(Def, Range));
 }
 
-void PreprocessingRecord::Ifdef(SourceLocation Loc, const Token &MacroNameTok,
+void PreprocessingRecord::Ifdef(SourceLocation HashLoc, SourceLocation Loc,
+                                const Token &MacroNameTok,
                                 const MacroDefinition &MD) {
   // This is not actually a macro expansion but record it as a macro reference.
   if (MD)

                       MacroNameTok.getLocation());
 }
 
-void PreprocessingRecord::Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+void PreprocessingRecord::Elifdef(SourceLocation HashLoc, SourceLocation Loc,
+                                  const Token &MacroNameTok,
                                   const MacroDefinition &MD) {
   // This is not actually a macro expansion but record it as a macro reference.
   if (MD)

                       MacroNameTok.getLocation());
 }
 
-void PreprocessingRecord::Ifndef(SourceLocation Loc, const Token &MacroNameTok,
+void PreprocessingRecord::Ifndef(SourceLocation HashLoc, SourceLocation Loc,
+                                 const Token &MacroNameTok,
                                  const MacroDefinition &MD) {
   // This is not actually a macro expansion but record it as a macro reference.
   if (MD)

                       MacroNameTok.getLocation());
 }
 
-void PreprocessingRecord::Elifndef(SourceLocation Loc,
+void PreprocessingRecord::Elifndef(SourceLocation HashLoc, SourceLocation Loc,
                                    const Token &MacroNameTok,
                                    const MacroDefinition &MD) {
   // This is not actually a macro expansion but record it as a macro reference.

   addMacroExpansion(Id, MD.getMacroInfo(), Range);
 }
 
-void PreprocessingRecord::MacroDefined(const Token &Id,
+void PreprocessingRecord::MacroDefined(SourceLocation HashLoc, const Token &Id,
                                        const MacroDirective *MD) {
   const MacroInfo *MI = MD->getMacroInfo();
   SourceRange R(MI->getDefinitionLoc(), MI->getDefinitionEndLoc());

   MacroDefinitions[MI] = Def;
 }
 
-void PreprocessingRecord::MacroUndefined(const Token &Id,
+void PreprocessingRecord::MacroUndefined(SourceLocation HashLoc,
+                                         const Token &Id,
                                          const MacroDefinition &MD,
                                          const MacroDirective *Undef) {
   MD.forAllDefinitions([&](MacroInfo *MI) { MacroDefinitions.erase(MI); });

clang/tools/libclang/Indexing.cpp

   }
 
   /// MacroDefined - This hook is called whenever a macro definition is seen.
-  void MacroDefined(const Token &Id, const MacroDirective *MD) override {}
+  void MacroDefined(SourceLocation HashLoc, const Token &Id,
+                    const MacroDirective *MD) override {}
 
   /// MacroUndefined - This hook is called whenever a macro #undef is seen.
   /// MI is released immediately following this callback.
-  void MacroUndefined(const Token &MacroNameTok,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
                       const MacroDefinition &MD,
                       const MacroDirective *UD) override {}
 

clang/unittests/Basic/SourceManagerTest.cpp

 public:
   explicit MacroTracker(std::vector<MacroAction> &Macros) : Macros(Macros) { }
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     Macros.push_back(MacroAction(MD->getLocation(),
                                  MacroNameTok.getIdentifierInfo()->getName(),
                                  MacroAction::kDefinition));
   }
-  void MacroUndefined(const Token &MacroNameTok,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroNameTok,
                       const MacroDefinition &MD,
-                      const MacroDirective  *UD) override {
+                      const MacroDirective *UD) override {
     Macros.push_back(
         MacroAction(UD ? UD->getLocation() : SourceLocation(),
                     MacroNameTok.getIdentifierInfo()->getName(),

clang/unittests/Lex/PPCallbacksTest.cpp

 
   std::vector<Result> Results;
 
-  void If(SourceLocation Loc, SourceRange ConditionRange,
+  void If(SourceLocation HashLoc, SourceLocation Loc,
+          SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override {
     Results.emplace_back(ConditionRange, ConditionValue);
   }
 
-  void Elif(SourceLocation Loc, SourceRange ConditionRange,
-            ConditionValueKind ConditionValue, SourceLocation IfLoc) override {
+  void Elif(SourceLocation HashLoc, SourceLocation Loc,
+            SourceRange ConditionRange, ConditionValueKind ConditionValue,
+            SourceLocation IfLoc) override {
     Results.emplace_back(ConditionRange, ConditionValue);
   }
 };