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
16using namespace clang;
17
18static unsigned computeODRHash(QualType Ty) {
19  ODRHash Hasher;
20  Hasher.AddQualType(Ty);
21  return Hasher.CalculateHash();
22}
23
24static unsigned computeODRHash(const Stmt *S) {
25  ODRHash Hasher;
26  Hasher.AddStmt(S);
27  return Hasher.CalculateHash();
28}
29
30static unsigned computeODRHash(const Decl *D) {
31  assert(D);
32  ODRHash Hasher;
33  Hasher.AddSubDecl(D);
34  return Hasher.CalculateHash();
35}
36
37static unsigned computeODRHash(const TemplateArgument &TA) {
38  ODRHash Hasher;
39  Hasher.AddTemplateArgument(TA);
40  return Hasher.CalculateHash();
41}
42
43std::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
52template <typename MethodT>
53static 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
144bool 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
246bool 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
286bool 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
361bool 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
420bool 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
504bool 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
580ODRDiagsEmitter::DiffResult
581ODRDiagsEmitter::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
650void 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
672void 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
706bool 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->isPureVirtual();
1106    const bool SecondPure = SecondMethod->isPureVirtual();
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
1560bool 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
1656bool 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
1789bool 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
1923bool 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
2109bool 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}
2214