clang/lib/AST/ODRDiagsEmitter.cpp

   1 //===-- ODRDiagsEmitter.cpp - Diagnostics for ODR mismatches ----*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "clang/AST/ODRDiagsEmitter.h"
  10 #include "clang/AST/DeclFriend.h"
  11 #include "clang/AST/DeclTemplate.h"
  12 #include "clang/AST/ODRHash.h"
  13 #include "clang/Basic/DiagnosticAST.h"
  14 #include "clang/Basic/Module.h"
  15
  16 using namespace clang;
  17
  18 static unsigned computeODRHash(QualType Ty) {
  19   ODRHash Hasher;
  20   Hasher.AddQualType(Ty);
  21   return Hasher.CalculateHash();
  22 }
  23
  24 static unsigned computeODRHash(const Stmt *S) {
  25   ODRHash Hasher;
  26   Hasher.AddStmt(S);
  27   return Hasher.CalculateHash();
  28 }
  29
  30 static unsigned computeODRHash(const Decl *D) {
  31   assert(D);
  32   ODRHash Hasher;
  33   Hasher.AddSubDecl(D);
  34   return Hasher.CalculateHash();
  35 }
  36
  37 static unsigned computeODRHash(const TemplateArgument &TA) {
  38   ODRHash Hasher;
  39   Hasher.AddTemplateArgument(TA);
  40   return Hasher.CalculateHash();
  41 }
  42
  43 std::string ODRDiagsEmitter::getOwningModuleNameForDiagnostic(const Decl *D) {
  44   // If we know the owning module, use it.
  45   if (Module *M = D->getImportedOwningModule())
  46     return M->getFullModuleName();
  47
  48   // Not from a module.
  49   return {};
  50 }
  51
  52 template <typename MethodT>
  53 static bool diagnoseSubMismatchMethodParameters(DiagnosticsEngine &Diags,
  54                                                 const NamedDecl *FirstContainer,
  55                                                 StringRef FirstModule,
  56                                                 StringRef SecondModule,
  57                                                 const MethodT *FirstMethod,
  58                                                 const MethodT *SecondMethod) {
  59   enum DiagMethodType {
  60     DiagMethod,
  61     DiagConstructor,
  62     DiagDestructor,
  63   };
  64   auto GetDiagMethodType = [](const NamedDecl *D) {
  65     if (isa<CXXConstructorDecl>(D))
  66       return DiagConstructor;
  67     if (isa<CXXDestructorDecl>(D))
  68       return DiagDestructor;
  69     return DiagMethod;
  70   };
  71
  72   enum ODRMethodParametersDifference {
  73     NumberParameters,
  74     ParameterType,
  75     ParameterName,
  76   };
  77   auto DiagError = [&Diags, &GetDiagMethodType, FirstContainer, FirstModule,
  78                     FirstMethod](ODRMethodParametersDifference DiffType) {
  79     DeclarationName FirstName = FirstMethod->getDeclName();
  80     DiagMethodType FirstMethodType = GetDiagMethodType(FirstMethod);
  81     return Diags.Report(FirstMethod->getLocation(),
  82                         diag::err_module_odr_violation_method_params)
  83            << FirstContainer << FirstModule.empty() << FirstModule
  84            << FirstMethod->getSourceRange() << DiffType << FirstMethodType
  85            << FirstName;
  86   };
  87   auto DiagNote = [&Diags, &GetDiagMethodType, SecondModule,
  88                    SecondMethod](ODRMethodParametersDifference DiffType) {
  89     DeclarationName SecondName = SecondMethod->getDeclName();
  90     DiagMethodType SecondMethodType = GetDiagMethodType(SecondMethod);
  91     return Diags.Report(SecondMethod->getLocation(),
  92                         diag::note_module_odr_violation_method_params)
  93            << SecondModule.empty() << SecondModule
  94            << SecondMethod->getSourceRange() << DiffType << SecondMethodType
  95            << SecondName;
  96   };
  97
  98   const unsigned FirstNumParameters = FirstMethod->param_size();
  99   const unsigned SecondNumParameters = SecondMethod->param_size();
 100   if (FirstNumParameters != SecondNumParameters) {
 101     DiagError(NumberParameters) << FirstNumParameters;
 102     DiagNote(NumberParameters) << SecondNumParameters;
 103     return true;
 104   }
 105
 106   for (unsigned I = 0; I < FirstNumParameters; ++I) {
 107     const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
 108     const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
 109
 110     QualType FirstParamType = FirstParam->getType();
 111     QualType SecondParamType = SecondParam->getType();
 112     if (FirstParamType != SecondParamType &&
 113         computeODRHash(FirstParamType) != computeODRHash(SecondParamType)) {
 114       if (const DecayedType *ParamDecayedType =
 115               FirstParamType->getAs<DecayedType>()) {
 116         DiagError(ParameterType) << (I + 1) << FirstParamType << true
 117                                  << ParamDecayedType->getOriginalType();
 118       } else {
 119         DiagError(ParameterType) << (I + 1) << FirstParamType << false;
 120       }
 121
 122       if (const DecayedType *ParamDecayedType =
 123               SecondParamType->getAs<DecayedType>()) {
 124         DiagNote(ParameterType) << (I + 1) << SecondParamType << true
 125                                 << ParamDecayedType->getOriginalType();
 126       } else {
 127         DiagNote(ParameterType) << (I + 1) << SecondParamType << false;
 128       }
 129       return true;
 130     }
 131
 132     DeclarationName FirstParamName = FirstParam->getDeclName();
 133     DeclarationName SecondParamName = SecondParam->getDeclName();
 134     if (FirstParamName != SecondParamName) {
 135       DiagError(ParameterName) << (I + 1) << FirstParamName;
 136       DiagNote(ParameterName) << (I + 1) << SecondParamName;
 137       return true;
 138     }
 139   }
 140
 141   return false;
 142 }
 143
 144 bool ODRDiagsEmitter::diagnoseSubMismatchField(
 145     const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
 146     const FieldDecl *FirstField, const FieldDecl *SecondField) const {
 147   enum ODRFieldDifference {
 148     FieldName,
 149     FieldTypeName,
 150     FieldSingleBitField,
 151     FieldDifferentWidthBitField,
 152     FieldSingleMutable,
 153     FieldSingleInitializer,
 154     FieldDifferentInitializers,
 155   };
 156
 157   auto DiagError = [FirstRecord, FirstField, FirstModule,
 158                     this](ODRFieldDifference DiffType) {
 159     return Diag(FirstField->getLocation(), diag::err_module_odr_violation_field)
 160            << FirstRecord << FirstModule.empty() << FirstModule
 161            << FirstField->getSourceRange() << DiffType;
 162   };
 163   auto DiagNote = [SecondField, SecondModule,
 164                    this](ODRFieldDifference DiffType) {
 165     return Diag(SecondField->getLocation(),
 166                 diag::note_module_odr_violation_field)
 167            << SecondModule.empty() << SecondModule << SecondField->getSourceRange() << DiffType;
 168   };
 169
 170   IdentifierInfo *FirstII = FirstField->getIdentifier();
 171   IdentifierInfo *SecondII = SecondField->getIdentifier();
 172   if (FirstII->getName() != SecondII->getName()) {
 173     DiagError(FieldName) << FirstII;
 174     DiagNote(FieldName) << SecondII;
 175     return true;
 176   }
 177
 178   QualType FirstType = FirstField->getType();
 179   QualType SecondType = SecondField->getType();
 180   if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
 181     DiagError(FieldTypeName) << FirstII << FirstType;
 182     DiagNote(FieldTypeName) << SecondII << SecondType;
 183     return true;
 184   }
 185
 186   assert(Context.hasSameType(FirstField->getType(), SecondField->getType()));
 187   (void)Context;
 188
 189   const bool IsFirstBitField = FirstField->isBitField();
 190   const bool IsSecondBitField = SecondField->isBitField();
 191   if (IsFirstBitField != IsSecondBitField) {
 192     DiagError(FieldSingleBitField) << FirstII << IsFirstBitField;
 193     DiagNote(FieldSingleBitField) << SecondII << IsSecondBitField;
 194     return true;
 195   }
 196
 197   if (IsFirstBitField && IsSecondBitField) {
 198     unsigned FirstBitWidthHash = computeODRHash(FirstField->getBitWidth());
 199     unsigned SecondBitWidthHash = computeODRHash(SecondField->getBitWidth());
 200     if (FirstBitWidthHash != SecondBitWidthHash) {
 201       DiagError(FieldDifferentWidthBitField)
 202           << FirstII << FirstField->getBitWidth()->getSourceRange();
 203       DiagNote(FieldDifferentWidthBitField)
 204           << SecondII << SecondField->getBitWidth()->getSourceRange();
 205       return true;
 206     }
 207   }
 208
 209   if (!LangOpts.CPlusPlus)
 210     return false;
 211
 212   const bool IsFirstMutable = FirstField->isMutable();
 213   const bool IsSecondMutable = SecondField->isMutable();
 214   if (IsFirstMutable != IsSecondMutable) {
 215     DiagError(FieldSingleMutable) << FirstII << IsFirstMutable;
 216     DiagNote(FieldSingleMutable) << SecondII << IsSecondMutable;
 217     return true;
 218   }
 219
 220   const Expr *FirstInitializer = FirstField->getInClassInitializer();
 221   const Expr *SecondInitializer = SecondField->getInClassInitializer();
 222   if ((!FirstInitializer && SecondInitializer) ||
 223       (FirstInitializer && !SecondInitializer)) {
 224     DiagError(FieldSingleInitializer)
 225         << FirstII << (FirstInitializer != nullptr);
 226     DiagNote(FieldSingleInitializer)
 227         << SecondII << (SecondInitializer != nullptr);
 228     return true;
 229   }
 230
 231   if (FirstInitializer && SecondInitializer) {
 232     unsigned FirstInitHash = computeODRHash(FirstInitializer);
 233     unsigned SecondInitHash = computeODRHash(SecondInitializer);
 234     if (FirstInitHash != SecondInitHash) {
 235       DiagError(FieldDifferentInitializers)
 236           << FirstII << FirstInitializer->getSourceRange();
 237       DiagNote(FieldDifferentInitializers)
 238           << SecondII << SecondInitializer->getSourceRange();
 239       return true;
 240     }
 241   }
 242
 243   return false;
 244 }
 245
 246 bool ODRDiagsEmitter::diagnoseSubMismatchTypedef(
 247     const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
 248     const TypedefNameDecl *FirstTD, const TypedefNameDecl *SecondTD,
 249     bool IsTypeAlias) const {
 250   enum ODRTypedefDifference {
 251     TypedefName,
 252     TypedefType,
 253   };
 254
 255   auto DiagError = [FirstRecord, FirstTD, FirstModule,
 256                     this](ODRTypedefDifference DiffType) {
 257     return Diag(FirstTD->getLocation(), diag::err_module_odr_violation_typedef)
 258            << FirstRecord << FirstModule.empty() << FirstModule
 259            << FirstTD->getSourceRange() << DiffType;
 260   };
 261   auto DiagNote = [SecondTD, SecondModule,
 262                    this](ODRTypedefDifference DiffType) {
 263     return Diag(SecondTD->getLocation(),
 264                 diag::note_module_odr_violation_typedef)
 265            << SecondModule << SecondTD->getSourceRange() << DiffType;
 266   };
 267
 268   DeclarationName FirstName = FirstTD->getDeclName();
 269   DeclarationName SecondName = SecondTD->getDeclName();
 270   if (FirstName != SecondName) {
 271     DiagError(TypedefName) << IsTypeAlias << FirstName;
 272     DiagNote(TypedefName) << IsTypeAlias << SecondName;
 273     return true;
 274   }
 275
 276   QualType FirstType = FirstTD->getUnderlyingType();
 277   QualType SecondType = SecondTD->getUnderlyingType();
 278   if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
 279     DiagError(TypedefType) << IsTypeAlias << FirstName << FirstType;
 280     DiagNote(TypedefType) << IsTypeAlias << SecondName << SecondType;
 281     return true;
 282   }
 283   return false;
 284 }
 285
 286 bool ODRDiagsEmitter::diagnoseSubMismatchVar(const NamedDecl *FirstRecord,
 287                                              StringRef FirstModule,
 288                                              StringRef SecondModule,
 289                                              const VarDecl *FirstVD,
 290                                              const VarDecl *SecondVD) const {
 291   enum ODRVarDifference {
 292     VarName,
 293     VarType,
 294     VarSingleInitializer,
 295     VarDifferentInitializer,
 296     VarConstexpr,
 297   };
 298
 299   auto DiagError = [FirstRecord, FirstVD, FirstModule,
 300                     this](ODRVarDifference DiffType) {
 301     return Diag(FirstVD->getLocation(), diag::err_module_odr_violation_variable)
 302            << FirstRecord << FirstModule.empty() << FirstModule
 303            << FirstVD->getSourceRange() << DiffType;
 304   };
 305   auto DiagNote = [SecondVD, SecondModule, this](ODRVarDifference DiffType) {
 306     return Diag(SecondVD->getLocation(),
 307                 diag::note_module_odr_violation_variable)
 308            << SecondModule << SecondVD->getSourceRange() << DiffType;
 309   };
 310
 311   DeclarationName FirstName = FirstVD->getDeclName();
 312   DeclarationName SecondName = SecondVD->getDeclName();
 313   if (FirstName != SecondName) {
 314     DiagError(VarName) << FirstName;
 315     DiagNote(VarName) << SecondName;
 316     return true;
 317   }
 318
 319   QualType FirstType = FirstVD->getType();
 320   QualType SecondType = SecondVD->getType();
 321   if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
 322     DiagError(VarType) << FirstName << FirstType;
 323     DiagNote(VarType) << SecondName << SecondType;
 324     return true;
 325   }
 326
 327   if (!LangOpts.CPlusPlus)
 328     return false;
 329
 330   const Expr *FirstInit = FirstVD->getInit();
 331   const Expr *SecondInit = SecondVD->getInit();
 332   if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
 333     DiagError(VarSingleInitializer)
 334         << FirstName << (FirstInit == nullptr)
 335         << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
 336     DiagNote(VarSingleInitializer)
 337         << SecondName << (SecondInit == nullptr)
 338         << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
 339     return true;
 340   }
 341
 342   if (FirstInit && SecondInit &&
 343       computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
 344     DiagError(VarDifferentInitializer)
 345         << FirstName << FirstInit->getSourceRange();
 346     DiagNote(VarDifferentInitializer)
 347         << SecondName << SecondInit->getSourceRange();
 348     return true;
 349   }
 350
 351   const bool FirstIsConstexpr = FirstVD->isConstexpr();
 352   const bool SecondIsConstexpr = SecondVD->isConstexpr();
 353   if (FirstIsConstexpr != SecondIsConstexpr) {
 354     DiagError(VarConstexpr) << FirstName << FirstIsConstexpr;
 355     DiagNote(VarConstexpr) << SecondName << SecondIsConstexpr;
 356     return true;
 357   }
 358   return false;
 359 }
 360
 361 bool ODRDiagsEmitter::diagnoseSubMismatchProtocols(
 362     const ObjCProtocolList &FirstProtocols,
 363     const ObjCContainerDecl *FirstContainer, StringRef FirstModule,
 364     const ObjCProtocolList &SecondProtocols,
 365     const ObjCContainerDecl *SecondContainer, StringRef SecondModule) const {
 366   // Keep in sync with err_module_odr_violation_referenced_protocols.
 367   enum ODRReferencedProtocolDifference {
 368     NumProtocols,
 369     ProtocolType,
 370   };
 371   auto DiagRefProtocolError = [FirstContainer, FirstModule,
 372                                this](SourceLocation Loc, SourceRange Range,
 373                                      ODRReferencedProtocolDifference DiffType) {
 374     return Diag(Loc, diag::err_module_odr_violation_referenced_protocols)
 375            << FirstContainer << FirstModule.empty() << FirstModule << Range
 376            << DiffType;
 377   };
 378   auto DiagRefProtocolNote = [SecondModule,
 379                               this](SourceLocation Loc, SourceRange Range,
 380                                     ODRReferencedProtocolDifference DiffType) {
 381     return Diag(Loc, diag::note_module_odr_violation_referenced_protocols)
 382            << SecondModule.empty() << SecondModule << Range << DiffType;
 383   };
 384   auto GetProtoListSourceRange = [](const ObjCProtocolList &PL) {
 385     if (PL.empty())
 386       return SourceRange();
 387     return SourceRange(*PL.loc_begin(), *std::prev(PL.loc_end()));
 388   };
 389
 390   if (FirstProtocols.size() != SecondProtocols.size()) {
 391     DiagRefProtocolError(FirstContainer->getLocation(),
 392                          GetProtoListSourceRange(FirstProtocols), NumProtocols)
 393         << FirstProtocols.size();
 394     DiagRefProtocolNote(SecondContainer->getLocation(),
 395                         GetProtoListSourceRange(SecondProtocols), NumProtocols)
 396         << SecondProtocols.size();
 397     return true;
 398   }
 399
 400   for (unsigned I = 0, E = FirstProtocols.size(); I != E; ++I) {
 401     const ObjCProtocolDecl *FirstProtocol = FirstProtocols[I];
 402     const ObjCProtocolDecl *SecondProtocol = SecondProtocols[I];
 403     DeclarationName FirstProtocolName = FirstProtocol->getDeclName();
 404     DeclarationName SecondProtocolName = SecondProtocol->getDeclName();
 405     if (FirstProtocolName != SecondProtocolName) {
 406       SourceLocation FirstLoc = *(FirstProtocols.loc_begin() + I);
 407       SourceLocation SecondLoc = *(SecondProtocols.loc_begin() + I);
 408       SourceRange EmptyRange;
 409       DiagRefProtocolError(FirstLoc, EmptyRange, ProtocolType)
 410           << (I + 1) << FirstProtocolName;
 411       DiagRefProtocolNote(SecondLoc, EmptyRange, ProtocolType)
 412           << (I + 1) << SecondProtocolName;
 413       return true;
 414     }
 415   }
 416
 417   return false;
 418 }
 419
 420 bool ODRDiagsEmitter::diagnoseSubMismatchObjCMethod(
 421     const NamedDecl *FirstObjCContainer, StringRef FirstModule,
 422     StringRef SecondModule, const ObjCMethodDecl *FirstMethod,
 423     const ObjCMethodDecl *SecondMethod) const {
 424   enum ODRMethodDifference {
 425     ReturnType,
 426     InstanceOrClass,
 427     ControlLevel, // optional/required
 428     DesignatedInitializer,
 429     Directness,
 430     Name,
 431   };
 432
 433   auto DiagError = [FirstObjCContainer, FirstModule, FirstMethod,
 434                     this](ODRMethodDifference DiffType) {
 435     return Diag(FirstMethod->getLocation(),
 436                 diag::err_module_odr_violation_objc_method)
 437            << FirstObjCContainer << FirstModule.empty() << FirstModule
 438            << FirstMethod->getSourceRange() << DiffType;
 439   };
 440   auto DiagNote = [SecondModule, SecondMethod,
 441                    this](ODRMethodDifference DiffType) {
 442     return Diag(SecondMethod->getLocation(),
 443                 diag::note_module_odr_violation_objc_method)
 444            << SecondModule.empty() << SecondModule
 445            << SecondMethod->getSourceRange() << DiffType;
 446   };
 447
 448   if (computeODRHash(FirstMethod->getReturnType()) !=
 449       computeODRHash(SecondMethod->getReturnType())) {
 450     DiagError(ReturnType) << FirstMethod << FirstMethod->getReturnType();
 451     DiagNote(ReturnType) << SecondMethod << SecondMethod->getReturnType();
 452     return true;
 453   }
 454
 455   if (FirstMethod->isInstanceMethod() != SecondMethod->isInstanceMethod()) {
 456     DiagError(InstanceOrClass)
 457         << FirstMethod << FirstMethod->isInstanceMethod();
 458     DiagNote(InstanceOrClass)
 459         << SecondMethod << SecondMethod->isInstanceMethod();
 460     return true;
 461   }
 462   if (FirstMethod->getImplementationControl() !=
 463       SecondMethod->getImplementationControl()) {
 464     DiagError(ControlLevel)
 465         << llvm::to_underlying(FirstMethod->getImplementationControl());
 466     DiagNote(ControlLevel) << llvm::to_underlying(
 467         SecondMethod->getImplementationControl());
 468     return true;
 469   }
 470   if (FirstMethod->isThisDeclarationADesignatedInitializer() !=
 471       SecondMethod->isThisDeclarationADesignatedInitializer()) {
 472     DiagError(DesignatedInitializer)
 473         << FirstMethod
 474         << FirstMethod->isThisDeclarationADesignatedInitializer();
 475     DiagNote(DesignatedInitializer)
 476         << SecondMethod
 477         << SecondMethod->isThisDeclarationADesignatedInitializer();
 478     return true;
 479   }
 480   if (FirstMethod->isDirectMethod() != SecondMethod->isDirectMethod()) {
 481     DiagError(Directness) << FirstMethod << FirstMethod->isDirectMethod();
 482     DiagNote(Directness) << SecondMethod << SecondMethod->isDirectMethod();
 483     return true;
 484   }
 485   if (diagnoseSubMismatchMethodParameters(Diags, FirstObjCContainer,
 486                                           FirstModule, SecondModule,
 487                                           FirstMethod, SecondMethod))
 488     return true;
 489
 490   // Check method name *after* looking at the parameters otherwise we get a
 491   // less ideal diagnostics: a ObjCMethodName mismatch given that selectors
 492   // for different parameters are likely to be different.
 493   DeclarationName FirstName = FirstMethod->getDeclName();
 494   DeclarationName SecondName = SecondMethod->getDeclName();
 495   if (FirstName != SecondName) {
 496     DiagError(Name) << FirstName;
 497     DiagNote(Name) << SecondName;
 498     return true;
 499   }
 500
 501   return false;
 502 }
 503
 504 bool ODRDiagsEmitter::diagnoseSubMismatchObjCProperty(
 505     const NamedDecl *FirstObjCContainer, StringRef FirstModule,
 506     StringRef SecondModule, const ObjCPropertyDecl *FirstProp,
 507     const ObjCPropertyDecl *SecondProp) const {
 508   enum ODRPropertyDifference {
 509     Name,
 510     Type,
 511     ControlLevel, // optional/required
 512     Attribute,
 513   };
 514
 515   auto DiagError = [FirstObjCContainer, FirstModule, FirstProp,
 516                     this](SourceLocation Loc, ODRPropertyDifference DiffType) {
 517     return Diag(Loc, diag::err_module_odr_violation_objc_property)
 518            << FirstObjCContainer << FirstModule.empty() << FirstModule
 519            << FirstProp->getSourceRange() << DiffType;
 520   };
 521   auto DiagNote = [SecondModule, SecondProp,
 522                    this](SourceLocation Loc, ODRPropertyDifference DiffType) {
 523     return Diag(Loc, diag::note_module_odr_violation_objc_property)
 524            << SecondModule.empty() << SecondModule
 525            << SecondProp->getSourceRange() << DiffType;
 526   };
 527
 528   IdentifierInfo *FirstII = FirstProp->getIdentifier();
 529   IdentifierInfo *SecondII = SecondProp->getIdentifier();
 530   if (FirstII->getName() != SecondII->getName()) {
 531     DiagError(FirstProp->getLocation(), Name) << FirstII;
 532     DiagNote(SecondProp->getLocation(), Name) << SecondII;
 533     return true;
 534   }
 535   if (computeODRHash(FirstProp->getType()) !=
 536       computeODRHash(SecondProp->getType())) {
 537     DiagError(FirstProp->getLocation(), Type)
 538         << FirstII << FirstProp->getType();
 539     DiagNote(SecondProp->getLocation(), Type)
 540         << SecondII << SecondProp->getType();
 541     return true;
 542   }
 543   if (FirstProp->getPropertyImplementation() !=
 544       SecondProp->getPropertyImplementation()) {
 545     DiagError(FirstProp->getLocation(), ControlLevel)
 546         << FirstProp->getPropertyImplementation();
 547     DiagNote(SecondProp->getLocation(), ControlLevel)
 548         << SecondProp->getPropertyImplementation();
 549     return true;
 550   }
 551
 552   // Go over the property attributes and stop at the first mismatch.
 553   unsigned FirstAttrs = (unsigned)FirstProp->getPropertyAttributes();
 554   unsigned SecondAttrs = (unsigned)SecondProp->getPropertyAttributes();
 555   if (FirstAttrs != SecondAttrs) {
 556     for (unsigned I = 0; I < NumObjCPropertyAttrsBits; ++I) {
 557       unsigned CheckedAttr = (1 << I);
 558       if ((FirstAttrs & CheckedAttr) == (SecondAttrs & CheckedAttr))
 559         continue;
 560
 561       bool IsFirstWritten =
 562           (unsigned)FirstProp->getPropertyAttributesAsWritten() & CheckedAttr;
 563       bool IsSecondWritten =
 564           (unsigned)SecondProp->getPropertyAttributesAsWritten() & CheckedAttr;
 565       DiagError(IsFirstWritten ? FirstProp->getLParenLoc()
 566                                : FirstProp->getLocation(),
 567                 Attribute)
 568           << FirstII << (I + 1) << IsFirstWritten;
 569       DiagNote(IsSecondWritten ? SecondProp->getLParenLoc()
 570                                : SecondProp->getLocation(),
 571                Attribute)
 572           << SecondII << (I + 1);
 573       return true;
 574     }
 575   }
 576
 577   return false;
 578 }
 579
 580 ODRDiagsEmitter::DiffResult
 581 ODRDiagsEmitter::FindTypeDiffs(DeclHashes &FirstHashes,
 582                                DeclHashes &SecondHashes) {
 583   auto DifferenceSelector = [](const Decl *D) {
 584     assert(D && "valid Decl required");
 585     switch (D->getKind()) {
 586     default:
 587       return Other;
 588     case Decl::AccessSpec:
 589       switch (D->getAccess()) {
 590       case AS_public:
 591         return PublicSpecifer;
 592       case AS_private:
 593         return PrivateSpecifer;
 594       case AS_protected:
 595         return ProtectedSpecifer;
 596       case AS_none:
 597         break;
 598       }
 599       llvm_unreachable("Invalid access specifier");
 600     case Decl::StaticAssert:
 601       return StaticAssert;
 602     case Decl::Field:
 603       return Field;
 604     case Decl::CXXMethod:
 605     case Decl::CXXConstructor:
 606     case Decl::CXXDestructor:
 607       return CXXMethod;
 608     case Decl::TypeAlias:
 609       return TypeAlias;
 610     case Decl::Typedef:
 611       return TypeDef;
 612     case Decl::Var:
 613       return Var;
 614     case Decl::Friend:
 615       return Friend;
 616     case Decl::FunctionTemplate:
 617       return FunctionTemplate;
 618     case Decl::ObjCMethod:
 619       return ObjCMethod;
 620     case Decl::ObjCIvar:
 621       return ObjCIvar;
 622     case Decl::ObjCProperty:
 623       return ObjCProperty;
 624     }
 625   };
 626
 627   DiffResult DR;
 628   auto FirstIt = FirstHashes.begin();
 629   auto SecondIt = SecondHashes.begin();
 630   while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
 631     if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
 632         FirstIt->second == SecondIt->second) {
 633       ++FirstIt;
 634       ++SecondIt;
 635       continue;
 636     }
 637
 638     DR.FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
 639     DR.SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
 640
 641     DR.FirstDiffType =
 642         DR.FirstDecl ? DifferenceSelector(DR.FirstDecl) : EndOfClass;
 643     DR.SecondDiffType =
 644         DR.SecondDecl ? DifferenceSelector(DR.SecondDecl) : EndOfClass;
 645     return DR;
 646   }
 647   return DR;
 648 }
 649
 650 void ODRDiagsEmitter::diagnoseSubMismatchUnexpected(
 651     DiffResult &DR, const NamedDecl *FirstRecord, StringRef FirstModule,
 652     const NamedDecl *SecondRecord, StringRef SecondModule) const {
 653   Diag(FirstRecord->getLocation(),
 654        diag::err_module_odr_violation_different_definitions)
 655       << FirstRecord << FirstModule.empty() << FirstModule;
 656
 657   if (DR.FirstDecl) {
 658     Diag(DR.FirstDecl->getLocation(), diag::note_first_module_difference)
 659         << FirstRecord << DR.FirstDecl->getSourceRange();
 660   }
 661
 662   Diag(SecondRecord->getLocation(),
 663        diag::note_module_odr_violation_different_definitions)
 664       << SecondModule;
 665
 666   if (DR.SecondDecl) {
 667     Diag(DR.SecondDecl->getLocation(), diag::note_second_module_difference)
 668         << DR.SecondDecl->getSourceRange();
 669   }
 670 }
 671
 672 void ODRDiagsEmitter::diagnoseSubMismatchDifferentDeclKinds(
 673     DiffResult &DR, const NamedDecl *FirstRecord, StringRef FirstModule,
 674     const NamedDecl *SecondRecord, StringRef SecondModule) const {
 675   auto GetMismatchedDeclLoc = [](const NamedDecl *Container,
 676                                  ODRMismatchDecl DiffType, const Decl *D) {
 677     SourceLocation Loc;
 678     SourceRange Range;
 679     if (DiffType == EndOfClass) {
 680       if (auto *Tag = dyn_cast<TagDecl>(Container))
 681         Loc = Tag->getBraceRange().getEnd();
 682       else if (auto *IF = dyn_cast<ObjCInterfaceDecl>(Container))
 683         Loc = IF->getAtEndRange().getBegin();
 684       else
 685         Loc = Container->getEndLoc();
 686     } else {
 687       Loc = D->getLocation();
 688       Range = D->getSourceRange();
 689     }
 690     return std::make_pair(Loc, Range);
 691   };
 692
 693   auto FirstDiagInfo =
 694       GetMismatchedDeclLoc(FirstRecord, DR.FirstDiffType, DR.FirstDecl);
 695   Diag(FirstDiagInfo.first, diag::err_module_odr_violation_mismatch_decl)
 696       << FirstRecord << FirstModule.empty() << FirstModule
 697       << FirstDiagInfo.second << DR.FirstDiffType;
 698
 699   auto SecondDiagInfo =
 700       GetMismatchedDeclLoc(SecondRecord, DR.SecondDiffType, DR.SecondDecl);
 701   Diag(SecondDiagInfo.first, diag::note_module_odr_violation_mismatch_decl)
 702       << SecondModule.empty() << SecondModule << SecondDiagInfo.second
 703       << DR.SecondDiffType;
 704 }
 705
 706 bool ODRDiagsEmitter::diagnoseMismatch(
 707     const CXXRecordDecl *FirstRecord, const CXXRecordDecl *SecondRecord,
 708     const struct CXXRecordDecl::DefinitionData *SecondDD) const {
 709   // Multiple different declarations got merged together; tell the user
 710   // where they came from.
 711   if (FirstRecord == SecondRecord)
 712     return false;
 713
 714   std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
 715   std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
 716
 717   const struct CXXRecordDecl::DefinitionData *FirstDD =
 718       FirstRecord->DefinitionData;
 719   assert(FirstDD && SecondDD && "Definitions without DefinitionData");
 720
 721   // Diagnostics from DefinitionData are emitted here.
 722   if (FirstDD != SecondDD) {
 723     // Keep in sync with err_module_odr_violation_definition_data.
 724     enum ODRDefinitionDataDifference {
 725       NumBases,
 726       NumVBases,
 727       BaseType,
 728       BaseVirtual,
 729       BaseAccess,
 730     };
 731     auto DiagBaseError = [FirstRecord, &FirstModule,
 732                           this](SourceLocation Loc, SourceRange Range,
 733                                 ODRDefinitionDataDifference DiffType) {
 734       return Diag(Loc, diag::err_module_odr_violation_definition_data)
 735              << FirstRecord << FirstModule.empty() << FirstModule << Range
 736              << DiffType;
 737     };
 738     auto DiagBaseNote = [&SecondModule,
 739                          this](SourceLocation Loc, SourceRange Range,
 740                                ODRDefinitionDataDifference DiffType) {
 741       return Diag(Loc, diag::note_module_odr_violation_definition_data)
 742              << SecondModule << Range << DiffType;
 743     };
 744     auto GetSourceRange = [](const struct CXXRecordDecl::DefinitionData *DD) {
 745       unsigned NumBases = DD->NumBases;
 746       if (NumBases == 0)
 747         return SourceRange();
 748       ArrayRef<CXXBaseSpecifier> bases = DD->bases();
 749       return SourceRange(bases[0].getBeginLoc(),
 750                          bases[NumBases - 1].getEndLoc());
 751     };
 752
 753     unsigned FirstNumBases = FirstDD->NumBases;
 754     unsigned FirstNumVBases = FirstDD->NumVBases;
 755     unsigned SecondNumBases = SecondDD->NumBases;
 756     unsigned SecondNumVBases = SecondDD->NumVBases;
 757     if (FirstNumBases != SecondNumBases) {
 758       DiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
 759                     NumBases)
 760           << FirstNumBases;
 761       DiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
 762                    NumBases)
 763           << SecondNumBases;
 764       return true;
 765     }
 766
 767     if (FirstNumVBases != SecondNumVBases) {
 768       DiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
 769                     NumVBases)
 770           << FirstNumVBases;
 771       DiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
 772                    NumVBases)
 773           << SecondNumVBases;
 774       return true;
 775     }
 776
 777     ArrayRef<CXXBaseSpecifier> FirstBases = FirstDD->bases();
 778     ArrayRef<CXXBaseSpecifier> SecondBases = SecondDD->bases();
 779     for (unsigned I = 0; I < FirstNumBases; ++I) {
 780       const CXXBaseSpecifier FirstBase = FirstBases[I];
 781       const CXXBaseSpecifier SecondBase = SecondBases[I];
 782       if (computeODRHash(FirstBase.getType()) !=
 783           computeODRHash(SecondBase.getType())) {
 784         DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
 785                       BaseType)
 786             << (I + 1) << FirstBase.getType();
 787         DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
 788                      BaseType)
 789             << (I + 1) << SecondBase.getType();
 790         return true;
 791       }
 792
 793       if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
 794         DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
 795                       BaseVirtual)
 796             << (I + 1) << FirstBase.isVirtual() << FirstBase.getType();
 797         DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
 798                      BaseVirtual)
 799             << (I + 1) << SecondBase.isVirtual() << SecondBase.getType();
 800         return true;
 801       }
 802
 803       if (FirstBase.getAccessSpecifierAsWritten() !=
 804           SecondBase.getAccessSpecifierAsWritten()) {
 805         DiagBaseError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
 806                       BaseAccess)
 807             << (I + 1) << FirstBase.getType()
 808             << (int)FirstBase.getAccessSpecifierAsWritten();
 809         DiagBaseNote(SecondRecord->getLocation(), SecondBase.getSourceRange(),
 810                      BaseAccess)
 811             << (I + 1) << SecondBase.getType()
 812             << (int)SecondBase.getAccessSpecifierAsWritten();
 813         return true;
 814       }
 815     }
 816   }
 817
 818   const ClassTemplateDecl *FirstTemplate =
 819       FirstRecord->getDescribedClassTemplate();
 820   const ClassTemplateDecl *SecondTemplate =
 821       SecondRecord->getDescribedClassTemplate();
 822
 823   assert(!FirstTemplate == !SecondTemplate &&
 824          "Both pointers should be null or non-null");
 825
 826   if (FirstTemplate && SecondTemplate) {
 827     ArrayRef<const NamedDecl *> FirstTemplateParams =
 828         FirstTemplate->getTemplateParameters()->asArray();
 829     ArrayRef<const NamedDecl *> SecondTemplateParams =
 830         SecondTemplate->getTemplateParameters()->asArray();
 831     assert(FirstTemplateParams.size() == SecondTemplateParams.size() &&
 832            "Number of template parameters should be equal.");
 833     for (auto Pair : llvm::zip(FirstTemplateParams, SecondTemplateParams)) {
 834       const NamedDecl *FirstDecl = std::get<0>(Pair);
 835       const NamedDecl *SecondDecl = std::get<1>(Pair);
 836       if (computeODRHash(FirstDecl) == computeODRHash(SecondDecl))
 837         continue;
 838
 839       assert(FirstDecl->getKind() == SecondDecl->getKind() &&
 840              "Parameter Decl's should be the same kind.");
 841
 842       enum ODRTemplateDifference {
 843         ParamEmptyName,
 844         ParamName,
 845         ParamSingleDefaultArgument,
 846         ParamDifferentDefaultArgument,
 847       };
 848
 849       auto hasDefaultArg = [](const NamedDecl *D) {
 850         if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
 851           return TTP->hasDefaultArgument() &&
 852                  !TTP->defaultArgumentWasInherited();
 853         if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
 854           return NTTP->hasDefaultArgument() &&
 855                  !NTTP->defaultArgumentWasInherited();
 856         auto *TTP = cast<TemplateTemplateParmDecl>(D);
 857         return TTP->hasDefaultArgument() && !TTP->defaultArgumentWasInherited();
 858       };
 859       bool hasFirstArg = hasDefaultArg(FirstDecl);
 860       bool hasSecondArg = hasDefaultArg(SecondDecl);
 861
 862       ODRTemplateDifference ErrDiffType;
 863       ODRTemplateDifference NoteDiffType;
 864
 865       DeclarationName FirstName = FirstDecl->getDeclName();
 866       DeclarationName SecondName = SecondDecl->getDeclName();
 867
 868       if (FirstName != SecondName) {
 869         bool FirstNameEmpty =
 870             FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
 871         bool SecondNameEmpty =
 872             SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
 873         ErrDiffType = FirstNameEmpty ? ParamEmptyName : ParamName;
 874         NoteDiffType = SecondNameEmpty ? ParamEmptyName : ParamName;
 875       } else if (hasFirstArg == hasSecondArg)
 876         ErrDiffType = NoteDiffType = ParamDifferentDefaultArgument;
 877       else
 878         ErrDiffType = NoteDiffType = ParamSingleDefaultArgument;
 879
 880       Diag(FirstDecl->getLocation(),
 881            diag::err_module_odr_violation_template_parameter)
 882           << FirstRecord << FirstModule.empty() << FirstModule
 883           << FirstDecl->getSourceRange() << ErrDiffType << hasFirstArg
 884           << FirstName;
 885       Diag(SecondDecl->getLocation(),
 886            diag::note_module_odr_violation_template_parameter)
 887           << SecondModule << SecondDecl->getSourceRange() << NoteDiffType
 888           << hasSecondArg << SecondName;
 889       return true;
 890     }
 891   }
 892
 893   auto PopulateHashes = [](DeclHashes &Hashes, const RecordDecl *Record,
 894                            const DeclContext *DC) {
 895     for (const Decl *D : Record->decls()) {
 896       if (!ODRHash::isSubDeclToBeProcessed(D, DC))
 897         continue;
 898       Hashes.emplace_back(D, computeODRHash(D));
 899     }
 900   };
 901
 902   DeclHashes FirstHashes;
 903   DeclHashes SecondHashes;
 904   const DeclContext *DC = FirstRecord;
 905   PopulateHashes(FirstHashes, FirstRecord, DC);
 906   PopulateHashes(SecondHashes, SecondRecord, DC);
 907
 908   DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
 909   ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
 910   ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
 911   const Decl *FirstDecl = DR.FirstDecl;
 912   const Decl *SecondDecl = DR.SecondDecl;
 913
 914   if (FirstDiffType == Other || SecondDiffType == Other) {
 915     diagnoseSubMismatchUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
 916                                   SecondModule);
 917     return true;
 918   }
 919
 920   if (FirstDiffType != SecondDiffType) {
 921     diagnoseSubMismatchDifferentDeclKinds(DR, FirstRecord, FirstModule,
 922                                           SecondRecord, SecondModule);
 923     return true;
 924   }
 925
 926   // Used with err_module_odr_violation_record and
 927   // note_module_odr_violation_record
 928   enum ODRCXXRecordDifference {
 929     StaticAssertCondition,
 930     StaticAssertMessage,
 931     StaticAssertOnlyMessage,
 932     MethodName,
 933     MethodDeleted,
 934     MethodDefaulted,
 935     MethodVirtual,
 936     MethodStatic,
 937     MethodVolatile,
 938     MethodConst,
 939     MethodInline,
 940     MethodParameterSingleDefaultArgument,
 941     MethodParameterDifferentDefaultArgument,
 942     MethodNoTemplateArguments,
 943     MethodDifferentNumberTemplateArguments,
 944     MethodDifferentTemplateArgument,
 945     MethodSingleBody,
 946     MethodDifferentBody,
 947     FriendTypeFunction,
 948     FriendType,
 949     FriendFunction,
 950     FunctionTemplateDifferentNumberParameters,
 951     FunctionTemplateParameterDifferentKind,
 952     FunctionTemplateParameterName,
 953     FunctionTemplateParameterSingleDefaultArgument,
 954     FunctionTemplateParameterDifferentDefaultArgument,
 955     FunctionTemplateParameterDifferentType,
 956     FunctionTemplatePackParameter,
 957   };
 958   auto DiagError = [FirstRecord, &FirstModule,
 959                     this](SourceLocation Loc, SourceRange Range,
 960                           ODRCXXRecordDifference DiffType) {
 961     return Diag(Loc, diag::err_module_odr_violation_record)
 962            << FirstRecord << FirstModule.empty() << FirstModule << Range
 963            << DiffType;
 964   };
 965   auto DiagNote = [&SecondModule, this](SourceLocation Loc, SourceRange Range,
 966                                         ODRCXXRecordDifference DiffType) {
 967     return Diag(Loc, diag::note_module_odr_violation_record)
 968            << SecondModule << Range << DiffType;
 969   };
 970
 971   assert(FirstDiffType == SecondDiffType);
 972   switch (FirstDiffType) {
 973   case Other:
 974   case EndOfClass:
 975   case PublicSpecifer:
 976   case PrivateSpecifer:
 977   case ProtectedSpecifer:
 978   case ObjCMethod:
 979   case ObjCIvar:
 980   case ObjCProperty:
 981     llvm_unreachable("Invalid diff type");
 982
 983   case StaticAssert: {
 984     const StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
 985     const StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
 986
 987     const Expr *FirstExpr = FirstSA->getAssertExpr();
 988     const Expr *SecondExpr = SecondSA->getAssertExpr();
 989     unsigned FirstODRHash = computeODRHash(FirstExpr);
 990     unsigned SecondODRHash = computeODRHash(SecondExpr);
 991     if (FirstODRHash != SecondODRHash) {
 992       DiagError(FirstExpr->getBeginLoc(), FirstExpr->getSourceRange(),
 993                 StaticAssertCondition);
 994       DiagNote(SecondExpr->getBeginLoc(), SecondExpr->getSourceRange(),
 995                StaticAssertCondition);
 996       return true;
 997     }
 998
 999     const Expr *FirstMessage = FirstSA->getMessage();
1000     const Expr *SecondMessage = SecondSA->getMessage();
1001     assert((FirstMessage || SecondMessage) && "Both messages cannot be empty");
1002     if ((FirstMessage && !SecondMessage) || (!FirstMessage && SecondMessage)) {
1003       SourceLocation FirstLoc, SecondLoc;
1004       SourceRange FirstRange, SecondRange;
1005       if (FirstMessage) {
1006         FirstLoc = FirstMessage->getBeginLoc();
1007         FirstRange = FirstMessage->getSourceRange();
1008       } else {
1009         FirstLoc = FirstSA->getBeginLoc();
1010         FirstRange = FirstSA->getSourceRange();
1011       }
1012       if (SecondMessage) {
1013         SecondLoc = SecondMessage->getBeginLoc();
1014         SecondRange = SecondMessage->getSourceRange();
1015       } else {
1016         SecondLoc = SecondSA->getBeginLoc();
1017         SecondRange = SecondSA->getSourceRange();
1018       }
1019       DiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
1020           << (FirstMessage == nullptr);
1021       DiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
1022           << (SecondMessage == nullptr);
1023       return true;
1024     }
1025
1026     if (FirstMessage && SecondMessage) {
1027       unsigned FirstMessageODRHash = computeODRHash(FirstMessage);
1028       unsigned SecondMessageODRHash = computeODRHash(SecondMessage);
1029       if (FirstMessageODRHash != SecondMessageODRHash) {
1030         DiagError(FirstMessage->getBeginLoc(), FirstMessage->getSourceRange(),
1031                   StaticAssertMessage);
1032         DiagNote(SecondMessage->getBeginLoc(), SecondMessage->getSourceRange(),
1033                  StaticAssertMessage);
1034         return true;
1035       }
1036     }
1037     break;
1038   }
1039
1040   case Field: {
1041     if (diagnoseSubMismatchField(FirstRecord, FirstModule, SecondModule,
1042                                  cast<FieldDecl>(FirstDecl),
1043                                  cast<FieldDecl>(SecondDecl)))
1044       return true;
1045     break;
1046   }
1047
1048   case CXXMethod: {
1049     enum {
1050       DiagMethod,
1051       DiagConstructor,
1052       DiagDestructor,
1053     } FirstMethodType,
1054         SecondMethodType;
1055     auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl *D) {
1056       if (isa<CXXConstructorDecl>(D))
1057         return DiagConstructor;
1058       if (isa<CXXDestructorDecl>(D))
1059         return DiagDestructor;
1060       return DiagMethod;
1061     };
1062     const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
1063     const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
1064     FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
1065     SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
1066     DeclarationName FirstName = FirstMethod->getDeclName();
1067     DeclarationName SecondName = SecondMethod->getDeclName();
1068     auto DiagMethodError = [&DiagError, FirstMethod, FirstMethodType,
1069                             FirstName](ODRCXXRecordDifference DiffType) {
1070       return DiagError(FirstMethod->getLocation(),
1071                        FirstMethod->getSourceRange(), DiffType)
1072              << FirstMethodType << FirstName;
1073     };
1074     auto DiagMethodNote = [&DiagNote, SecondMethod, SecondMethodType,
1075                            SecondName](ODRCXXRecordDifference DiffType) {
1076       return DiagNote(SecondMethod->getLocation(),
1077                       SecondMethod->getSourceRange(), DiffType)
1078              << SecondMethodType << SecondName;
1079     };
1080
1081     if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
1082       DiagMethodError(MethodName);
1083       DiagMethodNote(MethodName);
1084       return true;
1085     }
1086
1087     const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
1088     const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
1089     if (FirstDeleted != SecondDeleted) {
1090       DiagMethodError(MethodDeleted) << FirstDeleted;
1091       DiagMethodNote(MethodDeleted) << SecondDeleted;
1092       return true;
1093     }
1094
1095     const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
1096     const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
1097     if (FirstDefaulted != SecondDefaulted) {
1098       DiagMethodError(MethodDefaulted) << FirstDefaulted;
1099       DiagMethodNote(MethodDefaulted) << SecondDefaulted;
1100       return true;
1101     }
1102
1103     const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
1104     const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
1105     const bool FirstPure = FirstMethod->isPure();
1106     const bool SecondPure = SecondMethod->isPure();
1107     if ((FirstVirtual || SecondVirtual) &&
1108         (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
1109       DiagMethodError(MethodVirtual) << FirstPure << FirstVirtual;
1110       DiagMethodNote(MethodVirtual) << SecondPure << SecondVirtual;
1111       return true;
1112     }
1113
1114     // CXXMethodDecl::isStatic uses the canonical Decl.  With Decl merging,
1115     // FirstDecl is the canonical Decl of SecondDecl, so the storage
1116     // class needs to be checked instead.
1117     StorageClass FirstStorage = FirstMethod->getStorageClass();
1118     StorageClass SecondStorage = SecondMethod->getStorageClass();
1119     const bool FirstStatic = FirstStorage == SC_Static;
1120     const bool SecondStatic = SecondStorage == SC_Static;
1121     if (FirstStatic != SecondStatic) {
1122       DiagMethodError(MethodStatic) << FirstStatic;
1123       DiagMethodNote(MethodStatic) << SecondStatic;
1124       return true;
1125     }
1126
1127     const bool FirstVolatile = FirstMethod->isVolatile();
1128     const bool SecondVolatile = SecondMethod->isVolatile();
1129     if (FirstVolatile != SecondVolatile) {
1130       DiagMethodError(MethodVolatile) << FirstVolatile;
1131       DiagMethodNote(MethodVolatile) << SecondVolatile;
1132       return true;
1133     }
1134
1135     const bool FirstConst = FirstMethod->isConst();
1136     const bool SecondConst = SecondMethod->isConst();
1137     if (FirstConst != SecondConst) {
1138       DiagMethodError(MethodConst) << FirstConst;
1139       DiagMethodNote(MethodConst) << SecondConst;
1140       return true;
1141     }
1142
1143     const bool FirstInline = FirstMethod->isInlineSpecified();
1144     const bool SecondInline = SecondMethod->isInlineSpecified();
1145     if (FirstInline != SecondInline) {
1146       DiagMethodError(MethodInline) << FirstInline;
1147       DiagMethodNote(MethodInline) << SecondInline;
1148       return true;
1149     }
1150
1151     if (diagnoseSubMismatchMethodParameters(Diags, FirstRecord,
1152                                             FirstModule, SecondModule,
1153                                             FirstMethod, SecondMethod))
1154       return true;
1155
1156     for (unsigned I = 0, N = FirstMethod->param_size(); I < N; ++I) {
1157       const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
1158       const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
1159
1160       const Expr *FirstInit = FirstParam->getInit();
1161       const Expr *SecondInit = SecondParam->getInit();
1162       if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
1163         DiagMethodError(MethodParameterSingleDefaultArgument)
1164             << (I + 1) << (FirstInit == nullptr)
1165             << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
1166         DiagMethodNote(MethodParameterSingleDefaultArgument)
1167             << (I + 1) << (SecondInit == nullptr)
1168             << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
1169         return true;
1170       }
1171
1172       if (FirstInit && SecondInit &&
1173           computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
1174         DiagMethodError(MethodParameterDifferentDefaultArgument)
1175             << (I + 1) << FirstInit->getSourceRange();
1176         DiagMethodNote(MethodParameterDifferentDefaultArgument)
1177             << (I + 1) << SecondInit->getSourceRange();
1178         return true;
1179       }
1180     }
1181
1182     const TemplateArgumentList *FirstTemplateArgs =
1183         FirstMethod->getTemplateSpecializationArgs();
1184     const TemplateArgumentList *SecondTemplateArgs =
1185         SecondMethod->getTemplateSpecializationArgs();
1186
1187     if ((FirstTemplateArgs && !SecondTemplateArgs) ||
1188         (!FirstTemplateArgs && SecondTemplateArgs)) {
1189       DiagMethodError(MethodNoTemplateArguments)
1190           << (FirstTemplateArgs != nullptr);
1191       DiagMethodNote(MethodNoTemplateArguments)
1192           << (SecondTemplateArgs != nullptr);
1193       return true;
1194     }
1195
1196     if (FirstTemplateArgs && SecondTemplateArgs) {
1197       // Remove pack expansions from argument list.
1198       auto ExpandTemplateArgumentList = [](const TemplateArgumentList *TAL) {
1199         llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
1200         for (const TemplateArgument &TA : TAL->asArray()) {
1201           if (TA.getKind() != TemplateArgument::Pack) {
1202             ExpandedList.push_back(&TA);
1203             continue;
1204           }
1205           llvm::append_range(ExpandedList,
1206                              llvm::make_pointer_range(TA.getPackAsArray()));
1207         }
1208         return ExpandedList;
1209       };
1210       llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
1211           ExpandTemplateArgumentList(FirstTemplateArgs);
1212       llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
1213           ExpandTemplateArgumentList(SecondTemplateArgs);
1214
1215       if (FirstExpandedList.size() != SecondExpandedList.size()) {
1216         DiagMethodError(MethodDifferentNumberTemplateArguments)
1217             << (unsigned)FirstExpandedList.size();
1218         DiagMethodNote(MethodDifferentNumberTemplateArguments)
1219             << (unsigned)SecondExpandedList.size();
1220         return true;
1221       }
1222
1223       for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
1224         const TemplateArgument &FirstTA = *FirstExpandedList[i],
1225                                &SecondTA = *SecondExpandedList[i];
1226         if (computeODRHash(FirstTA) == computeODRHash(SecondTA))
1227           continue;
1228
1229         DiagMethodError(MethodDifferentTemplateArgument) << FirstTA << i + 1;
1230         DiagMethodNote(MethodDifferentTemplateArgument) << SecondTA << i + 1;
1231         return true;
1232       }
1233     }
1234
1235     // Compute the hash of the method as if it has no body.
1236     auto ComputeCXXMethodODRHash = [](const CXXMethodDecl *D) {
1237       ODRHash Hasher;
1238       Hasher.AddFunctionDecl(D, true /*SkipBody*/);
1239       return Hasher.CalculateHash();
1240     };
1241
1242     // Compare the hash generated to the hash stored.  A difference means
1243     // that a body was present in the original source.  Due to merging,
1244     // the standard way of detecting a body will not work.
1245     const bool HasFirstBody =
1246         ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
1247     const bool HasSecondBody =
1248         ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
1249
1250     if (HasFirstBody != HasSecondBody) {
1251       DiagMethodError(MethodSingleBody) << HasFirstBody;
1252       DiagMethodNote(MethodSingleBody) << HasSecondBody;
1253       return true;
1254     }
1255
1256     if (HasFirstBody && HasSecondBody) {
1257       DiagMethodError(MethodDifferentBody);
1258       DiagMethodNote(MethodDifferentBody);
1259       return true;
1260     }
1261
1262     break;
1263   }
1264
1265   case TypeAlias:
1266   case TypeDef: {
1267     if (diagnoseSubMismatchTypedef(FirstRecord, FirstModule, SecondModule,
1268                                    cast<TypedefNameDecl>(FirstDecl),
1269                                    cast<TypedefNameDecl>(SecondDecl),
1270                                    FirstDiffType == TypeAlias))
1271       return true;
1272     break;
1273   }
1274   case Var: {
1275     if (diagnoseSubMismatchVar(FirstRecord, FirstModule, SecondModule,
1276                                cast<VarDecl>(FirstDecl),
1277                                cast<VarDecl>(SecondDecl)))
1278       return true;
1279     break;
1280   }
1281   case Friend: {
1282     const FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
1283     const FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
1284
1285     const NamedDecl *FirstND = FirstFriend->getFriendDecl();
1286     const NamedDecl *SecondND = SecondFriend->getFriendDecl();
1287
1288     TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
1289     TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
1290
1291     if (FirstND && SecondND) {
1292       DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
1293                 FriendFunction)
1294           << FirstND;
1295       DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
1296                FriendFunction)
1297           << SecondND;
1298       return true;
1299     }
1300
1301     if (FirstTSI && SecondTSI) {
1302       QualType FirstFriendType = FirstTSI->getType();
1303       QualType SecondFriendType = SecondTSI->getType();
1304       assert(computeODRHash(FirstFriendType) !=
1305              computeODRHash(SecondFriendType));
1306       DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
1307                 FriendType)
1308           << FirstFriendType;
1309       DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
1310                FriendType)
1311           << SecondFriendType;
1312       return true;
1313     }
1314
1315     DiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
1316               FriendTypeFunction)
1317         << (FirstTSI == nullptr);
1318     DiagNote(SecondFriend->getFriendLoc(), SecondFriend->getSourceRange(),
1319              FriendTypeFunction)
1320         << (SecondTSI == nullptr);
1321     return true;
1322   }
1323   case FunctionTemplate: {
1324     const FunctionTemplateDecl *FirstTemplate =
1325         cast<FunctionTemplateDecl>(FirstDecl);
1326     const FunctionTemplateDecl *SecondTemplate =
1327         cast<FunctionTemplateDecl>(SecondDecl);
1328
1329     TemplateParameterList *FirstTPL = FirstTemplate->getTemplateParameters();
1330     TemplateParameterList *SecondTPL = SecondTemplate->getTemplateParameters();
1331
1332     auto DiagTemplateError = [&DiagError,
1333                               FirstTemplate](ODRCXXRecordDifference DiffType) {
1334       return DiagError(FirstTemplate->getLocation(),
1335                        FirstTemplate->getSourceRange(), DiffType)
1336              << FirstTemplate;
1337     };
1338     auto DiagTemplateNote = [&DiagNote,
1339                              SecondTemplate](ODRCXXRecordDifference DiffType) {
1340       return DiagNote(SecondTemplate->getLocation(),
1341                       SecondTemplate->getSourceRange(), DiffType)
1342              << SecondTemplate;
1343     };
1344
1345     if (FirstTPL->size() != SecondTPL->size()) {
1346       DiagTemplateError(FunctionTemplateDifferentNumberParameters)
1347           << FirstTPL->size();
1348       DiagTemplateNote(FunctionTemplateDifferentNumberParameters)
1349           << SecondTPL->size();
1350       return true;
1351     }
1352
1353     for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
1354       NamedDecl *FirstParam = FirstTPL->getParam(i);
1355       NamedDecl *SecondParam = SecondTPL->getParam(i);
1356
1357       if (FirstParam->getKind() != SecondParam->getKind()) {
1358         enum {
1359           TemplateTypeParameter,
1360           NonTypeTemplateParameter,
1361           TemplateTemplateParameter,
1362         };
1363         auto GetParamType = [](NamedDecl *D) {
1364           switch (D->getKind()) {
1365           default:
1366             llvm_unreachable("Unexpected template parameter type");
1367           case Decl::TemplateTypeParm:
1368             return TemplateTypeParameter;
1369           case Decl::NonTypeTemplateParm:
1370             return NonTypeTemplateParameter;
1371           case Decl::TemplateTemplateParm:
1372             return TemplateTemplateParameter;
1373           }
1374         };
1375
1376         DiagTemplateError(FunctionTemplateParameterDifferentKind)
1377             << (i + 1) << GetParamType(FirstParam);
1378         DiagTemplateNote(FunctionTemplateParameterDifferentKind)
1379             << (i + 1) << GetParamType(SecondParam);
1380         return true;
1381       }
1382
1383       if (FirstParam->getName() != SecondParam->getName()) {
1384         DiagTemplateError(FunctionTemplateParameterName)
1385             << (i + 1) << (bool)FirstParam->getIdentifier() << FirstParam;
1386         DiagTemplateNote(FunctionTemplateParameterName)
1387             << (i + 1) << (bool)SecondParam->getIdentifier() << SecondParam;
1388         return true;
1389       }
1390
1391       if (isa<TemplateTypeParmDecl>(FirstParam) &&
1392           isa<TemplateTypeParmDecl>(SecondParam)) {
1393         TemplateTypeParmDecl *FirstTTPD =
1394             cast<TemplateTypeParmDecl>(FirstParam);
1395         TemplateTypeParmDecl *SecondTTPD =
1396             cast<TemplateTypeParmDecl>(SecondParam);
1397         bool HasFirstDefaultArgument =
1398             FirstTTPD->hasDefaultArgument() &&
1399             !FirstTTPD->defaultArgumentWasInherited();
1400         bool HasSecondDefaultArgument =
1401             SecondTTPD->hasDefaultArgument() &&
1402             !SecondTTPD->defaultArgumentWasInherited();
1403         if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
1404           DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
1405               << (i + 1) << HasFirstDefaultArgument;
1406           DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
1407               << (i + 1) << HasSecondDefaultArgument;
1408           return true;
1409         }
1410
1411         if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
1412           QualType FirstType = FirstTTPD->getDefaultArgument();
1413           QualType SecondType = SecondTTPD->getDefaultArgument();
1414           if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
1415             DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
1416                 << (i + 1) << FirstType;
1417             DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
1418                 << (i + 1) << SecondType;
1419             return true;
1420           }
1421         }
1422
1423         if (FirstTTPD->isParameterPack() != SecondTTPD->isParameterPack()) {
1424           DiagTemplateError(FunctionTemplatePackParameter)
1425               << (i + 1) << FirstTTPD->isParameterPack();
1426           DiagTemplateNote(FunctionTemplatePackParameter)
1427               << (i + 1) << SecondTTPD->isParameterPack();
1428           return true;
1429         }
1430       }
1431
1432       if (isa<TemplateTemplateParmDecl>(FirstParam) &&
1433           isa<TemplateTemplateParmDecl>(SecondParam)) {
1434         TemplateTemplateParmDecl *FirstTTPD =
1435             cast<TemplateTemplateParmDecl>(FirstParam);
1436         TemplateTemplateParmDecl *SecondTTPD =
1437             cast<TemplateTemplateParmDecl>(SecondParam);
1438
1439         TemplateParameterList *FirstTPL = FirstTTPD->getTemplateParameters();
1440         TemplateParameterList *SecondTPL = SecondTTPD->getTemplateParameters();
1441
1442         auto ComputeTemplateParameterListODRHash =
1443             [](const TemplateParameterList *TPL) {
1444               assert(TPL);
1445               ODRHash Hasher;
1446               Hasher.AddTemplateParameterList(TPL);
1447               return Hasher.CalculateHash();
1448             };
1449
1450         if (ComputeTemplateParameterListODRHash(FirstTPL) !=
1451             ComputeTemplateParameterListODRHash(SecondTPL)) {
1452           DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
1453           DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
1454           return true;
1455         }
1456
1457         bool HasFirstDefaultArgument =
1458             FirstTTPD->hasDefaultArgument() &&
1459             !FirstTTPD->defaultArgumentWasInherited();
1460         bool HasSecondDefaultArgument =
1461             SecondTTPD->hasDefaultArgument() &&
1462             !SecondTTPD->defaultArgumentWasInherited();
1463         if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
1464           DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
1465               << (i + 1) << HasFirstDefaultArgument;
1466           DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
1467               << (i + 1) << HasSecondDefaultArgument;
1468           return true;
1469         }
1470
1471         if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
1472           TemplateArgument FirstTA =
1473               FirstTTPD->getDefaultArgument().getArgument();
1474           TemplateArgument SecondTA =
1475               SecondTTPD->getDefaultArgument().getArgument();
1476           if (computeODRHash(FirstTA) != computeODRHash(SecondTA)) {
1477             DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
1478                 << (i + 1) << FirstTA;
1479             DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
1480                 << (i + 1) << SecondTA;
1481             return true;
1482           }
1483         }
1484
1485         if (FirstTTPD->isParameterPack() != SecondTTPD->isParameterPack()) {
1486           DiagTemplateError(FunctionTemplatePackParameter)
1487               << (i + 1) << FirstTTPD->isParameterPack();
1488           DiagTemplateNote(FunctionTemplatePackParameter)
1489               << (i + 1) << SecondTTPD->isParameterPack();
1490           return true;
1491         }
1492       }
1493
1494       if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
1495           isa<NonTypeTemplateParmDecl>(SecondParam)) {
1496         NonTypeTemplateParmDecl *FirstNTTPD =
1497             cast<NonTypeTemplateParmDecl>(FirstParam);
1498         NonTypeTemplateParmDecl *SecondNTTPD =
1499             cast<NonTypeTemplateParmDecl>(SecondParam);
1500
1501         QualType FirstType = FirstNTTPD->getType();
1502         QualType SecondType = SecondNTTPD->getType();
1503         if (computeODRHash(FirstType) != computeODRHash(SecondType)) {
1504           DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
1505           DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
1506           return true;
1507         }
1508
1509         bool HasFirstDefaultArgument =
1510             FirstNTTPD->hasDefaultArgument() &&
1511             !FirstNTTPD->defaultArgumentWasInherited();
1512         bool HasSecondDefaultArgument =
1513             SecondNTTPD->hasDefaultArgument() &&
1514             !SecondNTTPD->defaultArgumentWasInherited();
1515         if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
1516           DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
1517               << (i + 1) << HasFirstDefaultArgument;
1518           DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
1519               << (i + 1) << HasSecondDefaultArgument;
1520           return true;
1521         }
1522
1523         if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
1524           Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
1525           Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
1526           if (computeODRHash(FirstDefaultArgument) !=
1527               computeODRHash(SecondDefaultArgument)) {
1528             DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
1529                 << (i + 1) << FirstDefaultArgument;
1530             DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
1531                 << (i + 1) << SecondDefaultArgument;
1532             return true;
1533           }
1534         }
1535
1536         if (FirstNTTPD->isParameterPack() != SecondNTTPD->isParameterPack()) {
1537           DiagTemplateError(FunctionTemplatePackParameter)
1538               << (i + 1) << FirstNTTPD->isParameterPack();
1539           DiagTemplateNote(FunctionTemplatePackParameter)
1540               << (i + 1) << SecondNTTPD->isParameterPack();
1541           return true;
1542         }
1543       }
1544     }
1545     break;
1546   }
1547   }
1548
1549   Diag(FirstDecl->getLocation(),
1550        diag::err_module_odr_violation_mismatch_decl_unknown)
1551       << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
1552       << FirstDecl->getSourceRange();
1553   Diag(SecondDecl->getLocation(),
1554        diag::note_module_odr_violation_mismatch_decl_unknown)
1555       << SecondModule.empty() << SecondModule << FirstDiffType
1556       << SecondDecl->getSourceRange();
1557   return true;
1558 }
1559
1560 bool ODRDiagsEmitter::diagnoseMismatch(const RecordDecl *FirstRecord,
1561                                        const RecordDecl *SecondRecord) const {
1562   if (FirstRecord == SecondRecord)
1563     return false;
1564
1565   std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
1566   std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
1567
1568   auto PopulateHashes = [](DeclHashes &Hashes, const RecordDecl *Record,
1569                            const DeclContext *DC) {
1570     for (const Decl *D : Record->decls()) {
1571       if (!ODRHash::isSubDeclToBeProcessed(D, DC))
1572         continue;
1573       Hashes.emplace_back(D, computeODRHash(D));
1574     }
1575   };
1576
1577   DeclHashes FirstHashes;
1578   DeclHashes SecondHashes;
1579   const DeclContext *DC = FirstRecord;
1580   PopulateHashes(FirstHashes, FirstRecord, DC);
1581   PopulateHashes(SecondHashes, SecondRecord, DC);
1582
1583   DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
1584   ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
1585   ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
1586   const Decl *FirstDecl = DR.FirstDecl;
1587   const Decl *SecondDecl = DR.SecondDecl;
1588
1589   if (FirstDiffType == Other || SecondDiffType == Other) {
1590     diagnoseSubMismatchUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
1591                                   SecondModule);
1592     return true;
1593   }
1594
1595   if (FirstDiffType != SecondDiffType) {
1596     diagnoseSubMismatchDifferentDeclKinds(DR, FirstRecord, FirstModule,
1597                                           SecondRecord, SecondModule);
1598     return true;
1599   }
1600
1601   assert(FirstDiffType == SecondDiffType);
1602   switch (FirstDiffType) {
1603   // Already handled.
1604   case EndOfClass:
1605   case Other:
1606   // C++ only, invalid in this context.
1607   case PublicSpecifer:
1608   case PrivateSpecifer:
1609   case ProtectedSpecifer:
1610   case StaticAssert:
1611   case CXXMethod:
1612   case TypeAlias:
1613   case Friend:
1614   case FunctionTemplate:
1615   // Cannot be contained by RecordDecl, invalid in this context.
1616   case ObjCMethod:
1617   case ObjCIvar:
1618   case ObjCProperty:
1619     llvm_unreachable("Invalid diff type");
1620
1621   case Field: {
1622     if (diagnoseSubMismatchField(FirstRecord, FirstModule, SecondModule,
1623                                  cast<FieldDecl>(FirstDecl),
1624                                  cast<FieldDecl>(SecondDecl)))
1625       return true;
1626     break;
1627   }
1628   case TypeDef: {
1629     if (diagnoseSubMismatchTypedef(FirstRecord, FirstModule, SecondModule,
1630                                    cast<TypedefNameDecl>(FirstDecl),
1631                                    cast<TypedefNameDecl>(SecondDecl),
1632                                    /*IsTypeAlias=*/false))
1633       return true;
1634     break;
1635   }
1636   case Var: {
1637     if (diagnoseSubMismatchVar(FirstRecord, FirstModule, SecondModule,
1638                                cast<VarDecl>(FirstDecl),
1639                                cast<VarDecl>(SecondDecl)))
1640       return true;
1641     break;
1642   }
1643   }
1644
1645   Diag(FirstDecl->getLocation(),
1646        diag::err_module_odr_violation_mismatch_decl_unknown)
1647       << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
1648       << FirstDecl->getSourceRange();
1649   Diag(SecondDecl->getLocation(),
1650        diag::note_module_odr_violation_mismatch_decl_unknown)
1651       << SecondModule.empty() << SecondModule << FirstDiffType
1652       << SecondDecl->getSourceRange();
1653   return true;
1654 }
1655
1656 bool ODRDiagsEmitter::diagnoseMismatch(
1657     const FunctionDecl *FirstFunction,
1658     const FunctionDecl *SecondFunction) const {
1659   if (FirstFunction == SecondFunction)
1660     return false;
1661
1662   // Keep in sync with select options in err_module_odr_violation_function.
1663   enum ODRFunctionDifference {
1664     ReturnType,
1665     ParameterName,
1666     ParameterType,
1667     ParameterSingleDefaultArgument,
1668     ParameterDifferentDefaultArgument,
1669     FunctionBody,
1670   };
1671
1672   std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
1673   std::string SecondModule = getOwningModuleNameForDiagnostic(SecondFunction);
1674
1675   auto DiagError = [FirstFunction, &FirstModule,
1676                     this](SourceLocation Loc, SourceRange Range,
1677                           ODRFunctionDifference DiffType) {
1678     return Diag(Loc, diag::err_module_odr_violation_function)
1679            << FirstFunction << FirstModule.empty() << FirstModule << Range
1680            << DiffType;
1681   };
1682   auto DiagNote = [&SecondModule, this](SourceLocation Loc, SourceRange Range,
1683                                         ODRFunctionDifference DiffType) {
1684     return Diag(Loc, diag::note_module_odr_violation_function)
1685            << SecondModule << Range << DiffType;
1686   };
1687
1688   if (computeODRHash(FirstFunction->getReturnType()) !=
1689       computeODRHash(SecondFunction->getReturnType())) {
1690     DiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
1691               FirstFunction->getReturnTypeSourceRange(), ReturnType)
1692         << FirstFunction->getReturnType();
1693     DiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
1694              SecondFunction->getReturnTypeSourceRange(), ReturnType)
1695         << SecondFunction->getReturnType();
1696     return true;
1697   }
1698
1699   assert(FirstFunction->param_size() == SecondFunction->param_size() &&
1700          "Merged functions with different number of parameters");
1701
1702   size_t ParamSize = FirstFunction->param_size();
1703   for (unsigned I = 0; I < ParamSize; ++I) {
1704     const ParmVarDecl *FirstParam = FirstFunction->getParamDecl(I);
1705     const ParmVarDecl *SecondParam = SecondFunction->getParamDecl(I);
1706
1707     assert(Context.hasSameType(FirstParam->getType(), SecondParam->getType()) &&
1708            "Merged function has different parameter types.");
1709
1710     if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
1711       DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
1712                 ParameterName)
1713           << I + 1 << FirstParam->getDeclName();
1714       DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
1715                ParameterName)
1716           << I + 1 << SecondParam->getDeclName();
1717       return true;
1718     };
1719
1720     QualType FirstParamType = FirstParam->getType();
1721     QualType SecondParamType = SecondParam->getType();
1722     if (FirstParamType != SecondParamType &&
1723         computeODRHash(FirstParamType) != computeODRHash(SecondParamType)) {
1724       if (const DecayedType *ParamDecayedType =
1725               FirstParamType->getAs<DecayedType>()) {
1726         DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
1727                   ParameterType)
1728             << (I + 1) << FirstParamType << true
1729             << ParamDecayedType->getOriginalType();
1730       } else {
1731         DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
1732                   ParameterType)
1733             << (I + 1) << FirstParamType << false;
1734       }
1735
1736       if (const DecayedType *ParamDecayedType =
1737               SecondParamType->getAs<DecayedType>()) {
1738         DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
1739                  ParameterType)
1740             << (I + 1) << SecondParamType << true
1741             << ParamDecayedType->getOriginalType();
1742       } else {
1743         DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
1744                  ParameterType)
1745             << (I + 1) << SecondParamType << false;
1746       }
1747       return true;
1748     }
1749
1750     // Note, these calls can trigger deserialization.
1751     const Expr *FirstInit = FirstParam->getInit();
1752     const Expr *SecondInit = SecondParam->getInit();
1753     if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
1754       DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
1755                 ParameterSingleDefaultArgument)
1756           << (I + 1) << (FirstInit == nullptr)
1757           << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
1758       DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
1759                ParameterSingleDefaultArgument)
1760           << (I + 1) << (SecondInit == nullptr)
1761           << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
1762       return true;
1763     }
1764
1765     if (FirstInit && SecondInit &&
1766         computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
1767       DiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
1768                 ParameterDifferentDefaultArgument)
1769           << (I + 1) << FirstInit->getSourceRange();
1770       DiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
1771                ParameterDifferentDefaultArgument)
1772           << (I + 1) << SecondInit->getSourceRange();
1773       return true;
1774     }
1775
1776     assert(computeODRHash(FirstParam) == computeODRHash(SecondParam) &&
1777            "Undiagnosed parameter difference.");
1778   }
1779
1780   // If no error has been generated before now, assume the problem is in
1781   // the body and generate a message.
1782   DiagError(FirstFunction->getLocation(), FirstFunction->getSourceRange(),
1783             FunctionBody);
1784   DiagNote(SecondFunction->getLocation(), SecondFunction->getSourceRange(),
1785            FunctionBody);
1786   return true;
1787 }
1788
1789 bool ODRDiagsEmitter::diagnoseMismatch(const EnumDecl *FirstEnum,
1790                                        const EnumDecl *SecondEnum) const {
1791   if (FirstEnum == SecondEnum)
1792     return false;
1793
1794   // Keep in sync with select options in err_module_odr_violation_enum.
1795   enum ODREnumDifference {
1796     SingleScopedEnum,
1797     EnumTagKeywordMismatch,
1798     SingleSpecifiedType,
1799     DifferentSpecifiedTypes,
1800     DifferentNumberEnumConstants,
1801     EnumConstantName,
1802     EnumConstantSingleInitializer,
1803     EnumConstantDifferentInitializer,
1804   };
1805
1806   std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
1807   std::string SecondModule = getOwningModuleNameForDiagnostic(SecondEnum);
1808
1809   auto DiagError = [FirstEnum, &FirstModule, this](const auto *DiagAnchor,
1810                                                    ODREnumDifference DiffType) {
1811     return Diag(DiagAnchor->getLocation(), diag::err_module_odr_violation_enum)
1812            << FirstEnum << FirstModule.empty() << FirstModule
1813            << DiagAnchor->getSourceRange() << DiffType;
1814   };
1815   auto DiagNote = [&SecondModule, this](const auto *DiagAnchor,
1816                                         ODREnumDifference DiffType) {
1817     return Diag(DiagAnchor->getLocation(), diag::note_module_odr_violation_enum)
1818            << SecondModule << DiagAnchor->getSourceRange() << DiffType;
1819   };
1820
1821   if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
1822     DiagError(FirstEnum, SingleScopedEnum) << FirstEnum->isScoped();
1823     DiagNote(SecondEnum, SingleScopedEnum) << SecondEnum->isScoped();
1824     return true;
1825   }
1826
1827   if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
1828     if (FirstEnum->isScopedUsingClassTag() !=
1829         SecondEnum->isScopedUsingClassTag()) {
1830       DiagError(FirstEnum, EnumTagKeywordMismatch)
1831           << FirstEnum->isScopedUsingClassTag();
1832       DiagNote(SecondEnum, EnumTagKeywordMismatch)
1833           << SecondEnum->isScopedUsingClassTag();
1834       return true;
1835     }
1836   }
1837
1838   QualType FirstUnderlyingType =
1839       FirstEnum->getIntegerTypeSourceInfo()
1840           ? FirstEnum->getIntegerTypeSourceInfo()->getType()
1841           : QualType();
1842   QualType SecondUnderlyingType =
1843       SecondEnum->getIntegerTypeSourceInfo()
1844           ? SecondEnum->getIntegerTypeSourceInfo()->getType()
1845           : QualType();
1846   if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
1847     DiagError(FirstEnum, SingleSpecifiedType) << !FirstUnderlyingType.isNull();
1848     DiagNote(SecondEnum, SingleSpecifiedType) << !SecondUnderlyingType.isNull();
1849     return true;
1850   }
1851
1852   if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
1853     if (computeODRHash(FirstUnderlyingType) !=
1854         computeODRHash(SecondUnderlyingType)) {
1855       DiagError(FirstEnum, DifferentSpecifiedTypes) << FirstUnderlyingType;
1856       DiagNote(SecondEnum, DifferentSpecifiedTypes) << SecondUnderlyingType;
1857       return true;
1858     }
1859   }
1860
1861   // Compare enum constants.
1862   using DeclHashes =
1863       llvm::SmallVector<std::pair<const EnumConstantDecl *, unsigned>, 4>;
1864   auto PopulateHashes = [FirstEnum](DeclHashes &Hashes, const EnumDecl *Enum) {
1865     for (const Decl *D : Enum->decls()) {
1866       // Due to decl merging, the first EnumDecl is the parent of
1867       // Decls in both records.
1868       if (!ODRHash::isSubDeclToBeProcessed(D, FirstEnum))
1869         continue;
1870       assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
1871       Hashes.emplace_back(cast<EnumConstantDecl>(D), computeODRHash(D));
1872     }
1873   };
1874   DeclHashes FirstHashes;
1875   PopulateHashes(FirstHashes, FirstEnum);
1876   DeclHashes SecondHashes;
1877   PopulateHashes(SecondHashes, SecondEnum);
1878
1879   if (FirstHashes.size() != SecondHashes.size()) {
1880     DiagError(FirstEnum, DifferentNumberEnumConstants)
1881         << (int)FirstHashes.size();
1882     DiagNote(SecondEnum, DifferentNumberEnumConstants)
1883         << (int)SecondHashes.size();
1884     return true;
1885   }
1886
1887   for (unsigned I = 0, N = FirstHashes.size(); I < N; ++I) {
1888     if (FirstHashes[I].second == SecondHashes[I].second)
1889       continue;
1890     const EnumConstantDecl *FirstConstant = FirstHashes[I].first;
1891     const EnumConstantDecl *SecondConstant = SecondHashes[I].first;
1892
1893     if (FirstConstant->getDeclName() != SecondConstant->getDeclName()) {
1894       DiagError(FirstConstant, EnumConstantName) << I + 1 << FirstConstant;
1895       DiagNote(SecondConstant, EnumConstantName) << I + 1 << SecondConstant;
1896       return true;
1897     }
1898
1899     const Expr *FirstInit = FirstConstant->getInitExpr();
1900     const Expr *SecondInit = SecondConstant->getInitExpr();
1901     if (!FirstInit && !SecondInit)
1902       continue;
1903
1904     if (!FirstInit || !SecondInit) {
1905       DiagError(FirstConstant, EnumConstantSingleInitializer)
1906           << I + 1 << FirstConstant << (FirstInit != nullptr);
1907       DiagNote(SecondConstant, EnumConstantSingleInitializer)
1908           << I + 1 << SecondConstant << (SecondInit != nullptr);
1909       return true;
1910     }
1911
1912     if (computeODRHash(FirstInit) != computeODRHash(SecondInit)) {
1913       DiagError(FirstConstant, EnumConstantDifferentInitializer)
1914           << I + 1 << FirstConstant;
1915       DiagNote(SecondConstant, EnumConstantDifferentInitializer)
1916           << I + 1 << SecondConstant;
1917       return true;
1918     }
1919   }
1920   return false;
1921 }
1922
1923 bool ODRDiagsEmitter::diagnoseMismatch(
1924     const ObjCInterfaceDecl *FirstID, const ObjCInterfaceDecl *SecondID,
1925     const struct ObjCInterfaceDecl::DefinitionData *SecondDD) const {
1926   // Multiple different declarations got merged together; tell the user
1927   // where they came from.
1928   if (FirstID == SecondID)
1929     return false;
1930
1931   std::string FirstModule = getOwningModuleNameForDiagnostic(FirstID);
1932   std::string SecondModule = getOwningModuleNameForDiagnostic(SecondID);
1933
1934   // Keep in sync with err_module_odr_violation_objc_interface.
1935   enum ODRInterfaceDifference {
1936     SuperClassType,
1937     IVarAccess,
1938   };
1939
1940   auto DiagError = [FirstID, &FirstModule,
1941                     this](SourceLocation Loc, SourceRange Range,
1942                           ODRInterfaceDifference DiffType) {
1943     return Diag(Loc, diag::err_module_odr_violation_objc_interface)
1944            << FirstID << FirstModule.empty() << FirstModule << Range
1945            << DiffType;
1946   };
1947   auto DiagNote = [&SecondModule, this](SourceLocation Loc, SourceRange Range,
1948                                         ODRInterfaceDifference DiffType) {
1949     return Diag(Loc, diag::note_module_odr_violation_objc_interface)
1950            << SecondModule.empty() << SecondModule << Range << DiffType;
1951   };
1952
1953   const struct ObjCInterfaceDecl::DefinitionData *FirstDD = &FirstID->data();
1954   assert(FirstDD && SecondDD && "Definitions without DefinitionData");
1955   if (FirstDD != SecondDD) {
1956     // Check for matching super class.
1957     auto GetSuperClassSourceRange = [](const TypeSourceInfo *SuperInfo,
1958                                        const ObjCInterfaceDecl *ID) {
1959       if (!SuperInfo)
1960         return ID->getSourceRange();
1961       TypeLoc Loc = SuperInfo->getTypeLoc();
1962       return SourceRange(Loc.getBeginLoc(), Loc.getEndLoc());
1963     };
1964
1965     ObjCInterfaceDecl *FirstSuperClass = FirstID->getSuperClass();
1966     ObjCInterfaceDecl *SecondSuperClass = nullptr;
1967     const TypeSourceInfo *FirstSuperInfo = FirstID->getSuperClassTInfo();
1968     const TypeSourceInfo *SecondSuperInfo = SecondDD->SuperClassTInfo;
1969     if (SecondSuperInfo)
1970       SecondSuperClass =
1971           SecondSuperInfo->getType()->castAs<ObjCObjectType>()->getInterface();
1972
1973     if ((FirstSuperClass && SecondSuperClass &&
1974          FirstSuperClass->getODRHash() != SecondSuperClass->getODRHash()) ||
1975         (FirstSuperClass && !SecondSuperClass) ||
1976         (!FirstSuperClass && SecondSuperClass)) {
1977       QualType FirstType;
1978       if (FirstSuperInfo)
1979         FirstType = FirstSuperInfo->getType();
1980
1981       DiagError(FirstID->getLocation(),
1982                 GetSuperClassSourceRange(FirstSuperInfo, FirstID),
1983                 SuperClassType)
1984           << (bool)FirstSuperInfo << FirstType;
1985
1986       QualType SecondType;
1987       if (SecondSuperInfo)
1988         SecondType = SecondSuperInfo->getType();
1989
1990       DiagNote(SecondID->getLocation(),
1991                GetSuperClassSourceRange(SecondSuperInfo, SecondID),
1992                SuperClassType)
1993           << (bool)SecondSuperInfo << SecondType;
1994       return true;
1995     }
1996
1997     // Check both interfaces reference the same protocols.
1998     auto &FirstProtos = FirstID->getReferencedProtocols();
1999     auto &SecondProtos = SecondDD->ReferencedProtocols;
2000     if (diagnoseSubMismatchProtocols(FirstProtos, FirstID, FirstModule,
2001                                      SecondProtos, SecondID, SecondModule))
2002       return true;
2003   }
2004
2005   auto PopulateHashes = [](DeclHashes &Hashes, const ObjCInterfaceDecl *ID,
2006                            const DeclContext *DC) {
2007     for (auto *D : ID->decls()) {
2008       if (!ODRHash::isSubDeclToBeProcessed(D, DC))
2009         continue;
2010       Hashes.emplace_back(D, computeODRHash(D));
2011     }
2012   };
2013
2014   DeclHashes FirstHashes;
2015   DeclHashes SecondHashes;
2016   // Use definition as DeclContext because definitions are merged when
2017   // DeclContexts are merged and separate when DeclContexts are separate.
2018   PopulateHashes(FirstHashes, FirstID, FirstID->getDefinition());
2019   PopulateHashes(SecondHashes, SecondID, SecondID->getDefinition());
2020
2021   DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
2022   ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
2023   ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
2024   const Decl *FirstDecl = DR.FirstDecl;
2025   const Decl *SecondDecl = DR.SecondDecl;
2026
2027   if (FirstDiffType == Other || SecondDiffType == Other) {
2028     diagnoseSubMismatchUnexpected(DR, FirstID, FirstModule, SecondID,
2029                                   SecondModule);
2030     return true;
2031   }
2032
2033   if (FirstDiffType != SecondDiffType) {
2034     diagnoseSubMismatchDifferentDeclKinds(DR, FirstID, FirstModule, SecondID,
2035                                           SecondModule);
2036     return true;
2037   }
2038
2039   assert(FirstDiffType == SecondDiffType);
2040   switch (FirstDiffType) {
2041   // Already handled.
2042   case EndOfClass:
2043   case Other:
2044   // Cannot be contained by ObjCInterfaceDecl, invalid in this context.
2045   case Field:
2046   case TypeDef:
2047   case Var:
2048   // C++ only, invalid in this context.
2049   case PublicSpecifer:
2050   case PrivateSpecifer:
2051   case ProtectedSpecifer:
2052   case StaticAssert:
2053   case CXXMethod:
2054   case TypeAlias:
2055   case Friend:
2056   case FunctionTemplate:
2057     llvm_unreachable("Invalid diff type");
2058
2059   case ObjCMethod: {
2060     if (diagnoseSubMismatchObjCMethod(FirstID, FirstModule, SecondModule,
2061                                       cast<ObjCMethodDecl>(FirstDecl),
2062                                       cast<ObjCMethodDecl>(SecondDecl)))
2063       return true;
2064     break;
2065   }
2066   case ObjCIvar: {
2067     if (diagnoseSubMismatchField(FirstID, FirstModule, SecondModule,
2068                                  cast<FieldDecl>(FirstDecl),
2069                                  cast<FieldDecl>(SecondDecl)))
2070       return true;
2071
2072     // Check if the access match.
2073     const ObjCIvarDecl *FirstIvar = cast<ObjCIvarDecl>(FirstDecl);
2074     const ObjCIvarDecl *SecondIvar = cast<ObjCIvarDecl>(SecondDecl);
2075     if (FirstIvar->getCanonicalAccessControl() !=
2076         SecondIvar->getCanonicalAccessControl()) {
2077       DiagError(FirstIvar->getLocation(), FirstIvar->getSourceRange(),
2078                 IVarAccess)
2079           << FirstIvar->getName()
2080           << (int)FirstIvar->getCanonicalAccessControl();
2081       DiagNote(SecondIvar->getLocation(), SecondIvar->getSourceRange(),
2082                IVarAccess)
2083           << SecondIvar->getName()
2084           << (int)SecondIvar->getCanonicalAccessControl();
2085       return true;
2086     }
2087     break;
2088   }
2089   case ObjCProperty: {
2090     if (diagnoseSubMismatchObjCProperty(FirstID, FirstModule, SecondModule,
2091                                         cast<ObjCPropertyDecl>(FirstDecl),
2092                                         cast<ObjCPropertyDecl>(SecondDecl)))
2093       return true;
2094     break;
2095   }
2096   }
2097
2098   Diag(FirstDecl->getLocation(),
2099        diag::err_module_odr_violation_mismatch_decl_unknown)
2100       << FirstID << FirstModule.empty() << FirstModule << FirstDiffType
2101       << FirstDecl->getSourceRange();
2102   Diag(SecondDecl->getLocation(),
2103        diag::note_module_odr_violation_mismatch_decl_unknown)
2104       << SecondModule.empty() << SecondModule << FirstDiffType
2105       << SecondDecl->getSourceRange();
2106   return true;
2107 }
2108
2109 bool ODRDiagsEmitter::diagnoseMismatch(
2110     const ObjCProtocolDecl *FirstProtocol,
2111     const ObjCProtocolDecl *SecondProtocol,
2112     const struct ObjCProtocolDecl::DefinitionData *SecondDD) const {
2113   if (FirstProtocol == SecondProtocol)
2114     return false;
2115
2116   std::string FirstModule = getOwningModuleNameForDiagnostic(FirstProtocol);
2117   std::string SecondModule = getOwningModuleNameForDiagnostic(SecondProtocol);
2118
2119   const ObjCProtocolDecl::DefinitionData *FirstDD = &FirstProtocol->data();
2120   assert(FirstDD && SecondDD && "Definitions without DefinitionData");
2121   // Diagnostics from ObjCProtocol DefinitionData are emitted here.
2122   if (FirstDD != SecondDD) {
2123     // Check both protocols reference the same protocols.
2124     const ObjCProtocolList &FirstProtocols =
2125         FirstProtocol->getReferencedProtocols();
2126     const ObjCProtocolList &SecondProtocols = SecondDD->ReferencedProtocols;
2127     if (diagnoseSubMismatchProtocols(FirstProtocols, FirstProtocol, FirstModule,
2128                                      SecondProtocols, SecondProtocol,
2129                                      SecondModule))
2130       return true;
2131   }
2132
2133   auto PopulateHashes = [](DeclHashes &Hashes, const ObjCProtocolDecl *ID,
2134                            const DeclContext *DC) {
2135     for (const Decl *D : ID->decls()) {
2136       if (!ODRHash::isSubDeclToBeProcessed(D, DC))
2137         continue;
2138       Hashes.emplace_back(D, computeODRHash(D));
2139     }
2140   };
2141
2142   DeclHashes FirstHashes;
2143   DeclHashes SecondHashes;
2144   // Use definition as DeclContext because definitions are merged when
2145   // DeclContexts are merged and separate when DeclContexts are separate.
2146   PopulateHashes(FirstHashes, FirstProtocol, FirstProtocol->getDefinition());
2147   PopulateHashes(SecondHashes, SecondProtocol, SecondProtocol->getDefinition());
2148
2149   DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
2150   ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
2151   ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
2152   const Decl *FirstDecl = DR.FirstDecl;
2153   const Decl *SecondDecl = DR.SecondDecl;
2154
2155   if (FirstDiffType == Other || SecondDiffType == Other) {
2156     diagnoseSubMismatchUnexpected(DR, FirstProtocol, FirstModule,
2157                                   SecondProtocol, SecondModule);
2158     return true;
2159   }
2160
2161   if (FirstDiffType != SecondDiffType) {
2162     diagnoseSubMismatchDifferentDeclKinds(DR, FirstProtocol, FirstModule,
2163                                           SecondProtocol, SecondModule);
2164     return true;
2165   }
2166
2167   assert(FirstDiffType == SecondDiffType);
2168   switch (FirstDiffType) {
2169   // Already handled.
2170   case EndOfClass:
2171   case Other:
2172   // Cannot be contained by ObjCProtocolDecl, invalid in this context.
2173   case Field:
2174   case TypeDef:
2175   case Var:
2176   case ObjCIvar:
2177   // C++ only, invalid in this context.
2178   case PublicSpecifer:
2179   case PrivateSpecifer:
2180   case ProtectedSpecifer:
2181   case StaticAssert:
2182   case CXXMethod:
2183   case TypeAlias:
2184   case Friend:
2185   case FunctionTemplate:
2186     llvm_unreachable("Invalid diff type");
2187   case ObjCMethod: {
2188     if (diagnoseSubMismatchObjCMethod(FirstProtocol, FirstModule, SecondModule,
2189                                       cast<ObjCMethodDecl>(FirstDecl),
2190                                       cast<ObjCMethodDecl>(SecondDecl)))
2191       return true;
2192     break;
2193   }
2194   case ObjCProperty: {
2195     if (diagnoseSubMismatchObjCProperty(FirstProtocol, FirstModule,
2196                                         SecondModule,
2197                                         cast<ObjCPropertyDecl>(FirstDecl),
2198                                         cast<ObjCPropertyDecl>(SecondDecl)))
2199       return true;
2200     break;
2201   }
2202   }
2203
2204   Diag(FirstDecl->getLocation(),
2205        diag::err_module_odr_violation_mismatch_decl_unknown)
2206       << FirstProtocol << FirstModule.empty() << FirstModule << FirstDiffType
2207       << FirstDecl->getSourceRange();
2208   Diag(SecondDecl->getLocation(),
2209        diag::note_module_odr_violation_mismatch_decl_unknown)
2210       << SecondModule.empty() << SecondModule << FirstDiffType
2211       << SecondDecl->getSourceRange();
2212   return true;
2213 }