[ODRHash diagnostics] Preparation to minimize subsequent diffs. NFC.

[vsapsai]

Summary

Specifically, making the following changes:

• Turn lambdas calculating ODR hashes into static functions.
• Move ODRCXXRecordDifference where it is used.
• Rename some variables and move some lines of code.
• Replace auto with explicit type when the deduced type is not mentioned.
• Add const for unmodified objects, so we can pass them to more functions.

[vsapsai]

More preparations to minimize subsequent diff.

[vsapsai]

Rebase.

[ChuanqiXu]

LGTM basically.

clang/lib/Serialization/ASTReader.cpp

10621–10626

Couldn't we hoist this like others?

[vsapsai]

clang/lib/Serialization/ASTReader.cpp

10621–10626

It is used only on the lines below - 10632 & 10634, so I think it is good to keep its scope small. And not hoisting is consistent with other places using lambdas close to their 2 calls like different kinds of PopulateHashes.

This is a good observation. I've checked the usage of other hoisted lambdas and ComputeTemplateParameterListODRHash is used only in 2 places, so now I think we shouldn't hoist it.

[ChuanqiXu]

clang/lib/Serialization/ASTReader.cpp

10621–10626

Makes sense to me : )

[vsapsai]

Rebase and unhoist ComputeTemplateParameterListODRHash.

[vsapsai]

Thanks for the review!

clang/lib/Serialization/ASTReader.cpp

void ASTReader::finishPendingActions() {
   PendingBodies.clear();
 
   // Do some cleanup.
   for (auto *ND : PendingMergedDefinitionsToDeduplicate)
     getContext().deduplicateMergedDefinitonsFor(ND);
   PendingMergedDefinitionsToDeduplicate.clear();
 }
 
+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 unsigned computeODRHash(const TemplateParameterList *TPL) {
+  assert(TPL);
+  ODRHash Hasher;
+  Hasher.AddTemplateParameterList(TPL);
+  return Hasher.CalculateHash();
+}
+
 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.
void ASTReader::diagnoseOdrViolations() {
   if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
       EnumOdrMergeFailures.empty())
     return;
 
   // Ensure we don't accidentally recursively enter deserialization while
   // we're producing our diagnostics.
   Deserializing RecursionGuard(this);
 
-  // Common code for hashing helpers.
-  ODRHash Hash;
-  auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
-    Hash.clear();
-    Hash.AddQualType(Ty);
-    return Hash.CalculateHash();
-  };
-
-  auto ComputeODRHash = [&Hash](const Stmt *S) {
-    assert(S);
-    Hash.clear();
-    Hash.AddStmt(S);
-    return Hash.CalculateHash();
-  };
-
-  auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
-    assert(D);
-    Hash.clear();
-    Hash.AddSubDecl(D);
-    return Hash.CalculateHash();
-  };
-
-  auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
-    Hash.clear();
-    Hash.AddTemplateArgument(TA);
-    return Hash.CalculateHash();
-  };
-
-  auto ComputeTemplateParameterListODRHash =
-      [&Hash](const TemplateParameterList *TPL) {
-        assert(TPL);
-        Hash.clear();
-        Hash.AddTemplateParameterList(TPL);
-        return Hash.CalculateHash();
-      };
-
   // 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
   };
 
-  // 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,
-  };
-
   // These lambdas have the common portions of the ODR diagnostics.  This
   // has the same return as Diag(), so addition parameters can be passed
   // in with operator<<
-  auto ODRDiagField = [this, &ComputeQualTypeODRHash, &ComputeODRHash](
-                          NamedDecl *FirstRecord, StringRef FirstModule,
-                          StringRef SecondModule, FieldDecl *FirstField,
-                          FieldDecl *SecondField) {
+  auto ODRDiagField = [this](NamedDecl *FirstRecord, StringRef FirstModule,
+                             StringRef SecondModule,
+                             const FieldDecl *FirstField,
+                             const FieldDecl *SecondField) {
     enum ODRFieldDifference {
       FieldName,
       FieldTypeName,
       FieldSingleBitField,
       FieldDifferentWidthBitField,
       FieldSingleMutable,
       FieldSingleInitializer,
       FieldDifferentInitializers,
if (FirstII->getName() != SecondII->getName()) {
       return true;
     }
 
     assert(getContext().hasSameType(FirstField->getType(),
                                     SecondField->getType()));
 
     QualType FirstType = FirstField->getType();
     QualType SecondType = SecondField->getType();
-    if (ComputeQualTypeODRHash(FirstType) !=
-        ComputeQualTypeODRHash(SecondType)) {
+    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());
+      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 ((!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);
+      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;
   };
 
   auto ODRDiagTypeDefOrAlias =
-      [this, &ComputeQualTypeODRHash](
-          NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
-          TypedefNameDecl *FirstTD, TypedefNameDecl *SecondTD,
-          bool IsTypeAlias) {
+      [this](NamedDecl *FirstRecord, StringRef FirstModule,
+             StringRef SecondModule, const TypedefNameDecl *FirstTD,
+             const TypedefNameDecl *SecondTD, bool IsTypeAlias) {
         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;
         };
 
-        auto FirstName = FirstTD->getDeclName();
-        auto SecondName = SecondTD->getDeclName();
+        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 (ComputeQualTypeODRHash(FirstType) !=
-            ComputeQualTypeODRHash(SecondType)) {
+        if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
           DiagError(TypedefType) << IsTypeAlias << FirstName << FirstType;
           DiagNote(TypedefType) << IsTypeAlias << SecondName << SecondType;
           return true;
         }
 
         return false;
       };
 
-  auto ODRDiagVar = [&ComputeQualTypeODRHash, &ComputeODRHash,
-                     this](NamedDecl *FirstRecord, StringRef FirstModule,
-                           StringRef SecondModule, VarDecl *FirstVD,
-                           VarDecl *SecondVD) {
+  auto ODRDiagVar = [this](NamedDecl *FirstRecord, StringRef FirstModule,
+                           StringRef SecondModule, const VarDecl *FirstVD,
+                           const VarDecl *SecondVD) {
     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;
     };
 
-    auto FirstName = FirstVD->getDeclName();
-    auto SecondName = SecondVD->getDeclName();
+    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 (ComputeQualTypeODRHash(FirstType) !=
-        ComputeQualTypeODRHash(SecondType)) {
+    if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
       DiagError(VarType) << FirstName << FirstType;
       DiagNote(VarType) << SecondName << SecondType;
       return true;
     }
 
     if (!PP.getLangOpts().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)) {
+        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;
   };
 
+  using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
+  auto PopulateHashes = [](DeclHashes &Hashes, RecordDecl *Record,
+                           const DeclContext *DC) {
+    for (auto *D : Record->decls()) {
+      if (!ODRHash::isDeclToBeProcessed(D, DC))
+        continue;
+      Hashes.emplace_back(D, computeODRHash(D));
+    }
+  };
+
+  struct DiffResult {
+    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.
+  auto FindTypeDiffs = [](DeclHashes &FirstHashes, DeclHashes &SecondHashes) {
     auto DifferenceSelector = [](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;
       }
     };
 
-  using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
-  auto PopulateHashes = [&ComputeSubDeclODRHash](DeclHashes &Hashes,
-                                                 RecordDecl *Record,
-                                                 const DeclContext *DC) {
-    for (auto *D : Record->decls()) {
-      if (!ODRHash::isDeclToBeProcessed(D, DC))
-        continue;
-      Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
-    }
-  };
-
-  struct DiffResult {
-    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.
-  auto FindTypeDiffs = [&DifferenceSelector](DeclHashes &FirstHashes,
-                                             DeclHashes &SecondHashes) {
     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;
for (auto &Merge : OdrMergeFailures) {
     for (auto &RecordPair : Merge.second) {
       CXXRecordDecl *SecondRecord = RecordPair.first;
       // Multiple different declarations got merged together; tell the user
       // where they came from.
       if (FirstRecord == SecondRecord)
         continue;
 
       std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
-      auto ODRDiagDeclError = [FirstRecord, &FirstModule,
-                               this](SourceLocation Loc, SourceRange Range,
-                                     ODRCXXRecordDifference DiffType) {
-        return Diag(Loc, diag::err_module_odr_violation_record)
-               << FirstRecord << FirstModule.empty() << FirstModule << Range
-               << DiffType;
-      };
-      auto ODRDiagDeclNote = [&SecondModule,
-                              this](SourceLocation Loc, SourceRange Range,
-                                    ODRCXXRecordDifference DiffType) {
-        return Diag(Loc, diag::note_module_odr_violation_record)
-               << SecondModule << Range << DiffType;
-      };
 
       auto *FirstDD = FirstRecord->DefinitionData;
       auto *SecondDD = RecordPair.second;
 
       assert(FirstDD && SecondDD && "Definitions without DefinitionData");
 
       // Diagnostics from DefinitionData are emitted here.
       if (FirstDD != SecondDD) {
for (auto &RecordPair : Merge.second) {
                  << DiffType;
         };
         auto ODRDiagBaseNote = [&SecondModule,
                                 this](SourceLocation Loc, SourceRange Range,
                                       ODRDefinitionDataDifference DiffType) {
           return Diag(Loc, diag::note_module_odr_violation_definition_data)
                  << SecondModule << Range << DiffType;
         };
-
-        unsigned FirstNumBases = FirstDD->NumBases;
-        unsigned FirstNumVBases = FirstDD->NumVBases;
-        unsigned SecondNumBases = SecondDD->NumBases;
-        unsigned SecondNumVBases = SecondDD->NumVBases;
-
         auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
           unsigned NumBases = DD->NumBases;
           if (NumBases == 0) return SourceRange();
-          auto bases = DD->bases();
+          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) {
           ODRDiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
                            NumBases)
               << FirstNumBases;
           ODRDiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
                           NumBases)
               << SecondNumBases;
           Diagnosed = true;
           break;
         }
 
         if (FirstNumVBases != SecondNumVBases) {
           ODRDiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
                            NumVBases)
               << FirstNumVBases;
           ODRDiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
                           NumVBases)
               << SecondNumVBases;
           Diagnosed = true;
           break;
         }
 
-        auto FirstBases = FirstDD->bases();
-        auto SecondBases = SecondDD->bases();
-        unsigned i = 0;
-        for (i = 0; i < FirstNumBases; ++i) {
-          auto FirstBase = FirstBases[i];
-          auto SecondBase = SecondBases[i];
-          if (ComputeQualTypeODRHash(FirstBase.getType()) !=
-              ComputeQualTypeODRHash(SecondBase.getType())) {
+        ArrayRef<CXXBaseSpecifier> FirstBases = FirstDD->bases();
+        ArrayRef<CXXBaseSpecifier> SecondBases = SecondDD->bases();
+        unsigned I = 0;
+        for (I = 0; I < FirstNumBases; ++I) {
+          const CXXBaseSpecifier FirstBase = FirstBases[I];
+          const CXXBaseSpecifier SecondBase = SecondBases[I];
+          if (computeODRHash(FirstBase.getType()) !=
+              computeODRHash(SecondBase.getType())) {
             ODRDiagBaseError(FirstRecord->getLocation(),
                              FirstBase.getSourceRange(), BaseType)
-                << (i + 1) << FirstBase.getType();
+                << (I + 1) << FirstBase.getType();
             ODRDiagBaseNote(SecondRecord->getLocation(),
                             SecondBase.getSourceRange(), BaseType)
-                << (i + 1) << SecondBase.getType();
+                << (I + 1) << SecondBase.getType();
             break;
           }
 
           if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
             ODRDiagBaseError(FirstRecord->getLocation(),
                              FirstBase.getSourceRange(), BaseVirtual)
-                << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
+                << (I + 1) << FirstBase.isVirtual() << FirstBase.getType();
             ODRDiagBaseNote(SecondRecord->getLocation(),
                             SecondBase.getSourceRange(), BaseVirtual)
-                << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
+                << (I + 1) << SecondBase.isVirtual() << SecondBase.getType();
             break;
           }
 
           if (FirstBase.getAccessSpecifierAsWritten() !=
               SecondBase.getAccessSpecifierAsWritten()) {
             ODRDiagBaseError(FirstRecord->getLocation(),
                              FirstBase.getSourceRange(), BaseAccess)
-                << (i + 1) << FirstBase.getType()
+                << (I + 1) << FirstBase.getType()
                 << (int)FirstBase.getAccessSpecifierAsWritten();
             ODRDiagBaseNote(SecondRecord->getLocation(),
                             SecondBase.getSourceRange(), BaseAccess)
-                << (i + 1) << SecondBase.getType()
+                << (I + 1) << SecondBase.getType()
                 << (int)SecondBase.getAccessSpecifierAsWritten();
             break;
           }
         }
 
-        if (i != FirstNumBases) {
+        if (I != FirstNumBases) {
           Diagnosed = true;
           break;
         }
       }
 
       const ClassTemplateDecl *FirstTemplate =
           FirstRecord->getDescribedClassTemplate();
       const ClassTemplateDecl *SecondTemplate =
           SecondRecord->getDescribedClassTemplate();
 
       assert(!FirstTemplate == !SecondTemplate &&
              "Both pointers should be null or non-null");
 
       if (FirstTemplate && SecondTemplate) {
         DeclHashes FirstTemplateHashes;
         DeclHashes SecondTemplateHashes;
 
-        auto PopulateTemplateParameterHashs =
-            [&ComputeSubDeclODRHash](DeclHashes &Hashes,
+        auto PopulateTemplateParameterHashs = [](DeclHashes &Hashes,
                                                  const ClassTemplateDecl *TD) {
-              for (auto *D : TD->getTemplateParameters()->asArray()) {
-                Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
-              }
-            };
+            Hashes.emplace_back(D, computeODRHash(D));
 
         PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
         PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
 
         assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
                "Number of template parameters should be equal.");
 
         auto FirstIt = FirstTemplateHashes.begin();
for (auto &RecordPair : Merge.second) {
       }
 
       DeclHashes FirstHashes;
       DeclHashes SecondHashes;
       const DeclContext *DC = FirstRecord;
       PopulateHashes(FirstHashes, FirstRecord, DC);
       PopulateHashes(SecondHashes, SecondRecord, DC);
 
-      auto DR = FindTypeDiffs(FirstHashes, SecondHashes);
+      DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
       ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
       ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
-      Decl *FirstDecl = DR.FirstDecl;
-      Decl *SecondDecl = DR.SecondDecl;
+      const Decl *FirstDecl = DR.FirstDecl;
+      const Decl *SecondDecl = DR.SecondDecl;
 
       if (FirstDiffType == Other || SecondDiffType == Other) {
         DiagnoseODRUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
                               SecondModule);
         Diagnosed = true;
         break;
       }
 
       if (FirstDiffType != SecondDiffType) {
         DiagnoseODRMismatch(DR, FirstRecord, FirstModule, SecondRecord,
                             SecondModule);
         Diagnosed = true;
         break;
       }
 
-      assert(FirstDiffType == SecondDiffType);
+      // 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 ODRDiagDeclError = [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 ODRDiagDeclNote = [&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: {
-        StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
-        StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
+        const StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
+        const StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
 
-        Expr *FirstExpr = FirstSA->getAssertExpr();
-        Expr *SecondExpr = SecondSA->getAssertExpr();
-        unsigned FirstODRHash = ComputeODRHash(FirstExpr);
-        unsigned SecondODRHash = ComputeODRHash(SecondExpr);
+        const Expr *FirstExpr = FirstSA->getAssertExpr();
+        const Expr *SecondExpr = SecondSA->getAssertExpr();
+        unsigned FirstODRHash = computeODRHash(FirstExpr);
+        unsigned SecondODRHash = computeODRHash(SecondExpr);
         if (FirstODRHash != SecondODRHash) {
           ODRDiagDeclError(FirstExpr->getBeginLoc(),
                            FirstExpr->getSourceRange(), StaticAssertCondition);
           ODRDiagDeclNote(SecondExpr->getBeginLoc(),
                           SecondExpr->getSourceRange(), StaticAssertCondition);
           Diagnosed = true;
           break;
         }
 
-        StringLiteral *FirstStr = FirstSA->getMessage();
-        StringLiteral *SecondStr = SecondSA->getMessage();
+        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 {
for (auto &RecordPair : Merge.second) {
           DiagMethodNote(MethodVirtual) << SecondPure << SecondVirtual;
           Diagnosed = true;
           break;
         }
 
         // 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.
-        const auto FirstStorage = FirstMethod->getStorageClass();
-        const auto SecondStorage = SecondMethod->getStorageClass();
+        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;
           Diagnosed = true;
           break;
         }
for (auto &RecordPair : Merge.second) {
         bool ParameterMismatch = false;
         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 &&
-              ComputeQualTypeODRHash(FirstParamType) !=
-                  ComputeQualTypeODRHash(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;
for (auto &RecordPair : Merge.second) {
             DiagMethodNote(MethodParameterSingleDefaultArgument)
                 << (I + 1) << (SecondInit == nullptr)
                 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
             ParameterMismatch = true;
             break;
           }
 
           if (FirstInit && SecondInit &&
-              ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
+              computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
             DiagMethodError(MethodParameterDifferentDefaultArgument)
                 << (I + 1) << FirstInit->getSourceRange();
             DiagMethodNote(MethodParameterDifferentDefaultArgument)
                 << (I + 1) << SecondInit->getSourceRange();
             ParameterMismatch = true;
             break;
-
           }
         }
 
         if (ParameterMismatch) {
           Diagnosed = true;
           break;
         }
 
-        const auto *FirstTemplateArgs =
+        const TemplateArgumentList *FirstTemplateArgs =
             FirstMethod->getTemplateSpecializationArgs();
-        const auto *SecondTemplateArgs =
+        const TemplateArgumentList *SecondTemplateArgs =
             SecondMethod->getTemplateSpecializationArgs();
 
         if ((FirstTemplateArgs && !SecondTemplateArgs) ||
             (!FirstTemplateArgs && SecondTemplateArgs)) {
           DiagMethodError(MethodNoTemplateArguments)
               << (FirstTemplateArgs != nullptr);
           DiagMethodNote(MethodNoTemplateArguments)
               << (SecondTemplateArgs != nullptr);
for (auto &RecordPair : Merge.second) {
             Diagnosed = true;
             break;
           }
 
           bool TemplateArgumentMismatch = false;
           for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
             const TemplateArgument &FirstTA = *FirstExpandedList[i],
                                    &SecondTA = *SecondExpandedList[i];
-            if (ComputeTemplateArgumentODRHash(FirstTA) ==
-                ComputeTemplateArgumentODRHash(SecondTA)) {
+            if (computeODRHash(FirstTA) == computeODRHash(SecondTA)) {
               continue;
             }
 
             DiagMethodError(MethodDifferentTemplateArgument)
                 << FirstTA << i + 1;
             DiagMethodNote(MethodDifferentTemplateArgument)
                 << SecondTA << i + 1;
             TemplateArgumentMismatch = true;
             break;
           }
 
           if (TemplateArgumentMismatch) {
             Diagnosed = true;
             break;
           }
         }
 
         // Compute the hash of the method as if it has no body.
-        auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
-          Hash.clear();
-          Hash.AddFunctionDecl(D, true /*SkipBody*/);
-          return Hash.CalculateHash();
+        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();
for (auto &RecordPair : Merge.second) {
       }
       case Var: {
         Diagnosed =
             ODRDiagVar(FirstRecord, FirstModule, SecondModule,
                        cast<VarDecl>(FirstDecl), cast<VarDecl>(SecondDecl));
         break;
       }
       case Friend: {
-        FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
-        FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
+        const FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
+        const FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
 
-        NamedDecl *FirstND = FirstFriend->getFriendDecl();
-        NamedDecl *SecondND = SecondFriend->getFriendDecl();
+        const NamedDecl *FirstND = FirstFriend->getFriendDecl();
+        const NamedDecl *SecondND = SecondFriend->getFriendDecl();
 
         TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
         TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
 
         if (FirstND && SecondND) {
           ODRDiagDeclError(FirstFriend->getFriendLoc(),
                            FirstFriend->getSourceRange(), FriendFunction)
               << FirstND;
           ODRDiagDeclNote(SecondFriend->getFriendLoc(),
                           SecondFriend->getSourceRange(), FriendFunction)
               << SecondND;
           Diagnosed = true;
           break;
         }
 
         if (FirstTSI && SecondTSI) {
           QualType FirstFriendType = FirstTSI->getType();
           QualType SecondFriendType = SecondTSI->getType();
-          assert(ComputeQualTypeODRHash(FirstFriendType) !=
-                 ComputeQualTypeODRHash(SecondFriendType));
+          assert(computeODRHash(FirstFriendType) !=
+                 computeODRHash(SecondFriendType));
           ODRDiagDeclError(FirstFriend->getFriendLoc(),
                            FirstFriend->getSourceRange(), FriendType)
               << FirstFriendType;
           ODRDiagDeclNote(SecondFriend->getFriendLoc(),
                           SecondFriend->getSourceRange(), FriendType)
               << SecondFriendType;
           Diagnosed = true;
           break;
         }
 
         ODRDiagDeclError(FirstFriend->getFriendLoc(),
                          FirstFriend->getSourceRange(), FriendTypeFunction)
             << (FirstTSI == nullptr);
         ODRDiagDeclNote(SecondFriend->getFriendLoc(),
                         SecondFriend->getSourceRange(), FriendTypeFunction)
             << (SecondTSI == nullptr);
         Diagnosed = true;
         break;
       }
       case FunctionTemplate: {
-        FunctionTemplateDecl *FirstTemplate =
+        const FunctionTemplateDecl *FirstTemplate =
             cast<FunctionTemplateDecl>(FirstDecl);
-        FunctionTemplateDecl *SecondTemplate =
+        const FunctionTemplateDecl *SecondTemplate =
             cast<FunctionTemplateDecl>(SecondDecl);
 
         TemplateParameterList *FirstTPL =
             FirstTemplate->getTemplateParameters();
         TemplateParameterList *SecondTPL =
             SecondTemplate->getTemplateParameters();
 
         auto DiagTemplateError = [&ODRDiagDeclError, FirstTemplate](
for (auto &RecordPair : Merge.second) {
                   << (i + 1) << HasSecondDefaultArgument;
               ParameterMismatch = true;
               break;
             }
 
             if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
               QualType FirstType = FirstTTPD->getDefaultArgument();
               QualType SecondType = SecondTTPD->getDefaultArgument();
-              if (ComputeQualTypeODRHash(FirstType) !=
-                  ComputeQualTypeODRHash(SecondType)) {
+              if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
                 DiagTemplateError(
                     FunctionTemplateParameterDifferentDefaultArgument)
                     << (i + 1) << FirstType;
                 DiagTemplateNote(
                     FunctionTemplateParameterDifferentDefaultArgument)
                     << (i + 1) << SecondType;
                 ParameterMismatch = true;
                 break;
for (auto &RecordPair : Merge.second) {
             TemplateTemplateParmDecl *SecondTTPD =
                 cast<TemplateTemplateParmDecl>(SecondParam);
 
             TemplateParameterList *FirstTPL =
                 FirstTTPD->getTemplateParameters();
             TemplateParameterList *SecondTPL =
                 SecondTTPD->getTemplateParameters();
 
-            if (ComputeTemplateParameterListODRHash(FirstTPL) !=
-                ComputeTemplateParameterListODRHash(SecondTPL)) {
+            if (computeODRHash(FirstTPL) != computeODRHash(SecondTPL)) {
               DiagTemplateError(FunctionTemplateParameterDifferentType)
                   << (i + 1);
               DiagTemplateNote(FunctionTemplateParameterDifferentType)
                   << (i + 1);
               ParameterMismatch = true;
               break;
             }
 
for (auto &RecordPair : Merge.second) {
               break;
             }
 
             if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
               TemplateArgument FirstTA =
                   FirstTTPD->getDefaultArgument().getArgument();
               TemplateArgument SecondTA =
                   SecondTTPD->getDefaultArgument().getArgument();
-              if (ComputeTemplateArgumentODRHash(FirstTA) !=
-                  ComputeTemplateArgumentODRHash(SecondTA)) {
+              if (computeODRHash(FirstTA) != computeODRHash(SecondTA)) {
                 DiagTemplateError(
                     FunctionTemplateParameterDifferentDefaultArgument)
                     << (i + 1) << FirstTA;
                 DiagTemplateNote(
                     FunctionTemplateParameterDifferentDefaultArgument)
                     << (i + 1) << SecondTA;
                 ParameterMismatch = true;
                 break;
for (auto &RecordPair : Merge.second) {
               isa<NonTypeTemplateParmDecl>(SecondParam)) {
             NonTypeTemplateParmDecl *FirstNTTPD =
                 cast<NonTypeTemplateParmDecl>(FirstParam);
             NonTypeTemplateParmDecl *SecondNTTPD =
                 cast<NonTypeTemplateParmDecl>(SecondParam);
 
             QualType FirstType = FirstNTTPD->getType();
             QualType SecondType = SecondNTTPD->getType();
-            if (ComputeQualTypeODRHash(FirstType) !=
-                ComputeQualTypeODRHash(SecondType)) {
+            if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
               DiagTemplateError(FunctionTemplateParameterDifferentType)
                   << (i + 1);
               DiagTemplateNote(FunctionTemplateParameterDifferentType)
                   << (i + 1);
               ParameterMismatch = true;
               break;
             }
 
for (auto &RecordPair : Merge.second) {
                   << (i + 1) << HasSecondDefaultArgument;
               ParameterMismatch = true;
               break;
             }
 
             if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
               Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
               Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
-              if (ComputeODRHash(FirstDefaultArgument) !=
-                  ComputeODRHash(SecondDefaultArgument)) {
+              if (computeODRHash(FirstDefaultArgument) !=
+                  computeODRHash(SecondDefaultArgument)) {
                 DiagTemplateError(
                     FunctionTemplateParameterDifferentDefaultArgument)
                     << (i + 1) << FirstDefaultArgument;
                 DiagTemplateNote(
                     FunctionTemplateParameterDifferentDefaultArgument)
                     << (i + 1) << SecondDefaultArgument;
                 ParameterMismatch = true;
                 break;
for (auto &SecondFunction : Merge.second) {
       };
       auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
                                                SourceRange Range,
                                                ODRFunctionDifference DiffType) {
         return Diag(Loc, diag::note_module_odr_violation_function)
                << SecondModule << Range << DiffType;
       };
 
-      if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
-          ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
+      if (computeODRHash(FirstFunction->getReturnType()) !=
+          computeODRHash(SecondFunction->getReturnType())) {
         ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
                      FirstFunction->getReturnTypeSourceRange(), ReturnType)
             << FirstFunction->getReturnType();
         ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
                     SecondFunction->getReturnTypeSourceRange(), ReturnType)
             << SecondFunction->getReturnType();
         Diagnosed = true;
         break;
       }
 
       assert(FirstFunction->param_size() == SecondFunction->param_size() &&
              "Merged functions with different number of parameters");
 
-      auto ParamSize = FirstFunction->param_size();
+      size_t ParamSize = FirstFunction->param_size();
       bool ParameterMismatch = false;
       for (unsigned I = 0; I < ParamSize; ++I) {
-        auto *FirstParam = FirstFunction->getParamDecl(I);
-        auto *SecondParam = SecondFunction->getParamDecl(I);
+        const ParmVarDecl *FirstParam = FirstFunction->getParamDecl(I);
+        const ParmVarDecl *SecondParam = SecondFunction->getParamDecl(I);
 
         assert(getContext().hasSameType(FirstParam->getType(),
                                       SecondParam->getType()) &&
                "Merged function has different parameter types.");
 
         if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
           ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
                        ParameterName)
               << I + 1 << FirstParam->getDeclName();
           ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
                       ParameterName)
               << I + 1 << SecondParam->getDeclName();
           ParameterMismatch = true;
           break;
         };
 
         QualType FirstParamType = FirstParam->getType();
         QualType SecondParamType = SecondParam->getType();
         if (FirstParamType != SecondParamType &&
-            ComputeQualTypeODRHash(FirstParamType) !=
-                ComputeQualTypeODRHash(SecondParamType)) {
+            computeODRHash(FirstParamType) != computeODRHash(SecondParamType)) {
           if (const DecayedType *ParamDecayedType =
                   FirstParamType->getAs<DecayedType>()) {
             ODRDiagError(FirstParam->getLocation(),
                          FirstParam->getSourceRange(), ParameterType)
                 << (I + 1) << FirstParamType << true
                 << ParamDecayedType->getOriginalType();
           } else {
             ODRDiagError(FirstParam->getLocation(),
for (auto &SecondFunction : Merge.second) {
                       ParameterSingleDefaultArgument)
               << (I + 1) << (SecondInit == nullptr)
               << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
           ParameterMismatch = true;
           break;
         }
 
         if (FirstInit && SecondInit &&
-            ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
+            computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
           ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
                        ParameterDifferentDefaultArgument)
               << (I + 1) << FirstInit->getSourceRange();
           ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
                       ParameterDifferentDefaultArgument)
               << (I + 1) << SecondInit->getSourceRange();
           ParameterMismatch = true;
           break;
         }
 
-        assert(ComputeSubDeclODRHash(FirstParam) ==
-                   ComputeSubDeclODRHash(SecondParam) &&
+        assert(computeODRHash(FirstParam) == computeODRHash(SecondParam) &&
                "Undiagnosed parameter difference.");
       }
 
       if (ParameterMismatch) {
         Diagnosed = true;
         break;
       }
 
for (auto &Merge : EnumOdrMergeFailures) {
     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
       continue;
 
     EnumDecl *FirstEnum = Merge.first;
     std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
 
     using DeclHashes =
         llvm::SmallVector<std::pair<EnumConstantDecl *, unsigned>, 4>;
-    auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
-                              DeclHashes &Hashes, EnumDecl *Enum) {
+    auto PopulateHashes = [FirstEnum](DeclHashes &Hashes, EnumDecl *Enum) {
       for (auto *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),
-                            ComputeSubDeclODRHash(D));
+        Hashes.emplace_back(cast<EnumConstantDecl>(D), computeODRHash(D));
       }
     };
     DeclHashes FirstHashes;
     PopulateHashes(FirstHashes, FirstEnum);
     bool Diagnosed = false;
     for (auto &SecondEnum : Merge.second) {
 
       if (FirstEnum == SecondEnum)
for (auto &SecondEnum : Merge.second) {
             << !FirstUnderlyingType.isNull();
         ODRDiagNote(SecondEnum, SingleSpecifiedType)
             << !SecondUnderlyingType.isNull();
         Diagnosed = true;
         continue;
       }
 
       if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
-        if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
-            ComputeQualTypeODRHash(SecondUnderlyingType)) {
+        if (computeODRHash(FirstUnderlyingType) !=
+            computeODRHash(SecondUnderlyingType)) {
           ODRDiagError(FirstEnum, DifferentSpecifiedTypes)
               << FirstUnderlyingType;
           ODRDiagNote(SecondEnum, DifferentSpecifiedTypes)
               << SecondUnderlyingType;
           Diagnosed = true;
           continue;
         }
       }
 
       DeclHashes SecondHashes;
       PopulateHashes(SecondHashes, SecondEnum);
 
       if (FirstHashes.size() != SecondHashes.size()) {
         ODRDiagError(FirstEnum, DifferentNumberEnumConstants)
             << (int)FirstHashes.size();
         ODRDiagNote(SecondEnum, DifferentNumberEnumConstants)
             << (int)SecondHashes.size();
         Diagnosed = true;
         continue;
       }
 
       for (unsigned I = 0; I < FirstHashes.size(); ++I) {
         if (FirstHashes[I].second == SecondHashes[I].second)
           continue;
-        const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
-        const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
+        const EnumConstantDecl *FirstConstant = FirstHashes[I].first;
+        const EnumConstantDecl *SecondConstant = SecondHashes[I].first;
 
-        if (FirstEnumConstant->getDeclName() !=
-            SecondEnumConstant->getDeclName()) {
+        if (FirstConstant->getDeclName() != SecondConstant->getDeclName()) {
 
-          ODRDiagError(FirstEnumConstant, EnumConstantName)
-              << I + 1 << FirstEnumConstant;
-          ODRDiagNote(SecondEnumConstant, EnumConstantName)
-              << I + 1 << SecondEnumConstant;
+          ODRDiagError(FirstConstant, EnumConstantName)
+              << I + 1 << FirstConstant;
+          ODRDiagNote(SecondConstant, EnumConstantName)
+              << I + 1 << SecondConstant;
           Diagnosed = true;
           break;
         }
 
-        const Expr *FirstInit = FirstEnumConstant->getInitExpr();
-        const Expr *SecondInit = SecondEnumConstant->getInitExpr();
+        const Expr *FirstInit = FirstConstant->getInitExpr();
+        const Expr *SecondInit = SecondConstant->getInitExpr();
         if (!FirstInit && !SecondInit)
           continue;
 
         if (!FirstInit || !SecondInit) {
-          ODRDiagError(FirstEnumConstant, EnumConstantSingleInitializer)
-              << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
-          ODRDiagNote(SecondEnumConstant, EnumConstantSingleInitializer)
-              << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
+          ODRDiagError(FirstConstant, EnumConstantSingleInitializer)
+              << I + 1 << FirstConstant << (FirstInit != nullptr);
+          ODRDiagNote(SecondConstant, EnumConstantSingleInitializer)
+              << I + 1 << SecondConstant << (SecondInit != nullptr);
           Diagnosed = true;
           break;
         }
 
-        if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
-          ODRDiagError(FirstEnumConstant, EnumConstantDifferentInitializer)
-              << I + 1 << FirstEnumConstant;
-          ODRDiagNote(SecondEnumConstant, EnumConstantDifferentInitializer)
-              << I + 1 << SecondEnumConstant;
+        if (computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
+          ODRDiagError(FirstConstant, EnumConstantDifferentInitializer)
+              << I + 1 << FirstConstant;
+          ODRDiagNote(SecondConstant, EnumConstantDifferentInitializer)
+              << I + 1 << SecondConstant;
           Diagnosed = true;
           break;
         }
       }
     }
 
     (void)Diagnosed;
     assert(Diagnosed && "Unable to emit ODR diagnostic.");