[clang] [Clang] [NFC] Introduce a helper for emitting compatibility diagnostics (PR #132348)

[via cfe-commits]

https://github.com/Sirraide updated https://github.com/llvm/llvm-project/pull/132348

>From 02d7ace6b775fcccd9036e9bff85f5196f1a2d1d Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 05:21:11 +0100
Subject: [PATCH 1/9] First proof of concept

---
 clang/include/clang/Basic/CMakeLists.txt      |  5 +++
 clang/include/clang/Basic/Diagnostic.h        |  5 +++
 clang/include/clang/Basic/Diagnostic.td       | 18 ++++++++
 clang/include/clang/Basic/DiagnosticSema.h    |  9 ++++
 .../clang/Basic/DiagnosticSemaKinds.td        |  2 +-
 clang/include/clang/Sema/SemaBase.h           |  5 +++
 clang/lib/Basic/Diagnostic.cpp                | 43 +++++++++++++++++++
 clang/lib/Sema/SemaBase.cpp                   |  6 +++
 clang/lib/Sema/SemaDeclCXX.cpp                | 19 ++------
 .../TableGen/ClangDiagnosticsEmitter.cpp      | 27 ++++++++++++
 clang/utils/TableGen/TableGen.cpp             |  6 +++
 clang/utils/TableGen/TableGenBackends.h       |  3 ++
 12 files changed, 132 insertions(+), 16 deletions(-)

diff --git a/clang/include/clang/Basic/CMakeLists.txt b/clang/include/clang/Basic/CMakeLists.txt
index a671d5c764c22..96588f19af124 100644
--- a/clang/include/clang/Basic/CMakeLists.txt
+++ b/clang/include/clang/Basic/CMakeLists.txt
@@ -8,6 +8,11 @@ macro(clang_diag_gen component)
     -gen-clang-diags-enums -clang-component=${component}
     SOURCE Diagnostic.td
     TARGET ClangDiagnostic${component}Enums)
+
+  clang_tablegen(Diagnostic${component}CompatEnums.inc
+    -gen-clang-diags-compat-enums -clang-component=${component}
+    SOURCE Diagnostic.td
+    TARGET ClangDiagnostic${component}CompatEnums)
 endmacro(clang_diag_gen)
 
 clang_diag_gen(Analysis)
diff --git a/clang/include/clang/Basic/Diagnostic.h b/clang/include/clang/Basic/Diagnostic.h
index 848acce3c4f13..97c05e2edf03e 100644
--- a/clang/include/clang/Basic/Diagnostic.h
+++ b/clang/include/clang/Basic/Diagnostic.h
@@ -63,6 +63,10 @@ enum TokenKind : unsigned short;
 
 } // namespace tok
 
+namespace diag_compat {
+enum SemaCompatDiagId : unsigned;
+} // namespace diag_compat
+
 /// Annotates a diagnostic with some code that should be
 /// inserted, removed, or replaced to fix the problem.
 ///
@@ -1794,6 +1798,7 @@ void ProcessWarningOptions(DiagnosticsEngine &Diags,
                            const DiagnosticOptions &Opts,
                            llvm::vfs::FileSystem &VFS, bool ReportDiags = true);
 void EscapeStringForDiagnostic(StringRef Str, SmallVectorImpl<char> &OutStr);
+unsigned GetCompatDiagId(const LangOptions& LangOpts, unsigned CompatDiagId);
 } // namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTIC_H
diff --git a/clang/include/clang/Basic/Diagnostic.td b/clang/include/clang/Basic/Diagnostic.td
index b31d846210a8e..65b19f3feea4f 100644
--- a/clang/include/clang/Basic/Diagnostic.td
+++ b/clang/include/clang/Basic/Diagnostic.td
@@ -155,6 +155,19 @@ class DefaultWarnNoWerror {
 }
 class DefaultRemark { Severity DefaultSeverity = SEV_Remark; }
 
+class CompatWarningId<string name, int std, string diag, string diag_pre> {
+  string Component = ?;
+  string Name = name;
+  string Diag = diag;
+  string DiagPre = diag_pre;
+  int Std = std;
+
+  // This is unused, but Tablegen will complain if it's missing because we define
+  // the compatibility ids in the same place as the other diagnostics (which means
+  // that we'll be inside a 'let CategoryName = "" in { ... }' block).
+  string CategoryName = ?;
+}
+
 // C++ compatibility warnings.
 multiclass CXXCompat<
     string message,
@@ -178,6 +191,11 @@ multiclass CXXCompat<
                                      "CXX98Compat",
                                      "CXXPre"#std_ver#"Compat"))>,
         DefaultIgnore;
+
+    def : CompatWarningId<
+        NAME, std_ver,
+        "compat_cxx"#std_ver#"_"#NAME,
+        "compat_pre_cxx"#std_ver#"_"#NAME>;
 }
 
 // These generate pairs of C++ compatibility warnings of the form:
diff --git a/clang/include/clang/Basic/DiagnosticSema.h b/clang/include/clang/Basic/DiagnosticSema.h
index 84986c7bccf71..008cbc91b7042 100644
--- a/clang/include/clang/Basic/DiagnosticSema.h
+++ b/clang/include/clang/Basic/DiagnosticSema.h
@@ -35,7 +35,16 @@ enum {
 #undef DIAG_ENUM_END
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
+
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM(name, ...) name,
+enum SemaCompatDiagId : unsigned {
+#include "clang/Basic/DiagnosticSemaCompatEnums.inc"
+};
+#undef DIAG_COMPAT_ENUM
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICSEMA_H
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index eed06657536f4..18a013b633816 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -61,7 +61,7 @@ defm decomp_decl_cond : CXX26Compat<"structured binding declaration in a conditi
 
 // Compatibility warnings duplicated across multiple language versions.
 foreach std = [14, 20, 23] in {
-  defm constexpr_body_invalid_stmt : CXXCompat<
+  defm cxx#std#_constexpr_body_invalid_stmt : CXXCompat<
     "use of this statement in a constexpr %select{function|constructor}0 is", std>;
 }
 
diff --git a/clang/include/clang/Sema/SemaBase.h b/clang/include/clang/Sema/SemaBase.h
index 463cae83c7e81..661f69a4b60ff 100644
--- a/clang/include/clang/Sema/SemaBase.h
+++ b/clang/include/clang/Sema/SemaBase.h
@@ -219,6 +219,11 @@ class SemaBase {
   SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD,
                              bool DeferHint = false);
 
+  /// Emit a compatibility diagnostic.
+  SemaDiagnosticBuilder DiagCompat(SourceLocation Loc,
+                                   diag_compat::SemaCompatDiagId CompatDiagId,
+                                   bool DeferHint = false);
+
   /// Build a partial diagnostic.
   PartialDiagnostic PDiag(unsigned DiagID = 0);
 };
diff --git a/clang/lib/Basic/Diagnostic.cpp b/clang/lib/Basic/Diagnostic.cpp
index 9e2f134135647..5ecc590c3cd85 100644
--- a/clang/lib/Basic/Diagnostic.cpp
+++ b/clang/lib/Basic/Diagnostic.cpp
@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/DiagnosticDriver.h"
@@ -39,6 +40,7 @@
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
+#include <clang/Basic/LangOptions.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
@@ -1339,6 +1341,47 @@ FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
   OutStr.append(Tree.begin(), Tree.end());
 }
 
+unsigned clang::GetCompatDiagId(const LangOptions &LangOpts,
+                                unsigned CompatDiagId) {
+  struct CompatDiag {
+    unsigned StdVer;
+    unsigned DiagId;
+    unsigned PreDiagId;
+  };
+
+  // We encode the standard version such that C++98 < C++11 < C++14 etc. The
+  // actual numbers don't really matter for this, but the definitions of the
+  // compat diags in the Tablegen file uses the standard version, so we base
+  // our encoding on that.
+#define DIAG_COMPAT_ENUM(Name, Std, Diag, DiagPre)                             \
+  {Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
+  static constexpr CompatDiag Diags[] {
+#include "clang/Basic/DiagnosticSemaCompatEnums.inc"
+  };
+#undef DIAG_COMPAT_ENUM
+
+  assert(CompatDiagId < std::size(Diags) && "Invalid compat diag id");
+
+  unsigned StdVer = [&] {
+    if (LangOpts.CPlusPlus26)
+      return 2026;
+    if (LangOpts.CPlusPlus23)
+      return 2023;
+    if (LangOpts.CPlusPlus20)
+      return 2020;
+    if (LangOpts.CPlusPlus17)
+      return 2017;
+    if (LangOpts.CPlusPlus14)
+      return 2014;
+    if (LangOpts.CPlusPlus11)
+      return 2011;
+    return 1998;
+  }();
+
+  const CompatDiag& D = Diags[CompatDiagId];
+  return StdVer >= D.StdVer ? D.DiagId : D.PreDiagId;
+}
+
 StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
                                    StringRef Message)
     : ID(ID), Level(Level), Message(Message) {}
diff --git a/clang/lib/Sema/SemaBase.cpp b/clang/lib/Sema/SemaBase.cpp
index 85c4a0ab40fed..d962c83e814ea 100644
--- a/clang/lib/Sema/SemaBase.cpp
+++ b/clang/lib/Sema/SemaBase.cpp
@@ -88,4 +88,10 @@ Sema::SemaDiagnosticBuilder SemaBase::Diag(SourceLocation Loc,
   return Diag(Loc, PD.getDiagID(), DeferHint) << PD;
 }
 
+SemaBase::SemaDiagnosticBuilder
+SemaBase::DiagCompat(SourceLocation Loc,
+                     diag_compat::SemaCompatDiagId CompatDiagId,
+                     bool DeferHint) {
+  return Diag(Loc, GetCompatDiagId(getLangOpts(), CompatDiagId), DeferHint);
+}
 } // namespace clang
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 8ea24deecd538..accd13bf14d2c 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -2421,22 +2421,13 @@ static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
         (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
       return false;
   } else if (Cxx2bLoc.isValid()) {
-    SemaRef.Diag(Cxx2bLoc,
-                 SemaRef.getLangOpts().CPlusPlus23
-                     ? diag::compat_cxx23_constexpr_body_invalid_stmt
-                     : diag::compat_pre_cxx23_constexpr_body_invalid_stmt)
+    SemaRef.DiagCompat(Cxx2bLoc, diag_compat::cxx23_constexpr_body_invalid_stmt)
         << isa<CXXConstructorDecl>(Dcl);
   } else if (Cxx2aLoc.isValid()) {
-    SemaRef.Diag(Cxx2aLoc,
-                 SemaRef.getLangOpts().CPlusPlus20
-                     ? diag::compat_cxx20_constexpr_body_invalid_stmt
-                     : diag::compat_pre_cxx20_constexpr_body_invalid_stmt)
+    SemaRef.DiagCompat(Cxx2aLoc, diag_compat::cxx20_constexpr_body_invalid_stmt)
         << isa<CXXConstructorDecl>(Dcl);
   } else if (Cxx1yLoc.isValid()) {
-    SemaRef.Diag(Cxx1yLoc,
-                 SemaRef.getLangOpts().CPlusPlus14
-                     ? diag::compat_cxx14_constexpr_body_invalid_stmt
-                     : diag::compat_pre_cxx14_constexpr_body_invalid_stmt)
+    SemaRef.DiagCompat(Cxx1yLoc, diag_compat::cxx14_constexpr_body_invalid_stmt)
         << isa<CXXConstructorDecl>(Dcl);
   }
 
@@ -17824,9 +17815,7 @@ Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
           << FixItHint::CreateInsertion(getLocForEndOfToken(FriendLoc),
                                         InsertionText);
     } else {
-      Diag(FriendLoc, getLangOpts().CPlusPlus11
-                          ? diag::compat_cxx11_nonclass_type_friend
-                          : diag::compat_pre_cxx11_nonclass_type_friend)
+      DiagCompat(FriendLoc, diag_compat::nonclass_type_friend)
           << T << DS.getSourceRange();
     }
   }
diff --git a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
index 8f846a4744bbf..b35ef8a25d0ee 100644
--- a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -1518,6 +1518,33 @@ static void verifyDiagnosticWording(const Record &Diag) {
   // runs into odd situations like [[clang::warn_unused_result]],
   // #pragma clang, or --unwindlib=libgcc.
 }
+
+/// ClangDiagsCompatEnumsEmitter - Emit an enumeration that maps a
+/// 'compatibility diagnostic id' to a set of 2 regular diagnostic
+/// ids to simplify emitting compatibility warnings.
+void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
+                                      llvm::raw_ostream &OS,
+                                      const std::string &Component) {
+  ArrayRef<const Record *> Ids =
+      Records.getAllDerivedDefinitions("CompatWarningId");
+  for (const Record &R : make_pointee_range(Ids)) {
+    if (!Component.empty() && Component != R.getValueAsString("Component"))
+      continue;
+
+    StringRef CompatDiagName = R.getValueAsString("Name");
+    StringRef Diag = R.getValueAsString("Diag");
+    StringRef DiagPre = R.getValueAsString("DiagPre");
+    int64_t CXXStdVer = R.getValueAsInt("Std");
+
+    // FIXME: We sometimes define multiple compat diagnostics with the same
+    // name, e.g. 'constexpr_body_invalid_stmt' exists for C++14/20/23. It would
+    // be nice if we could combine all of them into a single compatibility diag
+    // id.
+    OS << "DIAG_COMPAT_ENUM(" << CompatDiagName << "," << CXXStdVer << ","
+       << Diag << "," << DiagPre << ")\n";
+  }
+}
+
 /// ClangDiagsEnumsEmitter - The top-level class emits .def files containing
 /// declarations of Clang diagnostic enums for selects.
 void clang::EmitClangDiagsEnums(const RecordKeeper &Records, raw_ostream &OS,
diff --git a/clang/utils/TableGen/TableGen.cpp b/clang/utils/TableGen/TableGen.cpp
index 7ffe6d2a913a9..f043f94da97db 100644
--- a/clang/utils/TableGen/TableGen.cpp
+++ b/clang/utils/TableGen/TableGen.cpp
@@ -48,6 +48,7 @@ enum ActionType {
   GenClangBasicWriter,
   GenClangBuiltins,
   GenClangBuiltinTemplates,
+  GenClangDiagsCompatEnums,
   GenClangDiagsDefs,
   GenClangDiagsEnums,
   GenClangDiagGroups,
@@ -176,6 +177,8 @@ cl::opt<ActionType> Action(
                    "Generate clang builtins list"),
         clEnumValN(GenClangBuiltinTemplates, "gen-clang-builtin-templates",
                    "Generate clang builtins list"),
+        clEnumValN(GenClangDiagsCompatEnums, "gen-clang-diags-compat-enums",
+                   "Generate Clang diagnostic compatibility enums"),
         clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
                    "Generate Clang diagnostics definitions"),
         clEnumValN(GenClangDiagsEnums, "gen-clang-diags-enums",
@@ -399,6 +402,9 @@ bool ClangTableGenMain(raw_ostream &OS, const RecordKeeper &Records) {
   case GenClangBuiltinTemplates:
     EmitClangBuiltinTemplates(Records, OS);
     break;
+  case GenClangDiagsCompatEnums:
+    EmitClangDiagsCompatEnums(Records, OS, ClangComponent);
+    break;
   case GenClangDiagsDefs:
     EmitClangDiagsDefs(Records, OS, ClangComponent);
     break;
diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h
index ae8ea3ad34aa5..0133828c4ecb2 100644
--- a/clang/utils/TableGen/TableGenBackends.h
+++ b/clang/utils/TableGen/TableGenBackends.h
@@ -91,6 +91,9 @@ void EmitClangBuiltins(const llvm::RecordKeeper &Records,
 void EmitClangBuiltinTemplates(const llvm::RecordKeeper &Records,
                                llvm::raw_ostream &OS);
 
+void EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
+                               llvm::raw_ostream &OS,
+                               const std::string &Component);
 void EmitClangDiagsDefs(const llvm::RecordKeeper &Records,
                         llvm::raw_ostream &OS, const std::string &Component);
 void EmitClangDiagsEnums(const llvm::RecordKeeper &Records,

>From 31fb9dd3679f6270e0be1a9aac75c6419e425d35 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 05:37:28 +0100
Subject: [PATCH 2/9] Actually use DiagCompat()

---
 clang/lib/Sema/SemaDecl.cpp     | 11 ++-----
 clang/lib/Sema/SemaDeclCXX.cpp  | 56 ++++++++++-----------------------
 clang/lib/Sema/SemaExpr.cpp     |  4 +--
 clang/lib/Sema/SemaTemplate.cpp | 19 +++--------
 4 files changed, 25 insertions(+), 65 deletions(-)

diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 9042655dc1b88..0762467b788a1 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -7647,10 +7647,7 @@ NamedDecl *Sema::ActOnVariableDeclarator(
           IsVariableTemplate = true;
 
           // Only C++1y supports variable templates (N3651).
-          Diag(D.getIdentifierLoc(),
-               getLangOpts().CPlusPlus14
-                   ? diag::compat_cxx14_variable_template
-                   : diag::compat_pre_cxx14_variable_template);
+          DiagCompat(D.getIdentifierLoc(), diag_compat::variable_template);
         }
       }
     } else {
@@ -7716,10 +7713,8 @@ NamedDecl *Sema::ActOnVariableDeclarator(
           } else if (RD->isUnion()) {
             // C++98 [class.union]p1: If a union contains a static data member,
             // the program is ill-formed. C++11 drops this restriction.
-            Diag(D.getIdentifierLoc(),
-                 getLangOpts().CPlusPlus11
-                     ? diag::compat_cxx11_static_data_member_in_union
-                     : diag::compat_pre_cxx11_static_data_member_in_union)
+            DiagCompat(D.getIdentifierLoc(),
+                       diag_compat::static_data_member_in_union)
                 << Name;
           }
         }
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index accd13bf14d2c..05c373622bd1d 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -807,10 +807,8 @@ Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,
       for (auto Loc : BadSpecifierLocs)
         Err << SourceRange(Loc, Loc);
     } else if (!CPlusPlus20Specifiers.empty()) {
-      auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(),
-                         getLangOpts().CPlusPlus20
-                             ? diag::compat_cxx20_decomp_decl_spec
-                             : diag::compat_pre_cxx20_decomp_decl_spec);
+      auto &&Warn = DiagCompat(CPlusPlus20SpecifierLocs.front(),
+                               diag_compat::decomp_decl_spec);
       Warn << (int)CPlusPlus20Specifiers.size()
            << llvm::join(CPlusPlus20Specifiers.begin(),
                          CPlusPlus20Specifiers.end(), " ");
@@ -2040,10 +2038,8 @@ static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
       // C++1y allows types to be defined, not just declared.
       if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
         if (Kind == Sema::CheckConstexprKind::Diagnose) {
-          SemaRef.Diag(DS->getBeginLoc(),
-                       SemaRef.getLangOpts().CPlusPlus14
-                           ? diag::compat_cxx14_constexpr_type_definition
-                           : diag::compat_pre_cxx14_constexpr_type_definition)
+          SemaRef.DiagCompat(DS->getBeginLoc(),
+                             diag_compat::constexpr_type_definition)
               << isa<CXXConstructorDecl>(Dcl);
         } else if (!SemaRef.getLangOpts().CPlusPlus14) {
           return false;
@@ -2068,10 +2064,8 @@ static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
       if (VD->isThisDeclarationADefinition()) {
         if (VD->isStaticLocal()) {
           if (Kind == Sema::CheckConstexprKind::Diagnose) {
-            SemaRef.Diag(VD->getLocation(),
-                         SemaRef.getLangOpts().CPlusPlus23
-                             ? diag::compat_cxx23_constexpr_static_var
-                             : diag::compat_pre_cxx23_constexpr_static_var)
+            SemaRef.DiagCompat(VD->getLocation(),
+                               diag_compat::constexpr_static_var)
                 << isa<CXXConstructorDecl>(Dcl)
                 << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
           } else if (!SemaRef.getLangOpts().CPlusPlus23) {
@@ -2091,11 +2085,8 @@ static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
         if (!VD->getType()->isDependentType() &&
             !VD->hasInit() && !VD->isCXXForRangeDecl()) {
           if (Kind == Sema::CheckConstexprKind::Diagnose) {
-            SemaRef.Diag(
-                VD->getLocation(),
-                SemaRef.getLangOpts().CPlusPlus20
-                    ? diag::compat_cxx20_constexpr_local_var_no_init
-                    : diag::compat_pre_cxx20_constexpr_local_var_no_init)
+            SemaRef.DiagCompat(VD->getLocation(),
+                               diag_compat::constexpr_local_var_no_init)
                 << isa<CXXConstructorDecl>(Dcl);
           } else if (!SemaRef.getLangOpts().CPlusPlus20) {
             return false;
@@ -2104,10 +2095,7 @@ static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
         }
       }
       if (Kind == Sema::CheckConstexprKind::Diagnose) {
-        SemaRef.Diag(VD->getLocation(),
-                     SemaRef.getLangOpts().CPlusPlus14
-                         ? diag::compat_cxx14_constexpr_local_var
-                         : diag::compat_pre_cxx14_constexpr_local_var)
+        SemaRef.DiagCompat(VD->getLocation(), diag_compat::constexpr_local_var)
             << isa<CXXConstructorDecl>(Dcl);
       } else if (!SemaRef.getLangOpts().CPlusPlus14) {
         return false;
@@ -2177,10 +2165,8 @@ static bool CheckConstexprCtorInitializer(Sema &SemaRef,
   if (!Inits.count(Field)) {
     if (Kind == Sema::CheckConstexprKind::Diagnose) {
       if (!Diagnosed) {
-        SemaRef.Diag(Dcl->getLocation(),
-                     SemaRef.getLangOpts().CPlusPlus20
-                         ? diag::compat_cxx20_constexpr_ctor_missing_init
-                         : diag::compat_pre_cxx20_constexpr_ctor_missing_init);
+        SemaRef.DiagCompat(Dcl->getLocation(),
+                           diag_compat::constexpr_ctor_missing_init);
         Diagnosed = true;
       }
       SemaRef.Diag(Field->getLocation(),
@@ -2391,10 +2377,8 @@ static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
       break;
 
     case Sema::CheckConstexprKind::Diagnose:
-      SemaRef.Diag(Body->getBeginLoc(),
-                   SemaRef.getLangOpts().CPlusPlus20
-                       ? diag::compat_cxx20_constexpr_function_try_block
-                       : diag::compat_pre_cxx20_constexpr_function_try_block)
+      SemaRef.DiagCompat(Body->getBeginLoc(),
+                         diag_compat::constexpr_function_try_block)
           << isa<CXXConstructorDecl>(Dcl);
       break;
     }
@@ -2444,11 +2428,8 @@ static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
       if (Constructor->getNumCtorInitializers() == 0 &&
           RD->hasVariantMembers()) {
         if (Kind == Sema::CheckConstexprKind::Diagnose) {
-          SemaRef.Diag(
-              Dcl->getLocation(),
-              SemaRef.getLangOpts().CPlusPlus20
-                  ? diag::compat_cxx20_constexpr_union_ctor_no_init
-                  : diag::compat_pre_cxx20_constexpr_union_ctor_no_init);
+          SemaRef.DiagCompat(Dcl->getLocation(),
+                             diag_compat::constexpr_union_ctor_no_init);
         } else if (!SemaRef.getLangOpts().CPlusPlus20) {
           return false;
         }
@@ -2511,11 +2492,8 @@ static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
     } else if (ReturnStmts.size() > 1) {
       switch (Kind) {
       case Sema::CheckConstexprKind::Diagnose:
-        SemaRef.Diag(
-            ReturnStmts.back(),
-            SemaRef.getLangOpts().CPlusPlus14
-                ? diag::compat_cxx14_constexpr_body_multiple_return
-                : diag::compat_pre_cxx14_constexpr_body_multiple_return);
+        SemaRef.DiagCompat(ReturnStmts.back(),
+                           diag_compat::constexpr_body_multiple_return);
         for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
           SemaRef.Diag(ReturnStmts[I],
                        diag::note_constexpr_body_previous_return);
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 7d4f959434794..5b97367bbccc1 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -6483,9 +6483,7 @@ ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
   if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
       ULE && ULE->hasExplicitTemplateArgs() &&
       ULE->decls_begin() == ULE->decls_end()) {
-    Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus20
-                               ? diag::compat_cxx20_adl_only_template_id
-                               : diag::compat_pre_cxx20_adl_only_template_id)
+    DiagCompat(Fn->getExprLoc(), diag_compat::adl_only_template_id)
         << ULE->getName();
   }
 
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 97da433b8ddbc..d54f602e2650c 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -2235,10 +2235,7 @@ static bool DiagnoseDefaultTemplateArgument(Sema &S,
     //   template-argument, that declaration shall be a definition and shall be
     //   the only declaration of the function template in the translation unit.
     // (C++98/03 doesn't have this wording; see DR226).
-    S.Diag(ParamLoc,
-           S.getLangOpts().CPlusPlus11
-               ? diag::compat_cxx11_templ_default_in_function_templ
-               : diag::compat_pre_cxx11_templ_default_in_function_templ)
+    S.DiagCompat(ParamLoc, diag_compat::templ_default_in_function_templ)
         << DefArgRange;
     return false;
 
@@ -6427,10 +6424,7 @@ static bool CheckTemplateArgumentAddressOfObjectOrFunction(
     bool ExtraParens = false;
     while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
       if (!Invalid && !ExtraParens) {
-        S.Diag(Arg->getBeginLoc(),
-               S.getLangOpts().CPlusPlus11
-                   ? diag::compat_cxx11_template_arg_extra_parens
-                   : diag::compat_pre_cxx11_template_arg_extra_parens)
+        S.DiagCompat(Arg->getBeginLoc(), diag_compat::template_arg_extra_parens)
             << Arg->getSourceRange();
         ExtraParens = true;
       }
@@ -6650,10 +6644,7 @@ CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param,
   bool ExtraParens = false;
   while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
     if (!Invalid && !ExtraParens) {
-      S.Diag(Arg->getBeginLoc(),
-             S.getLangOpts().CPlusPlus11
-                 ? diag::compat_cxx11_template_arg_extra_parens
-                 : diag::compat_pre_cxx11_template_arg_extra_parens)
+      S.DiagCompat(Arg->getBeginLoc(), diag_compat::template_arg_extra_parens)
           << Arg->getSourceRange();
       ExtraParens = true;
     }
@@ -10635,9 +10626,7 @@ TypeResult Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
     return true;
 
   if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
-    Diag(TypenameLoc, getLangOpts().CPlusPlus11
-                          ? diag::compat_cxx11_typename_outside_of_template
-                          : diag::compat_pre_cxx11_typename_outside_of_template)
+    DiagCompat(TypenameLoc, diag_compat::typename_outside_of_template)
         << FixItHint::CreateRemoval(TypenameLoc);
 
   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);

>From 708832e4c05487eb5f073dcc6665f166b3b845bf Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 07:00:07 +0100
Subject: [PATCH 3/9] Support all diagnostic categories

---
 clang/include/clang/Basic/CMakeLists.txt      |  5 ++++
 clang/include/clang/Basic/Diagnostic.h        |  4 ----
 clang/include/clang/Basic/DiagnosticAST.h     | 10 ++++++++
 .../include/clang/Basic/DiagnosticAnalysis.h  | 10 ++++++++
 clang/include/clang/Basic/DiagnosticComment.h | 10 ++++++++
 clang/include/clang/Basic/DiagnosticCrossTU.h | 10 ++++++++
 clang/include/clang/Basic/DiagnosticDriver.h  | 10 ++++++++
 .../include/clang/Basic/DiagnosticFrontend.h  | 10 ++++++++
 clang/include/clang/Basic/DiagnosticIDs.h     | 10 ++++++++
 .../clang/Basic/DiagnosticInstallAPI.h        | 10 ++++++++
 clang/include/clang/Basic/DiagnosticLex.h     | 10 ++++++++
 clang/include/clang/Basic/DiagnosticParse.h   | 10 ++++++++
 .../clang/Basic/DiagnosticParseKinds.td       | 12 +++++-----
 .../clang/Basic/DiagnosticRefactoring.h       | 10 ++++++++
 clang/include/clang/Basic/DiagnosticSema.h    |  8 ++++---
 .../clang/Basic/DiagnosticSerialization.h     | 10 ++++++++
 clang/include/clang/Parse/Parser.h            |  6 +++++
 clang/include/clang/Sema/SemaBase.h           |  3 +--
 clang/lib/Basic/Diagnostic.cpp                |  8 +++++--
 clang/lib/Parse/ParseDecl.cpp                 |  7 ++----
 clang/lib/Parse/Parser.cpp                    |  9 ++++++++
 clang/lib/Sema/SemaBase.cpp                   |  7 +++---
 clang/test/Misc/show-diag-options.c           |  2 +-
 .../TableGen/ClangDiagnosticsEmitter.cpp      | 23 +++++++++++++++----
 24 files changed, 183 insertions(+), 31 deletions(-)

diff --git a/clang/include/clang/Basic/CMakeLists.txt b/clang/include/clang/Basic/CMakeLists.txt
index 96588f19af124..c75b7c1e5fb02 100644
--- a/clang/include/clang/Basic/CMakeLists.txt
+++ b/clang/include/clang/Basic/CMakeLists.txt
@@ -36,6 +36,11 @@ clang_tablegen(DiagnosticIndexName.inc -gen-clang-diags-index-name
   SOURCE Diagnostic.td
   TARGET ClangDiagnosticIndexName)
 
+clang_tablegen(DiagnosticAllCompatEnums.inc
+  -gen-clang-diags-compat-enums
+  SOURCE Diagnostic.td
+  TARGET ClangDiagnosticAllCompatEnums)
+
 clang_tablegen(AttrList.inc -gen-clang-attr-list
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE Attr.td
diff --git a/clang/include/clang/Basic/Diagnostic.h b/clang/include/clang/Basic/Diagnostic.h
index 97c05e2edf03e..caab3c47276a1 100644
--- a/clang/include/clang/Basic/Diagnostic.h
+++ b/clang/include/clang/Basic/Diagnostic.h
@@ -63,10 +63,6 @@ enum TokenKind : unsigned short;
 
 } // namespace tok
 
-namespace diag_compat {
-enum SemaCompatDiagId : unsigned;
-} // namespace diag_compat
-
 /// Annotates a diagnostic with some code that should be
 /// inserted, removed, or replaced to fix the problem.
 ///
diff --git a/clang/include/clang/Basic/DiagnosticAST.h b/clang/include/clang/Basic/DiagnosticAST.h
index 4f82114b7406b..6b670b29ccbd9 100644
--- a/clang/include/clang/Basic/DiagnosticAST.h
+++ b/clang/include/clang/Basic/DiagnosticAST.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticASTCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICAST_H
diff --git a/clang/include/clang/Basic/DiagnosticAnalysis.h b/clang/include/clang/Basic/DiagnosticAnalysis.h
index 1a49461bcd173..51bd63c785e99 100644
--- a/clang/include/clang/Basic/DiagnosticAnalysis.h
+++ b/clang/include/clang/Basic/DiagnosticAnalysis.h
@@ -35,6 +35,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticAnalysisCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICANALYSIS_H
diff --git a/clang/include/clang/Basic/DiagnosticComment.h b/clang/include/clang/Basic/DiagnosticComment.h
index 53143ef132e4b..1233f22d3ad77 100644
--- a/clang/include/clang/Basic/DiagnosticComment.h
+++ b/clang/include/clang/Basic/DiagnosticComment.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticCommentCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICCOMMENT_H
diff --git a/clang/include/clang/Basic/DiagnosticCrossTU.h b/clang/include/clang/Basic/DiagnosticCrossTU.h
index 428da95011027..b4eadb404519b 100644
--- a/clang/include/clang/Basic/DiagnosticCrossTU.h
+++ b/clang/include/clang/Basic/DiagnosticCrossTU.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticCrossTUCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICCROSSTU_H
diff --git a/clang/include/clang/Basic/DiagnosticDriver.h b/clang/include/clang/Basic/DiagnosticDriver.h
index c472afa3f6e96..484b506628d4b 100644
--- a/clang/include/clang/Basic/DiagnosticDriver.h
+++ b/clang/include/clang/Basic/DiagnosticDriver.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticDriverCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICDRIVER_H
diff --git a/clang/include/clang/Basic/DiagnosticFrontend.h b/clang/include/clang/Basic/DiagnosticFrontend.h
index 766cac3d655b3..224501cb9f198 100644
--- a/clang/include/clang/Basic/DiagnosticFrontend.h
+++ b/clang/include/clang/Basic/DiagnosticFrontend.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticFrontendCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICFRONTEND_H
diff --git a/clang/include/clang/Basic/DiagnosticIDs.h b/clang/include/clang/Basic/DiagnosticIDs.h
index 017ef7065610f..6f916a977806c 100644
--- a/clang/include/clang/Basic/DiagnosticIDs.h
+++ b/clang/include/clang/Basic/DiagnosticIDs.h
@@ -104,6 +104,16 @@ namespace clang {
     };
   }
 
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticCommonCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+  } // end namespace diag_compat
+
 class DiagnosticMapping {
   LLVM_PREFERRED_TYPE(diag::Severity)
   unsigned Severity : 3;
diff --git a/clang/include/clang/Basic/DiagnosticInstallAPI.h b/clang/include/clang/Basic/DiagnosticInstallAPI.h
index cbdb00362624b..4bdd077fc40d4 100644
--- a/clang/include/clang/Basic/DiagnosticInstallAPI.h
+++ b/clang/include/clang/Basic/DiagnosticInstallAPI.h
@@ -35,5 +35,15 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticInstallAPICompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // namespace clang
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICINSTALLAPI_H
diff --git a/clang/include/clang/Basic/DiagnosticLex.h b/clang/include/clang/Basic/DiagnosticLex.h
index d14bf97e8642e..93c1bada1b9a1 100644
--- a/clang/include/clang/Basic/DiagnosticLex.h
+++ b/clang/include/clang/Basic/DiagnosticLex.h
@@ -35,6 +35,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticLexCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICLEX_H
diff --git a/clang/include/clang/Basic/DiagnosticParse.h b/clang/include/clang/Basic/DiagnosticParse.h
index 275e1a4c39b3f..13ee81a5034b6 100644
--- a/clang/include/clang/Basic/DiagnosticParse.h
+++ b/clang/include/clang/Basic/DiagnosticParse.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticParseCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICPARSE_H
diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td
index 4dc956f7ae6f7..98d598f654cca 100644
--- a/clang/include/clang/Basic/DiagnosticParseKinds.td
+++ b/clang/include/clang/Basic/DiagnosticParseKinds.td
@@ -11,6 +11,12 @@
 //===----------------------------------------------------------------------===//
 
 let Component = "Parse" in {
+let CategoryName = "Parse Issue" in {
+// C++11 compatibility with C++98.
+defm enum_fixed_underlying_type : CXX11Compat<
+  "enumeration types with a fixed underlying type are",
+  /*ext_warn=*/false>;
+}
 
 def err_asm_qualifier_ignored : Error<
   "expected 'volatile', 'inline', 'goto', or '('">, CatInlineAsm;
@@ -107,9 +113,6 @@ def err_enumerator_list_missing_comma : Error<
   "missing ',' between enumerators">;
 def err_enumerator_unnamed_no_def : Error<
   "unnamed enumeration must be a definition">;
-def ext_cxx11_enum_fixed_underlying_type : Extension<
-  "enumeration types with a fixed underlying type are a C++11 extension">,
-  InGroup<CXX11>;
 def ext_ms_c_enum_fixed_underlying_type : Extension<
   "enumeration types with a fixed underlying type are a Microsoft extension">,
   InGroup<MicrosoftFixedEnum>;
@@ -119,9 +122,6 @@ def ext_c23_enum_fixed_underlying_type : Extension<
 def warn_c17_compat_enum_fixed_underlying_type : Warning<
   "enumeration types with a fixed underlying type are incompatible with C standards before C23">,
   DefaultIgnore, InGroup<CPre23Compat>;
-def warn_cxx98_compat_enum_fixed_underlying_type : Warning<
-  "enumeration types with a fixed underlying type are incompatible with C++98">,
-  InGroup<CXX98Compat>, DefaultIgnore;
 def ext_enum_base_in_type_specifier : ExtWarn<
   "non-defining declaration of enumeration with a fixed underlying type is "
   "only permitted as a standalone declaration"
diff --git a/clang/include/clang/Basic/DiagnosticRefactoring.h b/clang/include/clang/Basic/DiagnosticRefactoring.h
index 59d4bc912733a..e2684df11e4f7 100644
--- a/clang/include/clang/Basic/DiagnosticRefactoring.h
+++ b/clang/include/clang/Basic/DiagnosticRefactoring.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticRefactoringCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICREFACTORING_H
diff --git a/clang/include/clang/Basic/DiagnosticSema.h b/clang/include/clang/Basic/DiagnosticSema.h
index 008cbc91b7042..f63599b7911e0 100644
--- a/clang/include/clang/Basic/DiagnosticSema.h
+++ b/clang/include/clang/Basic/DiagnosticSema.h
@@ -39,11 +39,13 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM(name, ...) name,
-enum SemaCompatDiagId : unsigned {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticSemaCompatEnums.inc"
-};
 #undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticSerialization.h b/clang/include/clang/Basic/DiagnosticSerialization.h
index 6fb836dca1b04..bea6a423f86f5 100644
--- a/clang/include/clang/Basic/DiagnosticSerialization.h
+++ b/clang/include/clang/Basic/DiagnosticSerialization.h
@@ -36,6 +36,16 @@ enum {
 #undef DIAG_ENUM_ITEM
 #undef DIAG_ENUM
 } // end namespace diag
+
+namespace diag_compat {
+#define DIAG_COMPAT_ENUM_BEGIN() enum {
+#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticSerializationCompatEnums.inc"
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+} // end namespace diag_compat
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICSERIALIZATION_H
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index fbe2865b1b7c1..b48229f3f683c 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -1263,6 +1263,12 @@ class Parser : public CodeCompletionHandler {
     return Diag(Tok, DiagID);
   }
 
+  DiagnosticBuilder DiagCompat(SourceLocation Loc, unsigned CompatDiagId);
+  DiagnosticBuilder DiagCompat(const Token& Tok, unsigned CompatDiagId);
+  DiagnosticBuilder DiagCompat(unsigned CompatDiagId) {
+    return DiagCompat(Tok, CompatDiagId);
+  }
+
 private:
   void SuggestParentheses(SourceLocation Loc, unsigned DK,
                           SourceRange ParenRange);
diff --git a/clang/include/clang/Sema/SemaBase.h b/clang/include/clang/Sema/SemaBase.h
index 661f69a4b60ff..550f530af72f5 100644
--- a/clang/include/clang/Sema/SemaBase.h
+++ b/clang/include/clang/Sema/SemaBase.h
@@ -220,8 +220,7 @@ class SemaBase {
                              bool DeferHint = false);
 
   /// Emit a compatibility diagnostic.
-  SemaDiagnosticBuilder DiagCompat(SourceLocation Loc,
-                                   diag_compat::SemaCompatDiagId CompatDiagId,
+  SemaDiagnosticBuilder DiagCompat(SourceLocation Loc, unsigned CompatDiagId,
                                    bool DeferHint = false);
 
   /// Build a partial diagnostic.
diff --git a/clang/lib/Basic/Diagnostic.cpp b/clang/lib/Basic/Diagnostic.cpp
index 5ecc590c3cd85..d189602dc8fa1 100644
--- a/clang/lib/Basic/Diagnostic.cpp
+++ b/clang/lib/Basic/Diagnostic.cpp
@@ -1353,12 +1353,16 @@ unsigned clang::GetCompatDiagId(const LangOptions &LangOpts,
   // actual numbers don't really matter for this, but the definitions of the
   // compat diags in the Tablegen file uses the standard version, so we base
   // our encoding on that.
-#define DIAG_COMPAT_ENUM(Name, Std, Diag, DiagPre)                             \
+#define DIAG_COMPAT_ENUM_BEGIN()
+#define DIAG_COMPAT_ENUM_END()
+#define DIAG_COMPAT_ENUM(Value, Name, Std, Diag, DiagPre)                      \
   {Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
   static constexpr CompatDiag Diags[] {
-#include "clang/Basic/DiagnosticSemaCompatEnums.inc"
+#include "clang/Basic/DiagnosticAllCompatEnums.inc"
   };
 #undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
 
   assert(CompatDiagId < std::size(Diags) && "Invalid compat diag id");
 
diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
index 9ca3e2b5756ca..6fd4b605f6b41 100644
--- a/clang/lib/Parse/ParseDecl.cpp
+++ b/clang/lib/Parse/ParseDecl.cpp
@@ -5450,11 +5450,8 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
       BaseRange = SourceRange(ColonLoc, DeclaratorInfo.getSourceRange().getEnd());
 
       if (!getLangOpts().ObjC) {
-        if (getLangOpts().CPlusPlus11)
-          Diag(ColonLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type)
-              << BaseRange;
-        else if (getLangOpts().CPlusPlus)
-          Diag(ColonLoc, diag::ext_cxx11_enum_fixed_underlying_type)
+        if (getLangOpts().CPlusPlus)
+          DiagCompat(ColonLoc, diag_compat::enum_fixed_underlying_type)
               << BaseRange;
         else if (getLangOpts().MicrosoftExt && !getLangOpts().C23)
           Diag(ColonLoc, diag::ext_ms_c_enum_fixed_underlying_type)
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 6128bc58d69c0..a3ddd424d50b2 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -89,6 +89,15 @@ DiagnosticBuilder Parser::Diag(const Token &Tok, unsigned DiagID) {
   return Diag(Tok.getLocation(), DiagID);
 }
 
+DiagnosticBuilder Parser::DiagCompat(SourceLocation Loc,
+                                     unsigned CompatDiagId) {
+  return Diag(Loc, GetCompatDiagId(getLangOpts(), CompatDiagId));
+}
+
+DiagnosticBuilder Parser::DiagCompat(const Token &Tok, unsigned CompatDiagId) {
+  return DiagCompat(Tok.getLocation(), CompatDiagId);
+}
+
 /// Emits a diagnostic suggesting parentheses surrounding a
 /// given range.
 ///
diff --git a/clang/lib/Sema/SemaBase.cpp b/clang/lib/Sema/SemaBase.cpp
index d962c83e814ea..6c795d27e60f6 100644
--- a/clang/lib/Sema/SemaBase.cpp
+++ b/clang/lib/Sema/SemaBase.cpp
@@ -88,10 +88,9 @@ Sema::SemaDiagnosticBuilder SemaBase::Diag(SourceLocation Loc,
   return Diag(Loc, PD.getDiagID(), DeferHint) << PD;
 }
 
-SemaBase::SemaDiagnosticBuilder
-SemaBase::DiagCompat(SourceLocation Loc,
-                     diag_compat::SemaCompatDiagId CompatDiagId,
-                     bool DeferHint) {
+SemaBase::SemaDiagnosticBuilder SemaBase::DiagCompat(SourceLocation Loc,
+                                                     unsigned CompatDiagId,
+                                                     bool DeferHint) {
   return Diag(Loc, GetCompatDiagId(getLangOpts(), CompatDiagId), DeferHint);
 }
 } // namespace clang
diff --git a/clang/test/Misc/show-diag-options.c b/clang/test/Misc/show-diag-options.c
index 4e98d63195f10..b09820379da36 100644
--- a/clang/test/Misc/show-diag-options.c
+++ b/clang/test/Misc/show-diag-options.c
@@ -18,7 +18,7 @@ void test(int x, int y) {
   // BASE: {{.*}}: warning: {{[a-z ]+$}}
   // OPTION: {{.*}}: warning: {{[a-z ]+}} [-Wparentheses]
   // OPTION_ERROR: {{.*}}: error: {{[a-z ]+}} [-Werror,-Wparentheses]
-  // CATEGORY_ID: {{.*}}: warning: {{[a-z ]+}} [2]
+  // CATEGORY_ID: {{.*}}: warning: {{[a-z ]+}} [{{[0-9]+}}]
   // CATEGORY_NAME: {{.*}}: warning: {{[a-z ]+}} [Semantic Issue]
   // OPTION_ERROR_CATEGORY: {{.*}}: error: {{[a-z ]+}} [-Werror,-Wparentheses,Semantic Issue]
 
diff --git a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
index b35ef8a25d0ee..cb91448e9bdcf 100644
--- a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -1527,8 +1527,11 @@ void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
                                       const std::string &Component) {
   ArrayRef<const Record *> Ids =
       Records.getAllDerivedDefinitions("CompatWarningId");
-  for (const Record &R : make_pointee_range(Ids)) {
-    if (!Component.empty() && Component != R.getValueAsString("Component"))
+
+  StringRef PrevComponent = "";
+  for (auto [I, R] : enumerate(make_pointee_range(Ids))) {
+    StringRef DiagComponent = R.getValueAsString("Component");
+    if (!Component.empty() && Component != DiagComponent)
       continue;
 
     StringRef CompatDiagName = R.getValueAsString("Name");
@@ -1536,13 +1539,25 @@ void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
     StringRef DiagPre = R.getValueAsString("DiagPre");
     int64_t CXXStdVer = R.getValueAsInt("Std");
 
+    // We don't want to create empty enums since some compilers (including Clang)
+    // warn about that, so these macros are used to avoid having to unconditionally
+    // write 'enum {' and '};' in the headers.
+    if (PrevComponent != DiagComponent) {
+      if (!PrevComponent.empty()) OS << "DIAG_COMPAT_ENUM_END()\n";
+      OS << "DIAG_COMPAT_ENUM_BEGIN()\n";
+      PrevComponent = DiagComponent;
+    }
+
     // FIXME: We sometimes define multiple compat diagnostics with the same
     // name, e.g. 'constexpr_body_invalid_stmt' exists for C++14/20/23. It would
     // be nice if we could combine all of them into a single compatibility diag
     // id.
-    OS << "DIAG_COMPAT_ENUM(" << CompatDiagName << "," << CXXStdVer << ","
-       << Diag << "," << DiagPre << ")\n";
+    OS << "DIAG_COMPAT_ENUM(" << I << ",";
+    OS << CompatDiagName << "," << CXXStdVer << "," << Diag << "," << DiagPre;
+    OS << ")\n";
   }
+
+  if (!PrevComponent.empty()) OS << "DIAG_COMPAT_ENUM_END()\n";
 }
 
 /// ClangDiagsEnumsEmitter - The top-level class emits .def files containing

>From 5ebf46dbe8ab13aaee564fc2b8a9aef917ed9dce Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 07:15:38 +0100
Subject: [PATCH 4/9] Move compat diag ids code into DiagnosticIDs

---
 clang/include/clang/Basic/Diagnostic.h    |  1 -
 clang/include/clang/Basic/DiagnosticIDs.h |  5 +++
 clang/lib/Basic/Diagnostic.cpp            | 45 ----------------------
 clang/lib/Basic/DiagnosticIDs.cpp         | 47 +++++++++++++++++++++++
 clang/lib/Parse/Parser.cpp                |  2 +-
 clang/lib/Sema/SemaBase.cpp               |  3 +-
 6 files changed, 55 insertions(+), 48 deletions(-)

diff --git a/clang/include/clang/Basic/Diagnostic.h b/clang/include/clang/Basic/Diagnostic.h
index caab3c47276a1..848acce3c4f13 100644
--- a/clang/include/clang/Basic/Diagnostic.h
+++ b/clang/include/clang/Basic/Diagnostic.h
@@ -1794,7 +1794,6 @@ void ProcessWarningOptions(DiagnosticsEngine &Diags,
                            const DiagnosticOptions &Opts,
                            llvm::vfs::FileSystem &VFS, bool ReportDiags = true);
 void EscapeStringForDiagnostic(StringRef Str, SmallVectorImpl<char> &OutStr);
-unsigned GetCompatDiagId(const LangOptions& LangOpts, unsigned CompatDiagId);
 } // namespace clang
 
 #endif // LLVM_CLANG_BASIC_DIAGNOSTIC_H
diff --git a/clang/include/clang/Basic/DiagnosticIDs.h b/clang/include/clang/Basic/DiagnosticIDs.h
index 6f916a977806c..f4502c4505157 100644
--- a/clang/include/clang/Basic/DiagnosticIDs.h
+++ b/clang/include/clang/Basic/DiagnosticIDs.h
@@ -25,6 +25,7 @@
 namespace clang {
   class DiagnosticsEngine;
   class DiagnosticBuilder;
+  class LangOptions;
   class SourceLocation;
 
   // Import the diagnostic enums themselves.
@@ -474,6 +475,10 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
   /// given group name.
   static StringRef getNearestOption(diag::Flavor Flavor, StringRef Group);
 
+  /// Get the appropriate diagnostic Id to use for issuing a compatibility
+  /// diagnostic. For use by the various DiagCompat() helpers.
+  static unsigned getCompatDiagId(const LangOptions& LangOpts, unsigned CompatDiagId);
+
 private:
   /// Classify the specified diagnostic ID into a Level, consumable by
   /// the DiagnosticClient.
diff --git a/clang/lib/Basic/Diagnostic.cpp b/clang/lib/Basic/Diagnostic.cpp
index d189602dc8fa1..f0860c1b17537 100644
--- a/clang/lib/Basic/Diagnostic.cpp
+++ b/clang/lib/Basic/Diagnostic.cpp
@@ -1341,51 +1341,6 @@ FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
   OutStr.append(Tree.begin(), Tree.end());
 }
 
-unsigned clang::GetCompatDiagId(const LangOptions &LangOpts,
-                                unsigned CompatDiagId) {
-  struct CompatDiag {
-    unsigned StdVer;
-    unsigned DiagId;
-    unsigned PreDiagId;
-  };
-
-  // We encode the standard version such that C++98 < C++11 < C++14 etc. The
-  // actual numbers don't really matter for this, but the definitions of the
-  // compat diags in the Tablegen file uses the standard version, so we base
-  // our encoding on that.
-#define DIAG_COMPAT_ENUM_BEGIN()
-#define DIAG_COMPAT_ENUM_END()
-#define DIAG_COMPAT_ENUM(Value, Name, Std, Diag, DiagPre)                      \
-  {Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
-  static constexpr CompatDiag Diags[] {
-#include "clang/Basic/DiagnosticAllCompatEnums.inc"
-  };
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
-
-  assert(CompatDiagId < std::size(Diags) && "Invalid compat diag id");
-
-  unsigned StdVer = [&] {
-    if (LangOpts.CPlusPlus26)
-      return 2026;
-    if (LangOpts.CPlusPlus23)
-      return 2023;
-    if (LangOpts.CPlusPlus20)
-      return 2020;
-    if (LangOpts.CPlusPlus17)
-      return 2017;
-    if (LangOpts.CPlusPlus14)
-      return 2014;
-    if (LangOpts.CPlusPlus11)
-      return 2011;
-    return 1998;
-  }();
-
-  const CompatDiag& D = Diags[CompatDiagId];
-  return StdVer >= D.StdVer ? D.DiagId : D.PreDiagId;
-}
-
 StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
                                    StringRef Message)
     : ID(ID), Level(Level), Message(Message) {}
diff --git a/clang/lib/Basic/DiagnosticIDs.cpp b/clang/lib/Basic/DiagnosticIDs.cpp
index ca5b8d2da769e..ca4c1cec25bd4 100644
--- a/clang/lib/Basic/DiagnosticIDs.cpp
+++ b/clang/lib/Basic/DiagnosticIDs.cpp
@@ -13,6 +13,7 @@
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticCategories.h"
+#include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
@@ -769,6 +770,52 @@ StringRef DiagnosticIDs::getNearestOption(diag::Flavor Flavor,
   return Best;
 }
 
+unsigned DiagnosticIDs::getCompatDiagId(const LangOptions &LangOpts,
+                                        unsigned CompatDiagId) {
+  struct CompatDiag {
+    unsigned StdVer;
+    unsigned DiagId;
+    unsigned PreDiagId;
+  };
+
+  // We encode the standard version such that C++98 < C++11 < C++14 etc. The
+  // actual numbers don't really matter for this, but the definitions of the
+  // compat diags in the Tablegen file uses the standard version, so we base
+  // our encoding on that.
+#define DIAG_COMPAT_ENUM_BEGIN()
+#define DIAG_COMPAT_ENUM_END()
+#define DIAG_COMPAT_ENUM(Value, Name, Std, Diag, DiagPre)                      \
+{Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
+  static constexpr CompatDiag Diags[] {
+#include "clang/Basic/DiagnosticAllCompatEnums.inc"
+  };
+#undef DIAG_COMPAT_ENUM
+#undef DIAG_COMPAT_ENUM_BEGIN
+#undef DIAG_COMPAT_ENUM_END
+
+  assert(CompatDiagId < std::size(Diags) && "Invalid compat diag id");
+
+  unsigned StdVer = [&] {
+    if (LangOpts.CPlusPlus26)
+      return 2026;
+    if (LangOpts.CPlusPlus23)
+      return 2023;
+    if (LangOpts.CPlusPlus20)
+      return 2020;
+    if (LangOpts.CPlusPlus17)
+      return 2017;
+    if (LangOpts.CPlusPlus14)
+      return 2014;
+    if (LangOpts.CPlusPlus11)
+      return 2011;
+    return 1998;
+  }();
+
+  const CompatDiag& D = Diags[CompatDiagId];
+  return StdVer >= D.StdVer ? D.DiagId : D.PreDiagId;
+}
+
+
 /// ProcessDiag - This is the method used to report a diagnostic that is
 /// finally fully formed.
 bool DiagnosticIDs::ProcessDiag(DiagnosticsEngine &Diag,
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index a3ddd424d50b2..9a9449a75de16 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -91,7 +91,7 @@ DiagnosticBuilder Parser::Diag(const Token &Tok, unsigned DiagID) {
 
 DiagnosticBuilder Parser::DiagCompat(SourceLocation Loc,
                                      unsigned CompatDiagId) {
-  return Diag(Loc, GetCompatDiagId(getLangOpts(), CompatDiagId));
+  return Diag(Loc, DiagnosticIDs::getCompatDiagId(getLangOpts(), CompatDiagId));
 }
 
 DiagnosticBuilder Parser::DiagCompat(const Token &Tok, unsigned CompatDiagId) {
diff --git a/clang/lib/Sema/SemaBase.cpp b/clang/lib/Sema/SemaBase.cpp
index 6c795d27e60f6..af896edd54219 100644
--- a/clang/lib/Sema/SemaBase.cpp
+++ b/clang/lib/Sema/SemaBase.cpp
@@ -91,6 +91,7 @@ Sema::SemaDiagnosticBuilder SemaBase::Diag(SourceLocation Loc,
 SemaBase::SemaDiagnosticBuilder SemaBase::DiagCompat(SourceLocation Loc,
                                                      unsigned CompatDiagId,
                                                      bool DeferHint) {
-  return Diag(Loc, GetCompatDiagId(getLangOpts(), CompatDiagId), DeferHint);
+  return Diag(Loc, DiagnosticIDs::getCompatDiagId(getLangOpts(), CompatDiagId),
+              DeferHint);
 }
 } // namespace clang

>From 81fd5e859022a41976de8a7e281c90c8dc4f42ce Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 07:16:49 +0100
Subject: [PATCH 5/9] clang-format

---
 clang/include/clang/Basic/DiagnosticAST.h           |  4 +++-
 clang/include/clang/Basic/DiagnosticAnalysis.h      |  4 +++-
 clang/include/clang/Basic/DiagnosticComment.h       |  4 +++-
 clang/include/clang/Basic/DiagnosticCrossTU.h       |  4 +++-
 clang/include/clang/Basic/DiagnosticDriver.h        |  4 +++-
 clang/include/clang/Basic/DiagnosticFrontend.h      |  4 +++-
 clang/include/clang/Basic/DiagnosticIDs.h           |  9 ++++++---
 clang/include/clang/Basic/DiagnosticInstallAPI.h    |  4 +++-
 clang/include/clang/Basic/DiagnosticLex.h           |  4 +++-
 clang/include/clang/Basic/DiagnosticParse.h         |  4 +++-
 clang/include/clang/Basic/DiagnosticRefactoring.h   |  4 +++-
 clang/include/clang/Basic/DiagnosticSema.h          |  4 +++-
 clang/include/clang/Basic/DiagnosticSerialization.h |  4 +++-
 clang/include/clang/Parse/Parser.h                  |  2 +-
 clang/lib/Basic/Diagnostic.cpp                      |  2 +-
 clang/lib/Basic/DiagnosticIDs.cpp                   |  7 +++----
 clang/utils/TableGen/ClangDiagnosticsEmitter.cpp    | 12 +++++++-----
 17 files changed, 54 insertions(+), 26 deletions(-)

diff --git a/clang/include/clang/Basic/DiagnosticAST.h b/clang/include/clang/Basic/DiagnosticAST.h
index 6b670b29ccbd9..9536093381067 100644
--- a/clang/include/clang/Basic/DiagnosticAST.h
+++ b/clang/include/clang/Basic/DiagnosticAST.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticASTCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticAnalysis.h b/clang/include/clang/Basic/DiagnosticAnalysis.h
index 51bd63c785e99..3fb4a29d65865 100644
--- a/clang/include/clang/Basic/DiagnosticAnalysis.h
+++ b/clang/include/clang/Basic/DiagnosticAnalysis.h
@@ -38,7 +38,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticAnalysisCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticComment.h b/clang/include/clang/Basic/DiagnosticComment.h
index 1233f22d3ad77..b701dcaffca68 100644
--- a/clang/include/clang/Basic/DiagnosticComment.h
+++ b/clang/include/clang/Basic/DiagnosticComment.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticCommentCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticCrossTU.h b/clang/include/clang/Basic/DiagnosticCrossTU.h
index b4eadb404519b..dee144b1e8504 100644
--- a/clang/include/clang/Basic/DiagnosticCrossTU.h
+++ b/clang/include/clang/Basic/DiagnosticCrossTU.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticCrossTUCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticDriver.h b/clang/include/clang/Basic/DiagnosticDriver.h
index 484b506628d4b..8b3e4674d5deb 100644
--- a/clang/include/clang/Basic/DiagnosticDriver.h
+++ b/clang/include/clang/Basic/DiagnosticDriver.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticDriverCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticFrontend.h b/clang/include/clang/Basic/DiagnosticFrontend.h
index 224501cb9f198..dba700507f2eb 100644
--- a/clang/include/clang/Basic/DiagnosticFrontend.h
+++ b/clang/include/clang/Basic/DiagnosticFrontend.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticFrontendCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticIDs.h b/clang/include/clang/Basic/DiagnosticIDs.h
index f4502c4505157..e41174c15a412 100644
--- a/clang/include/clang/Basic/DiagnosticIDs.h
+++ b/clang/include/clang/Basic/DiagnosticIDs.h
@@ -105,9 +105,11 @@ namespace clang {
     };
   }
 
-namespace diag_compat {
+  namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                               \
+    }                                                                          \
+    ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticCommonCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
@@ -477,7 +479,8 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
 
   /// Get the appropriate diagnostic Id to use for issuing a compatibility
   /// diagnostic. For use by the various DiagCompat() helpers.
-  static unsigned getCompatDiagId(const LangOptions& LangOpts, unsigned CompatDiagId);
+  static unsigned getCompatDiagId(const LangOptions &LangOpts,
+                                  unsigned CompatDiagId);
 
 private:
   /// Classify the specified diagnostic ID into a Level, consumable by
diff --git a/clang/include/clang/Basic/DiagnosticInstallAPI.h b/clang/include/clang/Basic/DiagnosticInstallAPI.h
index 4bdd077fc40d4..db7bae64d9d23 100644
--- a/clang/include/clang/Basic/DiagnosticInstallAPI.h
+++ b/clang/include/clang/Basic/DiagnosticInstallAPI.h
@@ -38,7 +38,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticInstallAPICompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticLex.h b/clang/include/clang/Basic/DiagnosticLex.h
index 93c1bada1b9a1..20893d5c8b871 100644
--- a/clang/include/clang/Basic/DiagnosticLex.h
+++ b/clang/include/clang/Basic/DiagnosticLex.h
@@ -38,7 +38,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticLexCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticParse.h b/clang/include/clang/Basic/DiagnosticParse.h
index 13ee81a5034b6..5f0d4b21e72cf 100644
--- a/clang/include/clang/Basic/DiagnosticParse.h
+++ b/clang/include/clang/Basic/DiagnosticParse.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticParseCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticRefactoring.h b/clang/include/clang/Basic/DiagnosticRefactoring.h
index e2684df11e4f7..8b1adb3e793be 100644
--- a/clang/include/clang/Basic/DiagnosticRefactoring.h
+++ b/clang/include/clang/Basic/DiagnosticRefactoring.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticRefactoringCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticSema.h b/clang/include/clang/Basic/DiagnosticSema.h
index f63599b7911e0..c413faff6d59a 100644
--- a/clang/include/clang/Basic/DiagnosticSema.h
+++ b/clang/include/clang/Basic/DiagnosticSema.h
@@ -40,7 +40,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticSemaCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Basic/DiagnosticSerialization.h b/clang/include/clang/Basic/DiagnosticSerialization.h
index bea6a423f86f5..dde87c0db3f8e 100644
--- a/clang/include/clang/Basic/DiagnosticSerialization.h
+++ b/clang/include/clang/Basic/DiagnosticSerialization.h
@@ -39,7 +39,9 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END() };
+#define DIAG_COMPAT_ENUM_END()                                                 \
+  }                                                                            \
+  ;
 #define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
 #include "clang/Basic/DiagnosticSerializationCompatEnums.inc"
 #undef DIAG_COMPAT_ENUM
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index b48229f3f683c..928bc585cd811 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -1264,7 +1264,7 @@ class Parser : public CodeCompletionHandler {
   }
 
   DiagnosticBuilder DiagCompat(SourceLocation Loc, unsigned CompatDiagId);
-  DiagnosticBuilder DiagCompat(const Token& Tok, unsigned CompatDiagId);
+  DiagnosticBuilder DiagCompat(const Token &Tok, unsigned CompatDiagId);
   DiagnosticBuilder DiagCompat(unsigned CompatDiagId) {
     return DiagCompat(Tok, CompatDiagId);
   }
diff --git a/clang/lib/Basic/Diagnostic.cpp b/clang/lib/Basic/Diagnostic.cpp
index f0860c1b17537..6842e0ef3acb6 100644
--- a/clang/lib/Basic/Diagnostic.cpp
+++ b/clang/lib/Basic/Diagnostic.cpp
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticError.h"
diff --git a/clang/lib/Basic/DiagnosticIDs.cpp b/clang/lib/Basic/DiagnosticIDs.cpp
index ca4c1cec25bd4..cbc79e7a4a6ae 100644
--- a/clang/lib/Basic/DiagnosticIDs.cpp
+++ b/clang/lib/Basic/DiagnosticIDs.cpp
@@ -785,8 +785,8 @@ unsigned DiagnosticIDs::getCompatDiagId(const LangOptions &LangOpts,
 #define DIAG_COMPAT_ENUM_BEGIN()
 #define DIAG_COMPAT_ENUM_END()
 #define DIAG_COMPAT_ENUM(Value, Name, Std, Diag, DiagPre)                      \
-{Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
-  static constexpr CompatDiag Diags[] {
+  {Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
+  static constexpr CompatDiag Diags[]{
 #include "clang/Basic/DiagnosticAllCompatEnums.inc"
   };
 #undef DIAG_COMPAT_ENUM
@@ -811,11 +811,10 @@ unsigned DiagnosticIDs::getCompatDiagId(const LangOptions &LangOpts,
     return 1998;
   }();
 
-  const CompatDiag& D = Diags[CompatDiagId];
+  const CompatDiag &D = Diags[CompatDiagId];
   return StdVer >= D.StdVer ? D.DiagId : D.PreDiagId;
 }
 
-
 /// ProcessDiag - This is the method used to report a diagnostic that is
 /// finally fully formed.
 bool DiagnosticIDs::ProcessDiag(DiagnosticsEngine &Diag,
diff --git a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
index cb91448e9bdcf..c01d599671c83 100644
--- a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -1539,11 +1539,12 @@ void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
     StringRef DiagPre = R.getValueAsString("DiagPre");
     int64_t CXXStdVer = R.getValueAsInt("Std");
 
-    // We don't want to create empty enums since some compilers (including Clang)
-    // warn about that, so these macros are used to avoid having to unconditionally
-    // write 'enum {' and '};' in the headers.
+    // We don't want to create empty enums since some compilers (including
+    // Clang) warn about that, so these macros are used to avoid having to
+    // unconditionally write 'enum {' and '};' in the headers.
     if (PrevComponent != DiagComponent) {
-      if (!PrevComponent.empty()) OS << "DIAG_COMPAT_ENUM_END()\n";
+      if (!PrevComponent.empty())
+        OS << "DIAG_COMPAT_ENUM_END()\n";
       OS << "DIAG_COMPAT_ENUM_BEGIN()\n";
       PrevComponent = DiagComponent;
     }
@@ -1557,7 +1558,8 @@ void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
     OS << ")\n";
   }
 
-  if (!PrevComponent.empty()) OS << "DIAG_COMPAT_ENUM_END()\n";
+  if (!PrevComponent.empty())
+    OS << "DIAG_COMPAT_ENUM_END()\n";
 }
 
 /// ClangDiagsEnumsEmitter - The top-level class emits .def files containing

>From f3ad09473d04cb33bcb5333a460222d8803d0bc1 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 07:35:52 +0100
Subject: [PATCH 6/9] Rename compat enum -> compat id

---
 clang/include/clang/Basic/CMakeLists.txt      | 12 +++++------
 clang/include/clang/Basic/DiagnosticAST.h     | 14 ++++++-------
 .../include/clang/Basic/DiagnosticAnalysis.h  | 14 ++++++-------
 clang/include/clang/Basic/DiagnosticComment.h | 14 ++++++-------
 clang/include/clang/Basic/DiagnosticCrossTU.h | 14 ++++++-------
 clang/include/clang/Basic/DiagnosticDriver.h  | 14 ++++++-------
 .../include/clang/Basic/DiagnosticFrontend.h  | 14 ++++++-------
 clang/include/clang/Basic/DiagnosticIDs.h     | 14 ++++++-------
 .../clang/Basic/DiagnosticInstallAPI.h        | 14 ++++++-------
 clang/include/clang/Basic/DiagnosticLex.h     | 14 ++++++-------
 clang/include/clang/Basic/DiagnosticParse.h   | 14 ++++++-------
 .../clang/Basic/DiagnosticRefactoring.h       | 14 ++++++-------
 clang/include/clang/Basic/DiagnosticSema.h    | 14 ++++++-------
 .../clang/Basic/DiagnosticSerialization.h     | 14 ++++++-------
 clang/lib/Basic/DiagnosticIDs.cpp             | 14 ++++++-------
 .../TableGen/ClangDiagnosticsEmitter.cpp      | 20 +++++++++----------
 clang/utils/TableGen/TableGen.cpp             |  8 ++++----
 clang/utils/TableGen/TableGenBackends.h       |  2 +-
 18 files changed, 119 insertions(+), 119 deletions(-)

diff --git a/clang/include/clang/Basic/CMakeLists.txt b/clang/include/clang/Basic/CMakeLists.txt
index c75b7c1e5fb02..6be6d063c20b4 100644
--- a/clang/include/clang/Basic/CMakeLists.txt
+++ b/clang/include/clang/Basic/CMakeLists.txt
@@ -9,10 +9,10 @@ macro(clang_diag_gen component)
     SOURCE Diagnostic.td
     TARGET ClangDiagnostic${component}Enums)
 
-  clang_tablegen(Diagnostic${component}CompatEnums.inc
-    -gen-clang-diags-compat-enums -clang-component=${component}
+  clang_tablegen(Diagnostic${component}CompatIDs.inc
+    -gen-clang-diags-compat-ids -clang-component=${component}
     SOURCE Diagnostic.td
-    TARGET ClangDiagnostic${component}CompatEnums)
+    TARGET ClangDiagnostic${component}CompatIDs)
 endmacro(clang_diag_gen)
 
 clang_diag_gen(Analysis)
@@ -36,10 +36,10 @@ clang_tablegen(DiagnosticIndexName.inc -gen-clang-diags-index-name
   SOURCE Diagnostic.td
   TARGET ClangDiagnosticIndexName)
 
-clang_tablegen(DiagnosticAllCompatEnums.inc
-  -gen-clang-diags-compat-enums
+clang_tablegen(DiagnosticAllCompatIDs.inc
+  -gen-clang-diags-compat-ids
   SOURCE Diagnostic.td
-  TARGET ClangDiagnosticAllCompatEnums)
+  TARGET ClangDiagnosticAllCompatIDs)
 
 clang_tablegen(AttrList.inc -gen-clang-attr-list
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
diff --git a/clang/include/clang/Basic/DiagnosticAST.h b/clang/include/clang/Basic/DiagnosticAST.h
index 9536093381067..68a09949d482b 100644
--- a/clang/include/clang/Basic/DiagnosticAST.h
+++ b/clang/include/clang/Basic/DiagnosticAST.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticASTCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticASTCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticAnalysis.h b/clang/include/clang/Basic/DiagnosticAnalysis.h
index 3fb4a29d65865..a6ec2fb8a5e47 100644
--- a/clang/include/clang/Basic/DiagnosticAnalysis.h
+++ b/clang/include/clang/Basic/DiagnosticAnalysis.h
@@ -37,15 +37,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticAnalysisCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticAnalysisCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticComment.h b/clang/include/clang/Basic/DiagnosticComment.h
index b701dcaffca68..50e46783be95b 100644
--- a/clang/include/clang/Basic/DiagnosticComment.h
+++ b/clang/include/clang/Basic/DiagnosticComment.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticCommentCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticCommentCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticCrossTU.h b/clang/include/clang/Basic/DiagnosticCrossTU.h
index dee144b1e8504..289f850315ff7 100644
--- a/clang/include/clang/Basic/DiagnosticCrossTU.h
+++ b/clang/include/clang/Basic/DiagnosticCrossTU.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticCrossTUCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticCrossTUCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticDriver.h b/clang/include/clang/Basic/DiagnosticDriver.h
index 8b3e4674d5deb..4d1afa9eadae2 100644
--- a/clang/include/clang/Basic/DiagnosticDriver.h
+++ b/clang/include/clang/Basic/DiagnosticDriver.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticDriverCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticDriverCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticFrontend.h b/clang/include/clang/Basic/DiagnosticFrontend.h
index dba700507f2eb..0b0ac7be08b82 100644
--- a/clang/include/clang/Basic/DiagnosticFrontend.h
+++ b/clang/include/clang/Basic/DiagnosticFrontend.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticFrontendCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticFrontendCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticIDs.h b/clang/include/clang/Basic/DiagnosticIDs.h
index e41174c15a412..9a6b9610f63b9 100644
--- a/clang/include/clang/Basic/DiagnosticIDs.h
+++ b/clang/include/clang/Basic/DiagnosticIDs.h
@@ -106,15 +106,15 @@ namespace clang {
   }
 
   namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                               \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                               \
     }                                                                          \
     ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticCommonCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticCommonCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
   } // end namespace diag_compat
 
 class DiagnosticMapping {
diff --git a/clang/include/clang/Basic/DiagnosticInstallAPI.h b/clang/include/clang/Basic/DiagnosticInstallAPI.h
index db7bae64d9d23..63d4f8548964c 100644
--- a/clang/include/clang/Basic/DiagnosticInstallAPI.h
+++ b/clang/include/clang/Basic/DiagnosticInstallAPI.h
@@ -37,15 +37,15 @@ enum {
 } // namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticInstallAPICompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticInstallAPICompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // namespace clang
 #endif // LLVM_CLANG_BASIC_DIAGNOSTICINSTALLAPI_H
diff --git a/clang/include/clang/Basic/DiagnosticLex.h b/clang/include/clang/Basic/DiagnosticLex.h
index 20893d5c8b871..066218d9a69ea 100644
--- a/clang/include/clang/Basic/DiagnosticLex.h
+++ b/clang/include/clang/Basic/DiagnosticLex.h
@@ -37,15 +37,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticLexCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticLexCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticParse.h b/clang/include/clang/Basic/DiagnosticParse.h
index 5f0d4b21e72cf..26307f4bed865 100644
--- a/clang/include/clang/Basic/DiagnosticParse.h
+++ b/clang/include/clang/Basic/DiagnosticParse.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticParseCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticParseCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticRefactoring.h b/clang/include/clang/Basic/DiagnosticRefactoring.h
index 8b1adb3e793be..15a5145ccae03 100644
--- a/clang/include/clang/Basic/DiagnosticRefactoring.h
+++ b/clang/include/clang/Basic/DiagnosticRefactoring.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticRefactoringCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticRefactoringCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticSema.h b/clang/include/clang/Basic/DiagnosticSema.h
index c413faff6d59a..98b709672ad05 100644
--- a/clang/include/clang/Basic/DiagnosticSema.h
+++ b/clang/include/clang/Basic/DiagnosticSema.h
@@ -39,15 +39,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticSemaCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticSemaCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/DiagnosticSerialization.h b/clang/include/clang/Basic/DiagnosticSerialization.h
index dde87c0db3f8e..53a1c4e21db05 100644
--- a/clang/include/clang/Basic/DiagnosticSerialization.h
+++ b/clang/include/clang/Basic/DiagnosticSerialization.h
@@ -38,15 +38,15 @@ enum {
 } // end namespace diag
 
 namespace diag_compat {
-#define DIAG_COMPAT_ENUM_BEGIN() enum {
-#define DIAG_COMPAT_ENUM_END()                                                 \
+#define DIAG_COMPAT_IDS_BEGIN() enum {
+#define DIAG_COMPAT_IDS_END()                                                 \
   }                                                                            \
   ;
-#define DIAG_COMPAT_ENUM(IDX, NAME, ...) NAME = IDX,
-#include "clang/Basic/DiagnosticSerializationCompatEnums.inc"
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
+#include "clang/Basic/DiagnosticSerializationCompatIDs.inc"
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 } // end namespace diag_compat
 } // end namespace clang
 
diff --git a/clang/lib/Basic/DiagnosticIDs.cpp b/clang/lib/Basic/DiagnosticIDs.cpp
index cbc79e7a4a6ae..3c3e1f5402c27 100644
--- a/clang/lib/Basic/DiagnosticIDs.cpp
+++ b/clang/lib/Basic/DiagnosticIDs.cpp
@@ -782,16 +782,16 @@ unsigned DiagnosticIDs::getCompatDiagId(const LangOptions &LangOpts,
   // actual numbers don't really matter for this, but the definitions of the
   // compat diags in the Tablegen file uses the standard version, so we base
   // our encoding on that.
-#define DIAG_COMPAT_ENUM_BEGIN()
-#define DIAG_COMPAT_ENUM_END()
-#define DIAG_COMPAT_ENUM(Value, Name, Std, Diag, DiagPre)                      \
+#define DIAG_COMPAT_IDS_BEGIN()
+#define DIAG_COMPAT_IDS_END()
+#define DIAG_COMPAT_ID(Value, Name, Std, Diag, DiagPre)                      \
   {Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
   static constexpr CompatDiag Diags[]{
-#include "clang/Basic/DiagnosticAllCompatEnums.inc"
+#include "clang/Basic/DiagnosticAllCompatIDs.inc"
   };
-#undef DIAG_COMPAT_ENUM
-#undef DIAG_COMPAT_ENUM_BEGIN
-#undef DIAG_COMPAT_ENUM_END
+#undef DIAG_COMPAT_ID
+#undef DIAG_COMPAT_IDS_BEGIN
+#undef DIAG_COMPAT_IDS_END
 
   assert(CompatDiagId < std::size(Diags) && "Invalid compat diag id");
 
diff --git a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
index c01d599671c83..08b5946d5810e 100644
--- a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -1519,12 +1519,12 @@ static void verifyDiagnosticWording(const Record &Diag) {
   // #pragma clang, or --unwindlib=libgcc.
 }
 
-/// ClangDiagsCompatEnumsEmitter - Emit an enumeration that maps a
-/// 'compatibility diagnostic id' to a set of 2 regular diagnostic
-/// ids to simplify emitting compatibility warnings.
-void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
-                                      llvm::raw_ostream &OS,
-                                      const std::string &Component) {
+/// ClangDiagsCompatIDsEmitter - Emit a set of 'compatibility diagnostic ids'
+/// that map set of 2 regular diagnostic ids each and which are used to simplify
+/// emitting compatibility warnings.
+void clang::EmitClangDiagsCompatIDs(const llvm::RecordKeeper &Records,
+                                    llvm::raw_ostream &OS,
+                                    const std::string &Component) {
   ArrayRef<const Record *> Ids =
       Records.getAllDerivedDefinitions("CompatWarningId");
 
@@ -1544,8 +1544,8 @@ void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
     // unconditionally write 'enum {' and '};' in the headers.
     if (PrevComponent != DiagComponent) {
       if (!PrevComponent.empty())
-        OS << "DIAG_COMPAT_ENUM_END()\n";
-      OS << "DIAG_COMPAT_ENUM_BEGIN()\n";
+        OS << "DIAG_COMPAT_IDS_END()\n";
+      OS << "DIAG_COMPAT_IDS_BEGIN()\n";
       PrevComponent = DiagComponent;
     }
 
@@ -1553,13 +1553,13 @@ void clang::EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
     // name, e.g. 'constexpr_body_invalid_stmt' exists for C++14/20/23. It would
     // be nice if we could combine all of them into a single compatibility diag
     // id.
-    OS << "DIAG_COMPAT_ENUM(" << I << ",";
+    OS << "DIAG_COMPAT_ID(" << I << ",";
     OS << CompatDiagName << "," << CXXStdVer << "," << Diag << "," << DiagPre;
     OS << ")\n";
   }
 
   if (!PrevComponent.empty())
-    OS << "DIAG_COMPAT_ENUM_END()\n";
+    OS << "DIAG_COMPAT_IDS_END()\n";
 }
 
 /// ClangDiagsEnumsEmitter - The top-level class emits .def files containing
diff --git a/clang/utils/TableGen/TableGen.cpp b/clang/utils/TableGen/TableGen.cpp
index f043f94da97db..211bfc986427d 100644
--- a/clang/utils/TableGen/TableGen.cpp
+++ b/clang/utils/TableGen/TableGen.cpp
@@ -48,7 +48,7 @@ enum ActionType {
   GenClangBasicWriter,
   GenClangBuiltins,
   GenClangBuiltinTemplates,
-  GenClangDiagsCompatEnums,
+  GenClangDiagsCompatIDs,
   GenClangDiagsDefs,
   GenClangDiagsEnums,
   GenClangDiagGroups,
@@ -177,7 +177,7 @@ cl::opt<ActionType> Action(
                    "Generate clang builtins list"),
         clEnumValN(GenClangBuiltinTemplates, "gen-clang-builtin-templates",
                    "Generate clang builtins list"),
-        clEnumValN(GenClangDiagsCompatEnums, "gen-clang-diags-compat-enums",
+        clEnumValN(GenClangDiagsCompatIDs, "gen-clang-diags-compat-ids",
                    "Generate Clang diagnostic compatibility enums"),
         clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
                    "Generate Clang diagnostics definitions"),
@@ -402,8 +402,8 @@ bool ClangTableGenMain(raw_ostream &OS, const RecordKeeper &Records) {
   case GenClangBuiltinTemplates:
     EmitClangBuiltinTemplates(Records, OS);
     break;
-  case GenClangDiagsCompatEnums:
-    EmitClangDiagsCompatEnums(Records, OS, ClangComponent);
+  case GenClangDiagsCompatIDs:
+    EmitClangDiagsCompatIDs(Records, OS, ClangComponent);
     break;
   case GenClangDiagsDefs:
     EmitClangDiagsDefs(Records, OS, ClangComponent);
diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h
index 0133828c4ecb2..0ea643e91590b 100644
--- a/clang/utils/TableGen/TableGenBackends.h
+++ b/clang/utils/TableGen/TableGenBackends.h
@@ -91,7 +91,7 @@ void EmitClangBuiltins(const llvm::RecordKeeper &Records,
 void EmitClangBuiltinTemplates(const llvm::RecordKeeper &Records,
                                llvm::raw_ostream &OS);
 
-void EmitClangDiagsCompatEnums(const llvm::RecordKeeper &Records,
+void EmitClangDiagsCompatIDs(const llvm::RecordKeeper &Records,
                                llvm::raw_ostream &OS,
                                const std::string &Component);
 void EmitClangDiagsDefs(const llvm::RecordKeeper &Records,

>From 57313ec590379525a17d64cf75b66ea454565321 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 07:36:15 +0100
Subject: [PATCH 7/9] clang-format

---
 clang/include/clang/Basic/DiagnosticAST.h           | 2 +-
 clang/include/clang/Basic/DiagnosticAnalysis.h      | 2 +-
 clang/include/clang/Basic/DiagnosticComment.h       | 2 +-
 clang/include/clang/Basic/DiagnosticCrossTU.h       | 2 +-
 clang/include/clang/Basic/DiagnosticDriver.h        | 2 +-
 clang/include/clang/Basic/DiagnosticFrontend.h      | 2 +-
 clang/include/clang/Basic/DiagnosticIDs.h           | 2 +-
 clang/include/clang/Basic/DiagnosticInstallAPI.h    | 2 +-
 clang/include/clang/Basic/DiagnosticLex.h           | 2 +-
 clang/include/clang/Basic/DiagnosticParse.h         | 2 +-
 clang/include/clang/Basic/DiagnosticRefactoring.h   | 2 +-
 clang/include/clang/Basic/DiagnosticSema.h          | 2 +-
 clang/include/clang/Basic/DiagnosticSerialization.h | 2 +-
 clang/lib/Basic/DiagnosticIDs.cpp                   | 2 +-
 clang/utils/TableGen/TableGenBackends.h             | 4 ++--
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/clang/include/clang/Basic/DiagnosticAST.h b/clang/include/clang/Basic/DiagnosticAST.h
index 68a09949d482b..41e2598f7cc3b 100644
--- a/clang/include/clang/Basic/DiagnosticAST.h
+++ b/clang/include/clang/Basic/DiagnosticAST.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticAnalysis.h b/clang/include/clang/Basic/DiagnosticAnalysis.h
index a6ec2fb8a5e47..5ead092b946c5 100644
--- a/clang/include/clang/Basic/DiagnosticAnalysis.h
+++ b/clang/include/clang/Basic/DiagnosticAnalysis.h
@@ -38,7 +38,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticComment.h b/clang/include/clang/Basic/DiagnosticComment.h
index 50e46783be95b..08e66e8051834 100644
--- a/clang/include/clang/Basic/DiagnosticComment.h
+++ b/clang/include/clang/Basic/DiagnosticComment.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticCrossTU.h b/clang/include/clang/Basic/DiagnosticCrossTU.h
index 289f850315ff7..761716d781446 100644
--- a/clang/include/clang/Basic/DiagnosticCrossTU.h
+++ b/clang/include/clang/Basic/DiagnosticCrossTU.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticDriver.h b/clang/include/clang/Basic/DiagnosticDriver.h
index 4d1afa9eadae2..864a23a49e4cd 100644
--- a/clang/include/clang/Basic/DiagnosticDriver.h
+++ b/clang/include/clang/Basic/DiagnosticDriver.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticFrontend.h b/clang/include/clang/Basic/DiagnosticFrontend.h
index 0b0ac7be08b82..3506f05daae54 100644
--- a/clang/include/clang/Basic/DiagnosticFrontend.h
+++ b/clang/include/clang/Basic/DiagnosticFrontend.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticIDs.h b/clang/include/clang/Basic/DiagnosticIDs.h
index 9a6b9610f63b9..c20bf4fcfccb1 100644
--- a/clang/include/clang/Basic/DiagnosticIDs.h
+++ b/clang/include/clang/Basic/DiagnosticIDs.h
@@ -107,7 +107,7 @@ namespace clang {
 
   namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                               \
+#define DIAG_COMPAT_IDS_END()                                                \
     }                                                                          \
     ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticInstallAPI.h b/clang/include/clang/Basic/DiagnosticInstallAPI.h
index 63d4f8548964c..4619bfeea05a2 100644
--- a/clang/include/clang/Basic/DiagnosticInstallAPI.h
+++ b/clang/include/clang/Basic/DiagnosticInstallAPI.h
@@ -38,7 +38,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticLex.h b/clang/include/clang/Basic/DiagnosticLex.h
index 066218d9a69ea..6fa90f785bbf8 100644
--- a/clang/include/clang/Basic/DiagnosticLex.h
+++ b/clang/include/clang/Basic/DiagnosticLex.h
@@ -38,7 +38,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticParse.h b/clang/include/clang/Basic/DiagnosticParse.h
index 26307f4bed865..e2a4368a59c4b 100644
--- a/clang/include/clang/Basic/DiagnosticParse.h
+++ b/clang/include/clang/Basic/DiagnosticParse.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticRefactoring.h b/clang/include/clang/Basic/DiagnosticRefactoring.h
index 15a5145ccae03..b3f3a10925f09 100644
--- a/clang/include/clang/Basic/DiagnosticRefactoring.h
+++ b/clang/include/clang/Basic/DiagnosticRefactoring.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticSema.h b/clang/include/clang/Basic/DiagnosticSema.h
index 98b709672ad05..943b2f64f427e 100644
--- a/clang/include/clang/Basic/DiagnosticSema.h
+++ b/clang/include/clang/Basic/DiagnosticSema.h
@@ -40,7 +40,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/include/clang/Basic/DiagnosticSerialization.h b/clang/include/clang/Basic/DiagnosticSerialization.h
index 53a1c4e21db05..c8fb034e9bd4a 100644
--- a/clang/include/clang/Basic/DiagnosticSerialization.h
+++ b/clang/include/clang/Basic/DiagnosticSerialization.h
@@ -39,7 +39,7 @@ enum {
 
 namespace diag_compat {
 #define DIAG_COMPAT_IDS_BEGIN() enum {
-#define DIAG_COMPAT_IDS_END()                                                 \
+#define DIAG_COMPAT_IDS_END()                                                  \
   }                                                                            \
   ;
 #define DIAG_COMPAT_ID(IDX, NAME, ...) NAME = IDX,
diff --git a/clang/lib/Basic/DiagnosticIDs.cpp b/clang/lib/Basic/DiagnosticIDs.cpp
index 3c3e1f5402c27..ee6d9af8f411c 100644
--- a/clang/lib/Basic/DiagnosticIDs.cpp
+++ b/clang/lib/Basic/DiagnosticIDs.cpp
@@ -784,7 +784,7 @@ unsigned DiagnosticIDs::getCompatDiagId(const LangOptions &LangOpts,
   // our encoding on that.
 #define DIAG_COMPAT_IDS_BEGIN()
 #define DIAG_COMPAT_IDS_END()
-#define DIAG_COMPAT_ID(Value, Name, Std, Diag, DiagPre)                      \
+#define DIAG_COMPAT_ID(Value, Name, Std, Diag, DiagPre)                        \
   {Std == 98 ? 1998 : 2000 + Std, diag::Diag, diag::DiagPre},
   static constexpr CompatDiag Diags[]{
 #include "clang/Basic/DiagnosticAllCompatIDs.inc"
diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h
index 0ea643e91590b..c26ce2825ea99 100644
--- a/clang/utils/TableGen/TableGenBackends.h
+++ b/clang/utils/TableGen/TableGenBackends.h
@@ -92,8 +92,8 @@ void EmitClangBuiltinTemplates(const llvm::RecordKeeper &Records,
                                llvm::raw_ostream &OS);
 
 void EmitClangDiagsCompatIDs(const llvm::RecordKeeper &Records,
-                               llvm::raw_ostream &OS,
-                               const std::string &Component);
+                             llvm::raw_ostream &OS,
+                             const std::string &Component);
 void EmitClangDiagsDefs(const llvm::RecordKeeper &Records,
                         llvm::raw_ostream &OS, const std::string &Component);
 void EmitClangDiagsEnums(const llvm::RecordKeeper &Records,

>From ef0dc9589bc1544619c18449dbc1080af44fda94 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 07:38:59 +0100
Subject: [PATCH 8/9] update comment

---
 clang/lib/Basic/DiagnosticIDs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clang/lib/Basic/DiagnosticIDs.cpp b/clang/lib/Basic/DiagnosticIDs.cpp
index ee6d9af8f411c..0ab3ac884a161 100644
--- a/clang/lib/Basic/DiagnosticIDs.cpp
+++ b/clang/lib/Basic/DiagnosticIDs.cpp
@@ -780,8 +780,8 @@ unsigned DiagnosticIDs::getCompatDiagId(const LangOptions &LangOpts,
 
   // We encode the standard version such that C++98 < C++11 < C++14 etc. The
   // actual numbers don't really matter for this, but the definitions of the
-  // compat diags in the Tablegen file uses the standard version, so we base
-  // our encoding on that.
+  // compat diags in the Tablegen file use the standard version number (i.e.
+  // 98, 11, 14, etc.), so we base the encoding here on that.
 #define DIAG_COMPAT_IDS_BEGIN()
 #define DIAG_COMPAT_IDS_END()
 #define DIAG_COMPAT_ID(Value, Name, Std, Diag, DiagPre)                        \

>From e74bd561fbcd7f1b4315eeedd9f44119aea248d2 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalmail at gmail.com>
Date: Fri, 21 Mar 2025 07:47:21 +0100
Subject: [PATCH 9/9] undo unnecessary changes

---
 clang/lib/Basic/Diagnostic.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/clang/lib/Basic/Diagnostic.cpp b/clang/lib/Basic/Diagnostic.cpp
index 6842e0ef3acb6..9e2f134135647 100644
--- a/clang/lib/Basic/Diagnostic.cpp
+++ b/clang/lib/Basic/Diagnostic.cpp
@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticError.h"
@@ -40,7 +39,6 @@
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
-#include <clang/Basic/LangOptions.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>