46 return M->getFullModuleName();
52template <
typename MethodT>
55 StringRef FirstModule,
56 StringRef SecondModule,
57 const MethodT *FirstMethod,
58 const MethodT *SecondMethod) {
64 auto GetDiagMethodType = [](
const NamedDecl *D) {
65 if (isa<CXXConstructorDecl>(D))
66 return DiagConstructor;
67 if (isa<CXXDestructorDecl>(D))
68 return DiagDestructor;
72 enum ODRMethodParametersDifference {
77 auto DiagError = [&Diags, &GetDiagMethodType, FirstContainer, FirstModule,
78 FirstMethod](ODRMethodParametersDifference DiffType) {
80 DiagMethodType FirstMethodType = GetDiagMethodType(FirstMethod);
81 return Diags.
Report(FirstMethod->getLocation(),
82 diag::err_module_odr_violation_method_params)
83 << FirstContainer << FirstModule.empty() << FirstModule
87 auto DiagNote = [&Diags, &GetDiagMethodType, SecondModule,
88 SecondMethod](ODRMethodParametersDifference DiffType) {
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
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;
106 for (
unsigned I = 0; I < FirstNumParameters; ++I) {
107 const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
108 const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
112 if (FirstParamType != SecondParamType &&
116 DiagError(ParameterType) << (I + 1) << FirstParamType <<
true
117 << ParamDecayedType->getOriginalType();
119 DiagError(ParameterType) << (I + 1) << FirstParamType <<
false;
124 DiagNote(ParameterType) << (I + 1) << SecondParamType <<
true
125 << ParamDecayedType->getOriginalType();
127 DiagNote(ParameterType) << (I + 1) << SecondParamType <<
false;
134 if (FirstParamName != SecondParamName) {
135 DiagError(ParameterName) << (I + 1) << FirstParamName;
136 DiagNote(ParameterName) << (I + 1) << SecondParamName;
144bool ODRDiagsEmitter::diagnoseSubMismatchField(
145 const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
147 enum ODRFieldDifference {
151 FieldDifferentWidthBitField,
153 FieldSingleInitializer,
154 FieldDifferentInitializers,
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
163 auto DiagNote = [SecondField, SecondModule,
164 this](ODRFieldDifference DiffType) {
166 diag::note_module_odr_violation_field)
167 << SecondModule.empty() << SecondModule << SecondField->
getSourceRange() << DiffType;
173 DiagError(FieldName) << FirstII;
174 DiagNote(FieldName) << SecondII;
181 DiagError(FieldTypeName) << FirstII << FirstType;
182 DiagNote(FieldTypeName) << SecondII << SecondType;
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;
197 if (IsFirstBitField && IsSecondBitField) {
200 if (FirstBitWidthHash != SecondBitWidthHash) {
201 DiagError(FieldDifferentWidthBitField)
203 DiagNote(FieldDifferentWidthBitField)
209 if (!LangOpts.CPlusPlus)
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;
222 if ((!FirstInitializer && SecondInitializer) ||
223 (FirstInitializer && !SecondInitializer)) {
224 DiagError(FieldSingleInitializer)
225 << FirstII << (FirstInitializer !=
nullptr);
226 DiagNote(FieldSingleInitializer)
227 << SecondII << (SecondInitializer !=
nullptr);
231 if (FirstInitializer && SecondInitializer) {
234 if (FirstInitHash != SecondInitHash) {
235 DiagError(FieldDifferentInitializers)
237 DiagNote(FieldDifferentInitializers)
246bool ODRDiagsEmitter::diagnoseSubMismatchTypedef(
247 const NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
249 bool IsTypeAlias)
const {
250 enum ODRTypedefDifference {
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
261 auto DiagNote = [SecondTD, SecondModule,
262 this](ODRTypedefDifference DiffType) {
264 diag::note_module_odr_violation_typedef)
270 if (FirstName != SecondName) {
271 DiagError(TypedefName) << IsTypeAlias << FirstName;
272 DiagNote(TypedefName) << IsTypeAlias << SecondName;
279 DiagError(
TypedefType) << IsTypeAlias << FirstName << FirstType;
280 DiagNote(
TypedefType) << IsTypeAlias << SecondName << SecondType;
286bool ODRDiagsEmitter::diagnoseSubMismatchVar(
const NamedDecl *FirstRecord,
287 StringRef FirstModule,
288 StringRef SecondModule,
290 const VarDecl *SecondVD)
const {
291 enum ODRVarDifference {
294 VarSingleInitializer,
295 VarDifferentInitializer,
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
305 auto DiagNote = [SecondVD, SecondModule,
this](ODRVarDifference DiffType) {
307 diag::note_module_odr_violation_variable)
313 if (FirstName != SecondName) {
314 DiagError(VarName) << FirstName;
315 DiagNote(VarName) << SecondName;
322 DiagError(VarType) << FirstName << FirstType;
323 DiagNote(VarType) << SecondName << SecondType;
327 if (!LangOpts.CPlusPlus)
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());
342 if (FirstInit && SecondInit &&
344 DiagError(VarDifferentInitializer)
345 << FirstName << FirstInit->getSourceRange();
346 DiagNote(VarDifferentInitializer)
347 << SecondName << SecondInit->getSourceRange();
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;
361bool ODRDiagsEmitter::diagnoseSubMismatchProtocols(
367 enum ODRReferencedProtocolDifference {
371 auto DiagRefProtocolError = [FirstContainer, FirstModule,
373 ODRReferencedProtocolDifference DiffType) {
374 return Diag(Loc, diag::err_module_odr_violation_referenced_protocols)
375 << FirstContainer << FirstModule.empty() << FirstModule <<
Range
378 auto DiagRefProtocolNote = [SecondModule,
380 ODRReferencedProtocolDifference DiffType) {
381 return Diag(Loc, diag::note_module_odr_violation_referenced_protocols)
382 << SecondModule.empty() << SecondModule <<
Range << DiffType;
387 return SourceRange(*PL.loc_begin(), *std::prev(PL.loc_end()));
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();
400 for (
unsigned I = 0, E = FirstProtocols.
size(); I != E; ++I) {
405 if (FirstProtocolName != SecondProtocolName) {
409 DiagRefProtocolError(FirstLoc, EmptyRange, ProtocolType)
410 << (I + 1) << FirstProtocolName;
411 DiagRefProtocolNote(SecondLoc, EmptyRange, ProtocolType)
412 << (I + 1) << SecondProtocolName;
420bool ODRDiagsEmitter::diagnoseSubMismatchObjCMethod(
421 const NamedDecl *FirstObjCContainer, StringRef FirstModule,
424 enum ODRMethodDifference {
428 DesignatedInitializer,
433 auto DiagError = [FirstObjCContainer, FirstModule, FirstMethod,
434 this](ODRMethodDifference DiffType) {
436 diag::err_module_odr_violation_objc_method)
437 << FirstObjCContainer << FirstModule.empty() << FirstModule
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;
450 DiagError(ReturnType) << FirstMethod << FirstMethod->
getReturnType();
451 DiagNote(ReturnType) << SecondMethod << SecondMethod->getReturnType();
456 DiagError(InstanceOrClass)
458 DiagNote(InstanceOrClass)
459 << SecondMethod << SecondMethod->isInstanceMethod();
463 SecondMethod->getImplementationControl()) {
465 DiagNote(ControlLevel) << SecondMethod->getImplementationControl();
469 SecondMethod->isThisDeclarationADesignatedInitializer()) {
470 DiagError(DesignatedInitializer)
473 DiagNote(DesignatedInitializer)
475 << SecondMethod->isThisDeclarationADesignatedInitializer();
478 if (FirstMethod->
isDirectMethod() != SecondMethod->isDirectMethod()) {
479 DiagError(Directness) << FirstMethod << FirstMethod->
isDirectMethod();
480 DiagNote(Directness) << SecondMethod << SecondMethod->isDirectMethod();
484 FirstModule, SecondModule,
485 FirstMethod, SecondMethod))
493 if (FirstName != SecondName) {
494 DiagError(Name) << FirstName;
495 DiagNote(Name) << SecondName;
502bool ODRDiagsEmitter::diagnoseSubMismatchObjCProperty(
503 const NamedDecl *FirstObjCContainer, StringRef FirstModule,
506 enum ODRPropertyDifference {
513 auto DiagError = [FirstObjCContainer, FirstModule, FirstProp,
515 return Diag(Loc, diag::err_module_odr_violation_objc_property)
516 << FirstObjCContainer << FirstModule.empty() << FirstModule
519 auto DiagNote = [SecondModule, SecondProp,
521 return Diag(Loc, diag::note_module_odr_violation_objc_property)
522 << SecondModule.empty() << SecondModule
523 << SecondProp->getSourceRange() << DiffType;
529 DiagError(FirstProp->
getLocation(), Name) << FirstII;
530 DiagNote(SecondProp->getLocation(), Name) << SecondII;
536 << FirstII << FirstProp->
getType();
537 DiagNote(SecondProp->getLocation(),
Type)
538 << SecondII << SecondProp->getType();
542 SecondProp->getPropertyImplementation()) {
545 DiagNote(SecondProp->getLocation(), ControlLevel)
546 << SecondProp->getPropertyImplementation();
552 unsigned SecondAttrs = (
unsigned)SecondProp->getPropertyAttributes();
553 if (FirstAttrs != SecondAttrs) {
555 unsigned CheckedAttr = (1 << I);
556 if ((FirstAttrs & CheckedAttr) == (SecondAttrs & CheckedAttr))
559 bool IsFirstWritten =
561 bool IsSecondWritten =
562 (
unsigned)SecondProp->getPropertyAttributesAsWritten() & CheckedAttr;
566 << FirstII << (I + 1) << IsFirstWritten;
567 DiagNote(IsSecondWritten ? SecondProp->getLParenLoc()
568 : SecondProp->getLocation(),
570 << SecondII << (I + 1);
578ODRDiagsEmitter::DiffResult
579ODRDiagsEmitter::FindTypeDiffs(DeclHashes &FirstHashes,
580 DeclHashes &SecondHashes) {
581 auto DifferenceSelector = [](
const Decl *D) {
582 assert(D &&
"valid Decl required");
583 switch (D->getKind()) {
586 case Decl::AccessSpec:
587 switch (D->getAccess()) {
589 return PublicSpecifer;
591 return PrivateSpecifer;
593 return ProtectedSpecifer;
597 llvm_unreachable(
"Invalid access specifier");
598 case Decl::StaticAssert:
602 case Decl::CXXMethod:
603 case Decl::CXXConstructor:
604 case Decl::CXXDestructor:
606 case Decl::TypeAlias:
614 case Decl::FunctionTemplate:
615 return FunctionTemplate;
616 case Decl::ObjCMethod:
620 case Decl::ObjCProperty:
626 auto FirstIt = FirstHashes.begin();
627 auto SecondIt = SecondHashes.begin();
628 while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
629 if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
630 FirstIt->second == SecondIt->second) {
636 DR.FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
637 DR.SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
640 DR.FirstDecl ? DifferenceSelector(DR.FirstDecl) : EndOfClass;
642 DR.SecondDecl ? DifferenceSelector(DR.SecondDecl) : EndOfClass;
648void ODRDiagsEmitter::diagnoseSubMismatchUnexpected(
649 DiffResult &DR,
const NamedDecl *FirstRecord, StringRef FirstModule,
650 const NamedDecl *SecondRecord, StringRef SecondModule)
const {
652 diag::err_module_odr_violation_different_definitions)
653 << FirstRecord << FirstModule.empty() << FirstModule;
656 Diag(DR.FirstDecl->getLocation(), diag::note_first_module_difference)
661 diag::note_module_odr_violation_different_definitions)
665 Diag(DR.SecondDecl->getLocation(), diag::note_second_module_difference)
666 << DR.SecondDecl->getSourceRange();
670void ODRDiagsEmitter::diagnoseSubMismatchDifferentDeclKinds(
671 DiffResult &DR,
const NamedDecl *FirstRecord, StringRef FirstModule,
672 const NamedDecl *SecondRecord, StringRef SecondModule)
const {
673 auto GetMismatchedDeclLoc = [](
const NamedDecl *Container,
674 ODRMismatchDecl DiffType,
const Decl *D) {
677 if (DiffType == EndOfClass) {
678 if (
auto *Tag = dyn_cast<TagDecl>(Container))
679 Loc = Tag->getBraceRange().getEnd();
680 else if (
auto *IF = dyn_cast<ObjCInterfaceDecl>(Container))
681 Loc = IF->getAtEndRange().getBegin();
683 Loc = Container->getEndLoc();
685 Loc = D->getLocation();
686 Range = D->getSourceRange();
688 return std::make_pair(Loc, Range);
692 GetMismatchedDeclLoc(FirstRecord, DR.FirstDiffType, DR.FirstDecl);
693 Diag(FirstDiagInfo.first, diag::err_module_odr_violation_mismatch_decl)
694 << FirstRecord << FirstModule.empty() << FirstModule
695 << FirstDiagInfo.second << DR.FirstDiffType;
697 auto SecondDiagInfo =
698 GetMismatchedDeclLoc(SecondRecord, DR.SecondDiffType, DR.SecondDecl);
699 Diag(SecondDiagInfo.first, diag::note_module_odr_violation_mismatch_decl)
700 << SecondModule.empty() << SecondModule << SecondDiagInfo.second
701 << DR.SecondDiffType;
706 const struct CXXRecordDecl::DefinitionData *SecondDD)
const {
709 if (FirstRecord == SecondRecord)
715 const struct CXXRecordDecl::DefinitionData *FirstDD =
716 FirstRecord->DefinitionData;
717 assert(FirstDD && SecondDD &&
"Definitions without DefinitionData");
720 if (FirstDD != SecondDD) {
722 enum ODRDefinitionDataDifference {
729 auto DiagBaseError = [FirstRecord, &FirstModule,
731 ODRDefinitionDataDifference DiffType) {
732 return Diag(Loc, diag::err_module_odr_violation_definition_data)
733 << FirstRecord << FirstModule.empty() << FirstModule << Range
736 auto DiagBaseNote = [&SecondModule,
738 ODRDefinitionDataDifference DiffType) {
739 return Diag(Loc, diag::note_module_odr_violation_definition_data)
740 << SecondModule << Range << DiffType;
742 auto GetSourceRange = [](
const struct CXXRecordDecl::DefinitionData *DD) {
743 unsigned NumBases = DD->NumBases;
748 bases[NumBases - 1].getEndLoc());
751 unsigned FirstNumBases = FirstDD->NumBases;
752 unsigned FirstNumVBases = FirstDD->NumVBases;
753 unsigned SecondNumBases = SecondDD->NumBases;
754 unsigned SecondNumVBases = SecondDD->NumVBases;
755 if (FirstNumBases != SecondNumBases) {
756 DiagBaseError(FirstRecord->
getLocation(), GetSourceRange(FirstDD),
759 DiagBaseNote(SecondRecord->
getLocation(), GetSourceRange(SecondDD),
765 if (FirstNumVBases != SecondNumVBases) {
766 DiagBaseError(FirstRecord->
getLocation(), GetSourceRange(FirstDD),
769 DiagBaseNote(SecondRecord->
getLocation(), GetSourceRange(SecondDD),
777 for (
unsigned I = 0; I < FirstNumBases; ++I) {
784 << (I + 1) << FirstBase.
getType();
787 << (I + 1) << SecondBase.
getType();
805 << (I + 1) << FirstBase.
getType()
809 << (I + 1) << SecondBase.
getType()
821 assert(!FirstTemplate == !SecondTemplate &&
822 "Both pointers should be null or non-null");
824 if (FirstTemplate && SecondTemplate) {
829 assert(FirstTemplateParams.size() == SecondTemplateParams.size() &&
830 "Number of template parameters should be equal.");
831 for (
auto Pair : llvm::zip(FirstTemplateParams, SecondTemplateParams)) {
832 const NamedDecl *FirstDecl = std::get<0>(Pair);
833 const NamedDecl *SecondDecl = std::get<1>(Pair);
838 "Parameter Decl's should be the same kind.");
840 enum ODRTemplateDifference {
843 ParamSingleDefaultArgument,
844 ParamDifferentDefaultArgument,
847 auto hasDefaultArg = [](
const NamedDecl *D) {
848 if (
auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
849 return TTP->hasDefaultArgument() &&
850 !TTP->defaultArgumentWasInherited();
851 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
852 return NTTP->hasDefaultArgument() &&
853 !NTTP->defaultArgumentWasInherited();
854 auto *TTP = cast<TemplateTemplateParmDecl>(D);
855 return TTP->hasDefaultArgument() && !TTP->defaultArgumentWasInherited();
857 bool hasFirstArg = hasDefaultArg(FirstDecl);
858 bool hasSecondArg = hasDefaultArg(SecondDecl);
860 ODRTemplateDifference ErrDiffType;
861 ODRTemplateDifference NoteDiffType;
866 if (FirstName != SecondName) {
867 bool FirstNameEmpty =
869 bool SecondNameEmpty =
871 ErrDiffType = FirstNameEmpty ? ParamEmptyName : ParamName;
872 NoteDiffType = SecondNameEmpty ? ParamEmptyName : ParamName;
873 }
else if (hasFirstArg == hasSecondArg)
874 ErrDiffType = NoteDiffType = ParamDifferentDefaultArgument;
876 ErrDiffType = NoteDiffType = ParamSingleDefaultArgument;
879 diag::err_module_odr_violation_template_parameter)
880 << FirstRecord << FirstModule.empty() << FirstModule
884 diag::note_module_odr_violation_template_parameter)
886 << hasSecondArg << SecondName;
893 for (
const Decl *D : Record->decls()) {
903 PopulateHashes(FirstHashes, FirstRecord, DC);
904 PopulateHashes(SecondHashes, SecondRecord, DC);
906 DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
907 ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
908 ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
909 const Decl *FirstDecl = DR.FirstDecl;
910 const Decl *SecondDecl = DR.SecondDecl;
912 if (FirstDiffType == Other || SecondDiffType == Other) {
913 diagnoseSubMismatchUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
918 if (FirstDiffType != SecondDiffType) {
919 diagnoseSubMismatchDifferentDeclKinds(DR, FirstRecord, FirstModule,
920 SecondRecord, SecondModule);
926 enum ODRCXXRecordDifference {
927 StaticAssertCondition,
929 StaticAssertOnlyMessage,
938 MethodParameterSingleDefaultArgument,
939 MethodParameterDifferentDefaultArgument,
940 MethodNoTemplateArguments,
941 MethodDifferentNumberTemplateArguments,
942 MethodDifferentTemplateArgument,
948 FunctionTemplateDifferentNumberParameters,
949 FunctionTemplateParameterDifferentKind,
950 FunctionTemplateParameterName,
951 FunctionTemplateParameterSingleDefaultArgument,
952 FunctionTemplateParameterDifferentDefaultArgument,
953 FunctionTemplateParameterDifferentType,
954 FunctionTemplatePackParameter,
956 auto DiagError = [FirstRecord, &FirstModule,
958 ODRCXXRecordDifference DiffType) {
959 return Diag(Loc, diag::err_module_odr_violation_record)
960 << FirstRecord << FirstModule.empty() << FirstModule << Range
964 ODRCXXRecordDifference DiffType) {
965 return Diag(Loc, diag::note_module_odr_violation_record)
966 << SecondModule << Range << DiffType;
969 assert(FirstDiffType == SecondDiffType);
970 switch (FirstDiffType) {
974 case PrivateSpecifer:
975 case ProtectedSpecifer:
979 llvm_unreachable(
"Invalid diff type");
989 if (FirstODRHash != SecondODRHash) {
991 StaticAssertCondition);
993 StaticAssertCondition);
999 assert((FirstStr || SecondStr) &&
"Both messages cannot be empty");
1000 if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
1017 DiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
1018 << (FirstStr ==
nullptr);
1019 DiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
1020 << (SecondStr ==
nullptr);
1024 if (FirstStr && SecondStr &&
1027 StaticAssertMessage);
1029 StaticAssertMessage);
1036 if (diagnoseSubMismatchField(FirstRecord, FirstModule, SecondModule,
1037 cast<FieldDecl>(FirstDecl),
1038 cast<FieldDecl>(SecondDecl)))
1050 auto GetMethodTypeForDiagnostics = [](
const CXXMethodDecl *D) {
1051 if (isa<CXXConstructorDecl>(D))
1052 return DiagConstructor;
1053 if (isa<CXXDestructorDecl>(D))
1054 return DiagDestructor;
1057 const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
1058 const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
1059 FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
1060 SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
1063 auto DiagMethodError = [&DiagError, FirstMethod, FirstMethodType,
1064 FirstName](ODRCXXRecordDifference DiffType) {
1067 << FirstMethodType << FirstName;
1069 auto DiagMethodNote = [&DiagNote, SecondMethod, SecondMethodType,
1070 SecondName](ODRCXXRecordDifference DiffType) {
1073 << SecondMethodType << SecondName;
1076 if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
1077 DiagMethodError(MethodName);
1078 DiagMethodNote(MethodName);
1084 if (FirstDeleted != SecondDeleted) {
1085 DiagMethodError(MethodDeleted) << FirstDeleted;
1086 DiagMethodNote(MethodDeleted) << SecondDeleted;
1092 if (FirstDefaulted != SecondDefaulted) {
1093 DiagMethodError(MethodDefaulted) << FirstDefaulted;
1094 DiagMethodNote(MethodDefaulted) << SecondDefaulted;
1100 const bool FirstPure = FirstMethod->
isPure();
1101 const bool SecondPure = SecondMethod->
isPure();
1102 if ((FirstVirtual || SecondVirtual) &&
1103 (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
1104 DiagMethodError(MethodVirtual) << FirstPure << FirstVirtual;
1105 DiagMethodNote(MethodVirtual) << SecondPure << SecondVirtual;
1114 const bool FirstStatic = FirstStorage ==
SC_Static;
1115 const bool SecondStatic = SecondStorage ==
SC_Static;
1116 if (FirstStatic != SecondStatic) {
1117 DiagMethodError(MethodStatic) << FirstStatic;
1118 DiagMethodNote(MethodStatic) << SecondStatic;
1122 const bool FirstVolatile = FirstMethod->
isVolatile();
1123 const bool SecondVolatile = SecondMethod->
isVolatile();
1124 if (FirstVolatile != SecondVolatile) {
1125 DiagMethodError(MethodVolatile) << FirstVolatile;
1126 DiagMethodNote(MethodVolatile) << SecondVolatile;
1130 const bool FirstConst = FirstMethod->
isConst();
1131 const bool SecondConst = SecondMethod->
isConst();
1132 if (FirstConst != SecondConst) {
1133 DiagMethodError(MethodConst) << FirstConst;
1134 DiagMethodNote(MethodConst) << SecondConst;
1140 if (FirstInline != SecondInline) {
1141 DiagMethodError(MethodInline) << FirstInline;
1142 DiagMethodNote(MethodInline) << SecondInline;
1147 FirstModule, SecondModule,
1148 FirstMethod, SecondMethod))
1151 for (
unsigned I = 0, N = FirstMethod->
param_size(); I < N; ++I) {
1157 if ((FirstInit ==
nullptr) != (SecondInit ==
nullptr)) {
1158 DiagMethodError(MethodParameterSingleDefaultArgument)
1159 << (I + 1) << (FirstInit ==
nullptr)
1161 DiagMethodNote(MethodParameterSingleDefaultArgument)
1162 << (I + 1) << (SecondInit ==
nullptr)
1167 if (FirstInit && SecondInit &&
1169 DiagMethodError(MethodParameterDifferentDefaultArgument)
1171 DiagMethodNote(MethodParameterDifferentDefaultArgument)
1182 if ((FirstTemplateArgs && !SecondTemplateArgs) ||
1183 (!FirstTemplateArgs && SecondTemplateArgs)) {
1184 DiagMethodError(MethodNoTemplateArguments)
1185 << (FirstTemplateArgs !=
nullptr);
1186 DiagMethodNote(MethodNoTemplateArguments)
1187 << (SecondTemplateArgs !=
nullptr);
1191 if (FirstTemplateArgs && SecondTemplateArgs) {
1197 ExpandedList.push_back(&TA);
1200 llvm::append_range(ExpandedList,
1201 llvm::make_pointer_range(TA.getPackAsArray()));
1203 return ExpandedList;
1206 ExpandTemplateArgumentList(FirstTemplateArgs);
1208 ExpandTemplateArgumentList(SecondTemplateArgs);
1210 if (FirstExpandedList.size() != SecondExpandedList.size()) {
1211 DiagMethodError(MethodDifferentNumberTemplateArguments)
1212 << (
unsigned)FirstExpandedList.size();
1213 DiagMethodNote(MethodDifferentNumberTemplateArguments)
1214 << (
unsigned)SecondExpandedList.size();
1218 for (
unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
1220 &SecondTA = *SecondExpandedList[i];
1224 DiagMethodError(MethodDifferentTemplateArgument) << FirstTA << i + 1;
1225 DiagMethodNote(MethodDifferentTemplateArgument) << SecondTA << i + 1;
1240 const bool HasFirstBody =
1241 ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->
getODRHash();
1242 const bool HasSecondBody =
1243 ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->
getODRHash();
1245 if (HasFirstBody != HasSecondBody) {
1246 DiagMethodError(MethodSingleBody) << HasFirstBody;
1247 DiagMethodNote(MethodSingleBody) << HasSecondBody;
1251 if (HasFirstBody && HasSecondBody) {
1252 DiagMethodError(MethodDifferentBody);
1253 DiagMethodNote(MethodDifferentBody);
1262 if (diagnoseSubMismatchTypedef(FirstRecord, FirstModule, SecondModule,
1263 cast<TypedefNameDecl>(FirstDecl),
1264 cast<TypedefNameDecl>(SecondDecl),
1265 FirstDiffType == TypeAlias))
1270 if (diagnoseSubMismatchVar(FirstRecord, FirstModule, SecondModule,
1271 cast<VarDecl>(FirstDecl),
1272 cast<VarDecl>(SecondDecl)))
1277 const FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
1278 const FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
1286 if (FirstND && SecondND) {
1296 if (FirstTSI && SecondTSI) {
1306 << SecondFriendType;
1312 << (FirstTSI ==
nullptr);
1315 << (SecondTSI ==
nullptr);
1318 case FunctionTemplate: {
1320 cast<FunctionTemplateDecl>(FirstDecl);
1322 cast<FunctionTemplateDecl>(SecondDecl);
1327 auto DiagTemplateError = [&DiagError,
1328 FirstTemplate](ODRCXXRecordDifference DiffType) {
1333 auto DiagTemplateNote = [&DiagNote,
1334 SecondTemplate](ODRCXXRecordDifference DiffType) {
1340 if (FirstTPL->
size() != SecondTPL->
size()) {
1341 DiagTemplateError(FunctionTemplateDifferentNumberParameters)
1342 << FirstTPL->
size();
1343 DiagTemplateNote(FunctionTemplateDifferentNumberParameters)
1344 << SecondTPL->
size();
1348 for (
unsigned i = 0, e = FirstTPL->
size(); i != e; ++i) {
1354 TemplateTypeParameter,
1355 NonTypeTemplateParameter,
1356 TemplateTemplateParameter,
1359 switch (D->getKind()) {
1361 llvm_unreachable(
"Unexpected template parameter type");
1362 case Decl::TemplateTypeParm:
1363 return TemplateTypeParameter;
1364 case Decl::NonTypeTemplateParm:
1365 return NonTypeTemplateParameter;
1366 case Decl::TemplateTemplateParm:
1367 return TemplateTemplateParameter;
1371 DiagTemplateError(FunctionTemplateParameterDifferentKind)
1372 << (i + 1) << GetParamType(FirstParam);
1373 DiagTemplateNote(FunctionTemplateParameterDifferentKind)
1374 << (i + 1) << GetParamType(SecondParam);
1379 DiagTemplateError(FunctionTemplateParameterName)
1380 << (i + 1) << (
bool)FirstParam->
getIdentifier() << FirstParam;
1381 DiagTemplateNote(FunctionTemplateParameterName)
1382 << (i + 1) << (
bool)SecondParam->
getIdentifier() << SecondParam;
1386 if (isa<TemplateTypeParmDecl>(FirstParam) &&
1387 isa<TemplateTypeParmDecl>(SecondParam)) {
1389 cast<TemplateTypeParmDecl>(FirstParam);
1391 cast<TemplateTypeParmDecl>(SecondParam);
1392 bool HasFirstDefaultArgument =
1395 bool HasSecondDefaultArgument =
1398 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
1399 DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
1400 << (i + 1) << HasFirstDefaultArgument;
1401 DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
1402 << (i + 1) << HasSecondDefaultArgument;
1406 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
1410 DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
1411 << (i + 1) << FirstType;
1412 DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
1413 << (i + 1) << SecondType;
1419 DiagTemplateError(FunctionTemplatePackParameter)
1421 DiagTemplateNote(FunctionTemplatePackParameter)
1427 if (isa<TemplateTemplateParmDecl>(FirstParam) &&
1428 isa<TemplateTemplateParmDecl>(SecondParam)) {
1430 cast<TemplateTemplateParmDecl>(FirstParam);
1432 cast<TemplateTemplateParmDecl>(SecondParam);
1437 auto ComputeTemplateParameterListODRHash =
1445 if (ComputeTemplateParameterListODRHash(FirstTPL) !=
1446 ComputeTemplateParameterListODRHash(SecondTPL)) {
1447 DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
1448 DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
1452 bool HasFirstDefaultArgument =
1455 bool HasSecondDefaultArgument =
1458 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
1459 DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
1460 << (i + 1) << HasFirstDefaultArgument;
1461 DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
1462 << (i + 1) << HasSecondDefaultArgument;
1466 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
1472 DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
1473 << (i + 1) << FirstTA;
1474 DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
1475 << (i + 1) << SecondTA;
1481 DiagTemplateError(FunctionTemplatePackParameter)
1483 DiagTemplateNote(FunctionTemplatePackParameter)
1489 if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
1490 isa<NonTypeTemplateParmDecl>(SecondParam)) {
1492 cast<NonTypeTemplateParmDecl>(FirstParam);
1494 cast<NonTypeTemplateParmDecl>(SecondParam);
1499 DiagTemplateError(FunctionTemplateParameterDifferentType) << (i + 1);
1500 DiagTemplateNote(FunctionTemplateParameterDifferentType) << (i + 1);
1504 bool HasFirstDefaultArgument =
1507 bool HasSecondDefaultArgument =
1510 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
1511 DiagTemplateError(FunctionTemplateParameterSingleDefaultArgument)
1512 << (i + 1) << HasFirstDefaultArgument;
1513 DiagTemplateNote(FunctionTemplateParameterSingleDefaultArgument)
1514 << (i + 1) << HasSecondDefaultArgument;
1518 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
1523 DiagTemplateError(FunctionTemplateParameterDifferentDefaultArgument)
1524 << (i + 1) << FirstDefaultArgument;
1525 DiagTemplateNote(FunctionTemplateParameterDifferentDefaultArgument)
1526 << (i + 1) << SecondDefaultArgument;
1532 DiagTemplateError(FunctionTemplatePackParameter)
1534 DiagTemplateNote(FunctionTemplatePackParameter)
1545 diag::err_module_odr_violation_mismatch_decl_unknown)
1546 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
1549 diag::note_module_odr_violation_mismatch_decl_unknown)
1550 << SecondModule.empty() << SecondModule << FirstDiffType
1557 if (FirstRecord == SecondRecord)
1565 for (
const Decl *D : Record->decls()) {
1575 PopulateHashes(FirstHashes, FirstRecord, DC);
1576 PopulateHashes(SecondHashes, SecondRecord, DC);
1578 DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
1579 ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
1580 ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
1581 const Decl *FirstDecl = DR.FirstDecl;
1582 const Decl *SecondDecl = DR.SecondDecl;
1584 if (FirstDiffType == Other || SecondDiffType == Other) {
1585 diagnoseSubMismatchUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
1590 if (FirstDiffType != SecondDiffType) {
1591 diagnoseSubMismatchDifferentDeclKinds(DR, FirstRecord, FirstModule,
1592 SecondRecord, SecondModule);
1596 assert(FirstDiffType == SecondDiffType);
1597 switch (FirstDiffType) {
1602 case PublicSpecifer:
1603 case PrivateSpecifer:
1604 case ProtectedSpecifer:
1609 case FunctionTemplate:
1614 llvm_unreachable(
"Invalid diff type");
1617 if (diagnoseSubMismatchField(FirstRecord, FirstModule, SecondModule,
1618 cast<FieldDecl>(FirstDecl),
1619 cast<FieldDecl>(SecondDecl)))
1624 if (diagnoseSubMismatchTypedef(FirstRecord, FirstModule, SecondModule,
1625 cast<TypedefNameDecl>(FirstDecl),
1626 cast<TypedefNameDecl>(SecondDecl),
1632 if (diagnoseSubMismatchVar(FirstRecord, FirstModule, SecondModule,
1633 cast<VarDecl>(FirstDecl),
1634 cast<VarDecl>(SecondDecl)))
1641 diag::err_module_odr_violation_mismatch_decl_unknown)
1642 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
1645 diag::note_module_odr_violation_mismatch_decl_unknown)
1646 << SecondModule.empty() << SecondModule << FirstDiffType
1654 if (FirstFunction == SecondFunction)
1658 enum ODRFunctionDifference {
1662 ParameterSingleDefaultArgument,
1663 ParameterDifferentDefaultArgument,
1670 auto DiagError = [FirstFunction, &FirstModule,
1672 ODRFunctionDifference DiffType) {
1673 return Diag(Loc, diag::err_module_odr_violation_function)
1674 << FirstFunction << FirstModule.empty() << FirstModule << Range
1678 ODRFunctionDifference DiffType) {
1679 return Diag(Loc, diag::note_module_odr_violation_function)
1680 << SecondModule << Range << DiffType;
1695 "Merged functions with different number of parameters");
1697 size_t ParamSize = FirstFunction->
param_size();
1698 for (
unsigned I = 0; I < ParamSize; ++I) {
1703 "Merged function has different parameter types.");
1717 if (FirstParamType != SecondParamType &&
1723 << (I + 1) << FirstParamType <<
true
1724 << ParamDecayedType->getOriginalType();
1728 << (I + 1) << FirstParamType <<
false;
1735 << (I + 1) << SecondParamType <<
true
1736 << ParamDecayedType->getOriginalType();
1740 << (I + 1) << SecondParamType <<
false;
1747 if ((FirstInit ==
nullptr) != (SecondInit ==
nullptr)) {
1749 ParameterSingleDefaultArgument)
1750 << (I + 1) << (FirstInit ==
nullptr)
1753 ParameterSingleDefaultArgument)
1754 << (I + 1) << (SecondInit ==
nullptr)
1759 if (FirstInit && SecondInit &&
1762 ParameterDifferentDefaultArgument)
1765 ParameterDifferentDefaultArgument)
1771 "Undiagnosed parameter difference.");
1784 const EnumDecl *SecondEnum)
const {
1785 if (FirstEnum == SecondEnum)
1789 enum ODREnumDifference {
1791 EnumTagKeywordMismatch,
1792 SingleSpecifiedType,
1793 DifferentSpecifiedTypes,
1794 DifferentNumberEnumConstants,
1796 EnumConstantSingleInitializer,
1797 EnumConstantDifferentInitializer,
1803 auto DiagError = [FirstEnum, &FirstModule,
this](
const auto *DiagAnchor,
1804 ODREnumDifference DiffType) {
1805 return Diag(DiagAnchor->getLocation(), diag::err_module_odr_violation_enum)
1806 << FirstEnum << FirstModule.empty() << FirstModule
1809 auto DiagNote = [&SecondModule,
this](
const auto *DiagAnchor,
1810 ODREnumDifference DiffType) {
1811 return Diag(DiagAnchor->getLocation(), diag::note_module_odr_violation_enum)
1812 << SecondModule << DiagAnchor->getSourceRange() << DiffType;
1816 DiagError(FirstEnum, SingleScopedEnum) << FirstEnum->
isScoped();
1817 DiagNote(SecondEnum, SingleScopedEnum) << SecondEnum->
isScoped();
1824 DiagError(FirstEnum, EnumTagKeywordMismatch)
1826 DiagNote(SecondEnum, EnumTagKeywordMismatch)
1840 if (FirstUnderlyingType.
isNull() != SecondUnderlyingType.
isNull()) {
1841 DiagError(FirstEnum, SingleSpecifiedType) << !FirstUnderlyingType.
isNull();
1842 DiagNote(SecondEnum, SingleSpecifiedType) << !SecondUnderlyingType.
isNull();
1846 if (!FirstUnderlyingType.
isNull() && !SecondUnderlyingType.
isNull()) {
1849 DiagError(FirstEnum, DifferentSpecifiedTypes) << FirstUnderlyingType;
1850 DiagNote(SecondEnum, DifferentSpecifiedTypes) << SecondUnderlyingType;
1859 for (
const Decl *D :
Enum->decls()) {
1864 assert(isa<EnumConstantDecl>(D) &&
"Unexpected Decl kind");
1865 Hashes.emplace_back(cast<EnumConstantDecl>(D),
computeODRHash(D));
1869 PopulateHashes(FirstHashes, FirstEnum);
1871 PopulateHashes(SecondHashes, SecondEnum);
1873 if (FirstHashes.size() != SecondHashes.size()) {
1874 DiagError(FirstEnum, DifferentNumberEnumConstants)
1875 << (
int)FirstHashes.size();
1876 DiagNote(SecondEnum, DifferentNumberEnumConstants)
1877 << (
int)SecondHashes.size();
1881 for (
unsigned I = 0, N = FirstHashes.size(); I < N; ++I) {
1882 if (FirstHashes[I].second == SecondHashes[I].second)
1888 DiagError(FirstConstant, EnumConstantName) << I + 1 << FirstConstant;
1889 DiagNote(SecondConstant, EnumConstantName) << I + 1 << SecondConstant;
1895 if (!FirstInit && !SecondInit)
1898 if (!FirstInit || !SecondInit) {
1899 DiagError(FirstConstant, EnumConstantSingleInitializer)
1900 << I + 1 << FirstConstant << (FirstInit !=
nullptr);
1901 DiagNote(SecondConstant, EnumConstantSingleInitializer)
1902 << I + 1 << SecondConstant << (SecondInit !=
nullptr);
1907 DiagError(FirstConstant, EnumConstantDifferentInitializer)
1908 << I + 1 << FirstConstant;
1909 DiagNote(SecondConstant, EnumConstantDifferentInitializer)
1910 << I + 1 << SecondConstant;
1919 const struct ObjCInterfaceDecl::DefinitionData *SecondDD)
const {
1922 if (FirstID == SecondID)
1929 enum ODRInterfaceDifference {
1934 auto DiagError = [FirstID, &FirstModule,
1936 ODRInterfaceDifference DiffType) {
1937 return Diag(Loc, diag::err_module_odr_violation_objc_interface)
1938 << FirstID << FirstModule.empty() << FirstModule << Range
1942 ODRInterfaceDifference DiffType) {
1943 return Diag(Loc, diag::note_module_odr_violation_objc_interface)
1944 << SecondModule.empty() << SecondModule << Range << DiffType;
1947 const struct ObjCInterfaceDecl::DefinitionData *FirstDD = &FirstID->data();
1948 assert(FirstDD && SecondDD &&
"Definitions without DefinitionData");
1949 if (FirstDD != SecondDD) {
1951 auto GetSuperClassSourceRange = [](
const TypeSourceInfo *SuperInfo,
1954 return ID->getSourceRange();
1962 const TypeSourceInfo *SecondSuperInfo = SecondDD->SuperClassTInfo;
1963 if (SecondSuperInfo)
1967 if ((FirstSuperClass && SecondSuperClass &&
1969 (FirstSuperClass && !SecondSuperClass) ||
1970 (!FirstSuperClass && SecondSuperClass)) {
1973 FirstType = FirstSuperInfo->
getType();
1976 GetSuperClassSourceRange(FirstSuperInfo, FirstID),
1978 << (
bool)FirstSuperInfo << FirstType;
1981 if (SecondSuperInfo)
1982 SecondType = SecondSuperInfo->
getType();
1985 GetSuperClassSourceRange(SecondSuperInfo, SecondID),
1987 << (
bool)SecondSuperInfo << SecondType;
1993 auto &SecondProtos = SecondDD->ReferencedProtocols;
1994 if (diagnoseSubMismatchProtocols(FirstProtos, FirstID, FirstModule,
1995 SecondProtos, SecondID, SecondModule))
2001 for (
auto *D : ID->decls()) {
2012 PopulateHashes(FirstHashes, FirstID, FirstID->
getDefinition());
2013 PopulateHashes(SecondHashes, SecondID, SecondID->
getDefinition());
2015 DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
2016 ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
2017 ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
2018 const Decl *FirstDecl = DR.FirstDecl;
2019 const Decl *SecondDecl = DR.SecondDecl;
2021 if (FirstDiffType == Other || SecondDiffType == Other) {
2022 diagnoseSubMismatchUnexpected(DR, FirstID, FirstModule, SecondID,
2027 if (FirstDiffType != SecondDiffType) {
2028 diagnoseSubMismatchDifferentDeclKinds(DR, FirstID, FirstModule, SecondID,
2033 assert(FirstDiffType == SecondDiffType);
2034 switch (FirstDiffType) {
2043 case PublicSpecifer:
2044 case PrivateSpecifer:
2045 case ProtectedSpecifer:
2050 case FunctionTemplate:
2051 llvm_unreachable(
"Invalid diff type");
2054 if (diagnoseSubMismatchObjCMethod(FirstID, FirstModule, SecondModule,
2055 cast<ObjCMethodDecl>(FirstDecl),
2056 cast<ObjCMethodDecl>(SecondDecl)))
2061 if (diagnoseSubMismatchField(FirstID, FirstModule, SecondModule,
2062 cast<FieldDecl>(FirstDecl),
2063 cast<FieldDecl>(SecondDecl)))
2067 const ObjCIvarDecl *FirstIvar = cast<ObjCIvarDecl>(FirstDecl);
2068 const ObjCIvarDecl *SecondIvar = cast<ObjCIvarDecl>(SecondDecl);
2083 case ObjCProperty: {
2084 if (diagnoseSubMismatchObjCProperty(FirstID, FirstModule, SecondModule,
2085 cast<ObjCPropertyDecl>(FirstDecl),
2086 cast<ObjCPropertyDecl>(SecondDecl)))
2093 diag::err_module_odr_violation_mismatch_decl_unknown)
2094 << FirstID << FirstModule.empty() << FirstModule << FirstDiffType
2097 diag::note_module_odr_violation_mismatch_decl_unknown)
2098 << SecondModule << FirstDiffType << SecondDecl->
getSourceRange();
2105 const struct ObjCProtocolDecl::DefinitionData *SecondDD)
const {
2106 if (FirstProtocol == SecondProtocol)
2112 const ObjCProtocolDecl::DefinitionData *FirstDD = &FirstProtocol->data();
2113 assert(FirstDD && SecondDD &&
"Definitions without DefinitionData");
2115 if (FirstDD != SecondDD) {
2120 if (diagnoseSubMismatchProtocols(FirstProtocols, FirstProtocol, FirstModule,
2121 SecondProtocols, SecondProtocol,
2128 for (
const Decl *D : ID->decls()) {
2139 PopulateHashes(FirstHashes, FirstProtocol, FirstProtocol->
getDefinition());
2140 PopulateHashes(SecondHashes, SecondProtocol, SecondProtocol->
getDefinition());
2142 DiffResult DR = FindTypeDiffs(FirstHashes, SecondHashes);
2143 ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
2144 ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
2145 const Decl *FirstDecl = DR.FirstDecl;
2146 const Decl *SecondDecl = DR.SecondDecl;
2148 if (FirstDiffType == Other || SecondDiffType == Other) {
2149 diagnoseSubMismatchUnexpected(DR, FirstProtocol, FirstModule,
2150 SecondProtocol, SecondModule);
2154 if (FirstDiffType != SecondDiffType) {
2155 diagnoseSubMismatchDifferentDeclKinds(DR, FirstProtocol, FirstModule,
2156 SecondProtocol, SecondModule);
2160 assert(FirstDiffType == SecondDiffType);
2161 switch (FirstDiffType) {
2171 case PublicSpecifer:
2172 case PrivateSpecifer:
2173 case ProtectedSpecifer:
2178 case FunctionTemplate:
2179 llvm_unreachable(
"Invalid diff type");
2181 if (diagnoseSubMismatchObjCMethod(FirstProtocol, FirstModule, SecondModule,
2182 cast<ObjCMethodDecl>(FirstDecl),
2183 cast<ObjCMethodDecl>(SecondDecl)))
2187 case ObjCProperty: {
2188 if (diagnoseSubMismatchObjCProperty(FirstProtocol, FirstModule,
2190 cast<ObjCPropertyDecl>(FirstDecl),
2191 cast<ObjCPropertyDecl>(SecondDecl)))
2198 diag::err_module_odr_violation_mismatch_decl_unknown)
2199 << FirstProtocol << FirstModule.empty() << FirstModule << FirstDiffType
2202 diag::note_module_odr_violation_mismatch_decl_unknown)
2203 << SecondModule.empty() << SecondModule << FirstDiffType
Defines the C++ template declaration subclasses.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Defines the clang::Module class, which describes a module in the source code.
static unsigned computeODRHash(QualType Ty)
static bool diagnoseSubMismatchMethodParameters(DiagnosticsEngine &Diags, const NamedDecl *FirstContainer, StringRef FirstModule, StringRef SecondModule, const MethodT *FirstMethod, const MethodT *SecondMethod)
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes,...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Represents a base class of a C++ class.
AccessSpecifier getAccessSpecifierAsWritten() const
Retrieves the access specifier as written in the source code (which may mean that no access specifier...
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
QualType getType() const
Retrieves the type of the base class.
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Represents a static or instance method of a struct/union/class.
Represents a C++ struct/union/class.
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Declaration of a class template.
Represents a pointer type decayed from an array or function type.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Decl - This represents one declaration (or definition), e.g.
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
An instance of this object exists for each enum constant that is defined.
const Expr * getInitExpr() const
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
SourceRange getSourceRange() const override LLVM_READONLY
Overrides to provide correct range when there's an enum-base specifier with forward declarations.
This represents one expression.
Represents a member of a struct/union/class.
bool isMutable() const
Determines whether this field is mutable (C++ only).
bool isBitField() const
Determines whether this field is a bitfield.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
Expr * getBitWidth() const
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
SourceLocation getFriendLoc() const
Retrieves the location of the 'friend' keyword.
SourceRange getSourceRange() const override LLVM_READONLY
Retrieves the source range for the friend declaration.
NamedDecl * getFriendDecl() const
If this friend declaration doesn't name a type, return the inner declaration.
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
bool isPure() const
Whether this virtual function is pure, i.e.
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
QualType getReturnType() const
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
unsigned getODRHash()
Returns ODRHash of the function.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isDeletedAsWritten() const
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
size_t param_size() const
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Declaration of a template function.
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
Describes a module or submodule.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
bool diagnoseMismatch(const FunctionDecl *FirstFunction, const FunctionDecl *SecondFunction) const
Diagnose ODR mismatch between 2 FunctionDecl.
static std::string getOwningModuleNameForDiagnostic(const Decl *D)
Get the best name we know for the module that owns the given declaration, or an empty string if the d...
void AddStmt(const Stmt *S)
void AddFunctionDecl(const FunctionDecl *Function, bool SkipBody=false)
void AddSubDecl(const Decl *D)
void AddQualType(QualType T)
void AddTemplateParameterList(const TemplateParameterList *TPL)
void AddTemplateArgument(TemplateArgument TA)
static bool isSubDeclToBeProcessed(const Decl *D, const DeclContext *Parent)
ObjCContainerDecl - Represents a container for method declarations.
Represents an ObjC class declaration.
unsigned getODRHash()
Get precomputed ODRHash or add a new one.
const ObjCProtocolList & getReferencedProtocols() const
ObjCInterfaceDecl * getSuperClass() const
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
TypeSourceInfo * getSuperClassTInfo() const
ObjCIvarDecl - Represents an ObjC instance variable.
AccessControl getCanonicalAccessControl() const
ObjCMethodDecl - Represents an instance or class method declaration.
ImplementationControl getImplementationControl() const
bool isDirectMethod() const
True if the method is tagged as objc_direct.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isInstanceMethod() const
bool isThisDeclarationADesignatedInitializer() const
Returns true if this specific method declaration is marked with the designated initializer attribute.
QualType getReturnType() const
Represents a class type in Objective C.
Represents one property declaration in an Objective-C interface.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
SourceLocation getLParenLoc() const
ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const
ObjCPropertyAttribute::Kind getPropertyAttributes() const
PropertyControl getPropertyImplementation() const
Represents an Objective-C protocol declaration.
const ObjCProtocolList & getReferencedProtocols() const
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
A list of Objective-C protocols, along with the source locations at which they were referenced.
loc_iterator loc_begin() const
Represents a parameter to a function.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Represents a struct/union/class.
Encodes a location in the source.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
Represents a C++11 static_assert declaration.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
StringLiteral * getMessage()
Stmt - This represents one statement.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
StringRef getString() const
A template argument list.
const TemplateArgument & getArgument() const
Represents a template argument.
@ Pack
The template argument is actually a parameter pack.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
ArrayRef< NamedDecl * > asArray()
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Declaration of a template type parameter.
QualType getDefaultArgument() const
Retrieve the default argument, if any.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
bool isParameterPack() const
Returns whether this is a parameter pack.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Base wrapper for a particular "section" of type source info.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
const T * castAs() const
Member-template castAs<specific type>.
const T * getAs() const
Member-template getAs<specific type>'.
Base class for declarations which introduce a typedef-name.
QualType getUnderlyingType() const
Represents a variable declaration or definition.
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
const Expr * getInit() const
StorageClass
Storage classes.
@ NumObjCPropertyAttrsBits
Number of bits fitting all the property attributes.