[clang][lex] Consolidate PPCallbacks::PragmaDirective parameters

[KyleFromKitware]

Rebased onto main for D141000.

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

void InclusionDirective(SourceLocation DirectiveLoc,
                           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 PragmaDirective(SourceLocation Loc, PragmaIntroducerKind) 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,
                      StringRef) override;
   void PragmaDiagnosticPush(SourceLocation Loc, StringRef) override;
   void PragmaDiagnosticPop(SourceLocation Loc, StringRef) override;

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

 }
 
 // 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) {
   parseToLocation(Loc);
 }
-void ExpandModularHeadersPPCallbacks::PragmaDirective(SourceLocation Loc,
-                                                      PragmaIntroducerKind) {
-  parseToLocation(Loc);
+void ExpandModularHeadersPPCallbacks::PragmaDirective(
+    PragmaIntroducer Introducer) {
+  parseToLocation(Introducer.Loc);
 }
 void ExpandModularHeadersPPCallbacks::PragmaComment(SourceLocation Loc,
                                                     const IdentifierInfo *,
                                                     StringRef) {
   parseToLocation(Loc);
 }
 void ExpandModularHeadersPPCallbacks::PragmaDetectMismatch(SourceLocation Loc,
                                                            StringRef,

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

void Elifndef(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 Endif(SourceLocation Loc, SourceLocation IfLoc) override;
-  void PragmaDirective(SourceLocation Loc,
-                       PragmaIntroducerKind Introducer) override;
+  void PragmaDirective(PragmaIntroducer Introducer) override;
 
   // After we've seen everything, issue warnings and fix-its.
   void EndOfMainFile() override;
 
   void invalidateRange(SourceRange Range);
 
 private:
   void newEnum() {

 bool textEquals(const char (&Needle)[N], const char *HayStack) {
   return StringRef{HayStack, N - 1} == Needle;
 }
 
 template <size_t N> size_t len(const char (&)[N]) { return N - 1; }
 
 } // namespace
 
-void MacroToEnumCallbacks::PragmaDirective(SourceLocation Loc,
-                                           PragmaIntroducerKind Introducer) {
+void MacroToEnumCallbacks::PragmaDirective(PragmaIntroducer Introducer) {
   if (CurrentFile->GuardScanner != IncludeGuard::FileChanged)
     return;
 
   bool Invalid = false;
   const char *Text = SM.getCharacterData(
-      Lexer::getLocForEndOfToken(Loc, 0, SM, LangOpts), &Invalid);
+      Lexer::getLocForEndOfToken(Introducer.Loc, 0, SM, LangOpts), &Invalid);
   if (Invalid)
     return;
 
   while (*Text && std::isspace(*Text))
     ++Text;
 
   if (textEquals("pragma", Text))
     return;

clang-tools-extra/docs/pp-trace.rst

 
 `PragmaDirective <https://clang.llvm.org/doxygen/classclang_1_1PPCallbacks.html#a0a2d7a72c62184b3cbde31fb62c6f2f7>`_ Callback
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 PragmaDirective is called when start reading any pragma directive.
 
 Argument descriptions:
 
-==============   ==================================================   ============================== =================================
-Argument Name    Argument Value Syntax                                Clang C++ Type                 Description
-==============   ==================================================   ============================== =================================
-Loc              "(file):(line):(col)"                                SourceLocation                 The location of the directive.
-Introducer       (PIK_HashPragma|PIK__Pragma|PIK___pragma)            PragmaIntroducerKind           The type of the pragma directive.
-==============   ==================================================   ============================== =================================
+==============   =============================================================================   ============================== ===============================================
+Argument Name    Argument Value Syntax                                                           Clang C++ Type                 Description
+==============   =============================================================================   ============================== ===============================================
+Introducer       {Loc: "(file):(line):(col)", Kind: (PIK_HashPragma|PIK__Pragma|PIK___pragma)}   PragmaIntroducer               The location and kind of the pragma introducer.
+==============   =============================================================================   ============================== ===============================================
 
 Example:::
 
   - Callback: PragmaDirective
     Loc: "D:/Clang/llvm/clang-tools-extra/test/pp-trace/pp-trace-pragma.cpp:3:1"
     Introducer: PIK_HashPragma
 
 `PragmaComment <https://clang.llvm.org/doxygen/classclang_1_1PPCallbacks.html#ace0d940fc2c12ab76441466aab58dc37>`_ Callback

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

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           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 PragmaDirective(SourceLocation Loc,
-                       PragmaIntroducerKind Introducer) override;
+  void PragmaDirective(PragmaIntroducer Introducer) override;
   void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
                      llvm::StringRef Str) override;
   void PragmaDetectMismatch(SourceLocation Loc, llvm::StringRef Name,
                             llvm::StringRef Value) override;
   void PragmaDebug(SourceLocation Loc, llvm::StringRef DebugType) override;
   void PragmaMessage(SourceLocation Loc, llvm::StringRef Namespace,
                      PPCallbacks::PragmaMessageKind Kind,
                      llvm::StringRef Str) override;
public:
   void appendArgument(const char *Name, const MacroDefinition &Value);
 
   /// Append a MacroArgs argument to the top trace item.
   void appendArgument(const char *Name, const MacroArgs *Value);
 
   /// Append a Module argument to the top trace item.
   void appendArgument(const char *Name, const Module *Value);
 
+  // Append a PragmaIntroducer argument to the top trace item.
+  void appendArgument(const char *Name, PragmaIntroducer Introducer);
+
   /// Append a double-quoted argument to the top trace item.
   void appendQuotedArgument(const char *Name, const std::string &Value);
 
   /// Append a double-quoted file path argument to the top trace item.
   void appendFilePathArgument(const char *Name, llvm::StringRef Value);
 
   /// Get the raw source string of the range.
   llvm::StringRef getSourceString(CharSourceRange Range);

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

 // Callback invoked when a #ident or #sccs directive is read.
 void PPCallbacksTracker::Ident(SourceLocation Loc, llvm::StringRef Str) {
   beginCallback("Ident");
   appendArgument("Loc", Loc);
   appendArgument("Str", Str);
 }
 
 // Callback invoked when start reading any pragma directive.
-void PPCallbacksTracker::PragmaDirective(SourceLocation Loc,
-                                         PragmaIntroducerKind Introducer) {
+void PPCallbacksTracker::PragmaDirective(PragmaIntroducer Introducer) {
   beginCallback("PragmaDirective");
-  appendArgument("Loc", Loc);
-  appendArgument("Introducer", Introducer, PragmaIntroducerKindStrings);
+  appendArgument("Introducer", Introducer);
 }
 
 // Callback invoked when a #pragma comment directive is read.
 void PPCallbacksTracker::PragmaComment(SourceLocation Loc,
                                        const IdentifierInfo *Kind,
                                        llvm::StringRef Str) {
   beginCallback("PragmaComment");
   appendArgument("Loc", Loc);

 void PPCallbacksTracker::appendArgument(const char *Name, const Module *Value) {
   if (!Value) {
     appendArgument(Name, "(null)");
     return;
   }
   appendArgument(Name, Value->Name.c_str());
 }
 
+// Append a PragmaIntroducer argument to the top trace item.
+void PPCallbacksTracker::appendArgument(const char *Name,
+                                        PragmaIntroducer Value) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+
+  SS << "{Loc: ";
+  if (Value.Loc.isInvalid())
+    SS << "(invalid)";
+  else
+    SS << getSourceLocationString(PP, Value.Loc);
+  SS << ", Kind: " << PragmaIntroducerKindStrings[Value.Kind] << "}";
+  appendArgument(Name, SS.str());
+}
+
 // Append a double-quoted argument to the top trace item.
 void PPCallbacksTracker::appendQuotedArgument(const char *Name,
                                               const std::string &Value) {
   std::string Str;
   llvm::raw_string_ostream SS(Str);
   SS << "\"" << Value << "\"";
   appendArgument(Name, SS.str());
 }

clang-tools-extra/test/pp-trace/pp-trace-pragma-general.cpp

 
 void foo() {
 #pragma clang __debug captured
 { }
 }
 
 // CHECK: ---
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:3:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:3:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnosticPush
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:3:15"
 // CHECK-NEXT:   Namespace: clang
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:4:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:4:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnosticPop
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:4:15"
 // CHECK-NEXT:   Namespace: clang
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:5:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:5:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:5:15"
 // CHECK-NEXT:   Namespace: clang
 // CHECK-NEXT:   Mapping: MAP_IGNORE
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:6:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:6:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:6:15"
 // CHECK-NEXT:   Namespace: clang
 // CHECK-NEXT:   Mapping: MAP_WARNING
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:7:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:7:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:7:15"
 // CHECK-NEXT:   Namespace: clang
 // CHECK-NEXT:   Mapping: MAP_ERROR
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:8:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:8:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:8:15"
 // CHECK-NEXT:   Namespace: clang
 // CHECK-NEXT:   Mapping: MAP_FATAL
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:10:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:10:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnosticPush
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:10:13"
 // CHECK-NEXT:   Namespace: GCC
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:11:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:11:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnosticPop
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:11:13"
 // CHECK-NEXT:   Namespace: GCC
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:12:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:12:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:12:13"
 // CHECK-NEXT:   Namespace: GCC
 // CHECK-NEXT:   Mapping: MAP_IGNORE
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:13:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:13:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:13:13"
 // CHECK-NEXT:   Namespace: GCC
 // CHECK-NEXT:   Mapping: MAP_WARNING
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:14:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:14:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:14:13"
 // CHECK-NEXT:   Namespace: GCC
 // CHECK-NEXT:   Mapping: MAP_ERROR
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:15:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:15:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDiagnostic
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:15:13"
 // CHECK-NEXT:   Namespace: GCC
 // CHECK-NEXT:   Mapping: MAP_FATAL
 // CHECK-NEXT:   Str: -Wformat
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:18:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:18:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDebug
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-general.cpp:18:23"
 // CHECK-NEXT:   DebugType: captured
 // CHECK-NEXT: - Callback: EndOfMainFile
 // CHECK-NEXT: ...

clang-tools-extra/test/pp-trace/pp-trace-pragma-ms.cpp

 #pragma message("message argument")
 
 #pragma warning(push, 1)
 #pragma warning(pop)
 #pragma warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
 
 // CHECK: ---
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:3:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:3:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaComment
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:3:9"
 // CHECK-NEXT:   Kind: compiler
 // CHECK-NEXT:   Str: compiler comment
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:4:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:4:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaComment
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:4:9"
 // CHECK-NEXT:   Kind: exestr
 // CHECK-NEXT:   Str: exestr comment
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:5:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:5:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaComment
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:5:9"
 // CHECK-NEXT:   Kind: lib
 // CHECK-NEXT:   Str: lib comment
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:6:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:6:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaComment
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:6:9"
 // CHECK-NEXT:   Kind: linker
 // CHECK-NEXT:   Str: linker comment
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:7:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:7:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaComment
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:7:9"
 // CHECK-NEXT:   Kind: user
 // CHECK-NEXT:   Str: user comment
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:9:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:9:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDetectMismatch
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:9:9"
 // CHECK-NEXT:   Name: name argument
 // CHECK-NEXT:   Value: value argument
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:11:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:11:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:13:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:13:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaMessage
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:13:9"
 // CHECK-NEXT:   Namespace: 
 // CHECK-NEXT:   Kind: PMK_Message
 // CHECK-NEXT:   Str: message argument
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:15:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:15:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaWarningPush
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:15:9"
 // CHECK-NEXT:   Level: 1
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:16:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:16:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaWarningPop
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:16:9"
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:17:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:17:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaWarning
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:17:9"
 // CHECK-NEXT:   WarningSpec: PWS_Disable
 // CHECK-NEXT:   Ids: [1, 2, 3]
 // CHECK-NEXT: - Callback: PragmaWarning
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:17:9"
 // CHECK-NEXT:   WarningSpec: PWS_Error
 // CHECK-NEXT:   Ids: [4, 5, 6]
 // CHECK-NEXT: - Callback: PragmaWarning
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-ms.cpp:17:9"
 // CHECK-NEXT:   WarningSpec: PWS_Suppress
 // CHECK-NEXT:   Ids: [7, 8, 9]
 // CHECK-NEXT: - Callback: EndOfMainFile
 // CHECK-NEXT: ...

clang-tools-extra/test/pp-trace/pp-trace-pragma-opencl.cpp

 // RUN: pp-trace -callbacks '*,-FileChanged,-MacroDefined' %s -- -x cl -cl-no-stdinc | FileCheck --strict-whitespace %s
 
 #pragma OPENCL EXTENSION all : disable
 #pragma OPENCL EXTENSION cl_khr_int64_base_atomics : disable
 #pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
 
 // CHECK: ---
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:3:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:3:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaOpenCLExtension
 // CHECK-NEXT:   NameLoc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:3:26"
 // CHECK-NEXT:   Name: all
 // CHECK-NEXT:   StateLoc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:3:32"
 // CHECK-NEXT:   State: 0
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:4:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:4:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaOpenCLExtension
 // CHECK-NEXT:   NameLoc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:4:26"
 // CHECK-NEXT:   Name: cl_khr_int64_base_atomics
 // CHECK-NEXT:   StateLoc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:4:54"
 // CHECK-NEXT:   State: 0
 // CHECK-NEXT: - Callback: PragmaDirective
-// CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:5:1"
-// CHECK-NEXT:   Introducer: PIK_HashPragma
+// CHECK-NEXT:   Introducer: {Loc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:5:1", Kind: PIK_HashPragma}
 // CHECK-NEXT: - Callback: PragmaOpenCLExtension
 // CHECK-NEXT:   NameLoc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:5:26"
 // CHECK-NEXT:   Name: cl_khr_int64_base_atomics
 // CHECK-NEXT:   StateLoc: "{{.*}}{{[/\\]}}pp-trace-pragma-opencl.cpp:5:54"
 // CHECK-NEXT:   State: 1
 // CHECK-NEXT: - Callback: EndOfMainFile
 // CHECK-NEXT: ...

clang/include/clang/Lex/PPCallbacks.h

public:
   /// Callback invoked when a \#ident or \#sccs directive is read.
   /// \param Loc The location of the directive.
   /// \param str The text of the directive.
   ///
   virtual void Ident(SourceLocation Loc, StringRef str) {
   }
 
   /// Callback invoked when start reading any pragma directive.
-  virtual void PragmaDirective(SourceLocation Loc,
-                               PragmaIntroducerKind Introducer) {
-  }
+  virtual void PragmaDirective(PragmaIntroducer Introducer) {}
 
   /// Callback invoked when a \#pragma comment directive is read.
   virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
                              StringRef Str) {
   }
 
   /// Callback invoked when a \#pragma mark comment is read.
   virtual void PragmaMark(SourceLocation Loc, StringRef Trivia) {
void EndOfMainFile() override {
     Second->EndOfMainFile();
   }
 
   void Ident(SourceLocation Loc, StringRef str) override {
     First->Ident(Loc, str);
     Second->Ident(Loc, str);
   }
 
-  void PragmaDirective(SourceLocation Loc,
-                       PragmaIntroducerKind Introducer) override {
-    First->PragmaDirective(Loc, Introducer);
-    Second->PragmaDirective(Loc, Introducer);
+  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);
   }
 

clang/lib/Lex/Pragma.cpp

struct TokenCollector {
   }
 };
 } // namespace
 
 /// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
 /// rest of the pragma, passing it to the registered pragma handlers.
 void Preprocessor::HandlePragmaDirective(PragmaIntroducer Introducer) {
   if (Callbacks)
-    Callbacks->PragmaDirective(Introducer.Loc, Introducer.Kind);
+    Callbacks->PragmaDirective(Introducer);
 
   if (!PragmasEnabled)
     return;
 
   ++NumPragma;
 
   // Invoke the first level of pragma handlers which reads the namespace id.
   Token Tok;