[ODRHash diagnostics] Split `err_module_odr_violation_mismatch_decl_diff` into per-entity diagnostics. NFC.

[vsapsai]

Summary

We'll need to add more cases for Objective-C entities and adding
everything to err_module_odr_violation_mismatch_decl_diff makes it
harder to work with over time.

[vsapsai]

Rebase after blocking change has landed.

[ChuanqiXu]

LGTM if the changes is specific to C++. Otherwise we need to rename for that enumerate.

clang/lib/Serialization/ASTReader.cpp

9642

Is this specific to C++?

[vsapsai]

Thanks for the review, Chuanqi!

clang/lib/Serialization/ASTReader.cpp

9642

That is supposed to be for C++ only. In D128490 I'm moving it to

bool ODRDiagsEmitter::diagnoseMismatch(
    const CXXRecordDecl *, const CXXRecordDecl *,
    const struct CXXRecordDecl::DefinitionData *) const

so it will be even harder to use for non-C++ decls. And for pure C RecordDecl the plan is to move common checks there and call them from C++-specific code. So this enum should remain C++-specific. At most I might move some constants to ODRRecordDifference or something like that.

clang/include/clang/Basic/DiagnosticSerializationKinds.td

def err_module_odr_violation_mismatch_decl : Error<
   "%select{end of class|public access specifier|private access specifier|"
   "protected access specifier|static assert|field|method|type alias|typedef|"
   "data member|friend declaration|function template}3">;
 def note_module_odr_violation_mismatch_decl : Note<"but in '%0' found "
   "%select{end of class|public access specifier|private access specifier|"
   "protected access specifier|static assert|field|method|type alias|typedef|"
   "data member|friend declaration|function template}1">;
 
-def err_module_odr_violation_mismatch_decl_diff : Error<
+def err_module_odr_violation_record : Error<
   "%q0 has different definitions in different modules; first difference is "
   "%select{definition in module '%2'|defined here}1 found "
   "%select{"
   "static assert with condition|"
   "static assert with message|"
   "static assert with %select{|no }4message|"
-  "field %4|"
-  "field %4 with type %5|"
-  "%select{non-|}5bitfield %4|"
-  "bitfield %4 with one width expression|"
-  "%select{non-|}5mutable field %4|"
-  "field %4 with %select{no|an}5 initalizer|"
-  "field %4 with an initializer|"
   "%select{method %5|constructor|destructor}4|"
   "%select{method %5|constructor|destructor}4 "
     "is %select{not deleted|deleted}6|"
   "%select{method %5|constructor|destructor}4 "
     "is %select{not defaulted|defaulted}6|"
   "%select{method %5|constructor|destructor}4 "
     "is %select{|pure }6%select{not virtual|virtual}7|"
   "%select{method %5|constructor|destructor}4 "
def err_module_odr_violation_record : Error<
   "%select{method %5|constructor|destructor}4 "
     "with %6 template argument%s6|"
   "%select{method %5|constructor|destructor}4 "
     "with %6 for %ordinal7 template argument|"
   "%select{method %5|constructor|destructor}4 "
     "with %select{no body|body}6|"
   "%select{method %5|constructor|destructor}4 "
     "with body|"
-  "%select{typedef|type alias}4 name %5|"
-  "%select{typedef|type alias}4 %5 with underlying type %6|"
-  "data member with name %4|"
-  "data member %4 with type %5|"
-  "data member %4 with%select{out|}5 an initializer|"
-  "data member %4 with an initializer|"
-  "data member %4 %select{is constexpr|is not constexpr}5|"
   "friend %select{class|function}4|"
   "friend %4|"
   "friend function %4|"
   "function template %4 with %5 template parameter%s5|"
   "function template %4 with %ordinal5 template parameter being a "
     "%select{type|non-type|template}6 template parameter|"
   "function template %4 with %ordinal5 template parameter "
     "%select{with no name|named %7}6|"
   "function template %4 with %ordinal5 template parameter with "
     "%select{no |}6default argument|"
   "function template %4 with %ordinal5 template parameter with "
     "default argument %6|"
   "function template %4 with %ordinal5 template parameter with one type|"
   "function template %4 with %ordinal5 template parameter %select{not |}6"
     "being a template parameter pack|"
   "}3">;
 
-def note_module_odr_violation_mismatch_decl_diff : Note<"but in '%0' found "
+def note_module_odr_violation_record : Note<"but in '%0' found "
   "%select{"
   "static assert with different condition|"
   "static assert with different message|"
   "static assert with %select{|no }2message|"
-  "field %2|"
-  "field %2 with type %3|"
-  "%select{non-|}3bitfield %2|"
-  "bitfield %2 with different width expression|"
-  "%select{non-|}3mutable field %2|"
-  "field %2 with %select{no|an}3 initializer|"
-  "field %2 with a different initializer|"
   "%select{method %3|constructor|destructor}2|"
   "%select{method %3|constructor|destructor}2 "
     "is %select{not deleted|deleted}4|"
   "%select{method %3|constructor|destructor}2 "
     "is %select{not defaulted|defaulted}4|"
   "%select{method %3|constructor|destructor}2 "
     "is %select{|pure }4%select{not virtual|virtual}5|"
   "%select{method %3|constructor|destructor}2 "
def note_module_odr_violation_record : Note<"but in '%0' found "
   "%select{method %3|constructor|destructor}2 "
     "with %4 template argument%s4|"
   "%select{method %3|constructor|destructor}2 "
     "with %4 for %ordinal5 template argument|"
   "%select{method %3|constructor|destructor}2 "
     "with %select{no body|body}4|"
   "%select{method %3|constructor|destructor}2 "
     "with different body|"
-  "%select{typedef|type alias}2 name %3|"
-  "%select{typedef|type alias}2 %3 with different underlying type %4|"
-  "data member with name %2|"
-  "data member %2 with different type %3|"
-  "data member %2 with%select{out|}3 an initializer|"
-  "data member %2 with a different initializer|"
-  "data member %2 %select{is constexpr|is not constexpr}3|"
   "friend %select{class|function}2|"
   "friend %2|"
   "friend function %2|"
   "function template %2 with %3 template parameter%s3|"
   "function template %2 with %ordinal3 template paramter being a "
     "%select{type|non-type|template}4 template parameter|"
   "function template %2 with %ordinal3 template parameter "
     "%select{with no name|named %5}4|"
   "function template %2 with %ordinal3 template parameter with "
     "%select{no |}4default argument|"
   "function template %2 with %ordinal3 template parameter with "
     "default argument %4|"
   "function template %2 with %ordinal3 template parameter with different type|"
   "function template %2 with %ordinal3 template parameter %select{not |}4"
     "being a template parameter pack|"
   "}1">;
 
+def err_module_odr_violation_field : Error<
+  "%q0 has different definitions in different modules; first difference is "
+  "%select{definition in module '%2'|defined here}1 found "
+  "%select{"
+  "field %4|"
+  "field %4 with type %5|"
+  "%select{non-|}5bitfield %4|"
+  "bitfield %4 with one width expression|"
+  "%select{non-|}5mutable field %4|"
+  "field %4 with %select{no|an}5 initalizer|"
+  "field %4 with an initializer"
+  "}3">;
+def note_module_odr_violation_field : Note<"but in '%0' found "
+  "%select{"
+  "field %2|"
+  "field %2 with type %3|"
+  "%select{non-|}3bitfield %2|"
+  "bitfield %2 with different width expression|"
+  "%select{non-|}3mutable field %2|"
+  "field %2 with %select{no|an}3 initializer|"
+  "field %2 with a different initializer"
+  "}1">;
+
+def err_module_odr_violation_typedef : Error<
+  "%q0 has different definitions in different modules; first difference is "
+  "%select{definition in module '%2'|defined here}1 found "
+  "%select{"
+  "%select{typedef|type alias}4 name %5|"
+  "%select{typedef|type alias}4 %5 with underlying type %6"
+  "}3">;
+def note_module_odr_violation_typedef : Note<"but in '%0' found "
+  "%select{"
+  "%select{typedef|type alias}2 name %3|"
+  "%select{typedef|type alias}2 %3 with different underlying type %4"
+  "}1">;
+
+def err_module_odr_violation_variable : Error<
+  "%q0 has different definitions in different modules; first difference is "
+  "%select{definition in module '%2'|defined here}1 found "
+  "%select{"
+  "data member with name %4|"
+  "data member %4 with type %5|"
+  "data member %4 with%select{out|}5 an initializer|"
+  "data member %4 with an initializer|"
+  "data member %4 %select{is constexpr|is not constexpr}5"
+  "}3">;
+def note_module_odr_violation_variable : Note<"but in '%0' found "
+  "%select{"
+  "data member with name %2|"
+  "data member %2 with different type %3|"
+  "data member %2 with%select{out|}3 an initializer|"
+  "data member %2 with a different initializer|"
+  "data member %2 %select{is constexpr|is not constexpr}3"
+  "}1">;
+
 def err_module_odr_violation_function : Error<
   "%q0 has different definitions in different modules; "
   "%select{definition in module '%2'|defined here}1 "
   "first difference is "
   "%select{"
   "return type is %4|"
   "%ordinal4 parameter with name %5|"
   "%ordinal4 parameter with type %5%select{| decayed from %7}6|"

clang/lib/Serialization/ASTReader.cpp

enum ODRMismatchDecl {
     TypeAlias,
     TypeDef,
     Var,
     Friend,
     FunctionTemplate,
     Other
   };
 
-  // Used with err_module_odr_violation_mismatch_decl_diff and
-  // note_module_odr_violation_mismatch_decl_diff
-  enum ODRMismatchDeclDifference {
+  // Used with err_module_odr_violation_record and
+  // note_module_odr_violation_record
+  enum ODRCXXRecordDifference {
     StaticAssertCondition,
     StaticAssertMessage,
     StaticAssertOnlyMessage,
-    FieldName,
-    FieldTypeName,
-    FieldSingleBitField,
-    FieldDifferentWidthBitField,
-    FieldSingleMutable,
-    FieldSingleInitializer,
-    FieldDifferentInitializers,
     MethodName,
     MethodDeleted,
     MethodDefaulted,
     MethodVirtual,
     MethodStatic,
     MethodVolatile,
     MethodConst,
     MethodInline,
     MethodNumberParameters,
     MethodParameterType,
     MethodParameterName,
     MethodParameterSingleDefaultArgument,
     MethodParameterDifferentDefaultArgument,
     MethodNoTemplateArguments,
     MethodDifferentNumberTemplateArguments,
     MethodDifferentTemplateArgument,
     MethodSingleBody,
     MethodDifferentBody,
-    TypedefName,
-    TypedefType,
-    VarName,
-    VarType,
-    VarSingleInitializer,
-    VarDifferentInitializer,
-    VarConstexpr,
     FriendTypeFunction,
     FriendType,
     FriendFunction,
     FunctionTemplateDifferentNumberParameters,
     FunctionTemplateParameterDifferentKind,
     FunctionTemplateParameterName,
     FunctionTemplateParameterSingleDefaultArgument,
     FunctionTemplateParameterDifferentDefaultArgument,
     FunctionTemplateParameterDifferentType,
     FunctionTemplatePackParameter,
   };
 
   // These lambdas have the common portions of the ODR diagnostics.  This
   // has the same return as Diag(), so addition parameters can be passed
   // in with operator<<
   auto ODRDiagField = [this, &ComputeQualTypeODRHash, &ComputeODRHash](
                           NamedDecl *FirstRecord, StringRef FirstModule,
                           StringRef SecondModule, FieldDecl *FirstField,
                           FieldDecl *SecondField) {
+    enum ODRFieldDifference {
+      FieldName,
+      FieldTypeName,
+      FieldSingleBitField,
+      FieldDifferentWidthBitField,
+      FieldSingleMutable,
+      FieldSingleInitializer,
+      FieldDifferentInitializers,
+    };
+
     auto DiagError = [FirstRecord, FirstField, FirstModule,
-                      this](ODRMismatchDeclDifference DiffType) {
+                      this](ODRFieldDifference DiffType) {
       return Diag(FirstField->getLocation(),
-                  diag::err_module_odr_violation_mismatch_decl_diff)
+                  diag::err_module_odr_violation_field)
              << FirstRecord << FirstModule.empty() << FirstModule
              << FirstField->getSourceRange() << DiffType;
     };
     auto DiagNote = [SecondField, SecondModule,
-                     this](ODRMismatchDeclDifference DiffType) {
+                     this](ODRFieldDifference DiffType) {
       return Diag(SecondField->getLocation(),
-                  diag::note_module_odr_violation_mismatch_decl_diff)
+                  diag::note_module_odr_violation_field)
              << SecondModule << SecondField->getSourceRange() << DiffType;
     };
 
     IdentifierInfo *FirstII = FirstField->getIdentifier();
     IdentifierInfo *SecondII = SecondField->getIdentifier();
     if (FirstII->getName() != SecondII->getName()) {
       DiagError(FieldName) << FirstII;
       DiagNote(FieldName) << SecondII;
auto ODRDiagField = [this, &ComputeQualTypeODRHash, &ComputeODRHash](
     return false;
   };
 
   auto ODRDiagTypeDefOrAlias =
       [this, &ComputeQualTypeODRHash](
           NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
           TypedefNameDecl *FirstTD, TypedefNameDecl *SecondTD,
           bool IsTypeAlias) {
+        enum ODRTypedefDifference {
+          TypedefName,
+          TypedefType,
+        };
+
         auto DiagError = [FirstRecord, FirstTD, FirstModule,
-                          this](ODRMismatchDeclDifference DiffType) {
+                          this](ODRTypedefDifference DiffType) {
           return Diag(FirstTD->getLocation(),
-                      diag::err_module_odr_violation_mismatch_decl_diff)
+                      diag::err_module_odr_violation_typedef)
                  << FirstRecord << FirstModule.empty() << FirstModule
                  << FirstTD->getSourceRange() << DiffType;
         };
         auto DiagNote = [SecondTD, SecondModule,
-                         this](ODRMismatchDeclDifference DiffType) {
+                         this](ODRTypedefDifference DiffType) {
           return Diag(SecondTD->getLocation(),
-                      diag::note_module_odr_violation_mismatch_decl_diff)
+                      diag::note_module_odr_violation_typedef)
                  << SecondModule << SecondTD->getSourceRange() << DiffType;
         };
 
         auto FirstName = FirstTD->getDeclName();
         auto SecondName = SecondTD->getDeclName();
         if (FirstName != SecondName) {
           DiagError(TypedefName) << IsTypeAlias << FirstName;
           DiagNote(TypedefName) << IsTypeAlias << SecondName;
auto ODRDiagTypeDefOrAlias =
 
         return false;
       };
 
   auto ODRDiagVar = [&ComputeQualTypeODRHash, &ComputeODRHash,
                      this](NamedDecl *FirstRecord, StringRef FirstModule,
                            StringRef SecondModule, VarDecl *FirstVD,
                            VarDecl *SecondVD) {
+    enum ODRVarDifference {
+      VarName,
+      VarType,
+      VarSingleInitializer,
+      VarDifferentInitializer,
+      VarConstexpr,
+    };
+
     auto DiagError = [FirstRecord, FirstVD, FirstModule,
-                      this](ODRMismatchDeclDifference DiffType) {
+                      this](ODRVarDifference DiffType) {
       return Diag(FirstVD->getLocation(),
-                  diag::err_module_odr_violation_mismatch_decl_diff)
+                  diag::err_module_odr_violation_variable)
              << FirstRecord << FirstModule.empty() << FirstModule
              << FirstVD->getSourceRange() << DiffType;
     };
-    auto DiagNote = [SecondVD, SecondModule,
-                     this](ODRMismatchDeclDifference DiffType) {
+    auto DiagNote = [SecondVD, SecondModule, this](ODRVarDifference DiffType) {
       return Diag(SecondVD->getLocation(),
-                  diag::note_module_odr_violation_mismatch_decl_diff)
+                  diag::note_module_odr_violation_variable)
              << SecondModule << SecondVD->getSourceRange() << DiffType;
     };
 
     auto FirstName = FirstVD->getDeclName();
     auto SecondName = SecondVD->getDeclName();
     if (FirstName != SecondName) {
       DiagError(VarName) << FirstName;
       DiagNote(VarName) << SecondName;
for (auto &RecordPair : Merge.second) {
       // Multiple different declarations got merged together; tell the user
       // where they came from.
       if (FirstRecord == SecondRecord)
         continue;
 
       std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
       auto ODRDiagDeclError = [FirstRecord, &FirstModule,
                                this](SourceLocation Loc, SourceRange Range,
-                                     ODRMismatchDeclDifference DiffType) {
-        return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
+                                     ODRCXXRecordDifference DiffType) {
+        return Diag(Loc, diag::err_module_odr_violation_record)
                << FirstRecord << FirstModule.empty() << FirstModule << Range
                << DiffType;
       };
       auto ODRDiagDeclNote = [&SecondModule,
                               this](SourceLocation Loc, SourceRange Range,
-                                    ODRMismatchDeclDifference DiffType) {
-        return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
+                                    ODRCXXRecordDifference DiffType) {
+        return Diag(Loc, diag::note_module_odr_violation_record)
                << SecondModule << Range << DiffType;
       };
 
       auto *FirstDD = FirstRecord->DefinitionData;
       auto *SecondDD = RecordPair.second;
 
       assert(FirstDD && SecondDD && "Definitions without DefinitionData");
 
for (auto &RecordPair : Merge.second) {
         };
         const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
         const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
         FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
         SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
         DeclarationName FirstName = FirstMethod->getDeclName();
         DeclarationName SecondName = SecondMethod->getDeclName();
         auto DiagMethodError = [&ODRDiagDeclError, FirstMethod, FirstMethodType,
-                                FirstName](ODRMismatchDeclDifference DiffType) {
+                                FirstName](ODRCXXRecordDifference DiffType) {
           return ODRDiagDeclError(FirstMethod->getLocation(),
                                   FirstMethod->getSourceRange(), DiffType)
                  << FirstMethodType << FirstName;
         };
         auto DiagMethodNote = [&ODRDiagDeclNote, SecondMethod, SecondMethodType,
-                               SecondName](ODRMismatchDeclDifference DiffType) {
+                               SecondName](ODRCXXRecordDifference DiffType) {
           return ODRDiagDeclNote(SecondMethod->getLocation(),
                                  SecondMethod->getSourceRange(), DiffType)
                  << SecondMethodType << SecondName;
         };
 
         if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
           DiagMethodError(MethodName);
           DiagMethodNote(MethodName);
for (auto &RecordPair : Merge.second) {
             cast<FunctionTemplateDecl>(SecondDecl);
 
         TemplateParameterList *FirstTPL =
             FirstTemplate->getTemplateParameters();
         TemplateParameterList *SecondTPL =
             SecondTemplate->getTemplateParameters();
 
         auto DiagTemplateError = [&ODRDiagDeclError, FirstTemplate](
-                                     ODRMismatchDeclDifference DiffType) {
+                                     ODRCXXRecordDifference DiffType) {
           return ODRDiagDeclError(FirstTemplate->getLocation(),
                                   FirstTemplate->getSourceRange(), DiffType)
                  << FirstTemplate;
         };
         auto DiagTemplateNote = [&ODRDiagDeclNote, SecondTemplate](
-                                    ODRMismatchDeclDifference DiffType) {
+                                    ODRCXXRecordDifference DiffType) {
           return ODRDiagDeclNote(SecondTemplate->getLocation(),
                                  SecondTemplate->getSourceRange(), DiffType)
                  << SecondTemplate;
         };
 
         if (FirstTPL->size() != SecondTPL->size()) {
           DiagTemplateError(FunctionTemplateDifferentNumberParameters)
               << FirstTPL->size();