56 #include "llvm/ADT/APSInt.h"
57 #include "llvm/ADT/ArrayRef.h"
58 #include "llvm/ADT/DenseMap.h"
59 #include "llvm/ADT/STLExtras.h"
60 #include "llvm/ADT/ScopeExit.h"
61 #include "llvm/ADT/SmallVector.h"
62 #include "llvm/Support/Casting.h"
63 #include "llvm/Support/ErrorHandling.h"
64 #include "llvm/Support/MemoryBuffer.h"
70 #include <type_traits>
75 using llvm::make_error;
90 return "NameConflict";
92 return "UnsupportedConstruct";
94 return "Unknown error";
96 llvm_unreachable(
"Invalid error code.");
97 return "Invalid error code.";
103 llvm_unreachable(
"Function not implemented.");
114 Redecls.push_back(R);
117 std::reverse(Redecls.begin(), Redecls.end());
122 if (
auto *FD = dyn_cast<FunctionDecl>(D))
123 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
124 if (
auto *VD = dyn_cast<VarDecl>(D))
125 return getCanonicalForwardRedeclChain<VarDecl>(VD);
126 if (
auto *TD = dyn_cast<TagDecl>(D))
127 return getCanonicalForwardRedeclChain<TagDecl>(TD);
128 llvm_unreachable(
"Bad declaration kind");
149 bool const IgnoreChildErrors;
153 : FromDC(FromDC), IgnoreChildErrors(!
isa<
TagDecl>(FromDC)) {}
163 if (ChildErr && !IgnoreChildErrors)
164 ResultErr = joinErrors(std::move(ResultErr), std::move(ChildErr));
166 consumeError(std::move(ChildErr));
172 if (!IgnoreChildErrors || !FromDC)
180 public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
184 template <
typename ImportT>
185 [[nodiscard]]
Error importInto(ImportT &To,
const ImportT &From) {
190 template <
typename ImportT>
191 [[nodiscard]]
Error importInto(ImportT *&To, ImportT *From) {
192 auto ToOrErr = Importer.
Import(From);
194 To = cast_or_null<ImportT>(*ToOrErr);
195 return ToOrErr.takeError();
200 template <
typename T>
204 auto ToOrErr = Importer.
Import(From);
206 return ToOrErr.takeError();
207 return cast_or_null<T>(*ToOrErr);
210 template <
typename T>
211 auto import(
const T *From) {
212 return import(
const_cast<T *
>(From));
216 template <
typename T>
218 return Importer.
Import(From);
222 template <
typename T>
226 return import(*From);
233 template <
typename ToDeclT>
struct CallOverloadedCreateFun {
234 template <
typename... Args> decltype(
auto) operator()(Args &&... args) {
235 return ToDeclT::Create(std::forward<Args>(args)...);
245 template <
typename ToDeclT,
typename FromDeclT,
typename... Args>
246 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
251 CallOverloadedCreateFun<ToDeclT> OC;
252 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
253 std::forward<Args>(args)...);
260 template <
typename NewDeclT,
typename ToDeclT,
typename FromDeclT,
262 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
264 CallOverloadedCreateFun<NewDeclT> OC;
265 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
266 std::forward<Args>(args)...);
270 template <
typename ToDeclT,
typename CreateFunT,
typename FromDeclT,
273 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
274 FromDeclT *FromD, Args &&...args) {
282 ToD = CreateFun(std::forward<Args>(args)...);
285 Importer.SharedState->markAsNewDecl(ToD);
286 InitializeImportedDecl(FromD, ToD);
290 void InitializeImportedDecl(
Decl *FromD,
Decl *ToD) {
303 FoundFunction->
hasBody(Definition))
308 void addDeclToContexts(
Decl *FromD,
Decl *ToD) {
324 bool Visible =
false;
337 if (
auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
338 auto *ToNamed = cast<NamedDecl>(ToD);
340 FromDC->
lookup(FromNamed->getDeclName());
341 if (llvm::is_contained(FromLookup, FromNamed))
358 updateLookupTableForTemplateParameters(
477 template <
typename InContainerTy>
481 template<
typename InContainerTy>
488 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
505 template <
typename T>
698 Err = MaybeVal.takeError();
704 template<
typename IIter,
typename OIter>
706 using ItemT = std::remove_reference_t<decltype(*Obegin)>;
707 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
710 return ToOrErr.takeError();
713 return Error::success();
720 template<
typename InContainerTy,
typename OutContainerTy>
722 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
724 InContainer.begin(), InContainer.end(), OutContainer.begin());
727 template<
typename InContainerTy,
typename OIter>
744 template <
typename InContainerTy>
748 auto ToLAngleLocOrErr =
import(FromLAngleLoc);
749 if (!ToLAngleLocOrErr)
750 return ToLAngleLocOrErr.takeError();
751 auto ToRAngleLocOrErr =
import(FromRAngleLoc);
752 if (!ToRAngleLocOrErr)
753 return ToRAngleLocOrErr.takeError();
759 return Error::success();
763 Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
774 return ImportTemplateArgumentListInfo(
775 From.LAngleLoc, From.RAngleLoc, From.arguments(), Result);
787 if (
Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
788 return std::move(Err);
792 std::get<1>(Result)))
793 return std::move(Err);
803 return std::move(Err);
806 if (!ToRequiresClause)
807 return ToRequiresClause.takeError();
810 if (!ToTemplateLocOrErr)
811 return ToTemplateLocOrErr.takeError();
813 if (!ToLAngleLocOrErr)
814 return ToLAngleLocOrErr.takeError();
816 if (!ToRAngleLocOrErr)
817 return ToRAngleLocOrErr.takeError();
838 return ToTypeOrErr.takeError();
846 return ToTypeOrErr.takeError();
853 return ToOrErr.takeError();
856 return ToTypeOrErr.takeError();
863 return ToTypeOrErr.takeError();
870 if (!ToTemplateOrErr)
871 return ToTemplateOrErr.takeError();
879 if (!ToTemplateOrErr)
880 return ToTemplateOrErr.takeError();
890 return ToExpr.takeError();
896 return std::move(Err);
903 llvm_unreachable(
"Invalid template argument kind");
911 return ArgOrErr.takeError();
920 return E.takeError();
926 return TSIOrErr.takeError();
928 auto ToTemplateQualifierLocOrErr =
930 if (!ToTemplateQualifierLocOrErr)
931 return ToTemplateQualifierLocOrErr.takeError();
933 if (!ToTemplateNameLocOrErr)
934 return ToTemplateNameLocOrErr.takeError();
935 auto ToTemplateEllipsisLocOrErr =
937 if (!ToTemplateEllipsisLocOrErr)
938 return ToTemplateEllipsisLocOrErr.takeError();
941 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
951 size_t NumDecls = DG.
end() - DG.
begin();
953 ToDecls.reserve(NumDecls);
954 for (
Decl *FromD : DG) {
955 if (
auto ToDOrErr =
import(FromD))
956 ToDecls.push_back(*ToDOrErr);
958 return ToDOrErr.takeError();
973 return ToDotLocOrErr.takeError();
976 if (!ToFieldLocOrErr)
977 return ToFieldLocOrErr.takeError();
979 return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
983 if (!ToLBracketLocOrErr)
984 return ToLBracketLocOrErr.takeError();
987 if (!ToRBracketLocOrErr)
988 return ToRBracketLocOrErr.takeError();
992 *ToLBracketLocOrErr, *ToRBracketLocOrErr);
995 if (!ToEllipsisLocOrErr)
996 return ToEllipsisLocOrErr.takeError();
1001 *ToRBracketLocOrErr);
1011 return VarOrErr.takeError();
1016 return LocationOrErr.takeError();
1021 return std::move(Err);
1028 template <
typename T>
1030 if (Found->getLinkageInternal() != From->getLinkageInternal())
1033 if (From->hasExternalFormalLinkage())
1034 return Found->hasExternalFormalLinkage();
1037 if (From->isInAnonymousNamespace())
1038 return Found->isInAnonymousNamespace();
1040 return !Found->isInAnonymousNamespace() &&
1041 !Found->hasExternalFormalLinkage();
1061 using namespace clang;
1071 if (!UnderlyingTypeOrErr)
1072 return UnderlyingTypeOrErr.takeError();
1079 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1080 case BuiltinType::Id: \
1081 return Importer.getToContext().SingletonId;
1082 #include "clang/Basic/OpenCLImageTypes.def"
1083 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1084 case BuiltinType::Id: \
1085 return Importer.getToContext().Id##Ty;
1086 #include "clang/Basic/OpenCLExtensionTypes.def"
1087 #define SVE_TYPE(Name, Id, SingletonId) \
1088 case BuiltinType::Id: \
1089 return Importer.getToContext().SingletonId;
1090 #include "clang/Basic/AArch64SVEACLETypes.def"
1091 #define PPC_VECTOR_TYPE(Name, Id, Size) \
1092 case BuiltinType::Id: \
1093 return Importer.getToContext().Id##Ty;
1094 #include "clang/Basic/PPCTypes.def"
1095 #define RVV_TYPE(Name, Id, SingletonId) \
1096 case BuiltinType::Id: \
1097 return Importer.getToContext().SingletonId;
1098 #include "clang/Basic/RISCVVTypes.def"
1099 #define SHARED_SINGLETON_TYPE(Expansion)
1100 #define BUILTIN_TYPE(Id, SingletonId) \
1101 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1102 #include "clang/AST/BuiltinTypes.def"
1110 case BuiltinType::Char_U:
1119 case BuiltinType::Char_S:
1128 case BuiltinType::WChar_S:
1129 case BuiltinType::WChar_U:
1135 llvm_unreachable(
"Invalid BuiltinType Kind!");
1140 if (!ToOriginalTypeOrErr)
1141 return ToOriginalTypeOrErr.takeError();
1148 if (!ToElementTypeOrErr)
1149 return ToElementTypeOrErr.takeError();
1156 if (!ToPointeeTypeOrErr)
1157 return ToPointeeTypeOrErr.takeError();
1165 if (!ToPointeeTypeOrErr)
1166 return ToPointeeTypeOrErr.takeError();
1175 if (!ToPointeeTypeOrErr)
1176 return ToPointeeTypeOrErr.takeError();
1185 if (!ToPointeeTypeOrErr)
1186 return ToPointeeTypeOrErr.takeError();
1195 if (!ToPointeeTypeOrErr)
1196 return ToPointeeTypeOrErr.takeError();
1199 if (!ClassTypeOrErr)
1200 return ClassTypeOrErr.takeError();
1208 Error Err = Error::success();
1212 return std::move(Err);
1222 if (!ToElementTypeOrErr)
1223 return ToElementTypeOrErr.takeError();
1232 Error Err = Error::success();
1237 return std::move(Err);
1245 Error Err = Error::success();
1250 return std::move(Err);
1261 if (!ToElementTypeOrErr)
1262 return ToElementTypeOrErr.takeError();
1271 if (!ToElementTypeOrErr)
1272 return ToElementTypeOrErr.takeError();
1283 if (!ToReturnTypeOrErr)
1284 return ToReturnTypeOrErr.takeError();
1293 if (!ToReturnTypeOrErr)
1294 return ToReturnTypeOrErr.takeError();
1301 return TyOrErr.takeError();
1302 ArgTypes.push_back(*TyOrErr);
1310 return TyOrErr.takeError();
1311 ExceptionTypes.push_back(*TyOrErr);
1315 Error Err = Error::success();
1332 return std::move(Err);
1335 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1340 Error Err = Error::success();
1344 return std::move(Err);
1347 ToD, cast_or_null<TypeDecl>(ToPrevD));
1352 if (!ToInnerTypeOrErr)
1353 return ToInnerTypeOrErr.takeError();
1361 return ToDeclOrErr.takeError();
1363 if (!ToUnderlyingTypeOrErr)
1364 return ToUnderlyingTypeOrErr.takeError();
1367 *ToUnderlyingTypeOrErr);
1373 return ToExprOrErr.takeError();
1379 if (!ToUnderlyingTypeOrErr)
1380 return ToUnderlyingTypeOrErr.takeError();
1388 return FoundOrErr.takeError();
1390 if (!UnderlyingOrErr)
1391 return UnderlyingOrErr.takeError();
1400 return ToExprOrErr.takeError();
1403 if (!ToUnderlyingTypeOrErr)
1404 return ToUnderlyingTypeOrErr.takeError();
1407 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1413 if (!ToBaseTypeOrErr)
1414 return ToBaseTypeOrErr.takeError();
1417 if (!ToUnderlyingTypeOrErr)
1418 return ToUnderlyingTypeOrErr.takeError();
1421 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->
getUTTKind());
1427 if (!ToDeducedTypeOrErr)
1428 return ToDeducedTypeOrErr.takeError();
1431 if (!ToTypeConstraintConcept)
1432 return ToTypeConstraintConcept.takeError();
1437 return std::move(Err);
1441 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1449 if (!ToTemplateNameOrErr)
1450 return ToTemplateNameOrErr.takeError();
1452 if (!ToDeducedTypeOrErr)
1453 return ToDeducedTypeOrErr.takeError();
1463 return ToDeclOrErr.takeError();
1466 if (!ToInjTypeOrErr)
1467 return ToInjTypeOrErr.takeError();
1484 return ToDeclOrErr.takeError();
1492 return ToDeclOrErr.takeError();
1499 if (!ToModifiedTypeOrErr)
1500 return ToModifiedTypeOrErr.takeError();
1502 if (!ToEquivalentTypeOrErr)
1503 return ToEquivalentTypeOrErr.takeError();
1506 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1513 return ToDeclOrErr.takeError();
1523 return ReplacedOrErr.takeError();
1526 if (!ToReplacementTypeOrErr)
1527 return ToReplacementTypeOrErr.takeError();
1530 *ToReplacementTypeOrErr, *ReplacedOrErr, T->
getIndex(),
1538 return ReplacedOrErr.takeError();
1541 if (!ToArgumentPack)
1542 return ToArgumentPack.takeError();
1551 if (!ToTemplateOrErr)
1552 return ToTemplateOrErr.takeError();
1557 return std::move(Err);
1564 ToCanonType = *TyOrErr;
1566 return TyOrErr.takeError();
1576 if (!ToQualifierOrErr)
1577 return ToQualifierOrErr.takeError();
1580 if (!ToNamedTypeOrErr)
1581 return ToNamedTypeOrErr.takeError();
1584 if (!ToOwnedTagDeclOrErr)
1585 return ToOwnedTagDeclOrErr.takeError();
1590 *ToOwnedTagDeclOrErr);
1596 if (!ToPatternOrErr)
1597 return ToPatternOrErr.takeError();
1607 if (!ToQualifierOrErr)
1608 return ToQualifierOrErr.takeError();
1615 return std::move(Err);
1618 T->
getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1624 if (!ToQualifierOrErr)
1625 return ToQualifierOrErr.takeError();
1634 return TyOrErr.takeError();
1646 return ToDeclOrErr.takeError();
1653 if (!ToBaseTypeOrErr)
1654 return ToBaseTypeOrErr.takeError();
1659 TypeArgs.push_back(*TyOrErr);
1661 return TyOrErr.takeError();
1665 for (
auto *
P : T->
quals()) {
1667 Protocols.push_back(*ProtocolOrErr);
1669 return ProtocolOrErr.takeError();
1681 if (!ToPointeeTypeOrErr)
1682 return ToPointeeTypeOrErr.takeError();
1701 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1703 auto getLeafPointeeType = [](
const Type *T) {
1704 while (T->isPointerType() || T->isArrayType()) {
1705 T = T->getPointeeOrArrayElementType();
1711 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1712 auto *RT = dyn_cast<RecordType>(LeafT);
1713 if (RT && RT->getDecl() == D) {
1738 return Error::success();
1757 return Error::success();
1762 return Error::success();
1765 if (
Error Err = importInto(ToD, FromD))
1768 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1769 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1770 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1771 !ToRecord->getDefinition()) {
1776 return Error::success();
1779 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1780 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1781 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1786 return Error::success();
1789 return Error::success();
1804 return Error::success();
1810 return ToRangeOrErr.takeError();
1811 return Error::success();
1817 return LocOrErr.takeError();
1818 return Error::success();
1826 return ToTInfoOrErr.takeError();
1827 return Error::success();
1830 llvm_unreachable(
"Unknown name kind.");
1837 return ToDCOrErr.takeError();
1851 Error ChildErrors = Error::success();
1852 for (
auto *From : FromDC->
decls()) {
1859 if (ImportedOrErr) {
1860 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
1861 Decl *ImportedDecl = *ImportedOrErr;
1862 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
1863 if (FieldFrom && FieldTo) {
1874 if (!FromRecordDecl || !ToRecordDecl) {
1879 if (RecordFrom && RecordTo) {
1880 FromRecordDecl = RecordFrom->
getDecl();
1881 ToRecordDecl = RecordTo->getDecl();
1885 if (FromRecordDecl && ToRecordDecl) {
1896 ImportedOrErr.takeError());
1923 const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
1929 consumeError(std::move(ChildErrors));
1930 return ToDCOrErr.takeError();
1936 for (
auto *D : FromRD->decls()) {
1937 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) {
1938 assert(D &&
"DC contains a null decl");
1960 return ToDCOrErr.takeError();
1966 if (!ToLexicalDCOrErr)
1967 return ToLexicalDCOrErr.takeError();
1968 ToLexicalDC = *ToLexicalDCOrErr;
1972 return Error::success();
1978 "Import implicit methods to or from non-definition");
1981 if (FromM->isImplicit()) {
1984 return ToMOrErr.takeError();
1987 return Error::success();
1996 return ToTypedefOrErr.takeError();
1998 return Error::success();
2003 auto DefinitionCompleter = [To]() {
2022 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2024 ToCaptures.reserve(FromCXXRD->capture_size());
2025 for (
const auto &FromCapture : FromCXXRD->captures()) {
2026 if (
auto ToCaptureOrErr =
import(FromCapture))
2027 ToCaptures.push_back(*ToCaptureOrErr);
2029 return ToCaptureOrErr.takeError();
2031 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2038 DefinitionCompleter();
2042 return Error::success();
2057 auto DefinitionCompleterScopeExit =
2058 llvm::make_scope_exit(DefinitionCompleter);
2064 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2065 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2066 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2068 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2069 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2071 #define FIELD(Name, Width, Merge) \
2072 ToData.Name = FromData.Name;
2073 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2076 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2079 for (
const auto &Base1 : FromCXX->bases()) {
2082 return TyOrErr.takeError();
2085 if (Base1.isPackExpansion()) {
2086 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2087 EllipsisLoc = *LocOrErr;
2089 return LocOrErr.takeError();
2097 auto RangeOrErr =
import(Base1.getSourceRange());
2099 return RangeOrErr.takeError();
2101 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2103 return TSIOrErr.takeError();
2109 Base1.isBaseOfClass(),
2110 Base1.getAccessSpecifierAsWritten(),
2115 ToCXX->setBases(Bases.data(), Bases.size());
2123 return Error::success();
2128 return Error::success();
2132 return Error::success();
2136 return ToInitOrErr.takeError();
2147 return Error::success();
2155 return Error::success();
2166 return ToTypeOrErr.takeError();
2169 if (!ToPromotionTypeOrErr)
2170 return ToPromotionTypeOrErr.takeError();
2181 return Error::success();
2187 for (
const auto &Arg : FromArgs) {
2188 if (
auto ToOrErr =
import(Arg))
2189 ToArgs.push_back(*ToOrErr);
2191 return ToOrErr.takeError();
2194 return Error::success();
2200 return import(From);
2203 template <
typename InContainerTy>
2206 for (
const auto &FromLoc : Container) {
2207 if (
auto ToLocOrErr =
import(FromLoc))
2210 return ToLocOrErr.takeError();
2212 return Error::success();
2252 return std::move(Err);
2257 return LocOrErr.takeError();
2260 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, *LocOrErr))
2283 return std::move(Err);
2288 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, Loc,
2289 Name.getAsIdentifierInfo()))
2292 Error Err = Error::success();
2297 return std::move(Err);
2301 addDeclToContexts(D, ToD);
2309 return LocOrErr.takeError();
2312 return ColonLocOrErr.takeError();
2317 return DCOrErr.takeError();
2322 DC, *LocOrErr, *ColonLocOrErr))
2336 return DCOrErr.takeError();
2340 Error Err = Error::success();
2346 return std::move(Err);
2349 if (GetImportedOrCreateDecl(
2350 ToD, D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2366 return std::move(Err);
2375 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2381 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2382 for (
auto *FoundDecl : FoundDecls) {
2386 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2387 MergeWithNamespace = FoundNS;
2388 ConflictingDecls.clear();
2392 ConflictingDecls.push_back(FoundDecl);
2395 if (!ConflictingDecls.empty()) {
2398 ConflictingDecls.size());
2400 Name = NameOrErr.get();
2402 return NameOrErr.takeError();
2408 return BeginLocOrErr.takeError();
2410 if (!RBraceLocOrErr)
2411 return RBraceLocOrErr.takeError();
2416 if (GetImportedOrCreateDecl(ToNamespace, D, Importer.
getToContext(), DC,
2417 D->
isInline(), *BeginLocOrErr, Loc,
2418 Name.getAsIdentifierInfo(),
2428 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2429 TU->setAnonymousNamespace(ToNamespace);
2431 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2437 return std::move(Err);
2449 return std::move(Err);
2455 Error Err = Error::success();
2462 return std::move(Err);
2467 if (GetImportedOrCreateDecl(
2468 ToD, D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2469 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2487 return std::move(Err);
2506 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2507 for (
auto *FoundDecl : FoundDecls) {
2510 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2515 QualType FoundUT = FoundTypedef->getUnderlyingType();
2524 ConflictingDecls.push_back(FoundDecl);
2529 if (!ConflictingDecls.empty()) {
2531 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2533 Name = NameOrErr.get();
2535 return NameOrErr.takeError();
2539 Error Err = Error::success();
2544 return std::move(Err);
2551 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2552 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2553 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2555 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2556 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2557 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2562 return std::move(Err);
2566 Importer.AddToLookupTable(ToTypedef);
2571 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) :
nullptr;
2594 return std::move(Err);
2604 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2605 for (
auto *FoundDecl : FoundDecls) {
2608 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
2610 ConflictingDecls.push_back(FoundDecl);
2613 if (!ConflictingDecls.empty()) {
2615 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2617 Name = NameOrErr.get();
2619 return NameOrErr.takeError();
2623 Error Err = Error::success();
2627 return std::move(Err);
2630 if (GetImportedOrCreateDecl(ToAlias, D, Importer.
getToContext(), DC, Loc,
2631 Name, ToTemplateParameters, ToTemplatedDecl))
2634 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2640 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2651 return std::move(Err);
2661 return BeginLocOrErr.takeError();
2662 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2663 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2667 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2668 Name.getAsIdentifierInfo()))
2675 return ToStmtOrErr.takeError();
2677 ToLabel->
setStmt(*ToStmtOrErr);
2690 return std::move(Err);
2698 if (
Error Err = importInto(
2700 return std::move(Err);
2710 Importer.findDeclsInToCtx(DC, SearchName);
2711 for (
auto *FoundDecl : FoundDecls) {
2715 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2716 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2717 FoundDecl = Tag->getDecl();
2720 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2730 ConflictingDecls.push_back(FoundDecl);
2734 if (!ConflictingDecls.empty()) {
2736 SearchName, DC, IDNS, ConflictingDecls.data(),
2737 ConflictingDecls.size());
2739 Name = NameOrErr.get();
2741 return NameOrErr.takeError();
2745 Error Err = Error::success();
2751 return std::move(Err);
2755 if (GetImportedOrCreateDecl(
2757 Loc, Name.getAsIdentifierInfo(), PrevDecl, D->
isScoped(),
2766 addDeclToContexts(D, D2);
2772 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
2774 return ToInstOrErr.takeError();
2775 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
2778 return POIOrErr.takeError();
2784 return std::move(Err);
2790 bool IsFriendTemplate =
false;
2791 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2793 DCXX->getDescribedClassTemplate() &&
2794 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2804 return std::move(Err);
2812 if (
Error Err = importInto(
2814 return std::move(Err);
2824 Importer.findDeclsInToCtx(DC, SearchName);
2825 if (!FoundDecls.empty()) {
2832 for (
auto *FoundDecl : FoundDecls) {
2836 Decl *Found = FoundDecl;
2837 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2838 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2839 Found = Tag->getDecl();
2842 if (
auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2865 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2866 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2867 assert(FoundCXX &&
"Record type mismatch");
2873 return std::move(Err);
2879 ConflictingDecls.push_back(FoundDecl);
2883 if (!ConflictingDecls.empty() && SearchName) {
2885 SearchName, DC, IDNS, ConflictingDecls.data(),
2886 ConflictingDecls.size());
2888 Name = NameOrErr.get();
2890 return NameOrErr.takeError();
2896 return BeginLocOrErr.takeError();
2901 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2902 if (DCXX->isLambda()) {
2903 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
2905 return TInfoOrErr.takeError();
2906 if (GetImportedOrCreateSpecialDecl(
2908 DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
2909 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2911 ExpectedDecl CDeclOrErr =
import(DCXX->getLambdaContextDecl());
2913 return CDeclOrErr.takeError();
2915 DCXX->hasKnownLambdaInternalLinkage());
2917 DCXX->getDeviceLambdaManglingNumber());
2918 }
else if (DCXX->isInjectedClassName()) {
2921 const bool DelayTypeCreation =
true;
2922 if (GetImportedOrCreateDecl(
2924 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2925 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
2928 D2CXX, dyn_cast<CXXRecordDecl>(DC));
2930 if (GetImportedOrCreateDecl(D2CXX, D, Importer.
getToContext(),
2932 Name.getAsIdentifierInfo(),
2933 cast_or_null<CXXRecordDecl>(PrevDecl)))
2940 addDeclToContexts(D, D2);
2943 DCXX->getDescribedClassTemplate()) {
2945 if (
Error Err = importInto(ToDescribed, FromDescribed))
2946 return std::move(Err);
2948 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
2957 auto *Record = dyn_cast<CXXRecordDecl>(Found);
2958 if (Record && Record->isInjectedClassName()) {
2966 for (
auto *R : Redecls) {
2967 auto *RI = cast<CXXRecordDecl>(R);
2968 RI->setTypeForDecl(
nullptr);
2982 DCXX->getMemberSpecializationInfo()) {
2984 MemberInfo->getTemplateSpecializationKind();
2990 return ToInstOrErr.takeError();
2993 import(MemberInfo->getPointOfInstantiation()))
2997 return POIOrErr.takeError();
3001 if (GetImportedOrCreateDecl(D2, D, Importer.
getToContext(),
3003 Name.getAsIdentifierInfo(), PrevDecl))
3006 addDeclToContexts(D, D2);
3012 return BraceRangeOrErr.takeError();
3016 return QualifierLocOrErr.takeError();
3023 return std::move(Err);
3035 return std::move(Err);
3044 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3045 for (
auto *FoundDecl : FoundDecls) {
3049 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3051 return Importer.
MapImported(D, FoundEnumConstant);
3052 ConflictingDecls.push_back(FoundDecl);
3056 if (!ConflictingDecls.empty()) {
3058 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3060 Name = NameOrErr.get();
3062 return NameOrErr.takeError();
3068 return TypeOrErr.takeError();
3072 return InitOrErr.takeError();
3075 if (GetImportedOrCreateDecl(
3076 ToEnumerator, D, Importer.
getToContext(), cast<EnumDecl>(DC), Loc,
3077 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->
getInitVal()))
3078 return ToEnumerator;
3083 return ToEnumerator;
3090 return Error::success();
3092 for (
unsigned int I = 0; I < Num; ++I)
3095 ToTPLists[I] = *ToTPListOrErr;
3097 return ToTPListOrErr.takeError();
3099 return Error::success();
3107 return Error::success();
3113 return Error::success();
3119 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3121 return InstFDOrErr.takeError();
3127 return POIOrErr.takeError();
3129 return Error::success();
3133 auto FunctionAndArgsOrErr =
3135 if (!FunctionAndArgsOrErr)
3136 return FunctionAndArgsOrErr.takeError();
3139 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3143 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3144 if (FromTAArgsAsWritten)
3146 *FromTAArgsAsWritten, ToTAInfo))
3149 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3151 return POIOrErr.takeError();
3157 ToFD->setFunctionTemplateSpecialization(
3158 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3159 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3160 return Error::success();
3166 unsigned NumTemplates = FromInfo->getNumTemplates();
3167 for (
unsigned I = 0; I < NumTemplates; I++) {
3169 import(FromInfo->getTemplate(I)))
3170 TemplDecls.
addDecl(*ToFTDOrErr);
3172 return ToFTDOrErr.takeError();
3178 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
3180 FromInfo->getNumTemplateArgs()),
3185 TemplDecls, ToTAInfo);
3186 return Error::success();
3189 llvm_unreachable(
"All cases should be covered!");
3194 auto FunctionAndArgsOrErr =
3196 if (!FunctionAndArgsOrErr)
3197 return FunctionAndArgsOrErr.takeError();
3201 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3202 void *InsertPos =
nullptr;
3213 return ToBodyOrErr.takeError();
3215 return Error::success();
3221 const DeclContext *DCi = dyn_cast<DeclContext>(D);
3224 assert(DCi &&
"Declaration should have a context");
3238 ToProcess.push_back(S);
3239 while (!ToProcess.empty()) {
3240 const Stmt *CurrentS = ToProcess.pop_back_val();
3242 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS))
3243 if (
const Decl *D = DeclRef->getDecl())
3275 class IsTypeDeclaredInsideVisitor
3276 :
public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3278 IsTypeDeclaredInsideVisitor(
const FunctionDecl *ParentDC)
3279 : ParentDC(ParentDC) {}
3285 if (std::optional<bool> Res = Visit(T.
getTypePtr()))
3290 if (std::optional<bool> Res = Visit(DsT.
getTypePtr()))
3298 std::optional<bool> VisitTagType(
const TagType *T) {
3299 if (
auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(T->
getDecl()))
3300 for (
const auto &Arg : Spec->getTemplateArgs().asArray())
3301 if (checkTemplateArgument(Arg))
3306 std::optional<bool> VisitPointerType(
const PointerType *T) {
3310 std::optional<bool> VisitReferenceType(
const ReferenceType *T) {
3314 std::optional<bool> VisitTypedefType(
const TypedefType *T) {
3320 std::optional<bool> VisitUsingType(
const UsingType *T) {
3331 if (checkTemplateArgument(Arg))
3346 "Variable array should not occur in deduced return type of a function");
3350 llvm_unreachable(
"Incomplete array should not occur in deduced return type "
3355 llvm_unreachable(
"Dependent array should not occur in deduced return type "
3380 if (checkTemplateArgument(PackArg))
3392 llvm_unreachable(
"Unknown TemplateArgument::ArgKind enum");
3400 assert(FromFPT &&
"Must be called on FunctionProtoType");
3402 QualType RetT = FromFPT->getReturnType();
3405 IsTypeDeclaredInsideVisitor Visitor(Def ? Def : D);
3406 return Visitor.CheckType(RetT);
3423 auto RedeclIt = Redecls.begin();
3426 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3429 return ToRedeclOrErr.takeError();
3431 assert(*RedeclIt == D);
3439 return std::move(Err);
3454 if (!FoundFunctionOrErr)
3455 return FoundFunctionOrErr.takeError();
3456 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3457 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3459 FoundByLookup = FoundFunction;
3467 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3468 for (
auto *FoundDecl : FoundDecls) {
3472 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3477 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3479 FoundByLookup = FoundFunction;
3490 Importer.
ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3491 << Name << D->
getType() << FoundFunction->getType();
3492 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3493 << FoundFunction->getType();
3494 ConflictingDecls.push_back(FoundDecl);
3498 if (!ConflictingDecls.empty()) {
3500 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3502 Name = NameOrErr.get();
3504 return NameOrErr.takeError();
3514 if (FoundByLookup) {
3515 if (isa<CXXMethodDecl>(FoundByLookup)) {
3524 "Templated function mapped to non-templated?");
3540 return std::move(Err);
3551 bool UsedDifferentProtoType =
false;
3553 QualType FromReturnTy = FromFPT->getReturnType();
3561 UsedDifferentProtoType =
true;
3572 FromEPI = DefaultEPI;
3573 UsedDifferentProtoType =
true;
3576 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3581 Error Err = Error::success();
3588 auto TrailingRequiresClause =
3591 return std::move(Err);
3597 Parameters.push_back(*ToPOrErr);
3599 return ToPOrErr.takeError();
3604 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3606 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3608 return std::move(Err);
3610 if (FromConstructor->isInheritingConstructor()) {
3612 import(FromConstructor->getInheritedConstructor());
3613 if (!ImportedInheritedCtor)
3614 return ImportedInheritedCtor.takeError();
3615 ToInheritedConstructor = *ImportedInheritedCtor;
3617 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3618 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3619 ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->
UsesFPIntrin(),
3621 ToInheritedConstructor, TrailingRequiresClause))
3625 Error Err = Error::success();
3627 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3628 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3630 return std::move(Err);
3632 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3633 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3634 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3636 TrailingRequiresClause))
3643 dyn_cast<CXXConversionDecl>(D)) {
3645 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3647 return std::move(Err);
3648 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3649 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3650 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3654 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3655 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3656 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3657 ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3658 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3661 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3663 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3667 return std::move(Err);
3668 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3669 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart, ESpec,
3670 NameInfo, T, TInfo, ToEndLoc, Ctor))
3672 cast<CXXDeductionGuideDecl>(ToFunction)
3673 ->setIsCopyDeductionCandidate(Guide->isCopyDeductionCandidate());
3675 if (GetImportedOrCreateDecl(
3676 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart,
3684 if (FoundByLookup) {
3710 for (
auto *Param : Parameters) {
3711 Param->setOwningFunction(ToFunction);
3716 ToFunction->setParams(Parameters);
3723 for (
unsigned I = 0, N = Parameters.size(); I != N; ++I)
3724 ProtoLoc.setParam(I, Parameters[I]);
3730 auto ToFTOrErr =
import(FromFT);
3732 return ToFTOrErr.takeError();
3736 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3737 if (
unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3741 FromConstructor->inits(), CtorInitializers))
3742 return std::move(Err);
3745 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3746 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3747 ToCtor->setCtorInitializers(Memory);
3748 ToCtor->setNumCtorInitializers(NumInitializers);
3754 return std::move(Err);
3760 return std::move(Err);
3764 if (UsedDifferentProtoType) {
3766 ToFunction->
setType(*TyOrErr);
3768 return TyOrErr.takeError();
3772 return TSIOrErr.takeError();
3777 addDeclToContexts(D, ToFunction);
3779 if (
auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3782 return std::move(Err);
3785 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
3788 return ToRedeclOrErr.takeError();
3822 return std::move(Err);
3827 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3828 for (
auto *FoundDecl : FoundDecls) {
3829 if (
FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
3837 FoundField->getType())) {
3846 if (
ExpectedExpr ToInitializerOrErr =
import(FromInitializer)) {
3849 assert(FoundField->hasInClassInitializer() &&
3850 "Field should have an in-class initializer if it has an "
3851 "expression for it.");
3852 if (!FoundField->getInClassInitializer())
3853 FoundField->setInClassInitializer(*ToInitializerOrErr);
3855 return ToInitializerOrErr.takeError();
3862 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3863 << Name << D->
getType() << FoundField->getType();
3864 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3865 << FoundField->getType();
3871 Error Err = Error::success();
3878 return std::move(Err);
3879 const Type *ToCapturedVLAType =
nullptr;
3882 return std::move(Err);
3885 if (GetImportedOrCreateDecl(ToField, D, Importer.
getToContext(), DC,
3886 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3887 ToType, ToTInfo, ToBitWidth, D->
isMutable(),
3896 if (ToCapturedVLAType)
3909 return std::move(Err);
3914 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3915 for (
unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3916 if (
auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3924 FoundField->getType(),
3931 if (!Name && I < N-1)
3935 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3936 << Name << D->
getType() << FoundField->getType();
3937 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3938 << FoundField->getType();
3945 auto TypeOrErr =
import(D->
getType());
3947 return TypeOrErr.takeError();
3953 for (
auto *PI : D->
chain())
3955 NamedChain[i++] = *ToD;
3957 return ToD.takeError();
3961 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.
getToContext(), DC,
3962 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
3964 return ToIndirectField;
3969 return ToIndirectField;
3983 llvm::function_ref<T(
const FriendDecl *)> GetCanTypeOrDecl) {
3984 unsigned int FriendCount = 0;
3985 std::optional<unsigned int> FriendPosition;
3988 T TypeOrDecl = GetCanTypeOrDecl(FD);
3990 for (
const FriendDecl *FoundFriend : RD->friends()) {
3991 if (FoundFriend == FD) {
3992 FriendPosition = FriendCount;
3994 }
else if (!FoundFriend->getFriendDecl() == !FD->
getFriendDecl() &&
3995 GetCanTypeOrDecl(FoundFriend) == TypeOrDecl) {
4000 assert(FriendPosition &&
"Friend decl not found in own parent.");
4002 return {FriendCount, *FriendPosition};
4007 return getFriendCountAndPosition<QualType>(FD, [](
const FriendDecl *F) {
4009 return TSI->getType().getCanonicalType();
4010 llvm_unreachable(
"Wrong friend object type.");
4013 return getFriendCountAndPosition<Decl *>(FD, [](
const FriendDecl *F) {
4016 llvm_unreachable(
"Wrong friend object type.");
4024 return std::move(Err);
4029 const auto *RD = cast<CXXRecordDecl>(DC);
4030 FriendDecl *ImportedFriend = RD->getFirstFriend();
4033 while (ImportedFriend) {
4045 ImportedEquivalentFriends.push_back(ImportedFriend);
4047 ImportedFriend = ImportedFriend->getNextFriend();
4051 assert(ImportedEquivalentFriends.size() <= CountAndPosition.
TotalCount &&
4052 "Class with non-matching friends is imported, ODR check wrong?");
4053 if (ImportedEquivalentFriends.size() == CountAndPosition.
TotalCount)
4055 D, ImportedEquivalentFriends[CountAndPosition.
IndexOfDecl]);
4062 if (
Error Err = importInto(ToFriendD, FriendD))
4063 return std::move(Err);
4074 return TSIOrErr.takeError();
4079 for (
unsigned I = 0; I < D->NumTPLists; I++) {
4080 if (
auto ListOrErr =
import(FromTPLists[I]))
4081 ToTPLists[I] = *ListOrErr;
4083 return ListOrErr.takeError();
4088 return LocationOrErr.takeError();
4090 if (!FriendLocOrErr)
4091 return FriendLocOrErr.takeError();
4094 if (GetImportedOrCreateDecl(FrD, D, Importer.
getToContext(), DC,
4095 *LocationOrErr, ToFU,
4096 *FriendLocOrErr, ToTPLists))
4112 return std::move(Err);
4117 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4118 for (
auto *FoundDecl : FoundDecls) {
4119 if (
ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
4121 FoundIvar->getType())) {
4126 Importer.
ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
4127 << Name << D->
getType() << FoundIvar->getType();
4128 Importer.
ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
4129 << FoundIvar->getType();
4135 Error Err = Error::success();
4141 return std::move(Err);
4144 if (GetImportedOrCreateDecl(
4145 ToIvar, D, Importer.
getToContext(), cast<ObjCContainerDecl>(DC),
4146 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
4147 ToType, ToTypeSourceInfo,
4159 auto RedeclIt = Redecls.begin();
4162 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4165 return RedeclOrErr.takeError();
4167 assert(*RedeclIt == D);
4175 return std::move(Err);
4181 VarDecl *FoundByLookup =
nullptr;
4185 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4186 for (
auto *FoundDecl : FoundDecls) {
4190 if (
auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4194 FoundVar->getType())) {
4206 const VarDecl *FoundDInit =
nullptr;
4207 if (D->
getInit() && FoundVar->getAnyInitializer(FoundDInit))
4211 FoundByLookup = FoundVar;
4219 if (FoundArray && TArray) {
4220 if (isa<IncompleteArrayType>(FoundArray) &&
4221 isa<ConstantArrayType>(TArray)) {
4223 if (
auto TyOrErr =
import(D->
getType()))
4224 FoundVar->setType(*TyOrErr);
4226 return TyOrErr.takeError();
4228 FoundByLookup = FoundVar;
4230 }
else if (isa<IncompleteArrayType>(TArray) &&
4231 isa<ConstantArrayType>(FoundArray)) {
4232 FoundByLookup = FoundVar;
4237 Importer.
ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
4238 << Name << D->
getType() << FoundVar->getType();
4239 Importer.
ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4240 << FoundVar->getType();
4241 ConflictingDecls.push_back(FoundDecl);
4245 if (!ConflictingDecls.empty()) {
4247 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4249 Name = NameOrErr.get();
4251 return NameOrErr.takeError();
4255 Error Err = Error::success();
4261 return std::move(Err);
4264 if (
auto *FromDecomp = dyn_cast<DecompositionDecl>(D)) {
4268 return std::move(Err);
4270 if (GetImportedOrCreateDecl(
4271 ToDecomp, FromDecomp, Importer.
getToContext(), DC, ToInnerLocStart,
4277 if (GetImportedOrCreateDecl(ToVar, D, Importer.
getToContext(), DC,
4278 ToInnerLocStart, Loc,
4279 Name.getAsIdentifierInfo(), ToType,
4289 if (FoundByLookup) {
4298 return ToVTOrErr.takeError();
4302 return std::move(Err);
4307 addDeclToContexts(D, ToVar);
4310 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4313 return RedeclOrErr.takeError();
4324 Error Err = Error::success();
4329 return std::move(Err);
4333 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4334 ToLocation, ToDeclName.getAsIdentifierInfo(),
4349 return ToDefArgOrErr.takeError();
4353 if (
auto ToDefArgOrErr =
import(FromParam->
getDefaultArg()))
4356 return ToDefArgOrErr.takeError();
4359 return Error::success();
4364 Error Err = Error::success();
4369 return std::move(Err);
4378 Error Err = Error::success();
4385 return std::move(Err);
4388 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4389 ToInnerLocStart, ToLocation,
4390 ToDeclName.getAsIdentifierInfo(), ToType,
4399 return std::move(Err);
4419 return std::move(Err);
4423 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4424 for (
auto *FoundDecl : FoundDecls) {
4425 if (
auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4431 FoundMethod->getReturnType())) {
4432 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4434 << FoundMethod->getReturnType();
4435 Importer.
ToDiag(FoundMethod->getLocation(),
4436 diag::note_odr_objc_method_here)
4443 if (D->
param_size() != FoundMethod->param_size()) {
4444 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4446 << D->
param_size() << FoundMethod->param_size();
4447 Importer.
ToDiag(FoundMethod->getLocation(),
4448 diag::note_odr_objc_method_here)
4456 PEnd = D->
param_end(), FoundP = FoundMethod->param_begin();
4457 P != PEnd; ++
P, ++FoundP) {
4459 (*FoundP)->getType())) {
4460 Importer.
FromDiag((*P)->getLocation(),
4461 diag::warn_odr_objc_method_param_type_inconsistent)
4463 << (*P)->getType() << (*FoundP)->getType();
4464 Importer.
ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4465 << (*FoundP)->getType();
4473 if (D->
isVariadic() != FoundMethod->isVariadic()) {
4474 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4476 Importer.
ToDiag(FoundMethod->getLocation(),
4477 diag::note_odr_objc_method_here)
4488 Error Err = Error::success();
4491 auto ToReturnTypeSourceInfo =
4494 return std::move(Err);
4497 if (GetImportedOrCreateDecl(
4499 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4512 ToParams.push_back(*ToPOrErr);
4514 return ToPOrErr.takeError();
4518 for (
auto *ToParam : ToParams) {
4519 ToParam->setOwningFunction(ToMethod);
4527 return std::move(Err);
4551 return std::move(Err);
4555 Error Err = Error::success();
4561 return std::move(Err);
4564 if (GetImportedOrCreateDecl(
4567 ToLocation, Name.getAsIdentifierInfo(),
4568 ToColonLoc, ToTypeSourceInfo))
4582 return std::move(Err);
4588 return std::move(Err);
4596 Error Err = Error::success();
4602 return std::move(Err);
4604 if (GetImportedOrCreateDecl(ToCategory, D, Importer.
getToContext(), DC,
4607 Name.getAsIdentifierInfo(), ToInterface,
4620 return PListOrErr.takeError();
4629 FromProto != FromProtoEnd;
4630 ++FromProto, ++FromProtoLoc) {
4632 Protocols.push_back(*ToProtoOrErr);
4634 return ToProtoOrErr.takeError();
4636 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4637 ProtocolLocs.push_back(*ToProtoLocOrErr);
4639 return ToProtoLocOrErr.takeError();
4652 return std::move(Err);
4660 return ToImplOrErr.takeError();
4672 return Error::success();
4685 FromProto != FromProtoEnd;
4686 ++FromProto, ++FromProtoLoc) {
4688 Protocols.push_back(*ToProtoOrErr);
4690 return ToProtoOrErr.takeError();
4692 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4693 ProtocolLocs.push_back(*ToProtoLocOrErr);
4695 return ToProtoLocOrErr.takeError();
4708 return Error::success();
4716 if (Definition && Definition != D) {
4717 if (
ExpectedDecl ImportedDefOrErr =
import(Definition))
4718 return Importer.
MapImported(D, *ImportedDefOrErr);
4720 return ImportedDefOrErr.takeError();
4729 return std::move(Err);
4734 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4735 for (
auto *FoundDecl : FoundDecls) {
4739 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4746 if (!ToAtBeginLocOrErr)
4747 return ToAtBeginLocOrErr.takeError();
4749 if (GetImportedOrCreateDecl(ToProto, D, Importer.
getToContext(), DC,
4750 Name.getAsIdentifierInfo(), Loc,
4762 return std::move(Err);
4770 return std::move(Err);
4773 if (!ExternLocOrErr)
4774 return ExternLocOrErr.takeError();
4778 return LangLocOrErr.takeError();
4783 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.
getToContext(), DC,
4784 *ExternLocOrErr, *LangLocOrErr,
4786 return ToLinkageSpec;
4790 if (!RBraceLocOrErr)
4791 return RBraceLocOrErr.takeError();
4798 return ToLinkageSpec;
4809 return ToShadowOrErr.takeError();
4820 return std::move(Err);
4824 Error Err = Error::success();
4829 return std::move(Err);
4833 return std::move(Err);
4836 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
4837 ToUsingLoc, ToQualifierLoc, NameInfo,
4848 ToUsing, *ToPatternOrErr);
4850 return ToPatternOrErr.takeError();
4862 return std::move(Err);
4866 Error Err = Error::success();
4872 return std::move(Err);
4875 if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.
getToContext(), DC,
4876 ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType))
4888 return ToPatternOrErr.takeError();
4900 return std::move(Err);
4905 if (!ToIntroducerOrErr)
4906 return ToIntroducerOrErr.takeError();
4910 return ToTargetOrErr.takeError();
4913 if (
auto *FromConstructorUsingShadow =
4914 dyn_cast<ConstructorUsingShadowDecl>(D)) {
4915 Error Err = Error::success();
4917 Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
4919 return std::move(Err);
4925 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
4927 cast<UsingDecl>(*ToIntroducerOrErr),
4928 Nominated ? Nominated : *ToTargetOrErr,
4929 FromConstructorUsingShadow->constructsVirtualBase()))
4932 if (GetImportedOrCreateDecl(ToShadow, D, Importer.
getToContext(), DC, Loc,
4933 Name, *ToIntroducerOrErr, *ToTargetOrErr))
4944 ToShadow, *ToPatternOrErr);
4948 return ToPatternOrErr.takeError();
4962 return std::move(Err);
4967 if (!ToComAncestorOrErr)
4968 return ToComAncestorOrErr.takeError();
4970 Error Err = Error::success();
4973 auto ToNamespaceKeyLocation =
4978 return std::move(Err);
4981 if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.
getToContext(), DC,
4983 ToNamespaceKeyLocation,
4986 ToNominatedNamespace, *ToComAncestorOrErr))
5001 return std::move(Err);
5005 auto ToInstantiatedFromUsingOrErr =
5007 if (!ToInstantiatedFromUsingOrErr)
5008 return ToInstantiatedFromUsingOrErr.takeError();
5011 return std::move(Err);
5014 if (GetImportedOrCreateDecl(ToUsingPack, D, Importer.
getToContext(), DC,
5015 cast<NamedDecl>(*ToInstantiatedFromUsingOrErr),
5019 addDeclToContexts(D, ToUsingPack);
5031 return std::move(Err);
5035 Error Err = Error::success();
5041 return std::move(Err);
5045 return std::move(Err);
5048 if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.
getToContext(), DC,
5049 ToUsingLoc, ToQualifierLoc, NameInfo,
5051 return ToUsingValue;
5057 return ToUsingValue;
5067 return std::move(Err);
5071 Error Err = Error::success();
5077 return std::move(Err);
5080 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
5081 ToUsingLoc, ToTypenameLoc,
5082 ToQualifierLoc, Loc, Name, ToEllipsisLoc))
5093 Decl* ToD =
nullptr;
5102 assert(ToD &&
"BuiltinTemplateDecl of unsupported kind!");
5113 if (
auto FromSuperOrErr =
import(FromSuper))
5114 FromSuper = *FromSuperOrErr;
5116 return FromSuperOrErr.takeError();
5120 if ((
bool)FromSuper != (
bool)ToSuper ||
5123 diag::warn_odr_objc_superclass_inconsistent)
5130 diag::note_odr_objc_missing_superclass);
5133 diag::note_odr_objc_superclass)
5137 diag::note_odr_objc_missing_superclass);
5143 return Error::success();
5154 return SuperTInfoOrErr.takeError();
5165 FromProto != FromProtoEnd;
5166 ++FromProto, ++FromProtoLoc) {
5168 Protocols.push_back(*ToProtoOrErr);
5170 return ToProtoOrErr.takeError();
5172 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5173 ProtocolLocs.push_back(*ToProtoLocOrErr);
5175 return ToProtoLocOrErr.takeError();
5186 auto ToCatOrErr =
import(Cat);
5188 return ToCatOrErr.takeError();
5197 return ToImplOrErr.takeError();
5204 return Error::success();
5213 for (
auto *fromTypeParam : *list) {
5214 if (
auto toTypeParamOrErr =
import(fromTypeParam))
5215 toTypeParams.push_back(*toTypeParamOrErr);
5217 return toTypeParamOrErr.takeError();
5220 auto LAngleLocOrErr =
import(list->getLAngleLoc());
5221 if (!LAngleLocOrErr)
5222 return LAngleLocOrErr.takeError();
5224 auto RAngleLocOrErr =
import(list->getRAngleLoc());
5225 if (!RAngleLocOrErr)
5226 return RAngleLocOrErr.takeError();
5239 if (Definition && Definition != D) {
5240 if (
ExpectedDecl ImportedDefOrErr =
import(Definition))
5241 return Importer.
MapImported(D, *ImportedDefOrErr);
5243 return ImportedDefOrErr.takeError();
5252 return std::move(Err);
5258 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5259 for (
auto *FoundDecl : FoundDecls) {
5263 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
5271 if (!AtBeginLocOrErr)
5272 return AtBeginLocOrErr.takeError();
5274 if (GetImportedOrCreateDecl(
5276 *AtBeginLocOrErr, Name.getAsIdentifierInfo(),