[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

 /// The contexts of a macro will be ignored since they are not available during
 /// preprocessing period.
 class FindAllMacros : public clang::PPCallbacks {
 public:
   explicit FindAllMacros(SymbolReporter *Reporter, SourceManager *SM,
                          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;
 
 private:
   std::optional<SymbolInfo> CreateMacroSymbol(const Token &MacroNameTok,
                                               const MacroInfo *MD);
   // Not a callback, just a common path for all usage types.
   void MacroUsed(const Token &Name, const MacroDefinition &MD);

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

FindAllMacros::CreateMacroSymbol(const Token &MacroNameTok,
   std::string FilePath =
       getIncludePath(*SM, info->getDefinitionLoc(), Collector);
   if (FilePath.empty())
     return std::nullopt;
   return SymbolInfo(MacroNameTok.getIdentifierInfo()->getName(),
                     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;
 }
 
 void FindAllMacros::MacroUsed(const Token &Name, const MacroDefinition &MD) {
   if (!MD || !SM->isInMainFile(SM->getExpansionLoc(Name.getLocation())))
     return;
   if (auto Symbol = CreateMacroSymbol(Name, MD.getMacroInfo()))
     ++FileSymbols[*Symbol].Used;
 }
 
 void FindAllMacros::MacroExpands(const Token &MacroNameTok,
                                  const MacroDefinition &MD, SourceRange Range,
                                  const MacroArgs *Args) {
   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);
 }
 
 void FindAllMacros::EndOfMainFile() {
   Reporter->reportSymbols(SM->getFileEntryForID(SM->getMainFileID())->getName(),
                           FileSymbols);
   FileSymbols.clear();
 }
 
 } // namespace find_all_symbols
 } // namespace clang

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

void InclusionDirective(SourceLocation DirectiveLoc,
                           const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
   void EndOfMainFile() override;
 
   // Handle all other callbacks.
   // Just parse to the corresponding location to generate PPCallbacks for the
   // corresponding range
-  void Ident(SourceLocation Loc, StringRef) override;
+  void Ident(SourceLocation HashLoc, SourceLocation Loc, StringRef) override;
   void PragmaDirective(PragmaIntroducer Introducer) override;
-  void PragmaComment(SourceLocation Loc, const IdentifierInfo *,
-                     StringRef) override;
-  void PragmaDetectMismatch(SourceLocation Loc, StringRef, StringRef) override;
-  void PragmaDebug(SourceLocation Loc, StringRef) override;
-  void PragmaMessage(SourceLocation Loc, StringRef, PragmaMessageKind,
+  void PragmaComment(PragmaIntroducer Introducer, SourceLocation Loc,
+                     const IdentifierInfo *, StringRef) override;
+  void PragmaDetectMismatch(PragmaIntroducer Introducer, SourceLocation Loc,
+                            StringRef, StringRef) override;
+  void PragmaDebug(PragmaIntroducer Introducer, SourceLocation Loc,
+  void PragmaMessage(PragmaIntroducer Introducer, SourceLocation Loc, StringRef,
+                     PragmaMessageKind, StringRef) override;
+  void PragmaDiagnosticPush(PragmaIntroducer Introducer, SourceLocation Loc,
                             StringRef) override;
-  void PragmaDiagnosticPush(SourceLocation Loc, StringRef) override;
-  void PragmaDiagnosticPop(SourceLocation Loc, StringRef) override;
-  void PragmaDiagnostic(SourceLocation Loc, StringRef, diag::Severity,
+  void PragmaDiagnosticPop(PragmaIntroducer Introducer, SourceLocation Loc,
                            StringRef) override;
+  void PragmaDiagnostic(PragmaIntroducer Introducer, SourceLocation Loc,
+                        StringRef, diag::Severity, StringRef) override;
   void HasInclude(SourceLocation Loc, StringRef, bool, OptionalFileEntryRef,
                   SrcMgr::CharacteristicKind) override;
-  void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *,
+  void PragmaOpenCLExtension(PragmaIntroducer Introducer,
+                             SourceLocation NameLoc, const IdentifierInfo *,
                              SourceLocation StateLoc, unsigned) override;
-  void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier,
-                     ArrayRef<int>) override;
-  void PragmaWarningPush(SourceLocation Loc, int) override;
-  void PragmaWarningPop(SourceLocation Loc) override;
-  void PragmaAssumeNonNullBegin(SourceLocation Loc) override;
-  void PragmaAssumeNonNullEnd(SourceLocation Loc) override;
+  void PragmaWarning(PragmaIntroducer Introducer, SourceLocation Loc,
+                     PragmaWarningSpecifier, ArrayRef<int>) override;
+  void PragmaWarningPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                         int) override;
+  void PragmaWarningPop(PragmaIntroducer Introducer,
+                        SourceLocation Loc) override;
+  void PragmaAssumeNonNullBegin(PragmaIntroducer Introducer,
+                                SourceLocation Loc) override;
+  void PragmaAssumeNonNullEnd(PragmaIntroducer Introducer,
+                              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.
   llvm::DenseSet<serialization::ModuleFile *> VisitedModules;
 
   CompilerInstance &Compiler;
   // Additional filesystem for replay. Provides all input files from modules.
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFs;

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

 void ExpandModularHeadersPPCallbacks::EndOfMainFile() {
   while (!CurrentToken.is(tok::eof))
     PP->Lex(CurrentToken);
 }
 
 // Handle all other callbacks.
 // Just parse to the corresponding location to generate the same callback for
 // the PPCallbacks registered in our custom preprocessor.
-void ExpandModularHeadersPPCallbacks::Ident(SourceLocation Loc, StringRef) {
+void ExpandModularHeadersPPCallbacks::Ident(SourceLocation HashLoc,
+                                            SourceLocation Loc, StringRef) {
   parseToLocation(Loc);
 }
 void ExpandModularHeadersPPCallbacks::PragmaDirective(
     PragmaIntroducer Introducer) {
   parseToLocation(Introducer.Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaComment(SourceLocation Loc,
+void ExpandModularHeadersPPCallbacks::PragmaComment(PragmaIntroducer Introducer,
+                                                    SourceLocation Loc,
                                                     const IdentifierInfo *,
                                                     StringRef) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaDetectMismatch(SourceLocation Loc,
-                                                           StringRef,
-                                                           StringRef) {
+void ExpandModularHeadersPPCallbacks::PragmaDetectMismatch(
+    PragmaIntroducer Introducer, SourceLocation Loc, StringRef, StringRef) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaDebug(SourceLocation Loc,
+void ExpandModularHeadersPPCallbacks::PragmaDebug(PragmaIntroducer Introducer,
+                                                  SourceLocation Loc,
                                                   StringRef) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaMessage(SourceLocation Loc,
+void ExpandModularHeadersPPCallbacks::PragmaMessage(PragmaIntroducer Introducer,
+                                                    SourceLocation Loc,
                                                     StringRef,
                                                     PragmaMessageKind,
                                                     StringRef) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaDiagnosticPush(SourceLocation Loc,
-                                                           StringRef) {
+void ExpandModularHeadersPPCallbacks::PragmaDiagnosticPush(
+    PragmaIntroducer Introducer, SourceLocation Loc, StringRef) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaDiagnosticPop(SourceLocation Loc,
-                                                          StringRef) {
+void ExpandModularHeadersPPCallbacks::PragmaDiagnosticPop(
+    PragmaIntroducer Introducer, SourceLocation Loc, StringRef) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaDiagnostic(SourceLocation Loc,
-                                                       StringRef,
-                                                       diag::Severity,
-                                                       StringRef) {
+void ExpandModularHeadersPPCallbacks::PragmaDiagnostic(
+    PragmaIntroducer Introducer, SourceLocation Loc, StringRef, diag::Severity,
   parseToLocation(Loc);
 }
 void ExpandModularHeadersPPCallbacks::HasInclude(SourceLocation Loc, StringRef,
                                                  bool, OptionalFileEntryRef,
                                                  SrcMgr::CharacteristicKind) {
   parseToLocation(Loc);
 }
 void ExpandModularHeadersPPCallbacks::PragmaOpenCLExtension(
-    SourceLocation NameLoc, const IdentifierInfo *, SourceLocation StateLoc,
-    unsigned) {
+    PragmaIntroducer Introducer, SourceLocation NameLoc, const IdentifierInfo *,
+    SourceLocation StateLoc, unsigned) {
   // FIXME: Figure out whether it's the right location to parse to.
   parseToLocation(NameLoc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaWarning(SourceLocation Loc,
+void ExpandModularHeadersPPCallbacks::PragmaWarning(PragmaIntroducer Introducer,
+                                                    SourceLocation Loc,
                                                     PragmaWarningSpecifier,
                                                     ArrayRef<int>) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaWarningPush(SourceLocation Loc,
-                                                        int) {
+void ExpandModularHeadersPPCallbacks::PragmaWarningPush(
+    PragmaIntroducer Introducer, SourceLocation Loc, int) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaWarningPop(SourceLocation Loc) {
+void ExpandModularHeadersPPCallbacks::PragmaWarningPop(
+    PragmaIntroducer Introducer, SourceLocation Loc) {
   parseToLocation(Loc);
 }
 void ExpandModularHeadersPPCallbacks::PragmaAssumeNonNullBegin(
-    SourceLocation Loc) {
+    PragmaIntroducer Introducer, SourceLocation Loc) {
   parseToLocation(Loc);
 }
 void ExpandModularHeadersPPCallbacks::PragmaAssumeNonNullEnd(
-    SourceLocation Loc) {
+    PragmaIntroducer Introducer, SourceLocation Loc) {
   parseToLocation(Loc);
 }
 void ExpandModularHeadersPPCallbacks::MacroExpands(const Token &MacroNameTok,
                                                    const MacroDefinition &,
                                                    SourceRange Range,
                                                    const MacroArgs *) {
   // 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());
 }
 void ExpandModularHeadersPPCallbacks::Defined(const Token &MacroNameTok,
                                               const MacroDefinition &,
                                               SourceRange Range) {
   // FIXME: Figure out whether it's the right location to parse to.
   parseToLocation(Range.getBegin());
 }
 void ExpandModularHeadersPPCallbacks::SourceRangeSkipped(
     SourceRange Range, SourceLocation EndifLoc) {
   // 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);
 }
 
 } // namespace clang::tooling

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

 namespace clang::tidy::bugprone {
 
 namespace {
 class MacroParenthesesPPCallbacks : public PPCallbacks {
 public:
   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());
   }
 
 private:
   /// Replacement list with calculations should be enclosed in parentheses.
   void replacementList(const Token &MacroNameTok, const MacroInfo *MI);

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

 
 class MacroUsageCallbacks : public PPCallbacks {
 public:
   MacroUsageCallbacks(MacroUsageCheck *Check, const SourceManager &SM,
                       StringRef RegExpStr, bool CapsOnly,
                       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() ||
         MD->getMacroInfo()->getNumTokens() == 0)
       return;
 
     if (IgnoreCommandLineMacros &&
         SM.isWrittenInCommandLineFile(MD->getLocation()))

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

UpgradeGoogletestCasePPCallback(UpgradeGoogletestCaseCheck *Check,
                                   Preprocessor *PP)
       : ReplacementFound(false), Check(Check), PP(PP) {}
 
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *) override {
     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.
       // This ensures that the check creates warnings only if it is including a
       // recent enough version of Google Test.
       llvm::StringRef FileName = PP->getSourceManager().getFilename(
           MD->getMacroInfo()->getDefinitionLoc());
       ReplacementFound = FileName.endswith("gtest/gtest-typed-test.h") &&
                          PP->getSpelling(MacroNameTok) == "TYPED_TEST_SUITE";
     }
   }
 
   void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                SourceRange Range) override {
     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);
   }
 
 private:
   enum class CheckAction { Warn, Rename };
 
   void macroUsed(const clang::Token &MacroNameTok, const MacroDefinition &MD,
                  SourceLocation Loc, CheckAction Action) {

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

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           CharSourceRange FilenameRange,
                           OptionalFileEntryRef File, StringRef SearchPath,
                           StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     clearCurrentEnum(HashLoc);
   }
 
   // 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.
   // Macros used in conditional expressions clear any adjacent enum-like
   // macros.
   // Include guards are either
   //   #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(PragmaIntroducer Introducer) override;
 
   // After we've seen everything, issue warnings and fix-its.
   void EndOfMainFile() override;
 
   void invalidateRange(SourceRange Range);
 
 private:
if (isC && (Matcher.largestLiteralSize() != LiteralSize::Int &&
     return false;
 
   return Matched;
 }
 
 
 // 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) {
     CurrentFile->GuardScanner = IncludeGuard::DefineGuard;
     return;
   }
 
   if (insideConditional())
void MacroToEnumCallbacks::MacroDefined(SourceLocation HashLoc,
   if (!isConsecutiveMacro(MD))
     newEnum();
   Enums.back().emplace_back(MacroNameTok, MD);
   rememberLastMacroLocation(MD);
 }
 
 // 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);
 
   auto MatchesToken = [&MacroNameTok](const EnumMacro &Macro) {
     return getTokenName(Macro.Name) == getTokenName(MacroNameTok);
   };
 
   auto It = llvm::find_if(Enums, [MatchesToken](const MacroList &MacroList) {
     return llvm::any_of(MacroList, MatchesToken);
   });
   if (It != Enums.end())
     Enums.erase(It);
 
   clearLastMacroLocation();
   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 &&
       CurrentFile->GuardScanner == IncludeGuard::DefineGuard)
     return;
 
   // We don't need to clear the current enum because the start of the
   // conditional block already took care of that.

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

public:
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange,
                           OptionalFileEntryRef File, StringRef SearchPath,
                           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:
   // A list of included files is kept for each file we enter.
   SmallVector<FileList> Files;
   DuplicateIncludeCheck &Check;
   const SourceManager &SM;
 };
if (llvm::is_contained(Files.back(), FileName)) {
     SourceLocation End =
         advanceBeyondCurrentLine(SM, FilenameRange.getEnd(), 1);
     Check.diag(HashLoc, "duplicate include")
         << FixItHint::CreateRemoval(SourceRange{Start, End});
   } else
     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();
 }
 
 } // namespace
 
 void DuplicateIncludeCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
   PP->addPPCallbacks(std::make_unique<DuplicateIncludeCallbacks>(*this, SM));
 }
 
 } // namespace clang::tidy::readability

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

 namespace {
 
 class PPConditionalCollector : public PPCallbacks {
 public:
   PPConditionalCollector(
       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)];
     assert(Collection.empty() || Collection.back().getEnd() < Loc);
     Collection.emplace_back(IfLoc, Loc);
   }
 
 private:

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

 class RedundantPreprocessorCallbacks : public PPCallbacks {
   enum DirectiveKind { DK_If = 0, DK_Ifdef = 1, DK_Ifndef = 2 };
 
 public:
   explicit RedundantPreprocessorCallbacks(ClangTidyCheck &Check,
                                           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),
                              PP.getSourceManager(), PP.getLangOpts());
     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);
     checkMacroRedundancy(Loc, MacroName, IfndefStack, DK_Ifdef, DK_Ifndef,
                          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,
                          true);
     checkMacroRedundancy(Loc, MacroName, IfdefStack, DK_Ifndef, DK_Ifdef,
                          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)
       IfdefStack.pop_back();
     if (!IfndefStack.empty() && IfLoc == IfndefStack.back().Loc)
       IfndefStack.pop_back();
   }
 

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

void FileChanged(SourceLocation Loc, FileChangeReason Reason,
     if (Reason == EnterFile && FileType == SrcMgr::C_User) {
       if (const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc))) {
         std::string FileName = cleanPath(FE->getName());
         Files[FileName] = FE;
       }
     }
   }
 
-  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;
 
     // Record #ifndefs that succeeded. We also need the Location of the Name.
     Ifndefs[MacroNameTok.getIdentifierInfo()] =
         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;
   }
 
   void EndOfMainFile() override {
     // Now that we have all this information from the preprocessor, use it!
     SourceManager &SM = PP->getSourceManager();
 

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

 /// Callback supplies macros to RenamerClangTidyCheck::checkMacro
 class RenamerClangTidyCheckPPCallbacks : public PPCallbacks {
 public:
   RenamerClangTidyCheckPPCallbacks(Preprocessor *PP,
                                    RenamerClangTidyCheck *Check)
       : 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;
     if (PP->getSourceManager().isWrittenInBuiltinFile(
             MacroNameTok.getLocation()))
       return;
     if (PP->getSourceManager().isWrittenInCommandLineFile(
             MacroNameTok.getLocation()))

clang-tools-extra/clangd/CollectMacros.h

public:
   explicit CollectMainFileMacros(const SourceManager &SM, MainFileMacros &Out)
       : SM(SM), Out(Out) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason,
                    SrcMgr::CharacteristicKind, FileID) override {
     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);
   }
 
   void MacroExpands(const Token &MacroName, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {
     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());
   }
 
   void Defined(const Token &MacroName, const MacroDefinition &MD,
                SourceRange Range) override {
     add(MacroName, MD.getMacroInfo());
   }
 

clang-tools-extra/clangd/CollectMacros.cpp

 }
 
 class CollectPragmaMarks : public PPCallbacks {
 public:
   explicit CollectPragmaMarks(const SourceManager &SM,
                               std::vector<clangd::PragmaMark> &Out)
       : SM(SM), Out(Out) {}
 
-  void PragmaMark(SourceLocation Loc, StringRef Trivia) override {
+  void PragmaMark(PragmaIntroducer Introducer, SourceLocation Loc,
+                  StringRef Trivia) override {
     if (isInsideMainFile(Loc, SM)) {
       // FIXME: This range should just cover `XX` in `#pragma mark XX` and
       // `- XX` in `#pragma mark - XX`.
       Position Start = sourceLocToPosition(SM, Loc);
       Position End = {Start.line + 1, 0};
       Out.emplace_back(clangd::PragmaMark{{Start, End}, Trivia.str()});
     }
   }

clang-tools-extra/clangd/Preamble.cpp

DirectiveCollector(const Preprocessor &PP,
         TextualDirectives(TextualDirectives) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     InMainFile = SM.isWrittenInMainFile(Loc);
   }
 
-  void MacroDefined(const Token &MacroNameTok,
+  void MacroDefined(SourceLocation HashLoc, const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     if (!InMainFile)
       return;
     TextualDirectives.emplace_back();
     TextualPPDirective &TD = TextualDirectives.back();
 
     const auto *MI = MD->getMacroInfo();
     TD.Text =

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

public:
 
   void MacroExpands(const Token &MacroName, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {
     if (!Active)
       return;
     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;
 
     const auto *MI = MD->getMacroInfo();
     // The tokens of a macro definition could refer to a macro.
     // Formally this reference isn't resolved until this macro is expanded,
     // but we want to treat it as a reference anyway.
     for (const auto &Tok : MI->tokens()) {
       auto *II = Tok.getIdentifierInfo();
       // Could this token be a reference to a macro? (Not param to this macro).
       if (!II || !II->hadMacroDefinition() ||
           llvm::is_contained(MI->params(), II))
         continue;
       if (const MacroInfo *MI = PP.getMacroInfo(II))
         recordMacroRef(Tok, *MI);
     }
   }
 
-  void MacroUndefined(const Token &MacroName, const MacroDefinition &MD,
+  void MacroUndefined(SourceLocation HashLoc, const Token &MacroName,
+                      const MacroDefinition &MD,
                       const MacroDirective *) override {
     if (!Active)
       return;
     if (const auto *MI = MD.getMacroInfo())
       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())
       recordMacroRef(MacroNameTok, *MI, RefType::Ambiguous);
   }
 
   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())
       recordMacroRef(MacroNameTok, *MI, RefType::Ambiguous);
   }
 
   void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                SourceRange Range) override {

clang-tools-extra/modularize/PreprocessorTracker.cpp

void FileChanged(clang::SourceLocation Loc,
                    clang::SrcMgr::CharacteristicKind FileType,
                    clang::FileID PrevFID = clang::FileID()) override;
   void MacroExpands(const clang::Token &MacroNameTok,
                     const clang::MacroDefinition &MD, clang::SourceRange Range,
                     const clang::MacroArgs *Args) override;
   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:
   PreprocessorTrackerImpl &PPTracker;
   clang::Preprocessor &PP;
   std::string RootHeaderFile;
 };
 
void PreprocessorCallbacks::Defined(const clang::Token &MacroNameTok,
   std::string MacroName = II->getName().str();
   std::string Unexpanded(getSourceString(PP, Range));
   PPTracker.addMacroExpansionInstance(
       PP, PPTracker.getCurrentHeaderHandle(), Loc,
       (MI ? MI->getDefinitionLoc() : Loc), II, Unexpanded,
       (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,
   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,
   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 =
     (MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False );
   PPTracker.addConditionalExpansionInstance(
       PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_ifdef,
       IsDefined, PP.getSpelling(MacroNameTok),
       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 =
     (!MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False );
   PPTracker.addConditionalExpansionInstance(
       PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_ifndef,
       IsNotDefined, PP.getSpelling(MacroNameTok),
       PPTracker.getCurrentInclusionPathHandle());
 }
 } // end namespace Modularize

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

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange,
                           OptionalFileEntryRef File, llvm::StringRef SearchPath,
                           llvm::StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
                     const Module *Imported) override;
   void EndOfMainFile() override;
-  void Ident(SourceLocation Loc, llvm::StringRef str) override;
+  void Ident(SourceLocation HashLoc, SourceLocation Loc,
+             llvm::StringRef str) override;
   void PragmaDirective(PragmaIntroducer Introducer) override;
-  void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
-                     llvm::StringRef Str) override;
-  void PragmaDetectMismatch(SourceLocation Loc, llvm::StringRef Name,
+  void PragmaComment(PragmaIntroducer Introducer, SourceLocation Loc,
+                     const IdentifierInfo *Kind, llvm::StringRef Str) override;
+  void PragmaDetectMismatch(PragmaIntroducer Introducer, SourceLocation Loc,
+                            llvm::StringRef Name,
                             llvm::StringRef Value) override;
-  void PragmaDebug(SourceLocation Loc, llvm::StringRef DebugType) override;
-  void PragmaMessage(SourceLocation Loc, llvm::StringRef Namespace,
+  void PragmaDebug(PragmaIntroducer Introducer, SourceLocation Loc,
+                   llvm::StringRef DebugType) override;
+  void PragmaMessage(PragmaIntroducer Introducer, SourceLocation Loc,
+                     llvm::StringRef Namespace,
                      PPCallbacks::PragmaMessageKind Kind,
                      llvm::StringRef Str) override;
-  void PragmaDiagnosticPush(SourceLocation Loc,
+  void PragmaDiagnosticPush(PragmaIntroducer Introducer, SourceLocation Loc,
                             llvm::StringRef Namespace) override;
-  void PragmaDiagnosticPop(SourceLocation Loc,
+  void PragmaDiagnosticPop(PragmaIntroducer Introducer, SourceLocation Loc,
                            llvm::StringRef Namespace) override;
-  void PragmaDiagnostic(SourceLocation Loc, llvm::StringRef Namespace,
-                        diag::Severity mapping, llvm::StringRef Str) override;
-  void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,
+  void PragmaDiagnostic(PragmaIntroducer Introducer, SourceLocation Loc,
+                        llvm::StringRef Namespace, diag::Severity mapping,
+                        llvm::StringRef Str) override;
+  void PragmaOpenCLExtension(PragmaIntroducer Introducer,
+                             SourceLocation NameLoc, const IdentifierInfo *Name,
                              SourceLocation StateLoc, unsigned State) override;
-  void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec,
+  void PragmaWarning(PragmaIntroducer Introducer, SourceLocation Loc,
+                     PragmaWarningSpecifier WarningSpec,
                      llvm::ArrayRef<int> Ids) override;
-  void PragmaWarningPush(SourceLocation Loc, int Level) override;
-  void PragmaWarningPop(SourceLocation Loc) override;
-  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override;
-  void PragmaExecCharsetPop(SourceLocation Loc) override;
+  void PragmaWarningPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                         int Level) override;
+  void PragmaWarningPop(PragmaIntroducer Introducer,
+                        SourceLocation Loc) override;
+  void PragmaExecCharsetPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                             StringRef Str) override;
+  void PragmaExecCharsetPop(PragmaIntroducer Introducer,
+                            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.
 
   /// Start a new callback.
   void beginCallback(const char *Name);
 
   /// Append a string to the top trace item.
   void append(const char *Str);

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

void PPCallbacksTracker::moduleImport(SourceLocation ImportLoc,
   appendArgument("Imported", Imported);
 }
 
 // Callback invoked when the end of the main file is reached.
 // No subsequent callbacks will be made.
 void PPCallbacksTracker::EndOfMainFile() { beginCallback("EndOfMainFile"); }
 
 // Callback invoked when a #ident or #sccs directive is read.
-void PPCallbacksTracker::Ident(SourceLocation Loc, llvm::StringRef Str) {
+void PPCallbacksTracker::Ident(SourceLocation HashLoc, SourceLocation Loc,
+                               llvm::StringRef Str) {
   beginCallback("Ident");
   appendArgument("Loc", Loc);
   appendArgument("Str", Str);
 }
 
 // Callback invoked when start reading any pragma directive.
 void PPCallbacksTracker::PragmaDirective(PragmaIntroducer Introducer) {
   beginCallback("PragmaDirective");
   appendArgument("Introducer", Introducer);
 }
 
 // Callback invoked when a #pragma comment directive is read.
-void PPCallbacksTracker::PragmaComment(SourceLocation Loc,
+void PPCallbacksTracker::PragmaComment(PragmaIntroducer Introducer,
+                                       SourceLocation Loc,
                                        const IdentifierInfo *Kind,
                                        llvm::StringRef Str) {
   beginCallback("PragmaComment");
   appendArgument("Loc", Loc);
   appendArgument("Kind", Kind);
   appendArgument("Str", Str);
 }
 
 // Callback invoked when a #pragma detect_mismatch directive is
 // read.
-void PPCallbacksTracker::PragmaDetectMismatch(SourceLocation Loc,
+void PPCallbacksTracker::PragmaDetectMismatch(PragmaIntroducer Introducer,
+                                              SourceLocation Loc,
                                               llvm::StringRef Name,
                                               llvm::StringRef Value) {
   beginCallback("PragmaDetectMismatch");
   appendArgument("Loc", Loc);
   appendArgument("Name", Name);
   appendArgument("Value", Value);
 }
 
 // Callback invoked when a #pragma clang __debug directive is read.
-void PPCallbacksTracker::PragmaDebug(SourceLocation Loc,
+void PPCallbacksTracker::PragmaDebug(PragmaIntroducer Introducer,
+                                     SourceLocation Loc,
                                      llvm::StringRef DebugType) {
   beginCallback("PragmaDebug");
   appendArgument("Loc", Loc);
   appendArgument("DebugType", DebugType);
 }
 
 // Callback invoked when a #pragma message directive is read.
-void PPCallbacksTracker::PragmaMessage(SourceLocation Loc,
+void PPCallbacksTracker::PragmaMessage(PragmaIntroducer Introducer,
+                                       SourceLocation Loc,
                                        llvm::StringRef Namespace,
                                        PPCallbacks::PragmaMessageKind Kind,
                                        llvm::StringRef Str) {
   beginCallback("PragmaMessage");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
   appendArgument("Kind", Kind, PragmaMessageKindStrings);
   appendArgument("Str", Str);
 }
 
 // Callback invoked when a #pragma gcc diagnostic push directive
 // is read.
-void PPCallbacksTracker::PragmaDiagnosticPush(SourceLocation Loc,
+void PPCallbacksTracker::PragmaDiagnosticPush(PragmaIntroducer Introducer,
+                                              SourceLocation Loc,
                                               llvm::StringRef Namespace) {
   beginCallback("PragmaDiagnosticPush");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
 }
 
 // Callback invoked when a #pragma gcc diagnostic pop directive
 // is read.
-void PPCallbacksTracker::PragmaDiagnosticPop(SourceLocation Loc,
+void PPCallbacksTracker::PragmaDiagnosticPop(PragmaIntroducer Introducer,
+                                             SourceLocation Loc,
                                              llvm::StringRef Namespace) {
   beginCallback("PragmaDiagnosticPop");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
 }
 
 // Callback invoked when a #pragma gcc diagnostic directive is read.
-void PPCallbacksTracker::PragmaDiagnostic(SourceLocation Loc,
+void PPCallbacksTracker::PragmaDiagnostic(PragmaIntroducer Introducer,
+                                          SourceLocation Loc,
                                           llvm::StringRef Namespace,
                                           diag::Severity Mapping,
                                           llvm::StringRef Str) {
   beginCallback("PragmaDiagnostic");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
   appendArgument("Mapping", (unsigned)Mapping, MappingStrings);
   appendArgument("Str", Str);
 }
 
 // Called when an OpenCL extension is either disabled or
 // enabled with a pragma.
-void PPCallbacksTracker::PragmaOpenCLExtension(SourceLocation NameLoc,
+void PPCallbacksTracker::PragmaOpenCLExtension(PragmaIntroducer Introducer,
+                                               SourceLocation NameLoc,
                                                const IdentifierInfo *Name,
                                                SourceLocation StateLoc,
                                                unsigned State) {
   beginCallback("PragmaOpenCLExtension");
   appendArgument("NameLoc", NameLoc);
   appendArgument("Name", Name);
   appendArgument("StateLoc", StateLoc);
   appendArgument("State", (int)State);
 }
 
 // Callback invoked when a #pragma warning directive is read.
-void PPCallbacksTracker::PragmaWarning(SourceLocation Loc,
+void PPCallbacksTracker::PragmaWarning(PragmaIntroducer Introducer,
+                                       SourceLocation Loc,
                                        PragmaWarningSpecifier WarningSpec,
                                        llvm::ArrayRef<int> Ids) {
   beginCallback("PragmaWarning");
   appendArgument("Loc", Loc);
   appendArgument("WarningSpec", WarningSpec, PragmaWarningSpecifierStrings);
 
   std::string Str;
   llvm::raw_string_ostream SS(Str);
   SS << "[";
   for (int i = 0, e = Ids.size(); i != e; ++i) {
     if (i)
       SS << ", ";
     SS << Ids[i];
   }
   SS << "]";
   appendArgument("Ids", SS.str());
 }
 
 // Callback invoked when a #pragma warning(push) directive is read.
-void PPCallbacksTracker::PragmaWarningPush(SourceLocation Loc, int Level) {
+void PPCallbacksTracker::PragmaWarningPush(PragmaIntroducer Introducer,
+                                           SourceLocation Loc, int Level) {
   beginCallback("PragmaWarningPush");
   appendArgument("Loc", Loc);
   appendArgument("Level", Level);
 }
 
 // Callback invoked when a #pragma warning(pop) directive is read.
-void PPCallbacksTracker::PragmaWarningPop(SourceLocation Loc) {
+void PPCallbacksTracker::PragmaWarningPop(PragmaIntroducer Introducer,
+                                          SourceLocation Loc) {
   beginCallback("PragmaWarningPop");
   appendArgument("Loc", Loc);
 }
 
 // Callback invoked when a #pragma execution_character_set(push) directive
 // is read.
-void PPCallbacksTracker::PragmaExecCharsetPush(SourceLocation Loc,
+void PPCallbacksTracker::PragmaExecCharsetPush(PragmaIntroducer Introducer,
+                                               SourceLocation Loc,
                                                StringRef Str) {
   beginCallback("PragmaExecCharsetPush");
   appendArgument("Loc", Loc);
   appendArgument("Charset", Str);
 }
 
 // Callback invoked when a #pragma execution_character_set(pop) directive
 // is read.
-void PPCallbacksTracker::PragmaExecCharsetPop(SourceLocation Loc) {
+void PPCallbacksTracker::PragmaExecCharsetPop(PragmaIntroducer Introducer,
+                                              SourceLocation Loc) {
   beginCallback("PragmaExecCharsetPop");
   appendArgument("Loc", Loc);
 }
 
 // Called by Preprocessor::HandleMacroExpandedIdentifier when a
 // macro invocation is found.
 void PPCallbacksTracker::MacroExpands(const Token &MacroNameTok,
                                       const MacroDefinition &MacroDefinition,
                                       SourceRange Range,
                                       const MacroArgs *Args) {
   beginCallback("MacroExpands");
   appendArgument("MacroNameTok", MacroNameTok);
   appendArgument("MacroDefinition", MacroDefinition);
   appendArgument("Range", Range);
   appendArgument("Args", Args);
 }
 
 // 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("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("MacroNameTok", MacroNameTok);
   appendArgument("MacroDefinition", MacroDefinition);
 }
 
 // Hook called whenever the 'defined' operator is seen.

 // Hook called when a source range is skipped.
 void PPCallbacksTracker::SourceRangeSkipped(SourceRange Range,
                                             SourceLocation EndifLoc) {
   beginCallback("SourceRangeSkipped");
   appendArgument("Range", SourceRange(Range.getBegin(), EndifLoc));
 }
 
 // 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("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("Loc", Loc);
   appendArgument("ConditionRange", ConditionRange);
   appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);
   appendArgument("IfLoc", IfLoc);
 }
 
 // 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("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("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("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("Loc", Loc);
   appendArgument("IfLoc", IfLoc);
 }
 
 // Helper functions.
 
 // Start a new callback.

clang/include/clang/Lex/PPCallbacks.h

public:
 
   /// Callback invoked when the end of the main file is reached.
   ///
   /// No subsequent callbacks will be made.
   virtual void EndOfMainFile() {
   }
 
   /// Callback invoked when a \#ident or \#sccs directive is read.
+  /// \param HashLoc The location of the '#' that starts the directive.
   /// \param Loc The location of the directive.
   /// \param str The text of the directive.
   ///
-  virtual void Ident(SourceLocation Loc, StringRef str) {
-  }
+  virtual void Ident(SourceLocation HashLoc, SourceLocation Loc,
+                     StringRef str) {}
 
   /// Callback invoked when start reading any pragma directive.
   virtual void PragmaDirective(PragmaIntroducer Introducer) {}
 
   /// Callback invoked when a \#pragma comment directive is read.
-  virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
-                             StringRef Str) {
-  }
+  virtual void PragmaComment(PragmaIntroducer Introducer, SourceLocation Loc,
+                             const IdentifierInfo *Kind, StringRef Str) {}
 
   /// Callback invoked when a \#pragma mark comment is read.
-  virtual void PragmaMark(SourceLocation Loc, StringRef Trivia) {
-  }
+  virtual void PragmaMark(PragmaIntroducer Introducer, SourceLocation Loc,
+                          StringRef Trivia) {}
 
   /// Callback invoked when a \#pragma detect_mismatch directive is
   /// read.
-  virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
-                                    StringRef Value) {
-  }
+  virtual void PragmaDetectMismatch(PragmaIntroducer Introducer,
+                                    SourceLocation Loc, StringRef Name,
+                                    StringRef Value) {}
 
   /// Callback invoked when a \#pragma clang __debug directive is read.
+  /// \param Introducer The location and kind of the pragma directive.
   /// \param Loc The location of the debug directive.
   /// \param DebugType The identifier following __debug.
-  virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType) {
-  }
+  virtual void PragmaDebug(PragmaIntroducer Introducer, SourceLocation Loc,
+                           StringRef DebugType) {}
 
   /// Determines the kind of \#pragma invoking a call to PragmaMessage.
   enum PragmaMessageKind {
     /// \#pragma message has been invoked.
     PMK_Message,
 
     /// \#pragma GCC warning has been invoked.
     PMK_Warning,
 
     /// \#pragma GCC error has been invoked.
     PMK_Error
   };
 
   /// Callback invoked when a \#pragma message directive is read.
+  /// \param Introducer The location and kind of the pragma directive.
   /// \param Loc The location of the message directive.
   /// \param Namespace The namespace of the message directive.
   /// \param Kind The type of the message directive.
   /// \param Str The text of the message directive.
-  virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace,
-                             PragmaMessageKind Kind, StringRef Str) {
-  }
+  virtual void PragmaMessage(PragmaIntroducer Introducer, SourceLocation Loc,
+                             StringRef Namespace, PragmaMessageKind Kind,
+                             StringRef Str) {}
 
   /// Callback invoked when a \#pragma gcc diagnostic push directive
   /// is read.
-  virtual void PragmaDiagnosticPush(SourceLocation Loc,
-                                    StringRef Namespace) {
-  }
+  virtual void PragmaDiagnosticPush(PragmaIntroducer Introducer,
+                                    SourceLocation Loc, StringRef Namespace) {}
 
   /// Callback invoked when a \#pragma gcc diagnostic pop directive
   /// is read.
-  virtual void PragmaDiagnosticPop(SourceLocation Loc,
-                                   StringRef Namespace) {
-  }
+  virtual void PragmaDiagnosticPop(PragmaIntroducer Introducer,
+                                   SourceLocation Loc, StringRef Namespace) {}
 
   /// Callback invoked when a \#pragma gcc diagnostic directive is read.
-  virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
-                                diag::Severity mapping, StringRef Str) {}
+  virtual void PragmaDiagnostic(PragmaIntroducer Introducer, SourceLocation Loc,
+                                StringRef Namespace, diag::Severity mapping,
+                                StringRef Str) {}
 
   /// Called when an OpenCL extension is either disabled or
   /// enabled with a pragma.
-  virtual void PragmaOpenCLExtension(SourceLocation NameLoc,
+  virtual void PragmaOpenCLExtension(PragmaIntroducer Introducer,
+                                     SourceLocation NameLoc,
                                      const IdentifierInfo *Name,
-                                     SourceLocation StateLoc, unsigned State) {
-  }
+                                     SourceLocation StateLoc, unsigned State) {}
 
   /// Callback invoked when a \#pragma warning directive is read.
   enum PragmaWarningSpecifier {
     PWS_Default,
     PWS_Disable,
     PWS_Error,
     PWS_Once,
     PWS_Suppress,
     PWS_Level1,
     PWS_Level2,
     PWS_Level3,
     PWS_Level4,
   };
-  virtual void PragmaWarning(SourceLocation Loc,
+  virtual void PragmaWarning(PragmaIntroducer Introducer, SourceLocation Loc,
                              PragmaWarningSpecifier WarningSpec,
                              ArrayRef<int> Ids) {}
 
   /// Callback invoked when a \#pragma warning(push) directive is read.
-  virtual void PragmaWarningPush(SourceLocation Loc, int Level) {
-  }
+  virtual void PragmaWarningPush(PragmaIntroducer Introducer,
+                                 SourceLocation Loc, int Level) {}
 
   /// Callback invoked when a \#pragma warning(pop) directive is read.
-  virtual void PragmaWarningPop(SourceLocation Loc) {
-  }
+  virtual void PragmaWarningPop(PragmaIntroducer Introducer,
+                                SourceLocation Loc) {}
 
   /// Callback invoked when a \#pragma execution_character_set(push) directive
   /// is read.
-  virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) {}
+  virtual void PragmaExecCharsetPush(PragmaIntroducer Introducer,
+                                     SourceLocation Loc, StringRef Str) {}
 
   /// Callback invoked when a \#pragma execution_character_set(pop) directive
   /// is read.
-  virtual void PragmaExecCharsetPop(SourceLocation Loc) {}
+  virtual void PragmaExecCharsetPop(PragmaIntroducer Introducer,
+                                    SourceLocation Loc) {}
 
   /// Callback invoked when a \#pragma clang assume_nonnull begin directive
   /// is read.
-  virtual void PragmaAssumeNonNullBegin(SourceLocation Loc) {}
+  virtual void PragmaAssumeNonNullBegin(PragmaIntroducer Introducer,
+                                        SourceLocation Loc) {}
 
   /// Callback invoked when a \#pragma clang assume_nonnull end directive
   /// is read.
-  virtual void PragmaAssumeNonNullEnd(SourceLocation Loc) {}
+  virtual void PragmaAssumeNonNullEnd(PragmaIntroducer Introducer,
+                                      SourceLocation Loc) {}
 
   /// Called by Preprocessor::HandleMacroExpandedIdentifier when a
   /// macro invocation is found.
   virtual void MacroExpands(const Token &MacroNameTok,
                             const MacroDefinition &MD, SourceRange Range,
                             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.
   virtual void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                        SourceRange Range) {
   }
 
   /// Hook called when a '__has_include' or '__has_include_next' directive is
public:
   virtual void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) {
   }
 
   enum ConditionValueKind {
     CVK_NotEvaluated, CVK_False, CVK_True
   };
 
   /// 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.
 class PPChainedCallbacks : public PPCallbacks {
   std::unique_ptr<PPCallbacks> First, Second;
 
 public:
   PPChainedCallbacks(std::unique_ptr<PPCallbacks> _First,
void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
     Second->moduleImport(ImportLoc, Path, Imported);
   }
 
   void EndOfMainFile() override {
     First->EndOfMainFile();
     Second->EndOfMainFile();
   }
 
-  void Ident(SourceLocation Loc, StringRef str) override {
-    First->Ident(Loc, str);
-    Second->Ident(Loc, str);
+  void Ident(SourceLocation HashLoc, SourceLocation Loc,
+             StringRef str) override {
+    First->Ident(HashLoc, Loc, str);
+    Second->Ident(HashLoc, Loc, str);
   }
 
   void PragmaDirective(PragmaIntroducer Introducer) override {
     First->PragmaDirective(Introducer);
     Second->PragmaDirective(Introducer);
   }
 
-  void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
-                     StringRef Str) override {
-    First->PragmaComment(Loc, Kind, Str);
-    Second->PragmaComment(Loc, Kind, Str);
+  void PragmaComment(PragmaIntroducer Introducer, SourceLocation Loc,
+                     const IdentifierInfo *Kind, StringRef Str) override {
+    First->PragmaComment(Introducer, Loc, Kind, Str);
+    Second->PragmaComment(Introducer, Loc, Kind, Str);
   }
 
-  void PragmaMark(SourceLocation Loc, StringRef Trivia) override {
-    First->PragmaMark(Loc, Trivia);
-    Second->PragmaMark(Loc, Trivia);
+  void PragmaMark(PragmaIntroducer Introducer, SourceLocation Loc,
+                  StringRef Trivia) override {
+    First->PragmaMark(Introducer, Loc, Trivia);
+    Second->PragmaMark(Introducer, Loc, Trivia);
   }
 
-  void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
-                            StringRef Value) override {
-    First->PragmaDetectMismatch(Loc, Name, Value);
-    Second->PragmaDetectMismatch(Loc, Name, Value);
+  void PragmaDetectMismatch(PragmaIntroducer Introducer, SourceLocation Loc,
+                            StringRef Name, StringRef Value) override {
+    First->PragmaDetectMismatch(Introducer, Loc, Name, Value);
+    Second->PragmaDetectMismatch(Introducer, Loc, Name, Value);
   }
 
-  void PragmaDebug(SourceLocation Loc, StringRef DebugType) override {
-    First->PragmaDebug(Loc, DebugType);
-    Second->PragmaDebug(Loc, DebugType);
+  void PragmaDebug(PragmaIntroducer Introducer, SourceLocation Loc,
+                   StringRef DebugType) override {
+    First->PragmaDebug(Introducer, Loc, DebugType);
+    Second->PragmaDebug(Introducer, Loc, DebugType);
   }
 
-  void PragmaMessage(SourceLocation Loc, StringRef Namespace,
-                     PragmaMessageKind Kind, StringRef Str) override {
-    First->PragmaMessage(Loc, Namespace, Kind, Str);
-    Second->PragmaMessage(Loc, Namespace, Kind, Str);
+  void PragmaMessage(PragmaIntroducer Introducer, SourceLocation Loc,
+                     StringRef Namespace, PragmaMessageKind Kind,
+                     StringRef Str) override {
+    First->PragmaMessage(Introducer, Loc, Namespace, Kind, Str);
+    Second->PragmaMessage(Introducer, Loc, Namespace, Kind, Str);
   }
 
-  void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override {
-    First->PragmaDiagnosticPush(Loc, Namespace);
-    Second->PragmaDiagnosticPush(Loc, Namespace);
+  void PragmaDiagnosticPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                            StringRef Namespace) override {
+    First->PragmaDiagnosticPush(Introducer, Loc, Namespace);
+    Second->PragmaDiagnosticPush(Introducer, Loc, Namespace);
   }
 
-  void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override {
-    First->PragmaDiagnosticPop(Loc, Namespace);
-    Second->PragmaDiagnosticPop(Loc, Namespace);
+  void PragmaDiagnosticPop(PragmaIntroducer Introducer, SourceLocation Loc,
+                           StringRef Namespace) override {
+    First->PragmaDiagnosticPop(Introducer, Loc, Namespace);
+    Second->PragmaDiagnosticPop(Introducer, Loc, Namespace);
   }
 
-  void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
-                        diag::Severity mapping, StringRef Str) override {
-    First->PragmaDiagnostic(Loc, Namespace, mapping, Str);
-    Second->PragmaDiagnostic(Loc, Namespace, mapping, Str);
+  void PragmaDiagnostic(PragmaIntroducer Introducer, SourceLocation Loc,
+                        StringRef Namespace, diag::Severity mapping,
+                        StringRef Str) override {
+    First->PragmaDiagnostic(Introducer, Loc, Namespace, mapping, Str);
+    Second->PragmaDiagnostic(Introducer, Loc, Namespace, mapping, Str);
   }
 
   void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
                   OptionalFileEntryRef File,
                   SrcMgr::CharacteristicKind FileType) override;
 
-  void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,
+  void PragmaOpenCLExtension(PragmaIntroducer Introducer,
+                             SourceLocation NameLoc, const IdentifierInfo *Name,
                              SourceLocation StateLoc, unsigned State) override {
-    First->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
-    Second->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
+    First->PragmaOpenCLExtension(Introducer, NameLoc, Name, StateLoc, State);
+    Second->PragmaOpenCLExtension(Introducer, NameLoc, Name, StateLoc, State);
   }
 
-  void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec,
+  void PragmaWarning(PragmaIntroducer Introducer, SourceLocation Loc,
+                     PragmaWarningSpecifier WarningSpec,
                      ArrayRef<int> Ids) override {
-    First->PragmaWarning(Loc, WarningSpec, Ids);
-    Second->PragmaWarning(Loc, WarningSpec, Ids);
+    First->PragmaWarning(Introducer, Loc, WarningSpec, Ids);
+    Second->PragmaWarning(Introducer, Loc, WarningSpec, Ids);
   }
 
-  void PragmaWarningPush(SourceLocation Loc, int Level) override {
-    First->PragmaWarningPush(Loc, Level);
-    Second->PragmaWarningPush(Loc, Level);
+  void PragmaWarningPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                         int Level) override {
+    First->PragmaWarningPush(Introducer, Loc, Level);
+    Second->PragmaWarningPush(Introducer, Loc, Level);
   }
 
-  void PragmaWarningPop(SourceLocation Loc) override {
-    First->PragmaWarningPop(Loc);
-    Second->PragmaWarningPop(Loc);
+  void PragmaWarningPop(PragmaIntroducer Introducer,
+                        SourceLocation Loc) override {
+    First->PragmaWarningPop(Introducer, Loc);
+    Second->PragmaWarningPop(Introducer, Loc);
   }
 
-  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override {
-    First->PragmaExecCharsetPush(Loc, Str);
-    Second->PragmaExecCharsetPush(Loc, Str);
+  void PragmaExecCharsetPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                             StringRef Str) override {
+    First->PragmaExecCharsetPush(Introducer, Loc, Str);
+    Second->PragmaExecCharsetPush(Introducer, Loc, Str);
   }
 
-  void PragmaExecCharsetPop(SourceLocation Loc) override {
-    First->PragmaExecCharsetPop(Loc);
-    Second->PragmaExecCharsetPop(Loc);
+  void PragmaExecCharsetPop(PragmaIntroducer Introducer,
+                            SourceLocation Loc) override {
+    First->PragmaExecCharsetPop(Introducer, Loc);
+    Second->PragmaExecCharsetPop(Introducer, Loc);
   }
 
-  void PragmaAssumeNonNullBegin(SourceLocation Loc) override {
-    First->PragmaAssumeNonNullBegin(Loc);
-    Second->PragmaAssumeNonNullBegin(Loc);
+  void PragmaAssumeNonNullBegin(PragmaIntroducer Introducer,
+                                SourceLocation Loc) override {
+    First->PragmaAssumeNonNullBegin(Introducer, Loc);
+    Second->PragmaAssumeNonNullBegin(Introducer, Loc);
   }
 
-  void PragmaAssumeNonNullEnd(SourceLocation Loc) override {
-    First->PragmaAssumeNonNullEnd(Loc);
-    Second->PragmaAssumeNonNullEnd(Loc);
+  void PragmaAssumeNonNullEnd(PragmaIntroducer Introducer,
+                              SourceLocation Loc) override {
+    First->PragmaAssumeNonNullEnd(Introducer, Loc);
+    Second->PragmaAssumeNonNullEnd(Introducer, Loc);
   }
 
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {
     First->MacroExpands(MacroNameTok, MD, Range, Args);
     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,
                SourceRange Range) override {
     First->Defined(MacroNameTok, MD, Range);
     Second->Defined(MacroNameTok, MD, Range);
   }
 
   void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override {
     First->SourceRangeSkipped(Range, EndifLoc);
     Second->SourceRangeSkipped(Range, EndifLoc);
   }
 
   /// 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);
   }
 };
 
 }  // end namespace clang
 
 #endif

clang/include/clang/Lex/PPConditionalDirectiveRecord.h

bool areInDifferentConditionalDirectiveRegion(SourceLocation LHS,
                                                 SourceLocation RHS) const {
     return findConditionalDirectiveRegionLoc(LHS) !=
         findConditionalDirectiveRegionLoc(RHS);
   }
 
   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,
+  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,
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_LEX_PPCONDITIONALDIRECTIVERECORD_H

clang/include/clang/Lex/PreprocessingRecord.h

public:
     }
 
   private:
     friend class ASTReader;
     friend class ASTWriter;
 
     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,
                             CharSourceRange FilenameRange,
                             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.
     void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                  SourceRange Range) override;
 
     void SourceRangeSkipped(SourceRange Range,
                             SourceLocation EndifLoc) override;

clang/include/clang/Lex/Preprocessor.h

private:
 
   //===--------------------------------------------------------------------===//
   /// Handle*Directive - implement the various preprocessor directives.  These
   /// should side-effect the current preprocessor object so that the next call
   /// to Lex() will return the appropriate token next.
   void HandleLineDirective();
   void HandleDigitDirective(Token &Tok);
   void HandleUserDiagnosticDirective(Token &Tok, bool isWarning);
-  void HandleIdentSCCSDirective(Token &Tok);
+  void HandleIdentSCCSDirective(SourceLocation HashLoc, Token &Tok);
   void HandleMacroPublicDirective(Token &Tok);
   void HandleMacroPrivateDirective();
 
   /// An additional notification that can be produced by a header inclusion or
   /// import to tell the parser what happened.
   struct ImportAction {
     enum ActionKind {
       None,
public:
   }
 
 private:
   /// After processing predefined file, initialize the conditional stack from
   /// the preamble.
   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);
 
   // Pragmas.
   void HandlePragmaDirective(PragmaIntroducer Introducer);
 
 public:
   void HandlePragmaOnce(Token &OnceTok);
-  void HandlePragmaMark(Token &MarkTok);
+  void HandlePragmaMark(PragmaIntroducer Introducer, Token &MarkTok);
   void HandlePragmaPoison();
   void HandlePragmaSystemHeader(Token &SysHeaderTok);
   void HandlePragmaDependency(Token &DependencyTok);
   void HandlePragmaPushMacro(Token &Tok);
   void HandlePragmaPopMacro(Token &Tok);
   void HandlePragmaIncludeAlias(Token &Tok);
   void HandlePragmaModuleBuild(Token &Tok);
   void HandlePragmaHdrstop(Token &Tok);

clang/lib/CodeGen/MacroPPCallbacks.h

public:
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange,
                           OptionalFileEntryRef File, StringRef SearchPath,
                           StringRef RelativePath, const Module *Imported,
                           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;
 };
 
 } // end namespace clang
 
 #endif

clang/lib/CodeGen/MacroPPCallbacks.cpp

void MacroPPCallbacks::InclusionDirective(
     bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
 
   // Record the line location of the current included file.
   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());
   std::string NameBuffer, ValueBuffer;
   llvm::raw_string_ostream Name(NameBuffer);
   llvm::raw_string_ostream Value(ValueBuffer);
   writeMacroDefinition(*Id, *MD->getMacroInfo(), PP, Name, Value);
   Gen->getCGDebugInfo()->CreateMacro(getCurrentScope(),
                                      llvm::dwarf::DW_MACINFO_define, location,
                                      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();
   SourceLocation location = getCorrectLocation(MacroNameTok.getLocation());
   Gen->getCGDebugInfo()->CreateMacro(getCurrentScope(),
                                      llvm::dwarf::DW_MACINFO_undef, location,
                                      Id->getName(), "");
 }

clang/lib/ExtractAPI/ExtractAPIConsumer.cpp

 };
 
 class MacroCallback : public PPCallbacks {
 public:
   MacroCallback(const SourceManager &SM, LocationFileChecker &LCF, APISet &API,
                 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 (MacroInfo->isBuiltinMacro())
       return;
 
     auto SourceLoc = MacroNameToken.getLocation();
     if (SM.isWrittenInBuiltinFile(SourceLoc) ||
         SM.isWrittenInCommandLineFile(SourceLoc))
       return;
 
     PendingMacros.emplace_back(MacroNameToken, MD);
   }
 
   // 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.
     if (!Undef)
       return;
 
     llvm::erase_if(PendingMacros, [&MD, this](const PendingMacro &PM) {
       return MD.getMacroInfo()->isIdenticalTo(*PM.MD->getMacroInfo(), PP,

clang/lib/Frontend/ASTUnit.cpp

 /// Preprocessor callback class that updates a hash value with the names
 /// of all macros that have been defined by the translation unit.
 class MacroDefinitionTrackerPPCallbacks : public PPCallbacks {
   unsigned &Hash;
 
 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);
   }
 };
 
 } // namespace
 
 /// Add the given declaration to the hash of all top-level entities.

clang/lib/Frontend/PrintPreprocessedOutput.cpp

void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange,
                           OptionalFileEntryRef File, StringRef SearchPath,
                           StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
-  void Ident(SourceLocation Loc, StringRef str) override;
-  void PragmaMessage(SourceLocation Loc, StringRef Namespace,
-                     PragmaMessageKind Kind, StringRef Str) override;
-  void PragmaDebug(SourceLocation Loc, StringRef DebugType) override;
-  void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override;
-  void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override;
-  void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
-                        diag::Severity Map, StringRef Str) override;
-  void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec,
+  void Ident(SourceLocation HashLoc, SourceLocation Loc,
+             StringRef str) override;
+  void PragmaMessage(PragmaIntroducer Introducer, SourceLocation Loc,
+                     StringRef Namespace, PragmaMessageKind Kind,
+                     StringRef Str) override;
+  void PragmaDebug(PragmaIntroducer Introducer, SourceLocation Loc,
+                   StringRef DebugType) override;
+  void PragmaDiagnosticPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                            StringRef Namespace) override;
+  void PragmaDiagnosticPop(PragmaIntroducer Introducer, SourceLocation Loc,
+                           StringRef Namespace) override;
+  void PragmaDiagnostic(PragmaIntroducer Introducer, SourceLocation Loc,
+                        StringRef Namespace, diag::Severity Map,
+                        StringRef Str) override;
+  void PragmaWarning(PragmaIntroducer Introducer, SourceLocation Loc,
+                     PragmaWarningSpecifier WarningSpec,
                      ArrayRef<int> Ids) override;
-  void PragmaWarningPush(SourceLocation Loc, int Level) override;
-  void PragmaWarningPop(SourceLocation Loc) override;
-  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override;
-  void PragmaExecCharsetPop(SourceLocation Loc) override;
-  void PragmaAssumeNonNullBegin(SourceLocation Loc) override;
-  void PragmaAssumeNonNullEnd(SourceLocation Loc) override;
+  void PragmaWarningPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                         int Level) override;
+  void PragmaWarningPop(PragmaIntroducer Introducer,
+                        SourceLocation Loc) override;
+  void PragmaExecCharsetPush(PragmaIntroducer Introducer, SourceLocation Loc,
+                             StringRef Str) override;
+  void PragmaExecCharsetPop(PragmaIntroducer Introducer,
+                            SourceLocation Loc) override;
+  void PragmaAssumeNonNullBegin(PragmaIntroducer Introducer,
+                                SourceLocation Loc) override;
+  void PragmaAssumeNonNullEnd(PragmaIntroducer Introducer,
+                              SourceLocation Loc) override;
 
   /// Insert whitespace before emitting the next token.
   ///
   /// @param Tok             Next token to be emitted.
   /// @param RequireSpace    Ensure at least one whitespace is emitted. Useful
   ///                        if non-tokens have been emitted to the stream.
   /// @param RequireSameLine Never emit newlines. Useful when semantics depend
   ///                        on being on the same line, such as directives.
bool AvoidConcat(const Token &PrevPrevTok, const Token &PrevTok,
     return ConcatInfo.AvoidConcat(PrevPrevTok, PrevTok, Tok);
   }
   void WriteLineInfo(unsigned LineNo, const char *Extra=nullptr,
                      unsigned ExtraLen=0);
   bool LineMarkersAreDisabled() const { return DisableLineMarkers; }
   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;
 
   void BeginModule(const Module *M);
   void EndModule(const Module *M);
 };
 }  // end anonymous namespace
 

 void PrintPPOutputPPCallbacks::EndModule(const Module *M) {
   startNewLineIfNeeded();
   OS << "#pragma clang module end /*" << M->getFullModuleName(true) << "*/";
   setEmittedDirectiveOnThisLine();
 }
 
 /// Ident - Handle #ident directives when read by the preprocessor.
 ///
-void PrintPPOutputPPCallbacks::Ident(SourceLocation Loc, StringRef S) {
+void PrintPPOutputPPCallbacks::Ident(SourceLocation HashLoc, SourceLocation Loc,
+                                     StringRef S) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
 
   OS.write("#ident ", strlen("#ident "));
   OS.write(S.begin(), S.size());
   setEmittedTokensOnThisLine();
 }
 
 /// 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
   // for C++20 header units.
   if ((!DumpDefines && !DirectivesOnly) ||
       // Ignore __FILE__ etc.
       MI->isBuiltinMacro())
     return;
 
   SourceLocation DefLoc = MI->getDefinitionLoc();
   if (DirectivesOnly && !MI->isUsed()) {
     SourceManager &SM = PP.getSourceManager();
     if (SM.isWrittenInBuiltinFile(DefLoc) ||
         SM.isWrittenInCommandLineFile(DefLoc))
       return;
   }
   MoveToLine(DefLoc, /*RequireStartOfLine=*/true);
   PrintMacroDefinition(*MacroNameTok.getIdentifierInfo(), *MI, PP, OS);
   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
   // for C++20 header units.
   if (!DumpDefines && !DirectivesOnly)
     return;
 
   MoveToLine(MacroNameTok.getLocation(), /*RequireStartOfLine=*/true);
   OS << "#undef " << MacroNameTok.getIdentifierInfo()->getName();
   setEmittedDirectiveOnThisLine();
 }
 
 static void outputPrintable(raw_ostream &OS, StringRef Str) {
   for (unsigned char Char : Str) {
     if (isPrintable(Char) && Char != '\\' && Char != '"')
       OS << (char)Char;
     else // Output anything hard as an octal escape.
       OS << '\\'
          << (char)('0' + ((Char >> 6) & 7))
          << (char)('0' + ((Char >> 3) & 7))
          << (char)('0' + ((Char >> 0) & 7));
   }
 }
 
-void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc,
+void PrintPPOutputPPCallbacks::PragmaMessage(PragmaIntroducer Introducer,
+                                             SourceLocation Loc,
                                              StringRef Namespace,
                                              PragmaMessageKind Kind,
                                              StringRef Str) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma ";
   if (!Namespace.empty())
     OS << Namespace << ' ';
   switch (Kind) {
void PrintPPOutputPPCallbacks::PragmaMessage(PragmaIntroducer Introducer,
 
   outputPrintable(OS, Str);
   OS << '"';
   if (Kind == PMK_Message)
     OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc,
+void PrintPPOutputPPCallbacks::PragmaDebug(PragmaIntroducer Introducer,
+                                           SourceLocation Loc,
                                            StringRef DebugType) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
 
   OS << "#pragma clang __debug ";
   OS << DebugType;
 
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::
-PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) {
+void PrintPPOutputPPCallbacks::PragmaDiagnosticPush(PragmaIntroducer Introducer,
+                                                    SourceLocation Loc,
+                                                    StringRef Namespace) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma " << Namespace << " diagnostic push";
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::
-PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) {
+void PrintPPOutputPPCallbacks::PragmaDiagnosticPop(PragmaIntroducer Introducer,
+                                                   SourceLocation Loc,
+                                                   StringRef Namespace) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma " << Namespace << " diagnostic pop";
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc,
+void PrintPPOutputPPCallbacks::PragmaDiagnostic(PragmaIntroducer Introducer,
+                                                SourceLocation Loc,
                                                 StringRef Namespace,
                                                 diag::Severity Map,
                                                 StringRef Str) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma " << Namespace << " diagnostic ";
   switch (Map) {
   case diag::Severity::Remark:
     OS << "remark";
void PrintPPOutputPPCallbacks::PragmaDiagnostic(PragmaIntroducer Introducer,
   case diag::Severity::Fatal:
     OS << "fatal";
     break;
   }
   OS << " \"" << Str << '"';
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::PragmaWarning(SourceLocation Loc,
+void PrintPPOutputPPCallbacks::PragmaWarning(PragmaIntroducer Introducer,
+                                             SourceLocation Loc,
                                              PragmaWarningSpecifier WarningSpec,
                                              ArrayRef<int> Ids) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
 
   OS << "#pragma warning(";
   switch(WarningSpec) {
     case PWS_Default:  OS << "default"; break;
     case PWS_Disable:  OS << "disable"; break;
     case PWS_Error:    OS << "error"; break;
     case PWS_Once:     OS << "once"; break;
     case PWS_Suppress: OS << "suppress"; break;
     case PWS_Level1:   OS << '1'; break;
     case PWS_Level2:   OS << '2'; break;
     case PWS_Level3:   OS << '3'; break;
     case PWS_Level4:   OS << '4'; break;
   }
   OS << ':';
 
   for (ArrayRef<int>::iterator I = Ids.begin(), E = Ids.end(); I != E; ++I)
     OS << ' ' << *I;
   OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::PragmaWarningPush(SourceLocation Loc,
+void PrintPPOutputPPCallbacks::PragmaWarningPush(PragmaIntroducer Introducer,
+                                                 SourceLocation Loc,
                                                  int Level) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma warning(push";
   if (Level >= 0)
     OS << ", " << Level;
   OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::PragmaWarningPop(SourceLocation Loc) {
+void PrintPPOutputPPCallbacks::PragmaWarningPop(PragmaIntroducer Introducer,
+                                                SourceLocation Loc) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma warning(pop)";
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(SourceLocation Loc,
-                                                     StringRef Str) {
+void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(
+    PragmaIntroducer Introducer, SourceLocation Loc, StringRef Str) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma character_execution_set(push";
   if (!Str.empty())
     OS << ", " << Str;
   OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::PragmaExecCharsetPop(SourceLocation Loc) {
+void PrintPPOutputPPCallbacks::PragmaExecCharsetPop(PragmaIntroducer Introducer,
+                                                    SourceLocation Loc) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma character_execution_set(pop)";
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::
-PragmaAssumeNonNullBegin(SourceLocation Loc) {
+void PrintPPOutputPPCallbacks::PragmaAssumeNonNullBegin(
+    PragmaIntroducer Introducer, SourceLocation Loc) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma clang assume_nonnull begin";
   setEmittedDirectiveOnThisLine();
 }
 
-void PrintPPOutputPPCallbacks::
-PragmaAssumeNonNullEnd(SourceLocation Loc) {
+void PrintPPOutputPPCallbacks::PragmaAssumeNonNullEnd(
+    PragmaIntroducer Introducer, SourceLocation Loc) {
   MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma clang assume_nonnull end";
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::HandleWhitespaceBeforeTok(const Token &Tok,
                                                          bool RequireSpace,
                                                          bool RequireSameLine) {

clang/lib/Frontend/Rewrite/InclusionRewriter.cpp

private:
   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                    SrcMgr::CharacteristicKind FileType) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange,
                           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());
   void WriteImplicitModuleImport(const Module *Mod);
   void OutputContentUpTo(const MemoryBufferRef &FromFile, unsigned &WriteFrom,
                          unsigned WriteTo, StringRef EOL, int &lines,
                          bool EnsureNewline);
   void CommentOutDirective(Lexer &DirectivesLex, const Token &StartToken,
void InclusionRewriter::InclusionDirective(
   if (Imported) {
     auto P = ModuleIncludes.insert(std::make_pair(HashLoc, Imported));
     (void)P;
     assert(P.second && "Unexpected revisitation of the same include directive");
   } else
     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));
   (void)P;
   assert(P.second && "Unexpected revisitation of the same elif directive");
 }
 
 /// Simple lookup for a SourceLocation (specifically one denoting the hash in

clang/lib/Index/IndexingAction.cpp

IndexPPCallbacks(std::shared_ptr<IndexingContext> IndexCtx)
       : IndexCtx(std::move(IndexCtx)) {}
 
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {
     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
                                    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;
     IndexCtx->handleMacroUndefined(*MacroNameTok.getIdentifierInfo(),
                                    MacroNameTok.getLocation(),
                                    *MD.getMacroInfo());
   }
 
   void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                SourceRange Range) override {
     if (!MD.getMacroInfo()) // Ignore nonexistent macro.
       return;
     // Note: this is defined(M), not #define M
     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
                                    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(),
                                    MacroNameTok.getLocation(),
                                    *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 (!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(),
                                    MacroNameTok.getLocation(),
                                    *MD.getMacroInfo());
   }
 };
 

clang/lib/Lex/PPConditionalDirectiveRecord.cpp

if (SourceMgr.isInSystemHeader(DirLoc.getLoc()))
     return;
 
   assert(CondDirectiveLocs.empty() ||
          SourceMgr.isBeforeInTranslationUnit(CondDirectiveLocs.back().getLoc(),
                                              DirLoc.getLoc()));
   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) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   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());
   CondDirectiveStack.pop_back();
 }
 
 size_t PPConditionalDirectiveRecord::getTotalMemory() const {
   return llvm::capacity_in_bytes(CondDirectiveLocs);
 }

clang/lib/Lex/PPDirectives.cpp

while (true) {
     // directive mode.  Tell the lexer this so any newlines we see will be
     // converted into an EOD token (this terminates the macro).
     CurPPLexer->ParsingPreprocessorDirective = true;
     if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
 
     assert(Tok.is(tok::hash));
     const char *Hashptr = CurLexer->getBufferLocation() - Tok.getLength();
     assert(CurLexer->getSourceLocation(Hashptr) == Tok.getLocation());
+    SourceLocation LastHashLoc = Tok.getLocation();
 
     // Read the next token, the directive flavor.
     LexUnexpandedToken(Tok);
 
     // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
     // something bogus), skip it.
     if (Tok.isNot(tok::raw_identifier)) {
       CurPPLexer->ParsingPreprocessorDirective = false;
if (Directive.startswith("if")) {
         if (!CondInfo.WasSkipping) {
           SkippingRangeState.endLexPass(Hashptr);
           // Restore the value of LexingRawMode so that trailing comments
           // are handled correctly, if we've reached the outermost block.
           CurPPLexer->LexingRawMode = false;
           endLoc = CheckEndOfDirective("endif");
           CurPPLexer->LexingRawMode = true;
           if (Callbacks)
-            Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
+            Callbacks->Endif(LastHashLoc, Tok.getLocation(), CondInfo.IfLoc);
           break;
         } else {
           DiscardUntilEndOfDirective();
         }
       } else if (Sub == "lse") { // "else".
         // #else directive in a skipping conditional.  If not in some other
         // skipping conditional, and if #else hasn't already been seen, enter it
         // as a non-skipping conditional.
if (Directive.startswith("if")) {
         if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
           CondInfo.FoundNonSkip = true;
           // Restore the value of LexingRawMode so that trailing comments
           // are handled correctly.
           CurPPLexer->LexingRawMode = false;
           endLoc = CheckEndOfDirective("else");
           CurPPLexer->LexingRawMode = true;
           if (Callbacks)
-            Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
+            Callbacks->Else(LastHashLoc, Tok.getLocation(), CondInfo.IfLoc);
           break;
         } else {
           DiscardUntilEndOfDirective();  // C99 6.10p4.
         }
       } else if (Sub == "lif") {  // "elif".
         PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
 
         if (!CondInfo.WasSkipping)
if (Directive.startswith("if")) {
           DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
           // Stop if Lexer became invalid after hitting code completion token.
           if (!CurPPLexer)
             return;
           const bool CondValue = DER.Conditional;
           CurPPLexer->LexingRawMode = true;
           if (Callbacks) {
             Callbacks->Elif(
-                Tok.getLocation(), DER.ExprRange,
+                LastHashLoc, Tok.getLocation(), DER.ExprRange,
                 (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False),
                 CondInfo.IfLoc);
           }
           // If this condition is true, enter it!
           if (CondValue) {
             CondInfo.FoundNonSkip = true;
             break;
           }
if (Directive.startswith("if")) {
           CheckEndOfDirective(IsElifDef ? "elifdef" : "elifndef");
 
           IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
           auto MD = getMacroDefinition(MII);
           MacroInfo *MI = MD.getMacroInfo();
 
           if (Callbacks) {
             if (IsElifDef) {
-              Callbacks->Elifdef(DirectiveToken.getLocation(), MacroNameTok,
-                                 MD);
+              Callbacks->Elifdef(LastHashLoc, DirectiveToken.getLocation(),
+                                 MacroNameTok, MD);
             } else {
-              Callbacks->Elifndef(DirectiveToken.getLocation(), MacroNameTok,
-                                  MD);
+              Callbacks->Elifndef(LastHashLoc, DirectiveToken.getLocation(),
+                                  MacroNameTok, MD);
             }
           }
           // If this condition is true, enter it!
           if (static_cast<bool>(MI) == IsElifDef) {
             CondInfo.FoundNonSkip = true;
             break;
           }
         }

 /// #include (to check if it is the through header)
 /// #define (to warn about macros that don't match the PCH)
 /// #pragma (to check for pragma hdrstop).
 /// All other directives are completely discarded.
 void Preprocessor::HandleSkippedDirectiveWhileUsingPCH(Token &Result,
                                                        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 &&
         II->getPPKeywordID() == tok::pp_include) {
       return HandleIncludeDirective(HashLoc, Result);
     }
     if (SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) {
       Lex(Result);
default:
     case tok::pp_elif:
     case tok::pp_elifdef:
     case tok::pp_elifndef:
       return HandleElifFamilyDirective(Result, SavedHash, II->getPPKeywordID());
 
     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:
       // Handle #include.
       return HandleIncludeDirective(SavedHash.getLocation(), Result);
     case tok::pp___include_macros:
       // Handle -imacros.
       return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);
 
     // 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:
       return HandleLineDirective();
 
     // C99 6.10.5 - Error Directive.
     case tok::pp_error:
       return HandleUserDiagnosticDirective(Result, false);
case tok::pp_warning:
             << /*C++2b*/ 1;
       else
         Diag(Result, LangOpts.C2x ? diag::warn_c2x_compat_warning_directive
                                   : diag::ext_pp_warning_directive)
             << /*C2x*/ 0;
 
       return HandleUserDiagnosticDirective(Result, true);
     case tok::pp_ident:
-      return HandleIdentSCCSDirective(Result);
+      return HandleIdentSCCSDirective(SavedHash.getLocation(), Result);
     case tok::pp_sccs:
-      return HandleIdentSCCSDirective(Result);
+      return HandleIdentSCCSDirective(SavedHash.getLocation(), Result);
     case tok::pp_assert:
       //isExtension = true;  // FIXME: implement #assert
       break;
     case tok::pp_unassert:
       //isExtension = true;  // FIXME: implement #unassert
       break;
 
     case tok::pp___public_macro:
void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
   if (isWarning)
     Diag(Tok, diag::pp_hash_warning) << Msg;
   else
     Diag(Tok, diag::err_pp_hash_error) << Msg;
 }
 
 /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
 ///
-void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
+void Preprocessor::HandleIdentSCCSDirective(SourceLocation HashLoc,
+                                            Token &Tok) {
   // Yes, this directive is an extension.
   Diag(Tok, diag::ext_pp_ident_directive);
 
   // Read the string argument.
   Token StrTok;
   Lex(StrTok);
 
   // If the token kind isn't a string, it's a malformed directive.
void Preprocessor::HandleIdentSCCSDirective(SourceLocation HashLoc,
 
   // Verify that there is nothing after the string, other than EOD.
   CheckEndOfDirective("ident");
 
   if (Callbacks) {
     bool Invalid = false;
     std::string Str = getSpelling(StrTok, &Invalid);
     if (!Invalid)
-      Callbacks->Ident(Tok.getLocation(), Str);
+      Callbacks->Ident(HashLoc, Tok.getLocation(), Str);
   }
 }
 
 /// Handle a #public directive.
 void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
   Token MacroNameTok;
   ReadMacroName(MacroNameTok, MU_Undef);
 
MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(
   MI->setDefinitionEndLoc(LastTok.getLocation());
 
   MI->setTokens(Tokens, BP);
   return MI;
 }
 /// 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;
   bool MacroShadowsKeyword;
   ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
 
   // Error reading macro name?  If so, diagnostic already issued.
   if (MacroNameTok.is(tok::eod))
if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&
       getSourceManager().getFileID(MI->getDefinitionLoc()) !=
           getPredefinesFileID()) {
     MI->setIsWarnIfUnused(true);
     WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());
   }
 
   // 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
   // around their broken assert.h header file in C. Only do so if there isn't
   // already a static_assert macro defined.
   if (!getLangOpts().CPlusPlus && getLangOpts().MSVCCompat &&
       MacroNameTok.getIdentifierInfo()->isStr("assert") &&
       !isMacroDefined("static_assert")) {
     MacroInfo *MI = AllocateMacroInfo(SourceLocation());
 
     Token Tok;
     Tok.startToken();
     Tok.setKind(tok::kw__Static_assert);
     Tok.setIdentifierInfo(getIdentifierInfo("_Static_assert"));
     MI->setTokens({Tok}, BP);
     (void)appendDefMacroDirective(getIdentifierInfo("static_assert"), MI);
   }
 }
 
 /// HandleUndefDirective - Implements \#undef.
 ///
-void Preprocessor::HandleUndefDirective() {
+void Preprocessor::HandleUndefDirective(SourceLocation HashLoc) {
   ++NumUndefined;
 
   Token MacroNameTok;
   ReadMacroName(MacroNameTok, MU_Undef);
 
   // Error reading macro name?  If so, diagnostic already issued.
   if (MacroNameTok.is(tok::eod))
     return;
if (MI->isWarnIfUnused())
       WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
 
     Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());
   }
 
   // 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);
 }
 
 //===----------------------------------------------------------------------===//
 // Preprocessor Conditional Directive Handling.
 //===----------------------------------------------------------------------===//
void Preprocessor::HandleIfdefDirective(Token &Result,
   }
 
   // If there is a macro, process it.
   if (MI)  // Mark it used.
     markMacroAsUsed(MI);
 
   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 &&
     getSourceManager().isInMainFile(DirectiveTok.getLocation());
 
   // Should we include the stuff contained by this directive?
   if (PPOpts->SingleFileParseMode && !MI) {
     // In 'single-file-parse mode' undefined identifiers trigger parsing of all
if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)
       // FIXME: Pass in the location of the macro name, not the 'if' token.
       CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());
     else
       CurPPLexer->MIOpt.EnterTopLevelConditional();
   }
 
   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 &&
     getSourceManager().isInMainFile(IfToken.getLocation());
 
   // Should we include the stuff contained by this directive?
   if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {
     // In 'single-file-parse mode' undefined identifiers trigger parsing of all
if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {
     SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(),
                                  /*Foundnonskip*/ false,
                                  /*FoundElse*/ false);
   }
 }
 
 /// 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.
   CheckEndOfDirective("endif");
 
   PPConditionalInfo CondInfo;
   if (CurPPLexer->popConditionalLevel(CondInfo)) {
     // No conditionals on the stack: this is an #endif without an #if.
     Diag(EndifToken, diag::err_pp_endif_without_if);
     return;
   }
 
   // If this the end of a top-level #endif, inform MIOpt.
   if (CurPPLexer->getConditionalStackDepth() == 0)
     CurPPLexer->MIOpt.ExitTopLevelConditional();
 
   assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&
          "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.
 ///
 void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) {
   ++NumElse;
 
   // #else directive in a non-skipping conditional... start skipping.
   CheckEndOfDirective("else");
 
   PPConditionalInfo CI;
   if (CurPPLexer->popConditionalLevel(CI)) {
     Diag(Result, diag::pp_err_else_without_if);
     return;
   }
 
   // If this is a top-level #else, inform the MIOpt.
   if (CurPPLexer->getConditionalStackDepth() == 0)
     CurPPLexer->MIOpt.EnterTopLevelConditional();
 
   // If this is a #else with a #else before it, report the error.
   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 ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {
     // In 'single-file-parse mode' undefined identifiers trigger parsing of all
     // the directive blocks.
     CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false,
void Preprocessor::HandleElifFamilyDirective(Token &ElifToken,
 
   // If this is a #elif with a #else before it, report the error.
   if (CI.FoundElse)
     Diag(ElifToken, diag::pp_err_elif_after_else) << DirKind;
 
   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");
       break;
     }
   }
 
   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&

clang/lib/Lex/Pragma.cpp

if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {
     return;
   }
 
   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
   // Mark the file as a once-only file now.
   HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
 }
 
-void Preprocessor::HandlePragmaMark(Token &MarkTok) {
+void Preprocessor::HandlePragmaMark(PragmaIntroducer Introducer,
+                                    Token &MarkTok) {
   assert(CurPPLexer && "No current lexer?");
 
   SmallString<64> Buffer;
   CurLexer->ReadToEndOfLine(&Buffer);
   if (Callbacks)
-    Callbacks->PragmaMark(MarkTok.getLocation(), Buffer);
+    Callbacks->PragmaMark(Introducer, MarkTok.getLocation(), Buffer);
 }
 
 /// HandlePragmaPoison - Handle \#pragma GCC poison.  PoisonTok is the 'poison'.
 void Preprocessor::HandlePragmaPoison() {
   Token Tok;
 
   while (true) {
     // Read the next token to poison.  While doing this, pretend that we are

 
 /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
 /// rest of the line is not lexed.
 struct PragmaMarkHandler : public PragmaHandler {
   PragmaMarkHandler() : PragmaHandler("mark") {}
 
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &MarkTok) override {
-    PP.HandlePragmaMark(MarkTok);
+    PP.HandlePragmaMark(Introducer, MarkTok);
   }
 };
 
 /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
 struct PragmaPoisonHandler : public PragmaHandler {
   PragmaPoisonHandler() : PragmaHandler("poison") {}
 
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
if (II->isStr("assert")) {
                                                       MaxNotes);
     } else {
       PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
         << II->getName();
     }
 
     PPCallbacks *Callbacks = PP.getPPCallbacks();
     if (Callbacks)
-      Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
+      Callbacks->PragmaDebug(Introducer, Tok.getLocation(), II->getName());
   }
 
   void HandleCaptured(Preprocessor &PP) {
     Token Tok;
     PP.LexUnexpandedToken(Tok);
 
     if (Tok.isNot(tok::eod)) {
       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     }
     IdentifierInfo *II = Tok.getIdentifierInfo();
     PPCallbacks *Callbacks = PP.getPPCallbacks();
 
     if (II->isStr("pop")) {
       if (!PP.getDiagnostics().popMappings(DiagLoc))
         PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
       else if (Callbacks)
-        Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
+        Callbacks->PragmaDiagnosticPop(Introducer, DiagLoc, Namespace);
       return;
     } else if (II->isStr("push")) {
       PP.getDiagnostics().pushMappings(DiagLoc);
       if (Callbacks)
-        Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
+        Callbacks->PragmaDiagnosticPush(Introducer, DiagLoc, Namespace);
       return;
     }
 
     diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
                             .Case("ignored", diag::Severity::Ignored)
                             .Case("warning", diag::Severity::Warning)
                             .Case("error", diag::Severity::Error)
                             .Case("fatal", diag::Severity::Fatal)
if (Group == "everything") {
       PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
     } else
       unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
                                                             DiagLoc);
     if (unknownDiag)
       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
         << WarningName;
     else if (Callbacks)
-      Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
+      Callbacks->PragmaDiagnostic(Introducer, DiagLoc, Namespace, SV,
+                                  WarningName);
   }
 };
 
 /// "\#pragma hdrstop [<header-name-string>]"
 struct PragmaHdrstopHandler : public PragmaHandler {
   PragmaHdrstopHandler() : PragmaHandler("hdrstop") {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &DepToken) override {
if (II && II->isStr("push")) {
           Level = int(Value);
         if (Level < 0 || Level > 4) {
           PP.Diag(Tok, diag::warn_pragma_warning_push_level);
           return;
         }
       }
       PP.getDiagnostics().pushMappings(DiagLoc);
       if (Callbacks)
-        Callbacks->PragmaWarningPush(DiagLoc, Level);
+        Callbacks->PragmaWarningPush(Introducer, DiagLoc, Level);
     } else if (II && II->isStr("pop")) {
       // #pragma warning( pop )
       PP.Lex(Tok);
       if (!PP.getDiagnostics().popMappings(DiagLoc))
         PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
       else if (Callbacks)
-        Callbacks->PragmaWarningPop(DiagLoc);
+        Callbacks->PragmaWarningPop(Introducer, DiagLoc);
     } else {
       // #pragma warning( warning-specifier : warning-number-list
       //                  [; warning-specifier : warning-number-list...] )
       while (true) {
         II = Tok.getIdentifierInfo();
         if (!II && !Tok.is(tok::numeric_constant)) {
           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
           return;
if (II && II->isStr("push")) {
                   diag::Flavor::WarningOrError, *Group, SV, DiagLoc);
               assert(!unknownDiag &&
                      "wd table should only contain known diags");
               (void)unknownDiag;
             }
           }
 
         if (Callbacks)
-          Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
+          Callbacks->PragmaWarning(Introducer, DiagLoc, Specifier, Ids);
 
         // Parse the next specifier if there is a semicolon.
         if (Tok.isNot(tok::semi))
           break;
         PP.Lex(Tok);
       }
     }
 
if (II && II->isStr("push")) {
 
         // MSVC supports either of these, but nothing else.
         if (ExecCharset != "UTF-8" && ExecCharset != "utf-8") {
           PP.Diag(Tok, diag::warn_pragma_exec_charset_push_invalid) << ExecCharset;
           return;
         }
       }
       if (Callbacks)
-        Callbacks->PragmaExecCharsetPush(DiagLoc, "UTF-8");
+        Callbacks->PragmaExecCharsetPush(Introducer, DiagLoc, "UTF-8");
     } else if (II && II->isStr("pop")) {
       // #pragma execution_character_set( pop )
       PP.Lex(Tok);
       if (Callbacks)
-        Callbacks->PragmaExecCharsetPop(DiagLoc);
+        Callbacks->PragmaExecCharsetPop(Introducer, DiagLoc);
     } else {
       PP.Diag(Tok, diag::warn_pragma_exec_charset_spec_invalid);
       return;
     }
 
     if (Tok.isNot(tok::r_paren)) {
       PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << ")";
       return;
void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
 
     // Output the message.
     PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
                           ? diag::err_pragma_message
                           : diag::warn_pragma_message) << MessageString;
 
     // If the pragma is lexically sound, notify any interested PPCallbacks.
     if (PPCallbacks *Callbacks = PP.getPPCallbacks())
-      Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
+      Callbacks->PragmaMessage(Introducer, MessageLoc, Namespace, Kind,
+                               MessageString);
   }
 };
 
 /// Handle the clang \#pragma module import extension. The syntax is:
 /// \code
 ///   #pragma clang module import some.module.name
 /// \endcode
 struct PragmaModuleImportHandler : public PragmaHandler {
void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     if (IsBegin) {
       // Complain about attempts to re-enter an audit.
       if (BeginLoc.isValid()) {
         PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
       }
       NewLoc = Loc;
       if (Callbacks)
-        Callbacks->PragmaAssumeNonNullBegin(NewLoc);
+        Callbacks->PragmaAssumeNonNullBegin(Introducer, NewLoc);
     } else {
       // Complain about attempts to leave an audit that doesn't exist.
       if (!BeginLoc.isValid()) {
         PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
         return;
       }
       NewLoc = SourceLocation();
       if (Callbacks)
-        Callbacks->PragmaAssumeNonNullEnd(NewLoc);
+        Callbacks->PragmaAssumeNonNullEnd(Introducer, NewLoc);
     }
 
     PP.setPragmaAssumeNonNullLoc(NewLoc);
   }
 };
 
 /// Handle "\#pragma region [...]"
 ///

clang/lib/Lex/PreprocessingRecord.cpp

void PreprocessingRecord::addMacroExpansion(const Token &Id,
 
   if (MI->isBuiltinMacro())
     addPreprocessedEntity(new (*this)
                               MacroExpansion(Id.getIdentifierInfo(), Range));
   else if (MacroDefinitionRecord *Def = findMacroDefinition(MI))
     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)
     addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
                       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)
     addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
                       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)
     addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
                       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.
   if (MD)
     addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
                       MacroNameTok.getLocation());
 }
 

 
 void PreprocessingRecord::MacroExpands(const Token &Id,
                                        const MacroDefinition &MD,
                                        SourceRange Range,
                                        const MacroArgs *Args) {
   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());
   MacroDefinitionRecord *Def =
       new (*this) MacroDefinitionRecord(Id.getIdentifierInfo(), R);
   addPreprocessedEntity(Def);
   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); });
 }
 
 void PreprocessingRecord::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
     bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File,

clang/lib/Parse/ParsePragma.cpp

void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
   Toks[0].setKind(tok::annot_pragma_opencl_extension);
   Toks[0].setLocation(NameLoc);
   Toks[0].setAnnotationValue(static_cast<void*>(Info));
   Toks[0].setAnnotationEndLoc(StateLoc);
   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
                       /*IsReinject=*/false);
 
   if (PP.getPPCallbacks())
-    PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, Ext,
+    PP.getPPCallbacks()->PragmaOpenCLExtension(Introducer, NameLoc, Ext,
                                                StateLoc, State);
 }
 
 /// Handle '#pragma omp ...' when OpenMP is disabled.
 ///
 void PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP,
                                          PragmaIntroducer Introducer,
                                          Token &FirstTok) {
void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP,
 
   if (Tok.isNot(tok::eod)) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
     return;
   }
 
   // If the pragma is lexically sound, notify any interested PPCallbacks.
   if (PP.getPPCallbacks())
-    PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString,
-                                              ValueString);
+    PP.getPPCallbacks()->PragmaDetectMismatch(Introducer, DetectMismatchLoc,
+                                              NameString, ValueString);
 
   Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString);
 }
 
 /// Handle the microsoft \#pragma comment extension.
 ///
 /// The syntax is:
 /// \code
void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
 
   if (Tok.isNot(tok::eod)) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
     return;
   }
 
   // If the pragma is lexically sound, notify any interested PPCallbacks.
   if (PP.getPPCallbacks())
-    PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString);
+    PP.getPPCallbacks()->PragmaComment(Introducer, CommentLoc, II,
+                                       ArgumentString);
 
   Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString);
 }
 
 // #pragma clang optimize off
 // #pragma clang optimize on
 void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP,
                                          PragmaIntroducer Introducer,

clang/tools/libclang/Indexing.cpp

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           SrcMgr::CharacteristicKind FileType) override {
     bool isImport = (IncludeTok.is(tok::identifier) &&
             IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import);
     DataConsumer.ppIncludedFile(HashLoc, FileName, File, isImport, IsAngled,
                             Imported);
   }
 
   /// 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 {}
 
   /// MacroExpands - This is called by when a macro invocation is found.
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {}
 
   /// SourceRangeSkipped - This hook is called when a source range is skipped.

clang/unittests/Basic/SourceManagerTest.cpp

 };
 
 class MacroTracker : public PPCallbacks {
   std::vector<MacroAction> &Macros;
 
 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(),
                     UD ? MacroAction::kDefinition | MacroAction::kUnDefinition
                        : MacroAction::kUnDefinition));
   }
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {

clang/unittests/Lex/PPCallbacksTest.cpp

struct Result {
     ConditionValueKind ConditionValue;
 
     Result(SourceRange R, ConditionValueKind K)
         : ConditionRange(R), ConditionValue(K) {}
   };
 
   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);
   }
 };
 
 // Stub to collect data from PragmaOpenCLExtension callbacks.
 class PragmaOpenCLExtensionCallbacks : public PPCallbacks {
 public:
   typedef struct {
     SmallString<16> Name;
     unsigned State;
   } CallbackParameters;
 
   PragmaOpenCLExtensionCallbacks() : Name("Not called."), State(99) {}
 
-  void PragmaOpenCLExtension(clang::SourceLocation NameLoc,
+  void PragmaOpenCLExtension(clang::PragmaIntroducer Introducer,
+                             clang::SourceLocation NameLoc,
                              const clang::IdentifierInfo *Name,
                              clang::SourceLocation StateLoc,
                              unsigned State) override {
-      this->NameLoc = NameLoc;
-      this->Name = Name->getName();
-      this->StateLoc = StateLoc;
-      this->State = State;
   }
 
   SourceLocation NameLoc;
   SmallString<16> Name;
   SourceLocation StateLoc;
   unsigned State;
 };
 
 class PragmaMarkCallbacks : public PPCallbacks {
 public:
   struct Mark {
     SourceLocation Location;
     std::string Trivia;
   };
 
   std::vector<Mark> Marks;
 
-  void PragmaMark(SourceLocation Loc, StringRef Trivia) override {
+  void PragmaMark(PragmaIntroducer Introducer, SourceLocation Loc,
+                  StringRef Trivia) override {
     Marks.emplace_back(Mark{Loc, Trivia.str()});
   }
 };
 
 // PPCallbacks test fixture.
 class PPCallbacksTest : public ::testing::Test {
 protected:
   PPCallbacksTest()