[ODRHash diagnostics] Move `ODRDiagsEmitter` to libAST in separate files. NFC.

[vsapsai]

Summary

Intend to use ODRDiagsEmitter during parsing to diagnose a parsed
definition differing from a definition with the same name from a hidden
[sub]module.

[vsapsai]

Rebase.

[vsapsai]

If anybody knows how to demonstrate the code was moved without modification in process, I'll be happy to do that. Unfortunately, the only thing I've found is that it should be auto-detected.

[ChuanqiXu]

It looks like we lack a patch to use it in parser, right?

[vsapsai]

In D128695#3670552, @ChuanqiXu wrote:

It looks like we lack a patch to use it in parser, right?

Kinda. Things get a little bit more complicated before we can do that. But to see the bigger picture, I've published all planned intermediate steps with the final D130327. And there in clang/lib/Parse/ParseObjc.cpp you can see how ODRDiagsEmitter is used in the parser.

I'm not opening those patches for review yet as I want to polish them a little bit and to test all of this stuff on real projects. Landing all of NFC stuff should be sufficient to start testing.

[ChuanqiXu]

I see. It looks like the tricks in .git-blame-ignore-revs doesn't work for this kind of move. I admit I don't look these changes in details. But as long as it is helpful for future changes, I think it should be good.

[vsapsai]

Rebase on top of the previous change in the stack.

[vsapsai]

In D128695#3675112, @ChuanqiXu wrote:

I see. It looks like the tricks in .git-blame-ignore-revs doesn't work for this kind of move. I admit I don't look these changes in details. But as long as it is helpful for future changes, I think it should be good.

Yeah, looks like these kind of changes in git blame should be handled by flags -C and -M and not by ignoring revisions.

[ChuanqiXu]

If the code motion is helpful for further changes, it should be good.

[vsapsai]

Rebase.

clang/include/clang/AST/ODRDiagsEmitter.h

+//===- ODRDiagsEmitter.h - Emits diagnostic for ODR mismatches --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_ODRDIAGSEMITTER_H
+#define LLVM_CLANG_AST_ODRDIAGSEMITTER_H
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/LangOptions.h"
+
+namespace clang {
+
+class ODRDiagsEmitter {
+public:
+  ODRDiagsEmitter(DiagnosticsEngine &Diags, const ASTContext &Context,
+                  const LangOptions &LangOpts)
+      : Diags(Diags), Context(Context), LangOpts(LangOpts) {}
+
+  bool diagnoseMismatch(const FunctionDecl *FirstFunction,
+                        const FunctionDecl *SecondFunction) const;
+
+  bool diagnoseMismatch(const EnumDecl *FirstEnum,
+                        const EnumDecl *SecondEnum) const;
+
+  bool
+  diagnoseMismatch(const CXXRecordDecl *FirstRecord,
+                   const CXXRecordDecl *SecondRecord,
+                   const struct CXXRecordDecl::DefinitionData *SecondDD) const;
+
+private:
+  using DeclHashes = llvm::SmallVector<std::pair<const Decl *, unsigned>, 4>;
+
+  // Used with err_module_odr_violation_mismatch_decl and
+  // note_module_odr_violation_mismatch_decl
+  // This list should be the same Decl's as in ODRHash::isDeclToBeProcessed
+  enum ODRMismatchDecl {
+    EndOfClass,
+    PublicSpecifer,
+    PrivateSpecifer,
+    ProtectedSpecifer,
+    StaticAssert,
+    Field,
+    CXXMethod,
+    TypeAlias,
+    TypeDef,
+    Var,
+    Friend,
+    FunctionTemplate,
+    Other
+  };
+
+  struct DiffResult {
+    const Decl *FirstDecl = nullptr, *SecondDecl = nullptr;
+    ODRMismatchDecl FirstDiffType = Other, SecondDiffType = Other;
+  };
+
+  // If there is a diagnoseable difference, FirstDiffType and
+  // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
+  // filled in if not EndOfClass.
+  static DiffResult FindTypeDiffs(DeclHashes &FirstHashes,
+                                  DeclHashes &SecondHashes);
+
+  DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const {
+    return Diags.Report(Loc, DiagID);
+  }
+
+  // Use this to diagnose that an unexpected Decl was encountered
+  // or no difference was detected. This causes a generic error
+  // message to be emitted.
+  void diagnoseSubMismatchUnexpected(DiffResult &DR,
+                                     const NamedDecl *FirstRecord,
+                                     StringRef FirstModule,
+                                     const NamedDecl *SecondRecord,
+                                     StringRef SecondModule) const;
+
+  void diagnoseSubMismatchDifferentDeclKinds(DiffResult &DR,
+                                             const NamedDecl *FirstRecord,
+                                             StringRef FirstModule,
+                                             const NamedDecl *SecondRecord,
+                                             StringRef SecondModule) const;
+
+  bool diagnoseSubMismatchField(const NamedDecl *FirstRecord,
+                                StringRef FirstModule, StringRef SecondModule,
+                                const FieldDecl *FirstField,
+                                const FieldDecl *SecondField) const;
+
+  bool diagnoseSubMismatchTypedef(const NamedDecl *FirstRecord,
+                                  StringRef FirstModule, StringRef SecondModule,
+                                  const TypedefNameDecl *FirstTD,
+                                  const TypedefNameDecl *SecondTD,
+                                  bool IsTypeAlias) const;
+
+  bool diagnoseSubMismatchVar(const NamedDecl *FirstRecord,
+                              StringRef FirstModule, StringRef SecondModule,
+                              const VarDecl *FirstVD,
+                              const VarDecl *SecondVD) const;
+
+private:
+  DiagnosticsEngine &Diags;
+  const ASTContext &Context;
+  const LangOptions &LangOpts;
+};
+
+} // namespace clang
+
+#endif

clang/include/clang/Basic/DiagnosticASTKinds.td

def err_odr_non_type_parameter_type_inconsistent : Error<
   "non-type template parameter declared with incompatible types in different "
   "translation units (%0 vs. %1)">;
 def warn_odr_non_type_parameter_type_inconsistent : Warning<
   "non-type template parameter declared with incompatible types in different "
   "translation units (%0 vs. %1)">,
   InGroup<ODR>;
 def err_unsupported_ast_node: Error<"cannot import unsupported AST node %0">;
 
+// Compare ODR hashes
+def err_module_odr_violation_different_definitions : Error<
+  "%q0 has different definitions in different modules; "
+  "%select{definition in module '%2' is here|defined here}1">;
+def note_first_module_difference : Note<
+  "in first definition, possible difference is here">;
+def note_module_odr_violation_different_definitions : Note<
+  "definition in module '%0' is here">;
+def note_second_module_difference : Note<
+  "in second definition, possible difference is here">;
+
+def err_module_odr_violation_definition_data : Error <
+  "%q0 has different definitions in different modules; first difference is "
+  "%select{definition in module '%2'|defined here}1 found "
+  "%select{"
+  "%4 base %plural{1:class|:classes}4|"
+  "%4 virtual base %plural{1:class|:classes}4|"
+  "%ordinal4 base class with type %5|"
+  "%ordinal4 %select{non-virtual|virtual}5 base class %6|"
+  "%ordinal4 base class %5 with "
+  "%select{public|protected|private|no}6 access specifier}3">;
+
+def note_module_odr_violation_definition_data : Note <
+  "but in '%0' found "
+  "%select{"
+  "%2 base %plural{1:class|:classes}2|"
+  "%2 virtual base %plural{1:class|:classes}2|"
+  "%ordinal2 base class with different type %3|"
+  "%ordinal2 %select{non-virtual|virtual}3 base class %4|"
+  "%ordinal2 base class %3 with "
+  "%select{public|protected|private|no}4 access specifier}1">;
+
+def err_module_odr_violation_template_parameter : Error <
+  "%q0 has different definitions in different modules; first difference is "
+  "%select{definition in module '%2'|defined here}1 found "
+  "%select{"
+  "unnamed template parameter|"
+  "template parameter %5|"
+  "template parameter with %select{no |}4default argument|"
+  "template parameter with default argument}3">;
+
+def note_module_odr_violation_template_parameter : Note <
+  "but in '%0' found "
+  "%select{"
+  "unnamed template parameter %2|"
+  "template parameter %3|"
+  "template parameter with %select{no |}2default argument|"
+  "template parameter with different default argument}1">;
+
+def err_module_odr_violation_mismatch_decl : Error<
+  "%q0 has different definitions in different modules; first difference is "
+  "%select{definition in module '%2'|defined here}1 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}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_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|"
+  "%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 "
+    "is %select{not static|static}6|"
+  "%select{method %5|constructor|destructor}4 "
+    "is %select{not volatile|volatile}6|"
+  "%select{method %5|constructor|destructor}4 "
+    "is %select{not const|const}6|"
+  "%select{method %5|constructor|destructor}4 "
+    "is %select{not inline|inline}6|"
+  "%select{method %5|constructor|destructor}4 "
+    "that has %6 parameter%s6|"
+  "%select{method %5|constructor|destructor}4 "
+    "with %ordinal6 parameter of type %7%select{| decayed from %9}8|"
+  "%select{method %5|constructor|destructor}4 "
+    "with %ordinal6 parameter named %7|"
+  "%select{method %5|constructor|destructor}4 "
+    "with %ordinal6 parameter with%select{out|}7 a default argument|"
+  "%select{method %5|constructor|destructor}4 "
+    "with %ordinal6 parameter with a default argument|"
+  "%select{method %5|constructor|destructor}4 "
+    "with %select{no |}6template arguments|"
+  "%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|"
+  "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_record : Note<"but in '%0' found "
+  "%select{"
+  "static assert with different condition|"
+  "static assert with different message|"
+  "static assert with %select{|no }2message|"
+  "%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 "
+    "is %select{not static|static}4|"
+  "%select{method %3|constructor|destructor}2 "
+    "is %select{not volatile|volatile}4|"
+  "%select{method %3|constructor|destructor}2 "
+    "is %select{not const|const}4|"
+  "%select{method %3|constructor|destructor}2 "
+    "is %select{not inline|inline}4|"
+  "%select{method %3|constructor|destructor}2 "
+    "that has %4 parameter%s4|"
+  "%select{method %3|constructor|destructor}2 "
+    "with %ordinal4 parameter of type %5%select{| decayed from %7}6|"
+  "%select{method %3|constructor|destructor}2 "
+    "with %ordinal4 parameter named %5|"
+  "%select{method %3|constructor|destructor}2 "
+    "with %ordinal4 parameter with%select{out|}5 a default argument|"
+  "%select{method %3|constructor|destructor}2 "
+    "with %ordinal4 parameter with a different default argument|"
+  "%select{method %3|constructor|destructor}2 "
+    "with %select{no |}4template arguments|"
+  "%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|"
+  "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|"
+  "%ordinal4 parameter with%select{out|}5 a default argument|"
+  "%ordinal4 parameter with a default argument|"
+  "function body"
+  "}3">;
+
+def note_module_odr_violation_function : Note<"but in '%0' found "
+  "%select{"
+  "different return type %2|"
+  "%ordinal2 parameter with name %3|"
+  "%ordinal2 parameter with type %3%select{| decayed from %5}4|"
+  "%ordinal2 parameter with%select{out|}3 a default argument|"
+  "%ordinal2 parameter with a different default argument|"
+  "a different body"
+  "}1">;
+
+def err_module_odr_violation_enum : Error<
+  "%q0 has different definitions in different modules; "
+  "%select{definition in module '%2'|defined here}1 "
+  "first difference is "
+  "%select{"
+  "enum that is %select{not scoped|scoped}4|"
+  "enum scoped with keyword %select{struct|class}4|"
+  "enum %select{without|with}4 specified type|"
+  "enum with specified type %4|"
+  "enum with %4 element%s4|"
+  "%ordinal4 element has name %5|"
+  "%ordinal4 element %5 %select{has|does not have}6 an initializer|"
+  "%ordinal4 element %5 has an initializer|"
+  "}3">;
+
+def note_module_odr_violation_enum : Note<"but in '%0' found "
+  "%select{"
+  "enum that is %select{not scoped|scoped}2|"
+  "enum scoped with keyword %select{struct|class}2|"
+  "enum %select{without|with}2 specified type|"
+  "enum with specified type %2|"
+  "enum with %2 element%s2|"
+  "%ordinal2 element has name %3|"
+  "%ordinal2 element %3 %select{has|does not have}4 an initializer|"
+  "%ordinal2 element %3 has different initializer|"
+  "}1">;
+
+def err_module_odr_violation_mismatch_decl_unknown : Error<
+  "%q0 %select{with definition in module '%2'|defined here}1 has different "
+  "definitions in different modules; first difference is this "
+  "%select{||||static assert|field|method|type alias|typedef|data member|"
+  "friend declaration|function template|"
+  "unexpected decl}3">;
+def note_module_odr_violation_mismatch_decl_unknown : Note<
+  "but in '%0' found "
+  "%select{||||different static assert|different field|different method|"
+  "different type alias|different typedef|different data member|"
+  "different friend declaration|different function template|"
+  "another unexpected decl}1">;
+
+
 def remark_sanitize_address_insert_extra_padding_accepted : Remark<
     "-fsanitize-address-field-padding applied to %0">, ShowInSystemHeader,
     InGroup<SanitizeAddressRemarks>;
 def remark_sanitize_address_insert_extra_padding_rejected : Remark<
     "-fsanitize-address-field-padding ignored for %0 because it "
     "%select{is not C++|is packed|is a union|is trivially copyable|"
     "has trivial destructor|is standard layout|is in a ignorelisted file|"
     "is ignorelisted}1">, ShowInSystemHeader,

clang/include/clang/Basic/DiagnosticSerializationKinds.td

 
 def err_module_odr_violation_missing_decl : Error<
   "%q0 from module '%1' is not present in definition of %q2"
   "%select{ in module '%4'| provided earlier}3">, NoSFINAE;
 def note_module_odr_violation_no_possible_decls : Note<
   "definition has no member %0">;
 def note_module_odr_violation_possible_decl : Note<
   "declaration of %0 does not match">;
-def err_module_odr_violation_different_definitions : Error<
-  "%q0 has different definitions in different modules; "
-  "%select{definition in module '%2' is here|defined here}1">;
-def note_first_module_difference : Note<
-  "in first definition, possible difference is here">;
-def note_module_odr_violation_different_definitions : Note<
-  "definition in module '%0' is here">;
-def note_second_module_difference : Note<
-  "in second definition, possible difference is here">;
 
 def err_module_odr_violation_different_instantiations : Error<
   "instantiation of %q0 is different in different modules">;
 
-def err_module_odr_violation_definition_data : Error <
-  "%q0 has different definitions in different modules; first difference is "
-  "%select{definition in module '%2'|defined here}1 found "
-  "%select{"
-  "%4 base %plural{1:class|:classes}4|"
-  "%4 virtual base %plural{1:class|:classes}4|"
-  "%ordinal4 base class with type %5|"
-  "%ordinal4 %select{non-virtual|virtual}5 base class %6|"
-  "%ordinal4 base class %5 with "
-  "%select{public|protected|private|no}6 access specifier}3">;
-
-def note_module_odr_violation_definition_data : Note <
-  "but in '%0' found "
-  "%select{"
-  "%2 base %plural{1:class|:classes}2|"
-  "%2 virtual base %plural{1:class|:classes}2|"
-  "%ordinal2 base class with different type %3|"
-  "%ordinal2 %select{non-virtual|virtual}3 base class %4|"
-  "%ordinal2 base class %3 with "
-  "%select{public|protected|private|no}4 access specifier}1">;
-
-def err_module_odr_violation_template_parameter : Error <
-  "%q0 has different definitions in different modules; first difference is "
-  "%select{definition in module '%2'|defined here}1 found "
-  "%select{"
-  "unnamed template parameter|"
-  "template parameter %5|"
-  "template parameter with %select{no |}4default argument|"
-  "template parameter with default argument}3">;
-
-def note_module_odr_violation_template_parameter : Note <
-  "but in '%0' found "
-  "%select{"
-  "unnamed template parameter %2|"
-  "template parameter %3|"
-  "template parameter with %select{no |}2default argument|"
-  "template parameter with different default argument}1">;
-
-def err_module_odr_violation_mismatch_decl : Error<
-  "%q0 has different definitions in different modules; first difference is "
-  "%select{definition in module '%2'|defined here}1 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}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_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|"
-  "%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 "
-    "is %select{not static|static}6|"
-  "%select{method %5|constructor|destructor}4 "
-    "is %select{not volatile|volatile}6|"
-  "%select{method %5|constructor|destructor}4 "
-    "is %select{not const|const}6|"
-  "%select{method %5|constructor|destructor}4 "
-    "is %select{not inline|inline}6|"
-  "%select{method %5|constructor|destructor}4 "
-    "that has %6 parameter%s6|"
-  "%select{method %5|constructor|destructor}4 "
-    "with %ordinal6 parameter of type %7%select{| decayed from %9}8|"
-  "%select{method %5|constructor|destructor}4 "
-    "with %ordinal6 parameter named %7|"
-  "%select{method %5|constructor|destructor}4 "
-    "with %ordinal6 parameter with%select{out|}7 a default argument|"
-  "%select{method %5|constructor|destructor}4 "
-    "with %ordinal6 parameter with a default argument|"
-  "%select{method %5|constructor|destructor}4 "
-    "with %select{no |}6template arguments|"
-  "%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|"
-  "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_record : Note<"but in '%0' found "
-  "%select{"
-  "static assert with different condition|"
-  "static assert with different message|"
-  "static assert with %select{|no }2message|"
-  "%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 "
-    "is %select{not static|static}4|"
-  "%select{method %3|constructor|destructor}2 "
-    "is %select{not volatile|volatile}4|"
-  "%select{method %3|constructor|destructor}2 "
-    "is %select{not const|const}4|"
-  "%select{method %3|constructor|destructor}2 "
-    "is %select{not inline|inline}4|"
-  "%select{method %3|constructor|destructor}2 "
-    "that has %4 parameter%s4|"
-  "%select{method %3|constructor|destructor}2 "
-    "with %ordinal4 parameter of type %5%select{| decayed from %7}6|"
-  "%select{method %3|constructor|destructor}2 "
-    "with %ordinal4 parameter named %5|"
-  "%select{method %3|constructor|destructor}2 "
-    "with %ordinal4 parameter with%select{out|}5 a default argument|"
-  "%select{method %3|constructor|destructor}2 "
-    "with %ordinal4 parameter with a different default argument|"
-  "%select{method %3|constructor|destructor}2 "
-    "with %select{no |}4template arguments|"
-  "%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|"
-  "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|"
-  "%ordinal4 parameter with%select{out|}5 a default argument|"
-  "%ordinal4 parameter with a default argument|"
-  "function body"
-  "}3">;
-
-def note_module_odr_violation_function : Note<"but in '%0' found "
-  "%select{"
-  "different return type %2|"
-  "%ordinal2 parameter with name %3|"
-  "%ordinal2 parameter with type %3%select{| decayed from %5}4|"
-  "%ordinal2 parameter with%select{out|}3 a default argument|"
-  "%ordinal2 parameter with a different default argument|"
-  "a different body"
-  "}1">;
-
-def err_module_odr_violation_enum : Error<
-  "%q0 has different definitions in different modules; "
-  "%select{definition in module '%2'|defined here}1 "
-  "first difference is "
-  "%select{"
-  "enum that is %select{not scoped|scoped}4|"
-  "enum scoped with keyword %select{struct|class}4|"
-  "enum %select{without|with}4 specified type|"
-  "enum with specified type %4|"
-  "enum with %4 element%s4|"
-  "%ordinal4 element has name %5|"
-  "%ordinal4 element %5 %select{has|does not have}6 an initializer|"
-  "%ordinal4 element %5 has an initializer|"
-  "}3">;
-
-def note_module_odr_violation_enum : Note<"but in '%0' found "
-  "%select{"
-  "enum that is %select{not scoped|scoped}2|"
-  "enum scoped with keyword %select{struct|class}2|"
-  "enum %select{without|with}2 specified type|"
-  "enum with specified type %2|"
-  "enum with %2 element%s2|"
-  "%ordinal2 element has name %3|"
-  "%ordinal2 element %3 %select{has|does not have}4 an initializer|"
-  "%ordinal2 element %3 has different initializer|"
-  "}1">;
-
-def err_module_odr_violation_mismatch_decl_unknown : Error<
-  "%q0 %select{with definition in module '%2'|defined here}1 has different "
-  "definitions in different modules; first difference is this "
-  "%select{||||static assert|field|method|type alias|typedef|data member|"
-  "friend declaration|function template|"
-  "unexpected decl}3">;
-def note_module_odr_violation_mismatch_decl_unknown : Note<
-  "but in '%0' found "
-  "%select{||||different static assert|different field|different method|"
-  "different type alias|different typedef|different data member|"
-  "different friend declaration|different function template|"
-  "another unexpected decl}1">;
-
 def warn_duplicate_module_file_extension : Warning<
   "duplicate module file extension block name '%0'">,
   InGroup<ModuleFileExtension>;
 
 def warn_module_system_bit_conflict : Warning<
   "module file '%0' was validated as a system module and is now being imported "
   "as a non-system module; any difference in diagnostic options will be ignored">,
   InGroup<ModuleConflict>;

clang/lib/AST/CMakeLists.txt

add_clang_library(clangAST
   ItaniumCXXABI.cpp
   ItaniumMangle.cpp
   JSONNodeDumper.cpp
   Mangle.cpp
   MicrosoftCXXABI.cpp
   MicrosoftMangle.cpp
   NestedNameSpecifier.cpp
   NSAPI.cpp
+  ODRDiagsEmitter.cpp
   ODRHash.cpp
   OpenMPClause.cpp
   OSLog.cpp
   ParentMap.cpp
   PrintfFormatString.cpp
   QualTypeNames.cpp
   Randstruct.cpp
   RawCommentList.cpp

clang/lib/AST/ODRDiagsEmitter.cpp

+//===-- ODRDiagsEmitter.cpp - Diagnostics for ODR mismatches ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ODRDiagsEmitter.h"
+#include "clang/AST/DeclFriend.h"
+#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/ODRHash.h"
+#include "clang/Basic/DiagnosticAST.h"
+#include "clang/Basic/Module.h"
+
+using namespace clang;
+
+static unsigned computeODRHash(QualType Ty) {
+  ODRHash Hasher;
+  Hasher.AddQualType(Ty);
+  return Hasher.CalculateHash();
+}
+
+static unsigned computeODRHash(const Stmt *S) {
+  ODRHash Hasher;
+  Hasher.AddStmt(S);
+  return Hasher.CalculateHash();
+}
+
+static unsigned computeODRHash(const Decl *D) {
+  assert(D);
+  ODRHash Hasher;
+  Hasher.AddSubDecl(D);
+  return Hasher.CalculateHash();
+}
+
+static unsigned computeODRHash(const TemplateArgument &TA) {
+  ODRHash Hasher;
+  Hasher.AddTemplateArgument(TA);
+  return Hasher.CalculateHash();
+}
+
+static std::string getOwningModuleNameForDiagnostic(const Decl *D) {
+  // If we know the owning module, use it.
+  if (Module *M = D->getImportedOwningModule())
+    return M->getFullModuleName();
+
+  // Not from a module.
+  return {};
+}
+
+bool ODRDiagsEmitter::diagnoseSubMismatchField(
+    const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
+    const FieldDecl *FirstField, const FieldDecl *SecondField) const {
+  enum ODRFieldDifference {
+    FieldName,
+    FieldTypeName,
+    FieldSingleBitField,
+    FieldDifferentWidthBitField,
+    FieldSingleMutable,
+    FieldSingleInitializer,
+    FieldDifferentInitializers,
+  };
+
+  auto DiagError = [FirstRecord, FirstField, FirstModule,
+                    this](ODRFieldDifference DiffType) {
+    return Diag(FirstField->getLocation(), diag::err_module_odr_violation_field)
+           << FirstRecord << FirstModule.empty() << FirstModule
+           << FirstField->getSourceRange() << DiffType;
+  };
+  auto DiagNote = [SecondField, SecondModule,
+                   this](ODRFieldDifference DiffType) {
+    return Diag(SecondField->getLocation(),
+                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;
+    return true;
+  }
+
+  assert(Context.hasSameType(FirstField->getType(), SecondField->getType()));
+
+  QualType FirstType = FirstField->getType();
+  QualType SecondType = SecondField->getType();
+  if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
+    DiagError(FieldTypeName) << FirstII << FirstType;
+    DiagNote(FieldTypeName) << SecondII << SecondType;
+    return true;
+  }
+
+  const bool IsFirstBitField = FirstField->isBitField();
+  const bool IsSecondBitField = SecondField->isBitField();
+  if (IsFirstBitField != IsSecondBitField) {
+    DiagError(FieldSingleBitField) << FirstII << IsFirstBitField;
+    DiagNote(FieldSingleBitField) << SecondII << IsSecondBitField;
+    return true;
+  }
+
+  if (IsFirstBitField && IsSecondBitField) {
+    unsigned FirstBitWidthHash = computeODRHash(FirstField->getBitWidth());
+    unsigned SecondBitWidthHash = computeODRHash(SecondField->getBitWidth());
+    if (FirstBitWidthHash != SecondBitWidthHash) {
+      DiagError(FieldDifferentWidthBitField)
+          << FirstII << FirstField->getBitWidth()->getSourceRange();
+      DiagNote(FieldDifferentWidthBitField)
+          << SecondII << SecondField->getBitWidth()->getSourceRange();
+      return true;
+    }
+  }
+
+  if (!LangOpts.CPlusPlus)
+    return false;
+
+  const bool IsFirstMutable = FirstField->isMutable();
+  const bool IsSecondMutable = SecondField->isMutable();
+  if (IsFirstMutable != IsSecondMutable) {
+    DiagError(FieldSingleMutable) << FirstII << IsFirstMutable;
+    DiagNote(FieldSingleMutable) << SecondII << IsSecondMutable;
+    return true;
+  }
+
+  const Expr *FirstInitializer = FirstField->getInClassInitializer();
+  const Expr *SecondInitializer = SecondField->getInClassInitializer();
+  if ((!FirstInitializer && SecondInitializer) ||
+      (FirstInitializer && !SecondInitializer)) {
+    DiagError(FieldSingleInitializer)
+        << FirstII << (FirstInitializer != nullptr);
+    DiagNote(FieldSingleInitializer)
+        << SecondII << (SecondInitializer != nullptr);
+    return true;
+  }
+
+  if (FirstInitializer && SecondInitializer) {
+    unsigned FirstInitHash = computeODRHash(FirstInitializer);
+    unsigned SecondInitHash = computeODRHash(SecondInitializer);
+    if (FirstInitHash != SecondInitHash) {
+      DiagError(FieldDifferentInitializers)
+          << FirstII << FirstInitializer->getSourceRange();
+      DiagNote(FieldDifferentInitializers)
+          << SecondII << SecondInitializer->getSourceRange();
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool ODRDiagsEmitter::diagnoseSubMismatchTypedef(
+    const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
+    const TypedefNameDecl *FirstTD, const TypedefNameDecl *SecondTD,
+    bool IsTypeAlias) const {
+  enum ODRTypedefDifference {
+    TypedefName,
+    TypedefType,
+  };
+
+  auto DiagError = [FirstRecord, FirstTD, FirstModule,
+                    this](ODRTypedefDifference DiffType) {
+    return Diag(FirstTD->getLocation(), diag::err_module_odr_violation_typedef)
+           << FirstRecord << FirstModule.empty() << FirstModule
+           << FirstTD->getSourceRange() << DiffType;
+  };
+  auto DiagNote = [SecondTD, SecondModule,
+                   this](ODRTypedefDifference DiffType) {
+    return Diag(SecondTD->getLocation(),
+                diag::note_module_odr_violation_typedef)
+           << SecondModule << SecondTD->getSourceRange() << DiffType;
+  };
+
+  DeclarationName FirstName = FirstTD->getDeclName();
+  DeclarationName SecondName = SecondTD->getDeclName();
+  if (FirstName != SecondName) {
+    DiagError(TypedefName) << IsTypeAlias << FirstName;
+    DiagNote(TypedefName) << IsTypeAlias << SecondName;
+    return true;
+  }
+
+  QualType FirstType = FirstTD->getUnderlyingType();
+  QualType SecondType = SecondTD->getUnderlyingType();
+  if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
+    DiagError(TypedefType) << IsTypeAlias << FirstName << FirstType;
+    DiagNote(TypedefType) << IsTypeAlias << SecondName << SecondType;
+    return true;
+  }
+  return false;
+}
+
+bool ODRDiagsEmitter::diagnoseSubMismatchVar(const NamedDecl *FirstRecord,
+                                             StringRef FirstModule,
+                                             StringRef SecondModule,
+                                             const VarDecl *FirstVD,
+                                             const VarDecl *SecondVD) const {
+  enum ODRVarDifference {
+    VarName,
+    VarType,
+    VarSingleInitializer,
+    VarDifferentInitializer,
+    VarConstexpr,
+  };
+
+  auto DiagError = [FirstRecord, FirstVD, FirstModule,
+                    this](ODRVarDifference DiffType) {
+    return Diag(FirstVD->getLocation(), diag::err_module_odr_violation_variable)
+           << FirstRecord << FirstModule.empty() << FirstModule
+           << FirstVD->getSourceRange() << DiffType;
+  };
+  auto DiagNote = [SecondVD, SecondModule, this](ODRVarDifference DiffType) {
+    return Diag(SecondVD->getLocation(),
+                diag::note_module_odr_violation_variable)
+           << SecondModule << SecondVD->getSourceRange() << DiffType;
+  };
+
+  DeclarationName FirstName = FirstVD->getDeclName();
+  DeclarationName SecondName = SecondVD->getDeclName();
+  if (FirstName != SecondName) {
+    DiagError(VarName) << FirstName;
+    DiagNote(VarName) << SecondName;
+    return true;
+  }
+
+  QualType FirstType = FirstVD->getType();
+  QualType SecondType = SecondVD->getType();
+  if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
+    DiagError(VarType) << FirstName << FirstType;
+    DiagNote(VarType) << SecondName << SecondType;
+    return true;
+  }
+
+  if (!LangOpts.CPlusPlus)
+    return false;
+
+  const Expr *FirstInit = FirstVD->getInit();
+  const Expr *SecondInit = SecondVD->getInit();
+  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
+    DiagError(VarSingleInitializer)
+        << FirstName << (FirstInit == nullptr)
+        << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
+    DiagNote(VarSingleInitializer)
+        << SecondName << (SecondInit == nullptr)
+        << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
+    return true;
+  }
+
+  if (FirstInit && SecondInit &&
+      computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
+    DiagError(VarDifferentInitializer)
+        << FirstName << FirstInit->getSourceRange();
+    DiagNote(VarDifferentInitializer)
+        << SecondName << SecondInit->getSourceRange();
+    return true;
+  }
+
+  const bool FirstIsConstexpr = FirstVD->isConstexpr();
+  const bool SecondIsConstexpr = SecondVD->isConstexpr();
+  if (FirstIsConstexpr != SecondIsConstexpr) {
+    DiagError(VarConstexpr) << FirstName << FirstIsConstexpr;
+    DiagNote(VarConstexpr) << SecondName << SecondIsConstexpr;
+    return true;
+  }
+  return false;
+}
+
+ODRDiagsEmitter::DiffResult
+ODRDiagsEmitter::FindTypeDiffs(DeclHashes &FirstHashes,
+                               DeclHashes &SecondHashes) {
+  auto DifferenceSelector = [](const Decl *D) {
+    assert(D && "valid Decl required");
+    switch (D->getKind()) {
+    default:
+      return Other;
+    case Decl::AccessSpec:
+      switch (D->getAccess()) {
+      case AS_public:
+        return PublicSpecifer;
+      case AS_private:
+        return PrivateSpecifer;
+      case AS_protected:
+        return ProtectedSpecifer;
+      case AS_none:
+        break;
+      }
+      llvm_unreachable("Invalid access specifier");
+    case Decl::StaticAssert:
+      return StaticAssert;
+    case Decl::Field:
+      return Field;
+    case Decl::CXXMethod:
+    case Decl::CXXConstructor:
+    case Decl::CXXDestructor:
+      return CXXMethod;
+    case Decl::TypeAlias:
+      return TypeAlias;
+    case Decl::Typedef:
+      return TypeDef;
+    case Decl::Var:
+      return Var;
+    case Decl::Friend:
+      return Friend;
+    case Decl::FunctionTemplate:
+      return FunctionTemplate;
+    }
+  };
+
+  DiffResult DR;
+  auto FirstIt = FirstHashes.begin();
+  auto SecondIt = SecondHashes.begin();
+  while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
+    if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
+        FirstIt->second == SecondIt->second) {
+      ++FirstIt;
+      ++SecondIt;
+      continue;
+    }
+
+    DR.FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
+    DR.SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
+
+    DR.FirstDiffType =
+        DR.FirstDecl ? DifferenceSelector(DR.FirstDecl) : EndOfClass;
+    DR.SecondDiffType =
+        DR.SecondDecl ? DifferenceSelector(DR.SecondDecl) : EndOfClass;
+    return DR;
+  }
+  return DR;
+}
+
+void ODRDiagsEmitter::diagnoseSubMismatchUnexpected(
+    DiffResult &DR, const NamedDecl *FirstRecord, StringRef FirstModule,
+    const NamedDecl *SecondRecord, StringRef SecondModule) const {
+  Diag(FirstRecord->getLocation(),
+       diag::err_module_odr_violation_different_definitions)
+      << FirstRecord << FirstModule.empty() << FirstModule;
+
+  if (DR.FirstDecl) {
+    Diag(DR.FirstDecl->getLocation(), diag::note_first_module_difference)
+        << FirstRecord << DR.FirstDecl->getSourceRange();
+  }
+
+  Diag(SecondRecord->getLocation(),
+       diag::note_module_odr_violation_different_definitions)
+      << SecondModule;
+
+  if (DR.SecondDecl) {
+    Diag(DR.SecondDecl->getLocation(), diag::note_second_module_difference)
+        << DR.SecondDecl->getSourceRange();
+  }
+}
+
+void ODRDiagsEmitter::diagnoseSubMismatchDifferentDeclKinds(
+    DiffResult &DR, const NamedDecl *FirstRecord, StringRef FirstModule,
+    const NamedDecl *SecondRecord, StringRef SecondModule) const {
+  auto GetMismatchedDeclLoc = [](const NamedDecl *Container,
+                                 ODRMismatchDecl DiffType, const Decl *D) {
+    SourceLocation Loc;
+    SourceRange Range;
+    auto *Tag = dyn_cast<TagDecl>(Container);
+    if (DiffType == EndOfClass && Tag) {
+      Loc = Tag->getBraceRange().getEnd();
+    } else {
+      Loc = D->getLocation();
+      Range = D->getSourceRange();
+    }
+    return std::make_pair(Loc, Range);
+  };
+
+  auto FirstDiagInfo =
+      GetMismatchedDeclLoc(FirstRecord, DR.FirstDiffType, DR.FirstDecl);
+  Diag(FirstDiagInfo.first, diag::err_module_odr_violation_mismatch_decl)
+      << FirstRecord << FirstModule.empty() << FirstModule
+      << FirstDiagInfo.second << DR.FirstDiffType;
+
+  auto SecondDiagInfo =
+      GetMismatchedDeclLoc(SecondRecord, DR.SecondDiffType, DR.SecondDecl);
+  Diag(SecondDiagInfo.first, diag::note_module_odr_violation_mismatch_decl)
+      << SecondModule << SecondDiagInfo.second << DR.SecondDiffType;
+}
+
+bool ODRDiagsEmitter::diagnoseMismatch(
+    const CXXRecordDecl *FirstRecord, const CXXRecordDecl *SecondRecord,
+    const struct CXXRecordDecl::DefinitionData *SecondDD) const {
+  // Multiple different declarations got merged together; tell the user
+  // where they came from.
+  if (FirstRecord == SecondRecord)
+    return false;
+
+  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
+  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
+
+  const struct CXXRecordDecl::DefinitionData *FirstDD =
+      FirstRecord->DefinitionData;
+  assert(FirstDD && SecondDD && "Definitions without DefinitionData");
+
+  // Diagnostics from DefinitionData are emitted here.
+  if (FirstDD != SecondDD) {
+    // Keep in sync with err_module_odr_violation_definition_data.
+    enum ODRDefinitionDataDifference {
+      NumBases,
+      NumVBases,
+      BaseType,
+      BaseVirtual,
+      BaseAccess,
+    };
+    auto DiagBaseError = [FirstRecord, &FirstModule,
+                          this](SourceLocation Loc, SourceRange Range,
+                                ODRDefinitionDataDifference DiffType) {
+      return Diag(Loc, diag::err_module_odr_violation_definition_data)
+             << FirstRecord << FirstModule.empty() << FirstModule << Range
+             << DiffType;
+    };
+    auto DiagBaseNote = [&SecondModule,
+                         this](SourceLocation Loc, SourceRange Range,
+                               ODRDefinitionDataDifference DiffType) {
+      return Diag(Loc, diag::note_module_odr_violation_definition_data)
+             << SecondModule << Range << DiffType;
+    };
+    auto GetSourceRange = [](const struct CXXRecordDecl::DefinitionData *DD) {
+      unsigned NumBases = DD->NumBases;
+      if (NumBases == 0)
+        return SourceRange();
+      ArrayRef<CXXBaseSpecifier> bases = DD->bases();
+      return SourceRange(bases[0].getBeginLoc(),
+                         bases[NumBases - 1].getEndLoc());
+    };
+
+    unsigned FirstNumBases = FirstDD->NumBases;
+    unsigned FirstNumVBases = FirstDD->NumVBases;
+    unsigned SecondNumBases = SecondDD->NumBases;
+    unsigned SecondNumVBases = SecondDD->NumVBases;
+    if (FirstNumBases != SecondNumBases) {
+      DiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
+                    NumBases)
+          << FirstNumBases;
+      DiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
+                   NumBases)
+          << SecondNumBases;
+      return true;
+    }
+
+    if (FirstNumVBases != SecondNumVBases) {
+      DiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
+                    NumVBases)
+          << FirstNumVBases;
+      DiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
+                   NumVBases)
+          << SecondNumVBases;
+      return true;
+    }
+
+    ArrayRef<CXXBaseSpecifier> FirstBases = FirstDD->bases();
+    ArrayRef<CXXBaseSpecifier> SecondBases = SecondDD->bases();
+    for (unsigned I = 0; I < FirstNumBases; ++I) {
+      const CXXBaseSpecifier FirstBase = FirstBases[I];
+      const CXXBaseSpecifier SecondBase = SecondBases[I];
+      if (computeODRHash(FirstBase.getType()) !=
+          computeODRHash(SecondBase.getType())) {
+        DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
+                      BaseType)
+            << (I + 1) << FirstBase.getType();
+        DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
+                     BaseType)
+            << (I + 1) << SecondBase.getType();
+        return true;
+      }
+
+      if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
+        DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
+                      BaseVirtual)
+            << (I + 1) << FirstBase.isVirtual() << FirstBase.getType();
+        DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
+                     BaseVirtual)
+            << (I + 1) << SecondBase.isVirtual() << SecondBase.getType();
+        return true;
+      }
+
+      if (FirstBase.getAccessSpecifierAsWritten() !=
+          SecondBase.getAccessSpecifierAsWritten()) {
+        DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
+                      BaseAccess)
+            << (I + 1) << FirstBase.getType()
+            << (int)FirstBase.getAccessSpecifierAsWritten();
+        DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
+                     BaseAccess)
+            << (I + 1) << SecondBase.getType()
+            << (int)SecondBase.getAccessSpecifierAsWritten();
+        return true;
+      }
+    }
+  }
+
+  const ClassTemplateDecl *FirstTemplate =
+      FirstRecord->getDescribedClassTemplate();
+  const ClassTemplateDecl *SecondTemplate =
+      SecondRecord->getDescribedClassTemplate();
+
+  assert(!FirstTemplate == !SecondTemplate &&
+         "Both pointers should be null or non-null");
+
+  if (FirstTemplate && SecondTemplate) {
+    ArrayRef<const NamedDecl *> FirstTemplateParams =
+        FirstTemplate->getTemplateParameters()->asArray();
+    ArrayRef<const NamedDecl *> SecondTemplateParams =
+        SecondTemplate->getTemplateParameters()->asArray();
+    assert(FirstTemplateParams.size() == SecondTemplateParams.size() &&
+           "Number of template parameters should be equal.");
+    for (auto Pair : llvm::zip(FirstTemplateParams, SecondTemplateParams)) {
+      const NamedDecl *FirstDecl = std::get<0>(Pair);
+      const NamedDecl *SecondDecl = std::get<1>(Pair);
+      if (computeODRHash(FirstDecl) == computeODRHash(SecondDecl))
+        continue;
+
+      assert(FirstDecl->getKind() == SecondDecl->getKind() &&
+             "Parameter Decl's should be the same kind.");
+
+      enum ODRTemplateDifference {
+        ParamEmptyName,
+        ParamName,
+        ParamSingleDefaultArgument,
+        ParamDifferentDefaultArgument,
+      };
+
+      auto hasDefaultArg = [](const NamedDecl *D) {
+        if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
+          return TTP->hasDefaultArgument() &&
+                 !TTP->defaultArgumentWasInherited();
+        if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
+          return NTTP->hasDefaultArgument() &&
+                 !NTTP->defaultArgumentWasInherited();
+        auto *TTP = cast<TemplateTemplateParmDecl>(D);
+        return TTP->hasDefaultArgument() && !TTP->defaultArgumentWasInherited();
+      };
+      bool hasFirstArg = hasDefaultArg(FirstDecl);
+      bool hasSecondArg = hasDefaultArg(SecondDecl);
+
+      ODRTemplateDifference ErrDiffType;
+      ODRTemplateDifference NoteDiffType;
+
+      DeclarationName FirstName = FirstDecl->getDeclName();
+      DeclarationName SecondName = SecondDecl->getDeclName();
+
+      if (FirstName != SecondName) {
+        bool FirstNameEmpty =
+            FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
+        bool SecondNameEmpty =
+            SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
+        ErrDiffType = FirstNameEmpty ? ParamEmptyName : ParamName;
+        NoteDiffType = SecondNameEmpty ? ParamEmptyName : ParamName;
+      } else if (hasFirstArg == hasSecondArg)
+        ErrDiffType = NoteDiffType = ParamDifferentDefaultArgument;
+      else
+        ErrDiffType = NoteDiffType = ParamSingleDefaultArgument;
+
+      Diag(FirstDecl->getLocation(),
+           diag::err_module_odr_violation_template_parameter)
+          << FirstRecord << FirstModule.empty() << FirstModule
+          << FirstDecl->getSourceRange() << ErrDiffType << hasFirstArg
+          << FirstName;
+      Diag(SecondDecl->getLocation(),
+           diag::note_module_odr_violation_template_parameter)
+          << SecondModule << SecondDecl->getSourceRange() << NoteDiffType
+          << hasSecondArg << SecondName;
+      return true;
+    }
+  }
+
+  auto PopulateHashes = [](DeclHashes &Hashes, const RecordDecl *Record,
+                           const DeclContext *DC) {
+    for (const Decl *D : Record->decls()) {
+      if (!ODRHash::isDeclToBeProcessed(D, DC))
+        continue;
+      Hashes.emplace_back(D, computeODRHash(D));
+    }
+  };
+
+  DeclHashes FirstHashes;
+  DeclHashes SecondHashes;
+  const DeclContext *DC = FirstRecord;
+  PopulateHashes(FirstHashes, FirstRecord, DC);
+  PopulateHashes(SecondHashes, SecondRecord, DC);
+
+  DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
+  ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
+  ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
+  const Decl *FirstDecl = DR.FirstDecl;
+  const Decl *SecondDecl = DR.SecondDecl;
+
+  if (FirstDiffType == Other || SecondDiffType == Other) {
+    diagnoseSubMismatchUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
+                                  SecondModule);
+    return true;
+  }
+
+  if (FirstDiffType != SecondDiffType) {
+    diagnoseSubMismatchDifferentDeclKinds(DR, FirstRecord, FirstModule,
+                                          SecondRecord, SecondModule);
+    return true;
+  }
+
+  // Used with err_module_odr_violation_record and
+  // note_module_odr_violation_record
+  enum ODRCXXRecordDifference {
+    StaticAssertCondition,
+    StaticAssertMessage,
+    StaticAssertOnlyMessage,
+    MethodName,
+    MethodDeleted,
+    MethodDefaulted,
+    MethodVirtual,
+    MethodStatic,
+    MethodVolatile,
+    MethodConst,
+    MethodInline,
+    MethodNumberParameters,
+    MethodParameterType,
+    MethodParameterName,
+    MethodParameterSingleDefaultArgument,
+    MethodParameterDifferentDefaultArgument,
+    MethodNoTemplateArguments,
+    MethodDifferentNumberTemplateArguments,
+    MethodDifferentTemplateArgument,
+    MethodSingleBody,
+    MethodDifferentBody,
+    FriendTypeFunction,
+    FriendType,
+    FriendFunction,
+    FunctionTemplateDifferentNumberParameters,
+    FunctionTemplateParameterDifferentKind,
+    FunctionTemplateParameterName,
+    FunctionTemplateParameterSingleDefaultArgument,
+    FunctionTemplateParameterDifferentDefaultArgument,
+    FunctionTemplateParameterDifferentType,
+    FunctionTemplatePackParameter,
+  };
+  auto DiagError = [FirstRecord, &FirstModule,
+                    this](SourceLocation Loc, SourceRange Range,
+                          ODRCXXRecordDifference DiffType) {
+    return Diag(Loc, diag::err_module_odr_violation_record)
+           << FirstRecord << FirstModule.empty() << FirstModule << Range
+           << DiffType;
+  };
+  auto DiagNote = [&SecondModule, this](SourceLocation Loc, SourceRange Range,
+                                        ODRCXXRecordDifference DiffType) {
+    return Diag(Loc, diag::note_module_odr_violation_record)
+           << SecondModule << Range << DiffType;
+  };
+
+  assert(FirstDiffType == SecondDiffType);
+  switch (FirstDiffType) {
+  case Other:
+  case EndOfClass:
+  case PublicSpecifer:
+  case PrivateSpecifer:
+  case ProtectedSpecifer:
+    llvm_unreachable("Invalid diff type");
+
+  case StaticAssert: {
+    const StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
+    const StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
+
+    const Expr *FirstExpr = FirstSA->getAssertExpr();
+    const Expr *SecondExpr = SecondSA->getAssertExpr();
+    unsigned FirstODRHash = computeODRHash(FirstExpr);
+    unsigned SecondODRHash = computeODRHash(SecondExpr);
+    if (FirstODRHash != SecondODRHash) {
+      DiagError(FirstExpr->getBeginLoc(), FirstExpr->getSourceRange(),
+                StaticAssertCondition);
+      DiagNote(SecondExpr->getBeginLoc(), SecondExpr->getSourceRange(),
+               StaticAssertCondition);
+      return true;
+    }
+
+    const StringLiteral *FirstStr = FirstSA->getMessage();
+    const StringLiteral *SecondStr = SecondSA->getMessage();
+    assert((FirstStr || SecondStr) && "Both messages cannot be empty");
+    if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
+      SourceLocation FirstLoc, SecondLoc;
+      SourceRange FirstRange, SecondRange;
+      if (FirstStr) {
+        FirstLoc = FirstStr->getBeginLoc();
+        FirstRange = FirstStr->getSourceRange();
+      } else {
+        FirstLoc = FirstSA->getBeginLoc();
+        FirstRange = FirstSA->getSourceRange();
+      }
+      if (SecondStr) {
+        SecondLoc = SecondStr->getBeginLoc();
+        SecondRange = SecondStr->getSourceRange();
+      } else {
+        SecondLoc = SecondSA->getBeginLoc();
+        SecondRange = SecondSA->getSourceRange();
+      }
+      DiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
+          << (FirstStr == nullptr);
+      DiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
+          << (SecondStr == nullptr);
+      return true;
+    }
+
+    if (FirstStr && SecondStr &&
+        FirstStr->getString() != SecondStr->getString()) {
+      DiagError(FirstStr->getBeginLoc(), FirstStr->getSourceRange(),
+                StaticAssertMessage);
+      DiagNote(SecondStr->getBeginLoc(), SecondStr->getSourceRange(),
+               StaticAssertMessage);
+      return true;
+    }
+    break;
+  }
+
+  case Field: {
+    if (diagnoseSubMismatchField(FirstRecord, FirstModule, SecondModule,
+                                 cast<FieldDecl>(FirstDecl),
+                                 cast<FieldDecl>(SecondDecl)))
+      return true;
+    break;
+  }
+
+  case CXXMethod: {
+    enum {
+      DiagMethod,
+      DiagConstructor,
+      DiagDestructor,
+    } FirstMethodType,
+        SecondMethodType;
+    auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl *D) {
+      if (isa<CXXConstructorDecl>(D))
+        return DiagConstructor;
+      if (isa<CXXDestructorDecl>(D))
+        return DiagDestructor;
+      return DiagMethod;
+    };
+    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 = [&DiagError, FirstMethod, FirstMethodType,
+                            FirstName](ODRCXXRecordDifference DiffType) {
+      return DiagError(FirstMethod->getLocation(),
+                       FirstMethod->getSourceRange(), DiffType)
+             << FirstMethodType << FirstName;
+    };
+    auto DiagMethodNote = [&DiagNote, SecondMethod, SecondMethodType,
+                           SecondName](ODRCXXRecordDifference DiffType) {
+      return DiagNote(SecondMethod->getLocation(),
+                      SecondMethod->getSourceRange(), DiffType)
+             << SecondMethodType << SecondName;
+    };
+
+    if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
+      DiagMethodError(MethodName);
+      DiagMethodNote(MethodName);
+      return true;
+    }
+
+    const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
+    const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
+    if (FirstDeleted != SecondDeleted) {
+      DiagMethodError(MethodDeleted) << FirstDeleted;
+      DiagMethodNote(MethodDeleted) << SecondDeleted;
+      return true;
+    }
+
+    const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
+    const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
+    if (FirstDefaulted != SecondDefaulted) {
+      DiagMethodError(MethodDefaulted) << FirstDefaulted;
+      DiagMethodNote(MethodDefaulted) << SecondDefaulted;
+      return true;
+    }
+
+    const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
+    const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
+    const bool FirstPure = FirstMethod->isPure();
+    const bool SecondPure = SecondMethod->isPure();
+    if ((FirstVirtual || SecondVirtual) &&
+        (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
+      DiagMethodError(MethodVirtual) << FirstPure << FirstVirtual;
+      DiagMethodNote(MethodVirtual) << SecondPure << SecondVirtual;
+      return true;
+    }
+
+    // CXXMethodDecl::isStatic uses the canonical Decl.  With Decl merging,
+    // FirstDecl is the canonical Decl of SecondDecl, so the storage
+    // class needs to be checked instead.
+    StorageClass FirstStorage = FirstMethod->getStorageClass();
+    StorageClass SecondStorage = SecondMethod->getStorageClass();
+    const bool FirstStatic = FirstStorage == SC_Static;
+    const bool SecondStatic = SecondStorage == SC_Static;
+    if (FirstStatic != SecondStatic) {
+      DiagMethodError(MethodStatic) << FirstStatic;
+      DiagMethodNote(MethodStatic) << SecondStatic;
+      return true;
+    }
+
+    const bool FirstVolatile = FirstMethod->isVolatile();
+    const bool SecondVolatile = SecondMethod->isVolatile();
+    if (FirstVolatile != SecondVolatile) {
+      DiagMethodError(MethodVolatile) << FirstVolatile;
+      DiagMethodNote(MethodVolatile) << SecondVolatile;
+      return true;
+    }
+
+    const bool FirstConst = FirstMethod->isConst();
+    const bool SecondConst = SecondMethod->isConst();
+    if (FirstConst != SecondConst) {
+      DiagMethodError(MethodConst) << FirstConst;
+      DiagMethodNote(MethodConst) << SecondConst;
+      return true;
+    }
+
+    const bool FirstInline = FirstMethod->isInlineSpecified();
+    const bool SecondInline = SecondMethod->isInlineSpecified();
+    if (FirstInline != SecondInline) {
+      DiagMethodError(MethodInline) << FirstInline;
+      DiagMethodNote(MethodInline) << SecondInline;
+      return true;
+    }
+
+    const unsigned FirstNumParameters = FirstMethod->param_size();
+    const unsigned SecondNumParameters = SecondMethod->param_size();
+    if (FirstNumParameters != SecondNumParameters) {
+      DiagMethodError(MethodNumberParameters) << FirstNumParameters;
+      DiagMethodNote(MethodNumberParameters) << SecondNumParameters;
+      return true;
+    }
+
+    for (unsigned I = 0; I < FirstNumParameters; ++I) {
+      const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
+      const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
+
+      QualType FirstParamType = FirstParam->getType();
+      QualType SecondParamType = SecondParam->getType();
+      if (FirstParamType != SecondParamType &&
+          computeODRHash(FirstParamType) != computeODRHash(SecondParamType)) {
+        if (const DecayedType *ParamDecayedType =
+                FirstParamType->getAs<DecayedType>()) {
+          DiagMethodError(MethodParameterType)
+              << (I + 1) << FirstParamType << true
+              << ParamDecayedType->getOriginalType();
+        } else {
+          DiagMethodError(MethodParameterType)
+              << (I + 1) << FirstParamType << false;
+        }
+
+        if (const DecayedType *ParamDecayedType =
+                SecondParamType->getAs<DecayedType>()) {
+          DiagMethodNote(MethodParameterType)
+              << (I + 1) << SecondParamType << true
+              << ParamDecayedType->getOriginalType();
+        } else {
+          DiagMethodNote(MethodParameterType)
+              << (I + 1) << SecondParamType << false;
+        }
+        return true;
+      }
+
+      DeclarationName FirstParamName = FirstParam->getDeclName();
+      DeclarationName SecondParamName = SecondParam->getDeclName();
+      if (FirstParamName != SecondParamName) {
+        DiagMethodError(MethodParameterName) << (I + 1) << FirstParamName;
+        DiagMethodNote(MethodParameterName) << (I + 1) << SecondParamName;
+        return true;
+      }
+
+      const Expr *FirstInit = FirstParam->getInit();
+      const Expr *SecondInit = SecondParam->getInit();
+      if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
+        DiagMethodError(MethodParameterSingleDefaultArgument)
+            << (I + 1) << (FirstInit == nullptr)
+            << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
+        DiagMethodNote(MethodParameterSingleDefaultArgument)
+            << (I + 1) << (SecondInit == nullptr)
+            << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
+        return true;
+      }
+
+      if (FirstInit && SecondInit &&
+          computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
+        DiagMethodError(MethodParameterDifferentDefaultArgument)
+            << (I + 1) << FirstInit->getSourceRange();
+        DiagMethodNote(MethodParameterDifferentDefaultArgument)
+            << (I + 1) << SecondInit->getSourceRange();
+        return true;
+      }
+    }
+
+    const TemplateArgumentList *FirstTemplateArgs =
+        FirstMethod->getTemplateSpecializationArgs();
+    const TemplateArgumentList *SecondTemplateArgs =
+        SecondMethod->getTemplateSpecializationArgs();
+
+    if ((FirstTemplateArgs && !SecondTemplateArgs) ||
+        (!FirstTemplateArgs && SecondTemplateArgs)) {
+      DiagMethodError(MethodNoTemplateArguments)
+          << (FirstTemplateArgs != nullptr);
+      DiagMethodNote(MethodNoTemplateArguments)
+          << (SecondTemplateArgs != nullptr);
+      return true;
+    }
+
+    if (FirstTemplateArgs && SecondTemplateArgs) {
+      // Remove pack expansions from argument list.
+      auto ExpandTemplateArgumentList = [](const TemplateArgumentList *TAL) {
+        llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
+        for (const TemplateArgument &TA : TAL->asArray()) {
+          if (TA.getKind() != TemplateArgument::Pack) {
+            ExpandedList.push_back(&TA);
+            continue;
+          }
+          llvm::append_range(ExpandedList,
+                             llvm::make_pointer_range(TA.getPackAsArray()));
+        }
+        return ExpandedList;
+      };
+      llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
+          ExpandTemplateArgumentList(FirstTemplateArgs);
+      llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
+          ExpandTemplateArgumentList(SecondTemplateArgs);
+
+      if (FirstExpandedList.size() != SecondExpandedList.size()) {
+        DiagMethodError(MethodDifferentNumberTemplateArguments)
+            << (unsigned)FirstExpandedList.size();
+        DiagMethodNote(MethodDifferentNumberTemplateArguments)
+            << (unsigned)SecondExpandedList.size();
+        return true;
+      }
+
+      for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
+        const TemplateArgument &FirstTA = *FirstExpandedList[i],
+                               &SecondTA = *SecondExpandedList[i];
+        if (computeODRHash(FirstTA) == computeODRHash(SecondTA))
+          continue;
+
+        DiagMethodError(MethodDifferentTemplateArgument) << FirstTA << i + 1;
+        DiagMethodNote(MethodDifferentTemplateArgument) << SecondTA << i + 1;
+        return true;
+      }
+    }
+
+    // Compute the hash of the method as if it has no body.
+    auto ComputeCXXMethodODRHash = [](const CXXMethodDecl *D) {
+      ODRHash Hasher;
+      Hasher.AddFunctionDecl(D, true /*SkipBody*/);
+      return Hasher.CalculateHash();
+    };
+
+    // Compare the hash generated to the hash stored.  A difference means
+    // that a body was present in the original source.  Due to merging,
+    // the standard way of detecting a body will not work.
+    const bool HasFirstBody =
+        ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
+    const bool HasSecondBody =
+        ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
+
+    if (HasFirstBody != HasSecondBody) {
+      DiagMethodError(MethodSingleBody) << HasFirstBody;
+      DiagMethodNote(MethodSingleBody) << HasSecondBody;
+      return true;
+    }
+
+    if (HasFirstBody && HasSecondBody) {
+      DiagMethodError(MethodDifferentBody);
+      DiagMethodNote(MethodDifferentBody);
+      return true;
+    }
+
+    break;
+  }
+
+  case TypeAlias:
+  case TypeDef: {
+    if (diagnoseSubMismatchTypedef(FirstRecord, FirstModule, SecondModule,
+                                   cast<TypedefNameDecl>(FirstDecl),
+                                   cast<TypedefNameDecl>(SecondDecl),
+                                   FirstDiffType == TypeAlias))
+      return true;
+    break;
+  }
+  case Var: {
+    if (diagnoseSubMismatchVar(FirstRecord, FirstModule, SecondModule,
+                               cast<VarDecl>(FirstDecl),
+                               cast<VarDecl>(SecondDecl)))
+      return true;
+    break;
+  }
+  case Friend: {
+    const FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
+    const FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
+
+    const NamedDecl *FirstND = FirstFriend->getFriendDecl();
+    const NamedDecl *SecondND = SecondFriend->getFriendDecl();
+
+    TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
+    TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
+
+    if (FirstND && SecondND) {
+      DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
+                FriendFunction)
+          << FirstND;
+      DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
+               FriendFunction)
+          << SecondND;
+      return true;
+    }
+
+    if (FirstTSI && SecondTSI) {
+      QualType FirstFriendType = FirstTSI->getType();
+      QualType SecondFriendType = SecondTSI->getType();
+      assert(computeODRHash(FirstFriendType) !=
+             computeODRHash(SecondFriendType));
+      DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
+                FriendType)
+          << FirstFriendType;
+      DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
+               FriendType)
+          << SecondFriendType;
+      return true;
+    }
+
+    DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
+              FriendTypeFunction)
+        << (FirstTSI == nullptr);
+    DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
+             FriendTypeFunction)
+        << (SecondTSI == nullptr);
+    return true;
+  }
+  case FunctionTemplate: {
+    const FunctionTemplateDecl *FirstTemplate =
+        cast<FunctionTemplateDecl>(FirstDecl);
+    const FunctionTemplateDecl *SecondTemplate =
+        cast<FunctionTemplateDecl>(SecondDecl);
+
+    TemplateParameterList *FirstTPL = FirstTemplate->getTemplateParameters();
+    TemplateParameterList *SecondTPL = SecondTemplate->getTemplateParameters();
+
+    auto DiagTemplateError = [&DiagError,
+                              FirstTemplate](ODRCXXRecordDifference DiffType) {
+      return DiagError(FirstTemplate->getLocation(),
+                       FirstTemplate->getSourceRange(), DiffType)
+             << FirstTemplate;
+    };
+    auto DiagTemplateNote = [&DiagNote,
+                             SecondTemplate](ODRCXXRecordDifference DiffType) {
+      return DiagNote(SecondTemplate->getLocation(),
+                      SecondTemplate->getSourceRange(), DiffType)
+             << SecondTemplate;
+    };
+
+    if (FirstTPL->size() != SecondTPL->size()) {
+      DiagTemplateError(FunctionTemplateDifferentNumberParameters)
+          << FirstTPL->size();
+      DiagTemplateNote(FunctionTemplateDifferentNumberParameters)
+          << SecondTPL->size();
+      return true;
+    }
+
+    for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
+      NamedDecl *FirstParam = FirstTPL->getParam(i);
+      NamedDecl *SecondParam = SecondTPL->getParam(i);
+
+      if (FirstParam->getKind() != SecondParam->getKind()) {
+        enum {
+          TemplateTypeParameter,
+          NonTypeTemplateParameter,
+          TemplateTemplateParameter,
+        };
+        auto GetParamType = [](NamedDecl *D) {
+          switch (D->getKind()) {
+          default:
+            llvm_unreachable("Unexpected template parameter type");
+          case Decl::TemplateTypeParm:
+            return TemplateTypeParameter;
+          case Decl::NonTypeTemplateParm:
+            return NonTypeTemplateParameter;
+          case Decl::TemplateTemplateParm:
+            return TemplateTemplateParameter;
+          }
+        };
+
+        DiagTemplateError(FunctionTemplateParameterDifferentKind)
+            << (i + 1) << GetParamType(FirstParam);
+        DiagTemplateNote(FunctionTemplateParameterDifferentKind)
+            << (i + 1) << GetParamType(SecondParam);
+        return true;
+      }
+
+      if (FirstParam->getName() != SecondParam->getName()) {
+        DiagTemplateError(FunctionTemplateParameterName)
+            << (i + 1) << (bool)FirstParam->getIdentifier() << FirstParam;
+        DiagTemplateNote(FunctionTemplateParameterName)
+            << (i + 1) << (bool)SecondParam->getIdentifier() << SecondParam;
+        return true;
+      }
+
+      if (isa<TemplateTypeParmDecl>(FirstParam) &&
+          isa<TemplateTypeParmDecl>(SecondParam)) {
+        TemplateTypeParmDecl *FirstTTPD =
+            cast<TemplateTypeParmDecl>(FirstParam);
+        TemplateTypeParmDecl *SecondTTPD =
+            cast<TemplateTypeParmDecl>(SecondParam);
+        bool HasFirstDefaultArgument =
+            FirstTTPD->hasDefaultArgument() &&
+            !FirstTTPD->defaultArgumentWasInherited();
+        bool HasSecondDefaultArgument =
+            SecondTTPD->hasDefaultArgument() &&
+            !SecondTTPD->defaultArgumentWasInherited();
+        if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
+          DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
+              << (i + 1) << HasFirstDefaultArgument;
+          DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
+              << (i + 1) << HasSecondDefaultArgument;
+          return true;
+        }
+
+        if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
+          QualType FirstType = FirstTTPD->getDefaultArgument();
+          QualType SecondType = SecondTTPD->getDefaultArgument();
+          if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
+            DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
+                << (i + 1) << FirstType;
+            DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
+                << (i + 1) << SecondType;
+            return true;
+          }
+        }
+
+        if (FirstTTPD->isParameterPack() != SecondTTPD->isParameterPack()) {
+          DiagTemplateError(FunctionTemplatePackParameter)
+              << (i + 1) << FirstTTPD->isParameterPack();
+          DiagTemplateNote(FunctionTemplatePackParameter)
+              << (i + 1) << SecondTTPD->isParameterPack();
+          return true;
+        }
+      }
+
+      if (isa<TemplateTemplateParmDecl>(FirstParam) &&
+          isa<TemplateTemplateParmDecl>(SecondParam)) {
+        TemplateTemplateParmDecl *FirstTTPD =
+            cast<TemplateTemplateParmDecl>(FirstParam);
+        TemplateTemplateParmDecl *SecondTTPD =
+            cast<TemplateTemplateParmDecl>(SecondParam);
+
+        TemplateParameterList *FirstTPL = FirstTTPD->getTemplateParameters();
+        TemplateParameterList *SecondTPL = SecondTTPD->getTemplateParameters();
+
+        auto ComputeTemplateParameterListODRHash =
+            [](const TemplateParameterList *TPL) {
+              assert(TPL);
+              ODRHash Hasher;
+              Hasher.AddTemplateParameterList(TPL);
+              return Hasher.CalculateHash();
+            };
+
+        if (ComputeTemplateParameterListODRHash(FirstTPL) !=
+            ComputeTemplateParameterListODRHash(SecondTPL)) {
+          DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
+          DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
+          return true;
+        }
+
+        bool HasFirstDefaultArgument =
+            FirstTTPD->hasDefaultArgument() &&
+            !FirstTTPD->defaultArgumentWasInherited();
+        bool HasSecondDefaultArgument =
+            SecondTTPD->hasDefaultArgument() &&
+            !SecondTTPD->defaultArgumentWasInherited();
+        if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
+          DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
+              << (i + 1) << HasFirstDefaultArgument;
+          DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
+              << (i + 1) << HasSecondDefaultArgument;
+          return true;
+        }
+
+        if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
+          TemplateArgument FirstTA =
+              FirstTTPD->getDefaultArgument().getArgument();
+          TemplateArgument SecondTA =
+              SecondTTPD->getDefaultArgument().getArgument();
+          if (computeODRHash(FirstTA) != computeODRHash(SecondTA)) {
+            DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
+                << (i + 1) << FirstTA;
+            DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
+                << (i + 1) << SecondTA;
+            return true;
+          }
+        }
+
+        if (FirstTTPD->isParameterPack() != SecondTTPD->isParameterPack()) {
+          DiagTemplateError(FunctionTemplatePackParameter)
+              << (i + 1) << FirstTTPD->isParameterPack();
+          DiagTemplateNote(FunctionTemplatePackParameter)
+              << (i + 1) << SecondTTPD->isParameterPack();
+          return true;
+        }
+      }
+
+      if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
+          isa<NonTypeTemplateParmDecl>(SecondParam)) {
+        NonTypeTemplateParmDecl *FirstNTTPD =
+            cast<NonTypeTemplateParmDecl>(FirstParam);
+        NonTypeTemplateParmDecl *SecondNTTPD =
+            cast<NonTypeTemplateParmDecl>(SecondParam);
+
+        QualType FirstType = FirstNTTPD->getType();
+        QualType SecondType = SecondNTTPD->getType();
+        if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
+          DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
+          DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
+          return true;
+        }
+
+        bool HasFirstDefaultArgument =
+            FirstNTTPD->hasDefaultArgument() &&
+            !FirstNTTPD->defaultArgumentWasInherited();
+        bool HasSecondDefaultArgument =
+            SecondNTTPD->hasDefaultArgument() &&
+            !SecondNTTPD->defaultArgumentWasInherited();
+        if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
+          DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
+              << (i + 1) << HasFirstDefaultArgument;
+          DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
+              << (i + 1) << HasSecondDefaultArgument;
+          return true;
+        }
+
+        if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
+          Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
+          Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
+          if (computeODRHash(FirstDefaultArgument) !=
+              computeODRHash(SecondDefaultArgument)) {
+            DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
+                << (i + 1) << FirstDefaultArgument;
+            DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
+                << (i + 1) << SecondDefaultArgument;
+            return true;
+          }
+        }
+
+        if (FirstNTTPD->isParameterPack() != SecondNTTPD->isParameterPack()) {
+          DiagTemplateError(FunctionTemplatePackParameter)
+              << (i + 1) << FirstNTTPD->isParameterPack();
+          DiagTemplateNote(FunctionTemplatePackParameter)
+              << (i + 1) << SecondNTTPD->isParameterPack();
+          return true;
+        }
+      }
+    }
+    break;
+  }
+  }
+
+  Diag(FirstDecl->getLocation(),
+       diag::err_module_odr_violation_mismatch_decl_unknown)
+      << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
+      << FirstDecl->getSourceRange();
+  Diag(SecondDecl->getLocation(),
+       diag::note_module_odr_violation_mismatch_decl_unknown)
+      << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
+  return true;
+}
+
+bool ODRDiagsEmitter::diagnoseMismatch(
+    const FunctionDecl *FirstFunction,
+    const FunctionDecl *SecondFunction) const {
+  if (FirstFunction == SecondFunction)
+    return false;
+
+  // Keep in sync with select options in err_module_odr_violation_function.
+  enum ODRFunctionDifference {
+    ReturnType,
+    ParameterName,
+    ParameterType,
+    ParameterSingleDefaultArgument,
+    ParameterDifferentDefaultArgument,
+    FunctionBody,
+  };
+
+  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
+  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondFunction);
+
+  auto DiagError = [FirstFunction, &FirstModule,
+                    this](SourceLocation Loc, SourceRange Range,
+                          ODRFunctionDifference DiffType) {
+    return Diag(Loc, diag::err_module_odr_violation_function)
+           << FirstFunction << FirstModule.empty() << FirstModule << Range
+           << DiffType;
+  };
+  auto DiagNote = [&SecondModule, this](SourceLocation Loc, SourceRange Range,
+                                        ODRFunctionDifference DiffType) {
+    return Diag(Loc, diag::note_module_odr_violation_function)
+           << SecondModule << Range << DiffType;
+  };
+
+  if (computeODRHash(FirstFunction->getReturnType()) !=
+      computeODRHash(SecondFunction->getReturnType())) {
+    DiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
+              FirstFunction->getReturnTypeSourceRange(), ReturnType)
+        << FirstFunction->getReturnType();
+    DiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
+             SecondFunction->getReturnTypeSourceRange(), ReturnType)
+        << SecondFunction->getReturnType();
+    return true;
+  }
+
+  assert(FirstFunction->param_size() == SecondFunction->param_size() &&
+         "Merged functions with different number of parameters");
+
+  size_t ParamSize = FirstFunction->param_size();
+  for (unsigned I = 0; I < ParamSize; ++I) {
+    const ParmVarDecl *FirstParam = FirstFunction->getParamDecl(I);
+    const ParmVarDecl *SecondParam = SecondFunction->getParamDecl(I);
+
+    assert(Context.hasSameType(FirstParam->getType(), SecondParam->getType()) &&
+           "Merged function has different parameter types.");
+
+    if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
+      DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
+                ParameterName)
+          << I + 1 << FirstParam->getDeclName();
+      DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
+               ParameterName)
+          << I + 1 << SecondParam->getDeclName();
+      return true;
+    };
+
+    QualType FirstParamType = FirstParam->getType();
+    QualType SecondParamType = SecondParam->getType();
+    if (FirstParamType != SecondParamType &&
+        computeODRHash(FirstParamType) != computeODRHash(SecondParamType)) {
+      if (const DecayedType *ParamDecayedType =
+              FirstParamType->getAs<DecayedType>()) {
+        DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
+                  ParameterType)
+            << (I + 1) << FirstParamType << true
+            << ParamDecayedType->getOriginalType();
+      } else {
+        DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
+                  ParameterType)
+            << (I + 1) << FirstParamType << false;
+      }
+
+      if (const DecayedType *ParamDecayedType =
+              SecondParamType->getAs<DecayedType>()) {
+        DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
+                 ParameterType)
+            << (I + 1) << SecondParamType << true
+            << ParamDecayedType->getOriginalType();
+      } else {
+        DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
+                 ParameterType)
+            << (I + 1) << SecondParamType << false;
+      }
+      return true;
+    }
+
+    const Expr *FirstInit = FirstParam->getInit();
+    const Expr *SecondInit = SecondParam->getInit();
+    if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
+      DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
+                ParameterSingleDefaultArgument)
+          << (I + 1) << (FirstInit == nullptr)
+          << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
+      DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
+               ParameterSingleDefaultArgument)
+          << (I + 1) << (SecondInit == nullptr)
+          << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
+      return true;
+    }
+
+    if (FirstInit && SecondInit &&
+        computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
+      DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
+                ParameterDifferentDefaultArgument)
+          << (I + 1) << FirstInit->getSourceRange();
+      DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
+               ParameterDifferentDefaultArgument)
+          << (I + 1) << SecondInit->getSourceRange();
+      return true;
+    }
+
+    assert(computeODRHash(FirstParam) == computeODRHash(SecondParam) &&
+           "Undiagnosed parameter difference.");
+  }
+
+  // If no error has been generated before now, assume the problem is in
+  // the body and generate a message.
+  DiagError(FirstFunction->getLocation(), FirstFunction->getSourceRange(),
+            FunctionBody);
+  DiagNote(SecondFunction->getLocation(), SecondFunction->getSourceRange(),
+           FunctionBody);
+  return true;
+}
+
+bool ODRDiagsEmitter::diagnoseMismatch(const EnumDecl *FirstEnum,
+                                       const EnumDecl *SecondEnum) const {
+  if (FirstEnum == SecondEnum)
+    return false;
+
+  // Keep in sync with select options in err_module_odr_violation_enum.
+  enum ODREnumDifference {
+    SingleScopedEnum,
+    EnumTagKeywordMismatch,
+    SingleSpecifiedType,
+    DifferentSpecifiedTypes,
+    DifferentNumberEnumConstants,
+    EnumConstantName,
+    EnumConstantSingleInitializer,
+    EnumConstantDifferentInitializer,
+  };
+
+  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
+  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondEnum);
+
+  auto DiagError = [FirstEnum, &FirstModule, this](const auto *DiagAnchor,
+                                                   ODREnumDifference DiffType) {
+    return Diag(DiagAnchor->getLocation(), diag::err_module_odr_violation_enum)
+           << FirstEnum << FirstModule.empty() << FirstModule
+           << DiagAnchor->getSourceRange() << DiffType;
+  };
+  auto DiagNote = [&SecondModule, this](const auto *DiagAnchor,
+                                        ODREnumDifference DiffType) {
+    return Diag(DiagAnchor->getLocation(), diag::note_module_odr_violation_enum)
+           << SecondModule << DiagAnchor->getSourceRange() << DiffType;
+  };
+
+  if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
+    DiagError(FirstEnum, SingleScopedEnum) << FirstEnum->isScoped();
+    DiagNote(SecondEnum, SingleScopedEnum) << SecondEnum->isScoped();
+    return true;
+  }
+
+  if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
+    if (FirstEnum->isScopedUsingClassTag() !=
+        SecondEnum->isScopedUsingClassTag()) {
+      DiagError(FirstEnum, EnumTagKeywordMismatch)
+          << FirstEnum->isScopedUsingClassTag();
+      DiagNote(SecondEnum, EnumTagKeywordMismatch)
+          << SecondEnum->isScopedUsingClassTag();
+      return true;
+    }
+  }
+
+  QualType FirstUnderlyingType =
+      FirstEnum->getIntegerTypeSourceInfo()
+          ? FirstEnum->getIntegerTypeSourceInfo()->getType()
+          : QualType();
+  QualType SecondUnderlyingType =
+      SecondEnum->getIntegerTypeSourceInfo()
+          ? SecondEnum->getIntegerTypeSourceInfo()->getType()
+          : QualType();
+  if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
+    DiagError(FirstEnum, SingleSpecifiedType) << !FirstUnderlyingType.isNull();
+    DiagNote(SecondEnum, SingleSpecifiedType) << !SecondUnderlyingType.isNull();
+    return true;
+  }
+
+  if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
+    if (computeODRHash(FirstUnderlyingType) !=
+        computeODRHash(SecondUnderlyingType)) {
+      DiagError(FirstEnum, DifferentSpecifiedTypes) << FirstUnderlyingType;
+      DiagNote(SecondEnum, DifferentSpecifiedTypes) << SecondUnderlyingType;
+      return true;
+    }
+  }
+
+  // Compare enum constants.
+  using DeclHashes =
+      llvm::SmallVector<std::pair<const EnumConstantDecl *, unsigned>, 4>;
+  auto PopulateHashes = [FirstEnum](DeclHashes &Hashes, const EnumDecl *Enum) {
+    for (const Decl *D : Enum->decls()) {
+      // Due to decl merging, the first EnumDecl is the parent of
+      // Decls in both records.
+      if (!ODRHash::isDeclToBeProcessed(D, FirstEnum))
+        continue;
+      assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
+      Hashes.emplace_back(cast<EnumConstantDecl>(D), computeODRHash(D));
+    }
+  };
+  DeclHashes FirstHashes;
+  PopulateHashes(FirstHashes, FirstEnum);
+  DeclHashes SecondHashes;
+  PopulateHashes(SecondHashes, SecondEnum);
+
+  if (FirstHashes.size() != SecondHashes.size()) {
+    DiagError(FirstEnum, DifferentNumberEnumConstants)
+        << (int)FirstHashes.size();
+    DiagNote(SecondEnum, DifferentNumberEnumConstants)
+        << (int)SecondHashes.size();
+    return true;
+  }
+
+  for (unsigned I = 0, N = FirstHashes.size(); I < N; ++I) {
+    if (FirstHashes[I].second == SecondHashes[I].second)
+      continue;
+    const EnumConstantDecl *FirstConstant = FirstHashes[I].first;
+    const EnumConstantDecl *SecondConstant = SecondHashes[I].first;
+
+    if (FirstConstant->getDeclName() != SecondConstant->getDeclName()) {
+      DiagError(FirstConstant, EnumConstantName) << I + 1 << FirstConstant;
+      DiagNote(SecondConstant, EnumConstantName) << I + 1 << SecondConstant;
+      return true;
+    }
+
+    const Expr *FirstInit = FirstConstant->getInitExpr();
+    const Expr *SecondInit = SecondConstant->getInitExpr();
+    if (!FirstInit && !SecondInit)
+      continue;
+
+    if (!FirstInit || !SecondInit) {
+      DiagError(FirstConstant, EnumConstantSingleInitializer)
+          << I + 1 << FirstConstant << (FirstInit != nullptr);
+      DiagNote(SecondConstant, EnumConstantSingleInitializer)
+          << I + 1 << SecondConstant << (SecondInit != nullptr);
+      return true;
+    }
+
+    if (computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
+      DiagError(FirstConstant, EnumConstantDifferentInitializer)
+          << I + 1 << FirstConstant;
+      DiagNote(SecondConstant, EnumConstantDifferentInitializer)
+          << I + 1 << SecondConstant;
+      return true;
+    }
+  }
+  return false;
+}

clang/lib/Serialization/ASTReader.cpp

 #include "clang/AST/DeclGroup.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/ODRDiagsEmitter.h"
 #include "clang/AST/ODRHash.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeLocVisitor.h"
void ASTReader::finishPendingActions() {
   PendingBodies.clear();
 
   // Do some cleanup.
   for (auto *ND : PendingMergedDefinitionsToDeduplicate)
     getContext().deduplicateMergedDefinitonsFor(ND);
   PendingMergedDefinitionsToDeduplicate.clear();
 }
 
-namespace clang {
-class ODRDiagsEmitter {
-public:
-  ODRDiagsEmitter(DiagnosticsEngine &Diags, const ASTContext &Context,
-                  const LangOptions &LangOpts)
-      : Diags(Diags), Context(Context), LangOpts(LangOpts) {}
-
-  bool diagnoseMismatch(const FunctionDecl *FirstFunction,
-                        const FunctionDecl *SecondFunction) const;
-
-  bool diagnoseMismatch(const EnumDecl *FirstEnum,
-                        const EnumDecl *SecondEnum) const;
-
-  bool
-  diagnoseMismatch(const CXXRecordDecl *FirstRecord,
-                   const CXXRecordDecl *SecondRecord,
-                   const struct CXXRecordDecl::DefinitionData *SecondDD) const;
-
-private:
-  using DeclHashes = llvm::SmallVector<std::pair<const Decl *, unsigned>, 4>;
-
-  // Used with err_module_odr_violation_mismatch_decl and
-  // note_module_odr_violation_mismatch_decl
-  // This list should be the same Decl's as in ODRHash::isDeclToBeProcessed
-  enum ODRMismatchDecl {
-    EndOfClass,
-    PublicSpecifer,
-    PrivateSpecifer,
-    ProtectedSpecifer,
-    StaticAssert,
-    Field,
-    CXXMethod,
-    TypeAlias,
-    TypeDef,
-    Var,
-    Friend,
-    FunctionTemplate,
-    Other
-  };
-
-  struct DiffResult {
-    const Decl *FirstDecl = nullptr, *SecondDecl = nullptr;
-    ODRMismatchDecl FirstDiffType = Other, SecondDiffType = Other;
-  };
-
-  // If there is a diagnoseable difference, FirstDiffType and
-  // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
-  // filled in if not EndOfClass.
-  static DiffResult FindTypeDiffs(DeclHashes &FirstHashes,
-                                  DeclHashes &SecondHashes);
-
-  DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const {
-    return Diags.Report(Loc, DiagID);
-  }
-
-  // Use this to diagnose that an unexpected Decl was encountered
-  // or no difference was detected. This causes a generic error
-  // message to be emitted.
-  void diagnoseSubMismatchUnexpected(DiffResult &DR,
-                                     const NamedDecl *FirstRecord,
-                                     StringRef FirstModule,
-                                     const NamedDecl *SecondRecord,
-                                     StringRef SecondModule) const;
-
-  void diagnoseSubMismatchDifferentDeclKinds(DiffResult &DR,
-                                             const NamedDecl *FirstRecord,
-                                             StringRef FirstModule,
-                                             const NamedDecl *SecondRecord,
-                                             StringRef SecondModule) const;
-
-  bool diagnoseSubMismatchField(const NamedDecl *FirstRecord,
-                                StringRef FirstModule, StringRef SecondModule,
-                                const FieldDecl *FirstField,
-                                const FieldDecl *SecondField) const;
-
-  bool diagnoseSubMismatchTypedef(const NamedDecl *FirstRecord,
-                                  StringRef FirstModule, StringRef SecondModule,
-                                  const TypedefNameDecl *FirstTD,
-                                  const TypedefNameDecl *SecondTD,
-                                  bool IsTypeAlias) const;
-
-  bool diagnoseSubMismatchVar(const NamedDecl *FirstRecord,
-                              StringRef FirstModule, StringRef SecondModule,
-                              const VarDecl *FirstVD,
-                              const VarDecl *SecondVD) const;
-
-private:
-  DiagnosticsEngine &Diags;
-  const ASTContext &Context;
-  const LangOptions &LangOpts;
-};
-} // namespace clang
-
-static unsigned computeODRHash(QualType Ty) {
-  ODRHash Hasher;
-  Hasher.AddQualType(Ty);
-  return Hasher.CalculateHash();
-}
-
-static unsigned computeODRHash(const Stmt *S) {
-  ODRHash Hasher;
-  Hasher.AddStmt(S);
-  return Hasher.CalculateHash();
-}
-
-static unsigned computeODRHash(const Decl *D) {
-  assert(D);
-  ODRHash Hasher;
-  Hasher.AddSubDecl(D);
-  return Hasher.CalculateHash();
-}
-
-static unsigned computeODRHash(const TemplateArgument &TA) {
-  ODRHash Hasher;
-  Hasher.AddTemplateArgument(TA);
-  return Hasher.CalculateHash();
-}
-
-static std::string getOwningModuleNameForDiagnostic(const Decl *D) {
-  // If we know the owning module, use it.
-  if (Module *M = D->getImportedOwningModule())
-    return M->getFullModuleName();
-
-  // Not from a module.
-  return {};
-}
-
 void ASTReader::diagnoseOdrViolations() {
   if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
       PendingFunctionOdrMergeFailures.empty() &&
       PendingEnumOdrMergeFailures.empty())
     return;
 
   // Trigger the import of the full definition of each class that had any
   // odr-merging problems, so we can produce better diagnostics for them.
for (auto &SecondEnum : Merge.second) {
         break;
       }
     }
     (void)Diagnosed;
     assert(Diagnosed && "Unable to emit ODR diagnostic.");
   }
 }
 
-bool ODRDiagsEmitter::diagnoseSubMismatchField(
-    const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
-    const FieldDecl *FirstField, const FieldDecl *SecondField) const {
-  enum ODRFieldDifference {
-    FieldName,
-    FieldTypeName,
-    FieldSingleBitField,
-    FieldDifferentWidthBitField,
-    FieldSingleMutable,
-    FieldSingleInitializer,
-    FieldDifferentInitializers,
-  };
-
-  auto DiagError = [FirstRecord, FirstField, FirstModule,
-                    this](ODRFieldDifference DiffType) {
-    return Diag(FirstField->getLocation(), diag::err_module_odr_violation_field)
-           << FirstRecord << FirstModule.empty() << FirstModule
-           << FirstField->getSourceRange() << DiffType;
-  };
-  auto DiagNote = [SecondField, SecondModule,
-                   this](ODRFieldDifference DiffType) {
-    return Diag(SecondField->getLocation(),
-                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;
-    return true;
-  }
-
-  assert(Context.hasSameType(FirstField->getType(), SecondField->getType()));
-
-  QualType FirstType = FirstField->getType();
-  QualType SecondType = SecondField->getType();
-  if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
-    DiagError(FieldTypeName) << FirstII << FirstType;
-    DiagNote(FieldTypeName) << SecondII << SecondType;
-    return true;
-  }
-
-  const bool IsFirstBitField = FirstField->isBitField();
-  const bool IsSecondBitField = SecondField->isBitField();
-  if (IsFirstBitField != IsSecondBitField) {
-    DiagError(FieldSingleBitField) << FirstII << IsFirstBitField;
-    DiagNote(FieldSingleBitField) << SecondII << IsSecondBitField;
-    return true;
-  }
-
-  if (IsFirstBitField && IsSecondBitField) {
-    unsigned FirstBitWidthHash = computeODRHash(FirstField->getBitWidth());
-    unsigned SecondBitWidthHash = computeODRHash(SecondField->getBitWidth());
-    if (FirstBitWidthHash != SecondBitWidthHash) {
-      DiagError(FieldDifferentWidthBitField)
-          << FirstII << FirstField->getBitWidth()->getSourceRange();
-      DiagNote(FieldDifferentWidthBitField)
-          << SecondII << SecondField->getBitWidth()->getSourceRange();
-      return true;
-    }
-  }
-
-  if (!LangOpts.CPlusPlus)
-    return false;
-
-  const bool IsFirstMutable = FirstField->isMutable();
-  const bool IsSecondMutable = SecondField->isMutable();
-  if (IsFirstMutable != IsSecondMutable) {
-    DiagError(FieldSingleMutable) << FirstII << IsFirstMutable;
-    DiagNote(FieldSingleMutable) << SecondII << IsSecondMutable;
-    return true;
-  }
-
-  const Expr *FirstInitializer = FirstField->getInClassInitializer();
-  const Expr *SecondInitializer = SecondField->getInClassInitializer();
-  if ((!FirstInitializer && SecondInitializer) ||
-      (FirstInitializer && !SecondInitializer)) {
-    DiagError(FieldSingleInitializer)
-        << FirstII << (FirstInitializer != nullptr);
-    DiagNote(FieldSingleInitializer)
-        << SecondII << (SecondInitializer != nullptr);
-    return true;
-  }
-
-  if (FirstInitializer && SecondInitializer) {
-    unsigned FirstInitHash = computeODRHash(FirstInitializer);
-    unsigned SecondInitHash = computeODRHash(SecondInitializer);
-    if (FirstInitHash != SecondInitHash) {
-      DiagError(FieldDifferentInitializers)
-          << FirstII << FirstInitializer->getSourceRange();
-      DiagNote(FieldDifferentInitializers)
-          << SecondII << SecondInitializer->getSourceRange();
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool ODRDiagsEmitter::diagnoseSubMismatchTypedef(
-    const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
-    const TypedefNameDecl *FirstTD, const TypedefNameDecl *SecondTD,
-    bool IsTypeAlias) const {
-  enum ODRTypedefDifference {
-    TypedefName,
-    TypedefType,
-  };
-
-  auto DiagError = [FirstRecord, FirstTD, FirstModule,
-                    this](ODRTypedefDifference DiffType) {
-    return Diag(FirstTD->getLocation(), diag::err_module_odr_violation_typedef)
-           << FirstRecord << FirstModule.empty() << FirstModule
-           << FirstTD->getSourceRange() << DiffType;
-  };
-  auto DiagNote = [SecondTD, SecondModule,
-                   this](ODRTypedefDifference DiffType) {
-    return Diag(SecondTD->getLocation(),
-                diag::note_module_odr_violation_typedef)
-           << SecondModule << SecondTD->getSourceRange() << DiffType;
-  };
-
-  DeclarationName FirstName = FirstTD->getDeclName();
-  DeclarationName SecondName = SecondTD->getDeclName();
-  if (FirstName != SecondName) {
-    DiagError(TypedefName) << IsTypeAlias << FirstName;
-    DiagNote(TypedefName) << IsTypeAlias << SecondName;
-    return true;
-  }
-
-  QualType FirstType = FirstTD->getUnderlyingType();
-  QualType SecondType = SecondTD->getUnderlyingType();
-  if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
-    DiagError(TypedefType) << IsTypeAlias << FirstName << FirstType;
-    DiagNote(TypedefType) << IsTypeAlias << SecondName << SecondType;
-    return true;
-  }
-  return false;
-}
-
-bool ODRDiagsEmitter::diagnoseSubMismatchVar(const NamedDecl *FirstRecord,
-                                             StringRef FirstModule,
-                                             StringRef SecondModule,
-                                             const VarDecl *FirstVD,
-                                             const VarDecl *SecondVD) const {
-  enum ODRVarDifference {
-    VarName,
-    VarType,
-    VarSingleInitializer,
-    VarDifferentInitializer,
-    VarConstexpr,
-  };
-
-  auto DiagError = [FirstRecord, FirstVD, FirstModule,
-                    this](ODRVarDifference DiffType) {
-    return Diag(FirstVD->getLocation(), diag::err_module_odr_violation_variable)
-           << FirstRecord << FirstModule.empty() << FirstModule
-           << FirstVD->getSourceRange() << DiffType;
-  };
-  auto DiagNote = [SecondVD, SecondModule, this](ODRVarDifference DiffType) {
-    return Diag(SecondVD->getLocation(),
-                diag::note_module_odr_violation_variable)
-           << SecondModule << SecondVD->getSourceRange() << DiffType;
-  };
-
-  DeclarationName FirstName = FirstVD->getDeclName();
-  DeclarationName SecondName = SecondVD->getDeclName();
-  if (FirstName != SecondName) {
-    DiagError(VarName) << FirstName;
-    DiagNote(VarName) << SecondName;
-    return true;
-  }
-
-  QualType FirstType = FirstVD->getType();
-  QualType SecondType = SecondVD->getType();
-  if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
-    DiagError(VarType) << FirstName << FirstType;
-    DiagNote(VarType) << SecondName << SecondType;
-    return true;
-  }
-
-  if (!LangOpts.CPlusPlus)
-    return false;
-
-  const Expr *FirstInit = FirstVD->getInit();
-  const Expr *SecondInit = SecondVD->getInit();
-  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
-    DiagError(VarSingleInitializer)
-        << FirstName << (FirstInit == nullptr)
-        << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
-    DiagNote(VarSingleInitializer)
-        << SecondName << (SecondInit == nullptr)
-        << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
-    return true;
-  }
-
-  if (FirstInit && SecondInit &&
-      computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
-    DiagError(VarDifferentInitializer)
-        << FirstName << FirstInit->getSourceRange();
-    DiagNote(VarDifferentInitializer)
-        << SecondName << SecondInit->getSourceRange();
-    return true;
-  }
-
-  const bool FirstIsConstexpr = FirstVD->isConstexpr();
-  const bool SecondIsConstexpr = SecondVD->isConstexpr();
-  if (FirstIsConstexpr != SecondIsConstexpr) {
-    DiagError(VarConstexpr) << FirstName << FirstIsConstexpr;
-    DiagNote(VarConstexpr) << SecondName << SecondIsConstexpr;
-    return true;
-  }
-  return false;
-}
-
-ODRDiagsEmitter::DiffResult
-ODRDiagsEmitter::FindTypeDiffs(DeclHashes &FirstHashes,
-                               DeclHashes &SecondHashes) {
-  auto DifferenceSelector = [](const Decl *D) {
-    assert(D && "valid Decl required");
-    switch (D->getKind()) {
-    default:
-      return Other;
-    case Decl::AccessSpec:
-      switch (D->getAccess()) {
-      case AS_public:
-        return PublicSpecifer;
-      case AS_private:
-        return PrivateSpecifer;
-      case AS_protected:
-        return ProtectedSpecifer;
-      case AS_none:
-        break;
-      }
-      llvm_unreachable("Invalid access specifier");
-    case Decl::StaticAssert:
-      return StaticAssert;
-    case Decl::Field:
-      return Field;
-    case Decl::CXXMethod:
-    case Decl::CXXConstructor:
-    case Decl::CXXDestructor:
-      return CXXMethod;
-    case Decl::TypeAlias:
-      return TypeAlias;
-    case Decl::Typedef:
-      return TypeDef;
-    case Decl::Var:
-      return Var;
-    case Decl::Friend:
-      return Friend;
-    case Decl::FunctionTemplate:
-      return FunctionTemplate;
-    }
-  };
-
-  DiffResult DR;
-  auto FirstIt = FirstHashes.begin();
-  auto SecondIt = SecondHashes.begin();
-  while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
-    if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
-        FirstIt->second == SecondIt->second) {
-      ++FirstIt;
-      ++SecondIt;
-      continue;
-    }
-
-    DR.FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
-    DR.SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
-
-    DR.FirstDiffType =
-        DR.FirstDecl ? DifferenceSelector(DR.FirstDecl) : EndOfClass;
-    DR.SecondDiffType =
-        DR.SecondDecl ? DifferenceSelector(DR.SecondDecl) : EndOfClass;
-    return DR;
-  }
-  return DR;
-}
-
-void ODRDiagsEmitter::diagnoseSubMismatchUnexpected(
-    DiffResult &DR, const NamedDecl *FirstRecord, StringRef FirstModule,
-    const NamedDecl *SecondRecord, StringRef SecondModule) const {
-  Diag(FirstRecord->getLocation(),
-       diag::err_module_odr_violation_different_definitions)
-      << FirstRecord << FirstModule.empty() << FirstModule;
-
-  if (DR.FirstDecl) {
-    Diag(DR.FirstDecl->getLocation(), diag::note_first_module_difference)
-        << FirstRecord << DR.FirstDecl->getSourceRange();
-  }
-
-  Diag(SecondRecord->getLocation(),
-       diag::note_module_odr_violation_different_definitions)
-      << SecondModule;
-
-  if (DR.SecondDecl) {
-    Diag(DR.SecondDecl->getLocation(), diag::note_second_module_difference)
-        << DR.SecondDecl->getSourceRange();
-  }
-}
-
-void ODRDiagsEmitter::diagnoseSubMismatchDifferentDeclKinds(
-    DiffResult &DR, const NamedDecl *FirstRecord, StringRef FirstModule,
-    const NamedDecl *SecondRecord, StringRef SecondModule) const {
-  auto GetMismatchedDeclLoc = [](const NamedDecl *Container,
-                                 ODRMismatchDecl DiffType, const Decl *D) {
-    SourceLocation Loc;
-    SourceRange Range;
-    auto *Tag = dyn_cast<TagDecl>(Container);
-    if (DiffType == EndOfClass && Tag) {
-      Loc = Tag->getBraceRange().getEnd();
-    } else {
-      Loc = D->getLocation();
-      Range = D->getSourceRange();
-    }
-    return std::make_pair(Loc, Range);
-  };
-
-  auto FirstDiagInfo =
-      GetMismatchedDeclLoc(FirstRecord, DR.FirstDiffType, DR.FirstDecl);
-  Diag(FirstDiagInfo.first, diag::err_module_odr_violation_mismatch_decl)
-      << FirstRecord << FirstModule.empty() << FirstModule
-      << FirstDiagInfo.second << DR.FirstDiffType;
-
-  auto SecondDiagInfo =
-      GetMismatchedDeclLoc(SecondRecord, DR.SecondDiffType, DR.SecondDecl);
-  Diag(SecondDiagInfo.first, diag::note_module_odr_violation_mismatch_decl)
-      << SecondModule << SecondDiagInfo.second << DR.SecondDiffType;
-}
-
-bool ODRDiagsEmitter::diagnoseMismatch(
-    const CXXRecordDecl *FirstRecord, const CXXRecordDecl *SecondRecord,
-    const struct CXXRecordDecl::DefinitionData *SecondDD) const {
-  // Multiple different declarations got merged together; tell the user
-  // where they came from.
-  if (FirstRecord == SecondRecord)
-    return false;
-
-  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
-  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
-
-  const struct CXXRecordDecl::DefinitionData *FirstDD =
-      FirstRecord->DefinitionData;
-  assert(FirstDD && SecondDD && "Definitions without DefinitionData");
-
-  // Diagnostics from DefinitionData are emitted here.
-  if (FirstDD != SecondDD) {
-    // Keep in sync with err_module_odr_violation_definition_data.
-    enum ODRDefinitionDataDifference {
-      NumBases,
-      NumVBases,
-      BaseType,
-      BaseVirtual,
-      BaseAccess,
-    };
-    auto DiagBaseError = [FirstRecord, &FirstModule,
-                          this](SourceLocation Loc, SourceRange Range,
-                                ODRDefinitionDataDifference DiffType) {
-      return Diag(Loc, diag::err_module_odr_violation_definition_data)
-             << FirstRecord << FirstModule.empty() << FirstModule << Range
-             << DiffType;
-    };
-    auto DiagBaseNote = [&SecondModule,
-                         this](SourceLocation Loc, SourceRange Range,
-                               ODRDefinitionDataDifference DiffType) {
-      return Diag(Loc, diag::note_module_odr_violation_definition_data)
-             << SecondModule << Range << DiffType;
-    };
-    auto GetSourceRange = [](const struct CXXRecordDecl::DefinitionData *DD) {
-      unsigned NumBases = DD->NumBases;
-      if (NumBases == 0)
-        return SourceRange();
-      ArrayRef<CXXBaseSpecifier> bases = DD->bases();
-      return SourceRange(bases[0].getBeginLoc(),
-                         bases[NumBases - 1].getEndLoc());
-    };
-
-    unsigned FirstNumBases = FirstDD->NumBases;
-    unsigned FirstNumVBases = FirstDD->NumVBases;
-    unsigned SecondNumBases = SecondDD->NumBases;
-    unsigned SecondNumVBases = SecondDD->NumVBases;
-    if (FirstNumBases != SecondNumBases) {
-      DiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
-                    NumBases)
-          << FirstNumBases;
-      DiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
-                   NumBases)
-          << SecondNumBases;
-      return true;
-    }
-
-    if (FirstNumVBases != SecondNumVBases) {
-      DiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
-                    NumVBases)
-          << FirstNumVBases;
-      DiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
-                   NumVBases)
-          << SecondNumVBases;
-      return true;
-    }
-
-    ArrayRef<CXXBaseSpecifier> FirstBases = FirstDD->bases();
-    ArrayRef<CXXBaseSpecifier> SecondBases = SecondDD->bases();
-    for (unsigned I = 0; I < FirstNumBases; ++I) {
-      const CXXBaseSpecifier FirstBase = FirstBases[I];
-      const CXXBaseSpecifier SecondBase = SecondBases[I];
-      if (computeODRHash(FirstBase.getType()) !=
-          computeODRHash(SecondBase.getType())) {
-        DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
-                      BaseType)
-            << (I + 1) << FirstBase.getType();
-        DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
-                     BaseType)
-            << (I + 1) << SecondBase.getType();
-        return true;
-      }
-
-      if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
-        DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
-                      BaseVirtual)
-            << (I + 1) << FirstBase.isVirtual() << FirstBase.getType();
-        DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
-                     BaseVirtual)
-            << (I + 1) << SecondBase.isVirtual() << SecondBase.getType();
-        return true;
-      }
-
-      if (FirstBase.getAccessSpecifierAsWritten() !=
-          SecondBase.getAccessSpecifierAsWritten()) {
-        DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
-                      BaseAccess)
-            << (I + 1) << FirstBase.getType()
-            << (int)FirstBase.getAccessSpecifierAsWritten();
-        DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
-                     BaseAccess)
-            << (I + 1) << SecondBase.getType()
-            << (int)SecondBase.getAccessSpecifierAsWritten();
-        return true;
-      }
-    }
-  }
-
-  const ClassTemplateDecl *FirstTemplate =
-      FirstRecord->getDescribedClassTemplate();
-  const ClassTemplateDecl *SecondTemplate =
-      SecondRecord->getDescribedClassTemplate();
-
-  assert(!FirstTemplate == !SecondTemplate &&
-         "Both pointers should be null or non-null");
-
-  if (FirstTemplate && SecondTemplate) {
-    ArrayRef<const NamedDecl *> FirstTemplateParams =
-        FirstTemplate->getTemplateParameters()->asArray();
-    ArrayRef<const NamedDecl *> SecondTemplateParams =
-        SecondTemplate->getTemplateParameters()->asArray();
-    assert(FirstTemplateParams.size() == SecondTemplateParams.size() &&
-           "Number of template parameters should be equal.");
-    for (auto Pair : llvm::zip(FirstTemplateParams, SecondTemplateParams)) {
-      const NamedDecl *FirstDecl = std::get<0>(Pair);
-      const NamedDecl *SecondDecl = std::get<1>(Pair);
-      if (computeODRHash(FirstDecl) == computeODRHash(SecondDecl))
-        continue;
-
-      assert(FirstDecl->getKind() == SecondDecl->getKind() &&
-             "Parameter Decl's should be the same kind.");
-
-      enum ODRTemplateDifference {
-        ParamEmptyName,
-        ParamName,
-        ParamSingleDefaultArgument,
-        ParamDifferentDefaultArgument,
-      };
-
-      auto hasDefaultArg = [](const NamedDecl *D) {
-        if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
-          return TTP->hasDefaultArgument() &&
-                 !TTP->defaultArgumentWasInherited();
-        if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
-          return NTTP->hasDefaultArgument() &&
-                 !NTTP->defaultArgumentWasInherited();
-        auto *TTP = cast<TemplateTemplateParmDecl>(D);
-        return TTP->hasDefaultArgument() && !TTP->defaultArgumentWasInherited();
-      };
-      bool hasFirstArg = hasDefaultArg(FirstDecl);
-      bool hasSecondArg = hasDefaultArg(SecondDecl);
-
-      ODRTemplateDifference ErrDiffType;
-      ODRTemplateDifference NoteDiffType;
-
-      DeclarationName FirstName = FirstDecl->getDeclName();
-      DeclarationName SecondName = SecondDecl->getDeclName();
-
-      if (FirstName != SecondName) {
-        bool FirstNameEmpty =
-            FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
-        bool SecondNameEmpty =
-            SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
-        ErrDiffType = FirstNameEmpty ? ParamEmptyName : ParamName;
-        NoteDiffType = SecondNameEmpty ? ParamEmptyName : ParamName;
-      } else if (hasFirstArg == hasSecondArg)
-        ErrDiffType = NoteDiffType = ParamDifferentDefaultArgument;
-      else
-        ErrDiffType = NoteDiffType = ParamSingleDefaultArgument;
-
-      Diag(FirstDecl->getLocation(),
-           diag::err_module_odr_violation_template_parameter)
-          << FirstRecord << FirstModule.empty() << FirstModule
-          << FirstDecl->getSourceRange() << ErrDiffType << hasFirstArg
-          << FirstName;
-      Diag(SecondDecl->getLocation(),
-           diag::note_module_odr_violation_template_parameter)
-          << SecondModule << SecondDecl->getSourceRange() << NoteDiffType
-          << hasSecondArg << SecondName;
-      return true;
-    }
-  }
-
-  auto PopulateHashes = [](DeclHashes &Hashes, const RecordDecl *Record,
-                           const DeclContext *DC) {
-    for (const Decl *D : Record->decls()) {
-      if (!ODRHash::isDeclToBeProcessed(D, DC))
-        continue;
-      Hashes.emplace_back(D, computeODRHash(D));
-    }
-  };
-
-  DeclHashes FirstHashes;
-  DeclHashes SecondHashes;
-  const DeclContext *DC = FirstRecord;
-  PopulateHashes(FirstHashes, FirstRecord, DC);
-  PopulateHashes(SecondHashes, SecondRecord, DC);
-
-  DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
-  ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
-  ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
-  const Decl *FirstDecl = DR.FirstDecl;
-  const Decl *SecondDecl = DR.SecondDecl;
-
-  if (FirstDiffType == Other || SecondDiffType == Other) {
-    diagnoseSubMismatchUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
-                                  SecondModule);
-    return true;
-  }
-
-  if (FirstDiffType != SecondDiffType) {
-    diagnoseSubMismatchDifferentDeclKinds(DR, FirstRecord, FirstModule,
-                                          SecondRecord, SecondModule);
-    return true;
-  }
-
-  // Used with err_module_odr_violation_record and
-  // note_module_odr_violation_record
-  enum ODRCXXRecordDifference {
-    StaticAssertCondition,
-    StaticAssertMessage,
-    StaticAssertOnlyMessage,
-    MethodName,
-    MethodDeleted,
-    MethodDefaulted,
-    MethodVirtual,
-    MethodStatic,
-    MethodVolatile,
-    MethodConst,
-    MethodInline,
-    MethodNumberParameters,
-    MethodParameterType,
-    MethodParameterName,
-    MethodParameterSingleDefaultArgument,
-    MethodParameterDifferentDefaultArgument,
-    MethodNoTemplateArguments,
-    MethodDifferentNumberTemplateArguments,
-    MethodDifferentTemplateArgument,
-    MethodSingleBody,
-    MethodDifferentBody,
-    FriendTypeFunction,
-    FriendType,
-    FriendFunction,
-    FunctionTemplateDifferentNumberParameters,
-    FunctionTemplateParameterDifferentKind,
-    FunctionTemplateParameterName,
-    FunctionTemplateParameterSingleDefaultArgument,
-    FunctionTemplateParameterDifferentDefaultArgument,
-    FunctionTemplateParameterDifferentType,
-    FunctionTemplatePackParameter,
-  };
-  auto DiagError = [FirstRecord, &FirstModule,
-                    this](SourceLocation Loc, SourceRange Range,
-                          ODRCXXRecordDifference DiffType) {
-    return Diag(Loc, diag::err_module_odr_violation_record)
-           << FirstRecord << FirstModule.empty() << FirstModule << Range
-           << DiffType;
-  };
-  auto DiagNote = [&SecondModule, this](SourceLocation Loc, SourceRange Range,
-                                        ODRCXXRecordDifference DiffType) {
-    return Diag(Loc, diag::note_module_odr_violation_record)
-           << SecondModule << Range << DiffType;
-  };
-
-  assert(FirstDiffType == SecondDiffType);
-  switch (FirstDiffType) {
-  case Other:
-  case EndOfClass:
-  case PublicSpecifer:
-  case PrivateSpecifer:
-  case ProtectedSpecifer:
-    llvm_unreachable("Invalid diff type");
-
-  case StaticAssert: {
-    const StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
-    const StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
-
-    const Expr *FirstExpr = FirstSA->getAssertExpr();
-    const Expr *SecondExpr = SecondSA->getAssertExpr();
-    unsigned FirstODRHash = computeODRHash(FirstExpr);
-    unsigned SecondODRHash = computeODRHash(SecondExpr);
-    if (FirstODRHash != SecondODRHash) {
-      DiagError(FirstExpr->getBeginLoc(), FirstExpr->getSourceRange(),
-                StaticAssertCondition);
-      DiagNote(SecondExpr->getBeginLoc(), SecondExpr->getSourceRange(),
-               StaticAssertCondition);
-      return true;
-    }
-
-    const StringLiteral *FirstStr = FirstSA->getMessage();
-    const StringLiteral *SecondStr = SecondSA->getMessage();
-    assert((FirstStr || SecondStr) && "Both messages cannot be empty");
-    if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
-      SourceLocation FirstLoc, SecondLoc;
-      SourceRange FirstRange, SecondRange;
-      if (FirstStr) {
-        FirstLoc = FirstStr->getBeginLoc();
-        FirstRange = FirstStr->getSourceRange();
-      } else {
-        FirstLoc = FirstSA->getBeginLoc();
-        FirstRange = FirstSA->getSourceRange();
-      }
-      if (SecondStr) {
-        SecondLoc = SecondStr->getBeginLoc();
-        SecondRange = SecondStr->getSourceRange();
-      } else {
-        SecondLoc = SecondSA->getBeginLoc();
-        SecondRange = SecondSA->getSourceRange();
-      }
-      DiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
-          << (FirstStr == nullptr);
-      DiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
-          << (SecondStr == nullptr);
-      return true;
-    }
-
-    if (FirstStr && SecondStr &&
-        FirstStr->getString() != SecondStr->getString()) {
-      DiagError(FirstStr->getBeginLoc(), FirstStr->getSourceRange(),
-                StaticAssertMessage);
-      DiagNote(SecondStr->getBeginLoc(), SecondStr->getSourceRange(),
-               StaticAssertMessage);
-      return true;
-    }
-    break;
-  }
-
-  case Field: {
-    if (diagnoseSubMismatchField(FirstRecord, FirstModule, SecondModule,
-                                 cast<FieldDecl>(FirstDecl),
-                                 cast<FieldDecl>(SecondDecl)))
-      return true;
-    break;
-  }
-
-  case CXXMethod: {
-    enum {
-      DiagMethod,
-      DiagConstructor,
-      DiagDestructor,
-    } FirstMethodType,
-        SecondMethodType;
-    auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl *D) {
-      if (isa<CXXConstructorDecl>(D))
-        return DiagConstructor;
-      if (isa<CXXDestructorDecl>(D))
-        return DiagDestructor;
-      return DiagMethod;
-    };
-    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 = [&DiagError, FirstMethod, FirstMethodType,
-                            FirstName](ODRCXXRecordDifference DiffType) {
-      return DiagError(FirstMethod->getLocation(),
-                       FirstMethod->getSourceRange(), DiffType)
-             << FirstMethodType << FirstName;
-    };
-    auto DiagMethodNote = [&DiagNote, SecondMethod, SecondMethodType,
-                           SecondName](ODRCXXRecordDifference DiffType) {
-      return DiagNote(SecondMethod->getLocation(),
-                      SecondMethod->getSourceRange(), DiffType)
-             << SecondMethodType << SecondName;
-    };
-
-    if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
-      DiagMethodError(MethodName);
-      DiagMethodNote(MethodName);
-      return true;
-    }
-
-    const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
-    const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
-    if (FirstDeleted != SecondDeleted) {
-      DiagMethodError(MethodDeleted) << FirstDeleted;
-      DiagMethodNote(MethodDeleted) << SecondDeleted;
-      return true;
-    }
-
-    const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
-    const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
-    if (FirstDefaulted != SecondDefaulted) {
-      DiagMethodError(MethodDefaulted) << FirstDefaulted;
-      DiagMethodNote(MethodDefaulted) << SecondDefaulted;
-      return true;
-    }
-
-    const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
-    const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
-    const bool FirstPure = FirstMethod->isPure();
-    const bool SecondPure = SecondMethod->isPure();
-    if ((FirstVirtual || SecondVirtual) &&
-        (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
-      DiagMethodError(MethodVirtual) << FirstPure << FirstVirtual;
-      DiagMethodNote(MethodVirtual) << SecondPure << SecondVirtual;
-      return true;
-    }
-
-    // CXXMethodDecl::isStatic uses the canonical Decl.  With Decl merging,
-    // FirstDecl is the canonical Decl of SecondDecl, so the storage
-    // class needs to be checked instead.
-    StorageClass FirstStorage = FirstMethod->getStorageClass();
-    StorageClass SecondStorage = SecondMethod->getStorageClass();
-    const bool FirstStatic = FirstStorage == SC_Static;
-    const bool SecondStatic = SecondStorage == SC_Static;
-    if (FirstStatic != SecondStatic) {
-      DiagMethodError(MethodStatic) << FirstStatic;
-      DiagMethodNote(MethodStatic) << SecondStatic;
-      return true;
-    }
-
-    const bool FirstVolatile = FirstMethod->isVolatile();
-    const bool SecondVolatile = SecondMethod->isVolatile();
-    if (FirstVolatile != SecondVolatile) {
-      DiagMethodError(MethodVolatile) << FirstVolatile;
-      DiagMethodNote(MethodVolatile) << SecondVolatile;
-      return true;
-    }
-
-    const bool FirstConst = FirstMethod->isConst();
-    const bool SecondConst = SecondMethod->isConst();
-    if (FirstConst != SecondConst) {
-      DiagMethodError(MethodConst) << FirstConst;
-      DiagMethodNote(MethodConst) << SecondConst;
-      return true;
-    }
-
-    const bool FirstInline = FirstMethod->isInlineSpecified();
-    const bool SecondInline = SecondMethod->isInlineSpecified();
-    if (FirstInline != SecondInline) {
-      DiagMethodError(MethodInline) << FirstInline;
-      DiagMethodNote(MethodInline) << SecondInline;
-      return true;
-    }
-
-    const unsigned FirstNumParameters = FirstMethod->param_size();
-    const unsigned SecondNumParameters = SecondMethod->param_size();
-    if (FirstNumParameters != SecondNumParameters) {
-      DiagMethodError(MethodNumberParameters) << FirstNumParameters;
-      DiagMethodNote(MethodNumberParameters) << SecondNumParameters;
-      return true;
-    }
-
-    for (unsigned I = 0; I < FirstNumParameters; ++I) {
-      const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
-      const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
-
-      QualType FirstParamType = FirstParam->getType();
-      QualType SecondParamType = SecondParam->getType();
-      if (FirstParamType != SecondParamType &&
-          computeODRHash(FirstParamType) != computeODRHash(SecondParamType)) {
-        if (const DecayedType *ParamDecayedType =
-                FirstParamType->getAs<DecayedType>()) {
-          DiagMethodError(MethodParameterType)
-              << (I + 1) << FirstParamType << true
-              << ParamDecayedType->getOriginalType();
-        } else {
-          DiagMethodError(MethodParameterType)
-              << (I + 1) << FirstParamType << false;
-        }
-
-        if (const DecayedType *ParamDecayedType =
-                SecondParamType->getAs<DecayedType>()) {
-          DiagMethodNote(MethodParameterType)
-              << (I + 1) << SecondParamType << true
-              << ParamDecayedType->getOriginalType();
-        } else {
-          DiagMethodNote(MethodParameterType)
-              << (I + 1) << SecondParamType << false;
-        }
-        return true;
-      }
-
-      DeclarationName FirstParamName = FirstParam->getDeclName();
-      DeclarationName SecondParamName = SecondParam->getDeclName();
-      if (FirstParamName != SecondParamName) {
-        DiagMethodError(MethodParameterName) << (I + 1) << FirstParamName;
-        DiagMethodNote(MethodParameterName) << (I + 1) << SecondParamName;
-        return true;
-      }
-
-      const Expr *FirstInit = FirstParam->getInit();
-      const Expr *SecondInit = SecondParam->getInit();
-      if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
-        DiagMethodError(MethodParameterSingleDefaultArgument)
-            << (I + 1) << (FirstInit == nullptr)
-            << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
-        DiagMethodNote(MethodParameterSingleDefaultArgument)
-            << (I + 1) << (SecondInit == nullptr)
-            << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
-        return true;
-      }
-
-      if (FirstInit && SecondInit &&
-          computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
-        DiagMethodError(MethodParameterDifferentDefaultArgument)
-            << (I + 1) << FirstInit->getSourceRange();
-        DiagMethodNote(MethodParameterDifferentDefaultArgument)
-            << (I + 1) << SecondInit->getSourceRange();
-        return true;
-      }
-    }
-
-    const TemplateArgumentList *FirstTemplateArgs =
-        FirstMethod->getTemplateSpecializationArgs();
-    const TemplateArgumentList *SecondTemplateArgs =
-        SecondMethod->getTemplateSpecializationArgs();
-
-    if ((FirstTemplateArgs && !SecondTemplateArgs) ||
-        (!FirstTemplateArgs && SecondTemplateArgs)) {
-      DiagMethodError(MethodNoTemplateArguments)
-          << (FirstTemplateArgs != nullptr);
-      DiagMethodNote(MethodNoTemplateArguments)
-          << (SecondTemplateArgs != nullptr);
-      return true;
-    }
-
-    if (FirstTemplateArgs && SecondTemplateArgs) {
-      // Remove pack expansions from argument list.
-      auto ExpandTemplateArgumentList = [](const TemplateArgumentList *TAL) {
-        llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
-        for (const TemplateArgument &TA : TAL->asArray()) {
-          if (TA.getKind() != TemplateArgument::Pack) {
-            ExpandedList.push_back(&TA);
-            continue;
-          }
-          llvm::append_range(ExpandedList,
-                             llvm::make_pointer_range(TA.getPackAsArray()));
-        }
-        return ExpandedList;
-      };
-      llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
-          ExpandTemplateArgumentList(FirstTemplateArgs);
-      llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
-          ExpandTemplateArgumentList(SecondTemplateArgs);
-
-      if (FirstExpandedList.size() != SecondExpandedList.size()) {
-        DiagMethodError(MethodDifferentNumberTemplateArguments)
-            << (unsigned)FirstExpandedList.size();
-        DiagMethodNote(MethodDifferentNumberTemplateArguments)
-            << (unsigned)SecondExpandedList.size();
-        return true;
-      }
-
-      for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
-        const TemplateArgument &FirstTA = *FirstExpandedList[i],
-                               &SecondTA = *SecondExpandedList[i];
-        if (computeODRHash(FirstTA) == computeODRHash(SecondTA))
-          continue;
-
-        DiagMethodError(MethodDifferentTemplateArgument) << FirstTA << i + 1;
-        DiagMethodNote(MethodDifferentTemplateArgument) << SecondTA << i + 1;
-        return true;
-      }
-    }
-
-    // Compute the hash of the method as if it has no body.
-    auto ComputeCXXMethodODRHash = [](const CXXMethodDecl *D) {
-      ODRHash Hasher;
-      Hasher.AddFunctionDecl(D, true /*SkipBody*/);
-      return Hasher.CalculateHash();
-    };
-
-    // Compare the hash generated to the hash stored.  A difference means
-    // that a body was present in the original source.  Due to merging,
-    // the standard way of detecting a body will not work.
-    const bool HasFirstBody =
-        ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
-    const bool HasSecondBody =
-        ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
-
-    if (HasFirstBody != HasSecondBody) {
-      DiagMethodError(MethodSingleBody) << HasFirstBody;
-      DiagMethodNote(MethodSingleBody) << HasSecondBody;
-      return true;
-    }
-
-    if (HasFirstBody && HasSecondBody) {
-      DiagMethodError(MethodDifferentBody);
-      DiagMethodNote(MethodDifferentBody);
-      return true;
-    }
-
-    break;
-  }
-
-  case TypeAlias:
-  case TypeDef: {
-    if (diagnoseSubMismatchTypedef(FirstRecord, FirstModule, SecondModule,
-                                   cast<TypedefNameDecl>(FirstDecl),
-                                   cast<TypedefNameDecl>(SecondDecl),
-                                   FirstDiffType == TypeAlias))
-      return true;
-    break;
-  }
-  case Var: {
-    if (diagnoseSubMismatchVar(FirstRecord, FirstModule, SecondModule,
-                               cast<VarDecl>(FirstDecl),
-                               cast<VarDecl>(SecondDecl)))
-      return true;
-    break;
-  }
-  case Friend: {
-    const FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
-    const FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
-
-    const NamedDecl *FirstND = FirstFriend->getFriendDecl();
-    const NamedDecl *SecondND = SecondFriend->getFriendDecl();
-
-    TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
-    TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
-
-    if (FirstND && SecondND) {
-      DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
-                FriendFunction)
-          << FirstND;
-      DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
-               FriendFunction)
-          << SecondND;
-      return true;
-    }
-
-    if (FirstTSI && SecondTSI) {
-      QualType FirstFriendType = FirstTSI->getType();
-      QualType SecondFriendType = SecondTSI->getType();
-      assert(computeODRHash(FirstFriendType) !=
-             computeODRHash(SecondFriendType));
-      DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
-                FriendType)
-          << FirstFriendType;
-      DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
-               FriendType)
-          << SecondFriendType;
-      return true;
-    }
-
-    DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
-              FriendTypeFunction)
-        << (FirstTSI == nullptr);
-    DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
-             FriendTypeFunction)
-        << (SecondTSI == nullptr);
-    return true;
-  }
-  case FunctionTemplate: {
-    const FunctionTemplateDecl *FirstTemplate =
-        cast<FunctionTemplateDecl>(FirstDecl);
-    const FunctionTemplateDecl *SecondTemplate =
-        cast<FunctionTemplateDecl>(SecondDecl);
-
-    TemplateParameterList *FirstTPL = FirstTemplate->getTemplateParameters();
-    TemplateParameterList *SecondTPL = SecondTemplate->getTemplateParameters();
-
-    auto DiagTemplateError = [&DiagError,
-                              FirstTemplate](ODRCXXRecordDifference DiffType) {
-      return DiagError(FirstTemplate->getLocation(),
-                       FirstTemplate->getSourceRange(), DiffType)
-             << FirstTemplate;
-    };
-    auto DiagTemplateNote = [&DiagNote,
-                             SecondTemplate](ODRCXXRecordDifference DiffType) {
-      return DiagNote(SecondTemplate->getLocation(),
-                      SecondTemplate->getSourceRange(), DiffType)
-             << SecondTemplate;
-    };
-
-    if (FirstTPL->size() != SecondTPL->size()) {
-      DiagTemplateError(FunctionTemplateDifferentNumberParameters)
-          << FirstTPL->size();
-      DiagTemplateNote(FunctionTemplateDifferentNumberParameters)
-          << SecondTPL->size();
-      return true;
-    }
-
-    for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
-      NamedDecl *FirstParam = FirstTPL->getParam(i);
-      NamedDecl *SecondParam = SecondTPL->getParam(i);
-
-      if (FirstParam->getKind() != SecondParam->getKind()) {
-        enum {
-          TemplateTypeParameter,
-          NonTypeTemplateParameter,
-          TemplateTemplateParameter,
-        };
-        auto GetParamType = [](NamedDecl *D) {
-          switch (D->getKind()) {
-          default:
-            llvm_unreachable("Unexpected template parameter type");
-          case Decl::TemplateTypeParm:
-            return TemplateTypeParameter;
-          case Decl::NonTypeTemplateParm:
-            return NonTypeTemplateParameter;
-          case Decl::TemplateTemplateParm:
-            return TemplateTemplateParameter;
-          }
-        };
-
-        DiagTemplateError(FunctionTemplateParameterDifferentKind)
-            << (i + 1) << GetParamType(FirstParam);
-        DiagTemplateNote(FunctionTemplateParameterDifferentKind)
-            << (i + 1) << GetParamType(SecondParam);
-        return true;
-      }
-
-      if (FirstParam->getName() != SecondParam->getName()) {
-        DiagTemplateError(FunctionTemplateParameterName)
-            << (i + 1) << (bool)FirstParam->getIdentifier() << FirstParam;
-        DiagTemplateNote(FunctionTemplateParameterName)
-            << (i + 1) << (bool)SecondParam->getIdentifier() << SecondParam;
-        return true;
-      }
-
-      if (isa<TemplateTypeParmDecl>(FirstParam) &&
-          isa<TemplateTypeParmDecl>(SecondParam)) {
-        TemplateTypeParmDecl *FirstTTPD =
-            cast<TemplateTypeParmDecl>(FirstParam);
-        TemplateTypeParmDecl *SecondTTPD =
-            cast<TemplateTypeParmDecl>(SecondParam);
-        bool HasFirstDefaultArgument =
-            FirstTTPD->hasDefaultArgument() &&
-            !FirstTTPD->defaultArgumentWasInherited();
-        bool HasSecondDefaultArgument =
-            SecondTTPD->hasDefaultArgument() &&
-            !SecondTTPD->defaultArgumentWasInherited();
-        if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
-          DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
-              << (i + 1) << HasFirstDefaultArgument;
-          DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
-              << (i + 1) << HasSecondDefaultArgument;
-          return true;
-        }
-
-        if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
-          QualType FirstType = FirstTTPD->getDefaultArgument();
-          QualType SecondType = SecondTTPD->getDefaultArgument();
-          if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
-            DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
-                << (i + 1) << FirstType;
-            DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
-                << (i + 1) << SecondType;
-            return true;
-          }
-        }
-
-        if (FirstTTPD->isParameterPack() != SecondTTPD->isParameterPack()) {
-          DiagTemplateError(FunctionTemplatePackParameter)
-              << (i + 1) << FirstTTPD->isParameterPack();
-          DiagTemplateNote(FunctionTemplatePackParameter)
-              << (i + 1) << SecondTTPD->isParameterPack();
-          return true;
-        }
-      }
-
-      if (isa<TemplateTemplateParmDecl>(FirstParam) &&
-          isa<TemplateTemplateParmDecl>(SecondParam)) {
-        TemplateTemplateParmDecl *FirstTTPD =
-            cast<TemplateTemplateParmDecl>(FirstParam);
-        TemplateTemplateParmDecl *SecondTTPD =
-            cast<TemplateTemplateParmDecl>(SecondParam);
-
-        TemplateParameterList *FirstTPL = FirstTTPD->getTemplateParameters();
-        TemplateParameterList *SecondTPL = SecondTTPD->getTemplateParameters();
-
-        auto ComputeTemplateParameterListODRHash =
-            [](const TemplateParameterList *TPL) {
-              assert(TPL);
-              ODRHash Hasher;
-              Hasher.AddTemplateParameterList(TPL);
-              return Hasher.CalculateHash();
-            };
-
-        if (ComputeTemplateParameterListODRHash(FirstTPL) !=
-            ComputeTemplateParameterListODRHash(SecondTPL)) {
-          DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
-          DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
-          return true;
-        }
-
-        bool HasFirstDefaultArgument =
-            FirstTTPD->hasDefaultArgument() &&
-            !FirstTTPD->defaultArgumentWasInherited();
-        bool HasSecondDefaultArgument =
-            SecondTTPD->hasDefaultArgument() &&
-            !SecondTTPD->defaultArgumentWasInherited();
-        if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
-          DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
-              << (i + 1) << HasFirstDefaultArgument;
-          DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
-              << (i + 1) << HasSecondDefaultArgument;
-          return true;
-        }
-
-        if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
-          TemplateArgument FirstTA =
-              FirstTTPD->getDefaultArgument().getArgument();
-          TemplateArgument SecondTA =
-              SecondTTPD->getDefaultArgument().getArgument();
-          if (computeODRHash(FirstTA) != computeODRHash(SecondTA)) {
-            DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
-                << (i + 1) << FirstTA;
-            DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
-                << (i + 1) << SecondTA;
-            return true;
-          }
-        }
-
-        if (FirstTTPD->isParameterPack() != SecondTTPD->isParameterPack()) {
-          DiagTemplateError(FunctionTemplatePackParameter)
-              << (i + 1) << FirstTTPD->isParameterPack();
-          DiagTemplateNote(FunctionTemplatePackParameter)
-              << (i + 1) << SecondTTPD->isParameterPack();
-          return true;
-        }
-      }
-
-      if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
-          isa<NonTypeTemplateParmDecl>(SecondParam)) {
-        NonTypeTemplateParmDecl *FirstNTTPD =
-            cast<NonTypeTemplateParmDecl>(FirstParam);
-        NonTypeTemplateParmDecl *SecondNTTPD =
-            cast<NonTypeTemplateParmDecl>(SecondParam);
-
-        QualType FirstType = FirstNTTPD->getType();
-        QualType SecondType = SecondNTTPD->getType();
-        if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
-          DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
-          DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
-          return true;
-        }
-
-        bool HasFirstDefaultArgument =
-            FirstNTTPD->hasDefaultArgument() &&
-            !FirstNTTPD->defaultArgumentWasInherited();
-        bool HasSecondDefaultArgument =
-            SecondNTTPD->hasDefaultArgument() &&
-            !SecondNTTPD->defaultArgumentWasInherited();
-        if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
-          DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
-              << (i + 1) << HasFirstDefaultArgument;
-          DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
-              << (i + 1) << HasSecondDefaultArgument;
-          return true;
-        }
-
-        if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
-          Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
-          Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
-          if (computeODRHash(FirstDefaultArgument) !=
-              computeODRHash(SecondDefaultArgument)) {
-            DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
-                << (i + 1) << FirstDefaultArgument;
-            DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
-                << (i + 1) << SecondDefaultArgument;
-            return true;
-          }
-        }
-
-        if (FirstNTTPD->isParameterPack() != SecondNTTPD->isParameterPack()) {
-          DiagTemplateError(FunctionTemplatePackParameter)
-              << (i + 1) << FirstNTTPD->isParameterPack();
-          DiagTemplateNote(FunctionTemplatePackParameter)
-              << (i + 1) << SecondNTTPD->isParameterPack();
-          return true;
-        }
-      }
-    }
-    break;
-  }
-  }
-
-  Diag(FirstDecl->getLocation(),
-       diag::err_module_odr_violation_mismatch_decl_unknown)
-      << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
-      << FirstDecl->getSourceRange();
-  Diag(SecondDecl->getLocation(),
-       diag::note_module_odr_violation_mismatch_decl_unknown)
-      << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
-  return true;
-}
-
-bool ODRDiagsEmitter::diagnoseMismatch(
-    const FunctionDecl *FirstFunction,
-    const FunctionDecl *SecondFunction) const {
-  if (FirstFunction == SecondFunction)
-    return false;
-
-  // Keep in sync with select options in err_module_odr_violation_function.
-  enum ODRFunctionDifference {
-    ReturnType,
-    ParameterName,
-    ParameterType,
-    ParameterSingleDefaultArgument,
-    ParameterDifferentDefaultArgument,
-    FunctionBody,
-  };
-
-  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
-  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondFunction);
-
-  auto DiagError = [FirstFunction, &FirstModule,
-                    this](SourceLocation Loc, SourceRange Range,
-                          ODRFunctionDifference DiffType) {
-    return Diag(Loc, diag::err_module_odr_violation_function)
-           << FirstFunction << FirstModule.empty() << FirstModule << Range
-           << DiffType;
-  };
-  auto DiagNote = [&SecondModule, this](SourceLocation Loc, SourceRange Range,
-                                        ODRFunctionDifference DiffType) {
-    return Diag(Loc, diag::note_module_odr_violation_function)
-           << SecondModule << Range << DiffType;
-  };
-
-  if (computeODRHash(FirstFunction->getReturnType()) !=
-      computeODRHash(SecondFunction->getReturnType())) {
-    DiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
-              FirstFunction->getReturnTypeSourceRange(), ReturnType)
-        << FirstFunction->getReturnType();
-    DiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
-             SecondFunction->getReturnTypeSourceRange(), ReturnType)
-        << SecondFunction->getReturnType();
-    return true;
-  }
-
-  assert(FirstFunction->param_size() == SecondFunction->param_size() &&
-         "Merged functions with different number of parameters");
-
-  size_t ParamSize = FirstFunction->param_size();
-  for (unsigned I = 0; I < ParamSize; ++I) {
-    const ParmVarDecl *FirstParam = FirstFunction->getParamDecl(I);
-    const ParmVarDecl *SecondParam = SecondFunction->getParamDecl(I);
-
-    assert(Context.hasSameType(FirstParam->getType(), SecondParam->getType()) &&
-           "Merged function has different parameter types.");
-
-    if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
-      DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
-                ParameterName)
-          << I + 1 << FirstParam->getDeclName();
-      DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
-               ParameterName)
-          << I + 1 << SecondParam->getDeclName();
-      return true;
-    };
-
-    QualType FirstParamType = FirstParam->getType();
-    QualType SecondParamType = SecondParam->getType();
-    if (FirstParamType != SecondParamType &&
-        computeODRHash(FirstParamType) != computeODRHash(SecondParamType)) {
-      if (const DecayedType *ParamDecayedType =
-              FirstParamType->getAs<DecayedType>()) {
-        DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
-                  ParameterType)
-            << (I + 1) << FirstParamType << true
-            << ParamDecayedType->getOriginalType();
-      } else {
-        DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
-                  ParameterType)
-            << (I + 1) << FirstParamType << false;
-      }
-
-      if (const DecayedType *ParamDecayedType =
-              SecondParamType->getAs<DecayedType>()) {
-        DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
-                 ParameterType)
-            << (I + 1) << SecondParamType << true
-            << ParamDecayedType->getOriginalType();
-      } else {
-        DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
-                 ParameterType)
-            << (I + 1) << SecondParamType << false;
-      }
-      return true;
-    }
-
-    const Expr *FirstInit = FirstParam->getInit();
-    const Expr *SecondInit = SecondParam->getInit();
-    if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
-      DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
-                ParameterSingleDefaultArgument)
-          << (I + 1) << (FirstInit == nullptr)
-          << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
-      DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
-               ParameterSingleDefaultArgument)
-          << (I + 1) << (SecondInit == nullptr)
-          << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
-      return true;
-    }
-
-    if (FirstInit && SecondInit &&
-        computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
-      DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
-                ParameterDifferentDefaultArgument)
-          << (I + 1) << FirstInit->getSourceRange();
-      DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
-               ParameterDifferentDefaultArgument)
-          << (I + 1) << SecondInit->getSourceRange();
-      return true;
-    }
-
-    assert(computeODRHash(FirstParam) == computeODRHash(SecondParam) &&
-           "Undiagnosed parameter difference.");
-  }
-
-  // If no error has been generated before now, assume the problem is in
-  // the body and generate a message.
-  DiagError(FirstFunction->getLocation(), FirstFunction->getSourceRange(),
-            FunctionBody);
-  DiagNote(SecondFunction->getLocation(), SecondFunction->getSourceRange(),
-           FunctionBody);
-  return true;
-}
-
-bool ODRDiagsEmitter::diagnoseMismatch(const EnumDecl *FirstEnum,
-                                       const EnumDecl *SecondEnum) const {
-  if (FirstEnum == SecondEnum)
-    return false;
-
-  // Keep in sync with select options in err_module_odr_violation_enum.
-  enum ODREnumDifference {
-    SingleScopedEnum,
-    EnumTagKeywordMismatch,
-    SingleSpecifiedType,
-    DifferentSpecifiedTypes,
-    DifferentNumberEnumConstants,
-    EnumConstantName,
-    EnumConstantSingleInitializer,
-    EnumConstantDifferentInitializer,
-  };
-
-  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
-  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondEnum);
-
-  auto DiagError = [FirstEnum, &FirstModule, this](const auto *DiagAnchor,
-                                                   ODREnumDifference DiffType) {
-    return Diag(DiagAnchor->getLocation(), diag::err_module_odr_violation_enum)
-           << FirstEnum << FirstModule.empty() << FirstModule
-           << DiagAnchor->getSourceRange() << DiffType;
-  };
-  auto DiagNote = [&SecondModule, this](const auto *DiagAnchor,
-                                        ODREnumDifference DiffType) {
-    return Diag(DiagAnchor->getLocation(), diag::note_module_odr_violation_enum)
-           << SecondModule << DiagAnchor->getSourceRange() << DiffType;
-  };
-
-  if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
-    DiagError(FirstEnum, SingleScopedEnum) << FirstEnum->isScoped();
-    DiagNote(SecondEnum, SingleScopedEnum) << SecondEnum->isScoped();
-    return true;
-  }
-
-  if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
-    if (FirstEnum->isScopedUsingClassTag() !=
-        SecondEnum->isScopedUsingClassTag()) {
-      DiagError(FirstEnum, EnumTagKeywordMismatch)
-          << FirstEnum->isScopedUsingClassTag();
-      DiagNote(SecondEnum, EnumTagKeywordMismatch)
-          << SecondEnum->isScopedUsingClassTag();
-      return true;
-    }
-  }
-
-  QualType FirstUnderlyingType =
-      FirstEnum->getIntegerTypeSourceInfo()
-          ? FirstEnum->getIntegerTypeSourceInfo()->getType()
-          : QualType();
-  QualType SecondUnderlyingType =
-      SecondEnum->getIntegerTypeSourceInfo()
-          ? SecondEnum->getIntegerTypeSourceInfo()->getType()
-          : QualType();
-  if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
-    DiagError(FirstEnum, SingleSpecifiedType) << !FirstUnderlyingType.isNull();
-    DiagNote(SecondEnum, SingleSpecifiedType) << !SecondUnderlyingType.isNull();
-    return true;
-  }
-
-  if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
-    if (computeODRHash(FirstUnderlyingType) !=
-        computeODRHash(SecondUnderlyingType)) {
-      DiagError(FirstEnum, DifferentSpecifiedTypes) << FirstUnderlyingType;
-      DiagNote(SecondEnum, DifferentSpecifiedTypes) << SecondUnderlyingType;
-      return true;
-    }
-  }
-
-  // Compare enum constants.
-  using DeclHashes =
-      llvm::SmallVector<std::pair<const EnumConstantDecl *, unsigned>, 4>;
-  auto PopulateHashes = [FirstEnum](DeclHashes &Hashes, const EnumDecl *Enum) {
-    for (const Decl *D : Enum->decls()) {
-      // Due to decl merging, the first EnumDecl is the parent of
-      // Decls in both records.
-      if (!ODRHash::isDeclToBeProcessed(D, FirstEnum))
-        continue;
-      assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
-      Hashes.emplace_back(cast<EnumConstantDecl>(D), computeODRHash(D));
-    }
-  };
-  DeclHashes FirstHashes;
-  PopulateHashes(FirstHashes, FirstEnum);
-  DeclHashes SecondHashes;
-  PopulateHashes(SecondHashes, SecondEnum);
-
-  if (FirstHashes.size() != SecondHashes.size()) {
-    DiagError(FirstEnum, DifferentNumberEnumConstants)
-        << (int)FirstHashes.size();
-    DiagNote(SecondEnum, DifferentNumberEnumConstants)
-        << (int)SecondHashes.size();
-    return true;
-  }
-
-  for (unsigned I = 0, N = FirstHashes.size(); I < N; ++I) {
-    if (FirstHashes[I].second == SecondHashes[I].second)
-      continue;
-    const EnumConstantDecl *FirstConstant = FirstHashes[I].first;
-    const EnumConstantDecl *SecondConstant = SecondHashes[I].first;
-
-    if (FirstConstant->getDeclName() != SecondConstant->getDeclName()) {
-      DiagError(FirstConstant, EnumConstantName) << I + 1 << FirstConstant;
-      DiagNote(SecondConstant, EnumConstantName) << I + 1 << SecondConstant;
-      return true;
-    }
-
-    const Expr *FirstInit = FirstConstant->getInitExpr();
-    const Expr *SecondInit = SecondConstant->getInitExpr();
-    if (!FirstInit && !SecondInit)
-      continue;
-
-    if (!FirstInit || !SecondInit) {
-      DiagError(FirstConstant, EnumConstantSingleInitializer)
-          << I + 1 << FirstConstant << (FirstInit != nullptr);
-      DiagNote(SecondConstant, EnumConstantSingleInitializer)
-          << I + 1 << SecondConstant << (SecondInit != nullptr);
-      return true;
-    }
-
-    if (computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
-      DiagError(FirstConstant, EnumConstantDifferentInitializer)
-          << I + 1 << FirstConstant;
-      DiagNote(SecondConstant, EnumConstantDifferentInitializer)
-          << I + 1 << SecondConstant;
-      return true;
-    }
-  }
-  return false;
-}
-
 void ASTReader::StartedDeserializing() {
   if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
     ReadTimer->startTimer();
 }
 
 void ASTReader::FinishedDeserializing() {
   assert(NumCurrentElementsDeserializing &&
          "FinishedDeserializing not paired with StartedDeserializing");