56 #include "llvm/ADT/APSInt.h"
57 #include "llvm/ADT/ArrayRef.h"
58 #include "llvm/ADT/DenseMap.h"
59 #include "llvm/ADT/None.h"
60 #include "llvm/ADT/Optional.h"
61 #include "llvm/ADT/ScopeExit.h"
62 #include "llvm/ADT/STLExtras.h"
63 #include "llvm/ADT/SmallVector.h"
64 #include "llvm/Support/Casting.h"
65 #include "llvm/Support/ErrorHandling.h"
66 #include "llvm/Support/MemoryBuffer.h"
71 #include <type_traits>
76 using llvm::make_error;
91 return "NameConflict";
93 return "UnsupportedConstruct";
95 return "Unknown error";
97 llvm_unreachable(
"Invalid error code.");
98 return "Invalid error code.";
104 llvm_unreachable(
"Function not implemented.");
115 Redecls.push_back(R);
118 std::reverse(Redecls.begin(), Redecls.end());
123 if (
auto *FD = dyn_cast<FunctionDecl>(D))
124 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
125 if (
auto *VD = dyn_cast<VarDecl>(D))
126 return getCanonicalForwardRedeclChain<VarDecl>(VD);
127 if (
auto *TD = dyn_cast<TagDecl>(D))
128 return getCanonicalForwardRedeclChain<TagDecl>(TD);
129 llvm_unreachable(
"Bad declaration kind");
150 bool const IgnoreChildErrors;
154 : FromDC(FromDC), IgnoreChildErrors(!
isa<
TagDecl>(FromDC)) {}
164 if (ChildErr && !IgnoreChildErrors)
165 ResultErr = joinErrors(std::move(ResultErr), std::move(ChildErr));
167 consumeError(std::move(ChildErr));
173 if (!IgnoreChildErrors || !FromDC)
181 public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
185 template <
typename ImportT>
186 LLVM_NODISCARD
Error importInto(ImportT &To,
const ImportT &From) {
191 template <
typename ImportT>
192 LLVM_NODISCARD
Error importInto(ImportT *&To, ImportT *From) {
193 auto ToOrErr = Importer.
Import(From);
195 To = cast_or_null<ImportT>(*ToOrErr);
196 return ToOrErr.takeError();
201 template <
typename T>
203 -> std::conditional_t<std::is_base_of<Type, T>::value,
205 auto ToOrErr = Importer.
Import(From);
207 return ToOrErr.takeError();
208 return cast_or_null<T>(*ToOrErr);
211 template <
typename T>
212 auto import(
const T *From) {
213 return import(
const_cast<T *
>(From));
217 template <
typename T>
219 return Importer.
Import(From);
227 return import(*From);
234 template <
typename ToDeclT>
struct CallOverloadedCreateFun {
235 template <
typename... Args> decltype(
auto) operator()(Args &&... args) {
236 return ToDeclT::Create(std::forward<Args>(args)...);
246 template <
typename ToDeclT,
typename FromDeclT,
typename... Args>
247 LLVM_NODISCARD
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
252 CallOverloadedCreateFun<ToDeclT> OC;
253 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
254 std::forward<Args>(args)...);
261 template <
typename NewDeclT,
typename ToDeclT,
typename FromDeclT,
263 LLVM_NODISCARD
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
265 CallOverloadedCreateFun<NewDeclT> OC;
266 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
267 std::forward<Args>(args)...);
271 template <
typename ToDeclT,
typename CreateFunT,
typename FromDeclT,
274 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
275 FromDeclT *FromD, Args &&... args) {
283 ToD = CreateFun(std::forward<Args>(args)...);
286 Importer.SharedState->markAsNewDecl(ToD);
287 InitializeImportedDecl(FromD, ToD);
291 void InitializeImportedDecl(
Decl *FromD,
Decl *ToD) {
304 FoundFunction->
hasBody(Definition))
309 void addDeclToContexts(
Decl *FromD,
Decl *ToD) {
325 bool Visible =
false;
338 if (
auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
339 auto *ToNamed = cast<NamedDecl>(ToD);
341 FromDC->
lookup(FromNamed->getDeclName());
342 if (llvm::is_contained(FromLookup, FromNamed))
359 updateLookupTableForTemplateParameters(
479 template <
typename InContainerTy>
483 template<
typename InContainerTy>
490 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
507 template <
typename T>
700 Err = MaybeVal.takeError();
706 template<
typename IIter,
typename OIter>
708 using ItemT = std::remove_reference_t<decltype(*Obegin)>;
709 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
712 return ToOrErr.takeError();
715 return Error::success();
722 template<
typename InContainerTy,
typename OutContainerTy>
724 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
726 InContainer.begin(), InContainer.end(), OutContainer.begin());
729 template<
typename InContainerTy,
typename OIter>
746 template <
typename InContainerTy>
750 auto ToLAngleLocOrErr =
import(FromLAngleLoc);
751 if (!ToLAngleLocOrErr)
752 return ToLAngleLocOrErr.takeError();
753 auto ToRAngleLocOrErr =
import(FromRAngleLoc);
754 if (!ToRAngleLocOrErr)
755 return ToRAngleLocOrErr.takeError();
761 return Error::success();
765 Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
776 return ImportTemplateArgumentListInfo(
777 From.LAngleLoc, From.RAngleLoc, From.arguments(), Result);
789 if (
Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
790 return std::move(Err);
793 auto TemplArgs = FTSInfo->TemplateArguments->asArray();
795 std::get<1>(Result)))
796 return std::move(Err);
806 return std::move(Err);
809 if (!ToRequiresClause)
810 return ToRequiresClause.takeError();
813 if (!ToTemplateLocOrErr)
814 return ToTemplateLocOrErr.takeError();
816 if (!ToLAngleLocOrErr)
817 return ToLAngleLocOrErr.takeError();
819 if (!ToRAngleLocOrErr)
820 return ToRAngleLocOrErr.takeError();
841 return ToTypeOrErr.takeError();
848 return ToTypeOrErr.takeError();
855 return ToOrErr.takeError();
858 return ToTypeOrErr.takeError();
865 return ToTypeOrErr.takeError();
871 if (!ToTemplateOrErr)
872 return ToTemplateOrErr.takeError();
880 if (!ToTemplateOrErr)
881 return ToTemplateOrErr.takeError();
891 return ToExpr.takeError();
898 return std::move(Err);
901 llvm::makeArrayRef(ToPack).copy(Importer.
getToContext()));
905 llvm_unreachable(
"Invalid template argument kind");
913 return ArgOrErr.takeError();
922 return E.takeError();
928 return TSIOrErr.takeError();
930 auto ToTemplateQualifierLocOrErr =
932 if (!ToTemplateQualifierLocOrErr)
933 return ToTemplateQualifierLocOrErr.takeError();
935 if (!ToTemplateNameLocOrErr)
936 return ToTemplateNameLocOrErr.takeError();
937 auto ToTemplateEllipsisLocOrErr =
939 if (!ToTemplateEllipsisLocOrErr)
940 return ToTemplateEllipsisLocOrErr.takeError();
943 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
953 size_t NumDecls = DG.
end() - DG.
begin();
955 ToDecls.reserve(NumDecls);
956 for (
Decl *FromD : DG) {
957 if (
auto ToDOrErr =
import(FromD))
958 ToDecls.push_back(*ToDOrErr);
960 return ToDOrErr.takeError();
975 return ToDotLocOrErr.takeError();
978 if (!ToFieldLocOrErr)
979 return ToFieldLocOrErr.takeError();
981 return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
985 if (!ToLBracketLocOrErr)
986 return ToLBracketLocOrErr.takeError();
989 if (!ToRBracketLocOrErr)
990 return ToRBracketLocOrErr.takeError();
994 *ToLBracketLocOrErr, *ToRBracketLocOrErr);
997 if (!ToEllipsisLocOrErr)
998 return ToEllipsisLocOrErr.takeError();
1003 *ToRBracketLocOrErr);
1013 return VarOrErr.takeError();
1018 return LocationOrErr.takeError();
1023 return std::move(Err);
1030 template <
typename T>
1032 if (Found->getLinkageInternal() != From->getLinkageInternal())
1035 if (From->hasExternalFormalLinkage())
1036 return Found->hasExternalFormalLinkage();
1039 if (From->isInAnonymousNamespace())
1040 return Found->isInAnonymousNamespace();
1042 return !Found->isInAnonymousNamespace() &&
1043 !Found->hasExternalFormalLinkage();
1063 using namespace clang;
1073 if (!UnderlyingTypeOrErr)
1074 return UnderlyingTypeOrErr.takeError();
1081 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1082 case BuiltinType::Id: \
1083 return Importer.getToContext().SingletonId;
1084 #include "clang/Basic/OpenCLImageTypes.def"
1085 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1086 case BuiltinType::Id: \
1087 return Importer.getToContext().Id##Ty;
1088 #include "clang/Basic/OpenCLExtensionTypes.def"
1089 #define SVE_TYPE(Name, Id, SingletonId) \
1090 case BuiltinType::Id: \
1091 return Importer.getToContext().SingletonId;
1092 #include "clang/Basic/AArch64SVEACLETypes.def"
1093 #define PPC_VECTOR_TYPE(Name, Id, Size) \
1094 case BuiltinType::Id: \
1095 return Importer.getToContext().Id##Ty;
1096 #include "clang/Basic/PPCTypes.def"
1097 #define RVV_TYPE(Name, Id, SingletonId) \
1098 case BuiltinType::Id: \
1099 return Importer.getToContext().SingletonId;
1100 #include "clang/Basic/RISCVVTypes.def"
1101 #define SHARED_SINGLETON_TYPE(Expansion)
1102 #define BUILTIN_TYPE(Id, SingletonId) \
1103 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1104 #include "clang/AST/BuiltinTypes.def"
1112 case BuiltinType::Char_U:
1121 case BuiltinType::Char_S:
1130 case BuiltinType::WChar_S:
1131 case BuiltinType::WChar_U:
1137 llvm_unreachable(
"Invalid BuiltinType Kind!");
1142 if (!ToOriginalTypeOrErr)
1143 return ToOriginalTypeOrErr.takeError();
1150 if (!ToElementTypeOrErr)
1151 return ToElementTypeOrErr.takeError();
1158 if (!ToPointeeTypeOrErr)
1159 return ToPointeeTypeOrErr.takeError();
1167 if (!ToPointeeTypeOrErr)
1168 return ToPointeeTypeOrErr.takeError();
1177 if (!ToPointeeTypeOrErr)
1178 return ToPointeeTypeOrErr.takeError();
1187 if (!ToPointeeTypeOrErr)
1188 return ToPointeeTypeOrErr.takeError();
1197 if (!ToPointeeTypeOrErr)
1198 return ToPointeeTypeOrErr.takeError();
1201 if (!ClassTypeOrErr)
1202 return ClassTypeOrErr.takeError();
1210 Error Err = Error::success();
1214 return std::move(Err);
1224 if (!ToElementTypeOrErr)
1225 return ToElementTypeOrErr.takeError();
1234 Error Err = Error::success();
1239 return std::move(Err);
1247 Error Err = Error::success();
1252 return std::move(Err);
1263 if (!ToElementTypeOrErr)
1264 return ToElementTypeOrErr.takeError();
1273 if (!ToElementTypeOrErr)
1274 return ToElementTypeOrErr.takeError();
1285 if (!ToReturnTypeOrErr)
1286 return ToReturnTypeOrErr.takeError();
1295 if (!ToReturnTypeOrErr)
1296 return ToReturnTypeOrErr.takeError();
1303 return TyOrErr.takeError();
1304 ArgTypes.push_back(*TyOrErr);
1312 return TyOrErr.takeError();
1313 ExceptionTypes.push_back(*TyOrErr);
1317 Error Err = Error::success();
1334 return std::move(Err);
1337 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1342 Error Err = Error::success();
1346 return std::move(Err);
1349 ToD, cast_or_null<TypeDecl>(ToPrevD));
1354 if (!ToInnerTypeOrErr)
1355 return ToInnerTypeOrErr.takeError();
1363 return ToDeclOrErr.takeError();
1371 return ToExprOrErr.takeError();
1378 if (!ToUnderlyingTypeOrErr)
1379 return ToUnderlyingTypeOrErr.takeError();
1387 return FoundOrErr.takeError();
1389 if (!UnderlyingOrErr)
1390 return UnderlyingOrErr.takeError();
1399 return ToExprOrErr.takeError();
1402 if (!ToUnderlyingTypeOrErr)
1403 return ToUnderlyingTypeOrErr.takeError();
1406 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1412 if (!ToBaseTypeOrErr)
1413 return ToBaseTypeOrErr.takeError();
1416 if (!ToUnderlyingTypeOrErr)
1417 return ToUnderlyingTypeOrErr.takeError();
1420 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->
getUTTKind());
1426 if (!ToDeducedTypeOrErr)
1427 return ToDeducedTypeOrErr.takeError();
1430 if (!ToTypeConstraintConcept)
1431 return ToTypeConstraintConcept.takeError();
1436 FromTemplateArgs.size(),
1438 return std::move(Err);
1442 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1450 if (!ToTemplateNameOrErr)
1451 return ToTemplateNameOrErr.takeError();
1453 if (!ToDeducedTypeOrErr)
1454 return ToDeducedTypeOrErr.takeError();
1464 return ToDeclOrErr.takeError();
1467 if (!ToInjTypeOrErr)
1468 return ToInjTypeOrErr.takeError();
1485 return ToDeclOrErr.takeError();
1493 return ToDeclOrErr.takeError();
1500 if (!ToModifiedTypeOrErr)
1501 return ToModifiedTypeOrErr.takeError();
1503 if (!ToEquivalentTypeOrErr)
1504 return ToEquivalentTypeOrErr.takeError();
1507 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1514 return ToDeclOrErr.takeError();
1525 return ReplacedOrErr.takeError();
1528 if (!ToReplacementTypeOrErr)
1529 return ToReplacementTypeOrErr.takeError();
1532 *ReplacedOrErr, ToReplacementTypeOrErr->getCanonicalType());
1540 return ReplacedOrErr.takeError();
1543 if (!ToArgumentPack)
1544 return ToArgumentPack.takeError();
1547 *ReplacedOrErr, *ToArgumentPack);
1553 if (!ToTemplateOrErr)
1554 return ToTemplateOrErr.takeError();
1559 return std::move(Err);
1566 ToCanonType = *TyOrErr;
1568 return TyOrErr.takeError();
1578 if (!ToQualifierOrErr)
1579 return ToQualifierOrErr.takeError();
1582 if (!ToNamedTypeOrErr)
1583 return ToNamedTypeOrErr.takeError();
1586 if (!ToOwnedTagDeclOrErr)
1587 return ToOwnedTagDeclOrErr.takeError();
1592 *ToOwnedTagDeclOrErr);
1598 if (!ToPatternOrErr)
1599 return ToPatternOrErr.takeError();
1609 if (!ToQualifierOrErr)
1610 return ToQualifierOrErr.takeError();
1618 return std::move(Err);
1621 T->
getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1627 if (!ToQualifierOrErr)
1628 return ToQualifierOrErr.takeError();
1637 return TyOrErr.takeError();
1649 return ToDeclOrErr.takeError();
1656 if (!ToBaseTypeOrErr)
1657 return ToBaseTypeOrErr.takeError();
1662 TypeArgs.push_back(*TyOrErr);
1664 return TyOrErr.takeError();
1668 for (
auto *
P : T->
quals()) {
1670 Protocols.push_back(*ProtocolOrErr);
1672 return ProtocolOrErr.takeError();
1684 if (!ToPointeeTypeOrErr)
1685 return ToPointeeTypeOrErr.takeError();
1704 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1706 auto getLeafPointeeType = [](
const Type *T) {
1707 while (T->isPointerType() || T->isArrayType()) {
1708 T = T->getPointeeOrArrayElementType();
1714 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1715 auto *RT = dyn_cast<RecordType>(LeafT);
1716 if (RT && RT->getDecl() == D) {
1741 return Error::success();
1760 return Error::success();
1765 return Error::success();
1768 if (
Error Err = importInto(ToD, FromD))
1771 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1772 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1773 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1774 !ToRecord->getDefinition()) {
1779 return Error::success();
1782 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1783 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1784 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1789 return Error::success();
1792 return Error::success();
1807 return Error::success();
1813 return ToRangeOrErr.takeError();
1814 return Error::success();
1820 return LocOrErr.takeError();
1821 return Error::success();
1829 return ToTInfoOrErr.takeError();
1830 return Error::success();
1833 llvm_unreachable(
"Unknown name kind.");
1840 return ToDCOrErr.takeError();
1854 Error ChildErrors = Error::success();
1855 for (
auto *From : FromDC->
decls()) {
1862 if (ImportedOrErr) {
1863 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
1864 Decl *ImportedDecl = *ImportedOrErr;
1865 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
1866 if (FieldFrom && FieldTo) {
1877 if (!FromRecordDecl || !ToRecordDecl) {
1882 if (RecordFrom && RecordTo) {
1883 FromRecordDecl = RecordFrom->
getDecl();
1884 ToRecordDecl = RecordTo->getDecl();
1888 if (FromRecordDecl && ToRecordDecl) {
1899 ImportedOrErr.takeError());
1926 const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
1932 consumeError(std::move(ChildErrors));
1933 return ToDCOrErr.takeError();
1939 for (
auto *D : FromRD->decls()) {
1940 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) {
1941 assert(D &&
"DC contains a null decl");
1963 return ToDCOrErr.takeError();
1969 if (!ToLexicalDCOrErr)
1970 return ToLexicalDCOrErr.takeError();
1971 ToLexicalDC = *ToLexicalDCOrErr;
1975 return Error::success();
1981 "Import implicit methods to or from non-definition");
1984 if (FromM->isImplicit()) {
1987 return ToMOrErr.takeError();
1990 return Error::success();
1999 return ToTypedefOrErr.takeError();
2001 return Error::success();
2006 auto DefinitionCompleter = [To]() {
2025 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2027 ToCaptures.reserve(FromCXXRD->capture_size());
2028 for (
const auto &FromCapture : FromCXXRD->captures()) {
2029 if (
auto ToCaptureOrErr =
import(FromCapture))
2030 ToCaptures.push_back(*ToCaptureOrErr);
2032 return ToCaptureOrErr.takeError();
2034 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2041 DefinitionCompleter();
2045 return Error::success();
2060 auto DefinitionCompleterScopeExit =
2061 llvm::make_scope_exit(DefinitionCompleter);
2067 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2068 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2069 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2071 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2072 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2074 #define FIELD(Name, Width, Merge) \
2075 ToData.Name = FromData.Name;
2076 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2079 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2082 for (
const auto &Base1 : FromCXX->bases()) {
2085 return TyOrErr.takeError();
2088 if (Base1.isPackExpansion()) {
2089 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2090 EllipsisLoc = *LocOrErr;
2092 return LocOrErr.takeError();
2100 auto RangeOrErr =
import(Base1.getSourceRange());
2102 return RangeOrErr.takeError();
2104 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2106 return TSIOrErr.takeError();
2112 Base1.isBaseOfClass(),
2113 Base1.getAccessSpecifierAsWritten(),
2118 ToCXX->setBases(Bases.data(), Bases.size());
2126 return Error::success();
2131 return Error::success();
2135 return Error::success();
2139 return ToInitOrErr.takeError();
2150 return Error::success();
2158 return Error::success();
2169 return ToTypeOrErr.takeError();
2172 if (!ToPromotionTypeOrErr)
2173 return ToPromotionTypeOrErr.takeError();
2184 return Error::success();
2190 for (
unsigned I = 0; I != NumFromArgs; ++I) {
2191 if (
auto ToOrErr =
import(FromArgs[I]))
2192 ToArgs.push_back(*ToOrErr);
2194 return ToOrErr.takeError();
2197 return Error::success();
2203 return import(From);
2206 template <
typename InContainerTy>
2209 for (
const auto &FromLoc : Container) {
2210 if (
auto ToLocOrErr =
import(FromLoc))
2213 return ToLocOrErr.takeError();
2215 return Error::success();
2255 return std::move(Err);
2260 return LocOrErr.takeError();
2263 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, *LocOrErr))
2286 return std::move(Err);
2291 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, Loc,
2292 Name.getAsIdentifierInfo()))
2295 Error Err = Error::success();
2300 return std::move(Err);
2304 addDeclToContexts(D, ToD);
2312 return LocOrErr.takeError();
2315 return ColonLocOrErr.takeError();
2320 return DCOrErr.takeError();
2325 DC, *LocOrErr, *ColonLocOrErr))
2339 return DCOrErr.takeError();
2343 Error Err = Error::success();
2349 return std::move(Err);
2352 if (GetImportedOrCreateDecl(
2353 ToD, D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2369 return std::move(Err);
2378 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2384 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2385 for (
auto *FoundDecl : FoundDecls) {
2389 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2390 MergeWithNamespace = FoundNS;
2391 ConflictingDecls.clear();
2395 ConflictingDecls.push_back(FoundDecl);
2398 if (!ConflictingDecls.empty()) {
2401 ConflictingDecls.size());
2403 Name = NameOrErr.get();
2405 return NameOrErr.takeError();
2411 return BeginLocOrErr.takeError();
2413 if (!RBraceLocOrErr)
2414 return RBraceLocOrErr.takeError();
2419 if (GetImportedOrCreateDecl(
2421 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2431 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2432 TU->setAnonymousNamespace(ToNamespace);
2434 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2440 return std::move(Err);
2452 return std::move(Err);
2458 Error Err = Error::success();
2465 return std::move(Err);
2470 if (GetImportedOrCreateDecl(
2471 ToD, D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2472 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2490 return std::move(Err);
2509 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2510 for (
auto *FoundDecl : FoundDecls) {
2513 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2518 QualType FoundUT = FoundTypedef->getUnderlyingType();
2527 ConflictingDecls.push_back(FoundDecl);
2532 if (!ConflictingDecls.empty()) {
2534 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2536 Name = NameOrErr.get();
2538 return NameOrErr.takeError();
2542 Error Err = Error::success();
2547 return std::move(Err);
2554 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2555 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2556 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2558 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2559 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2560 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2565 return std::move(Err);
2569 Importer.AddToLookupTable(ToTypedef);
2574 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) :
nullptr;
2597 return std::move(Err);
2607 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2608 for (
auto *FoundDecl : FoundDecls) {
2611 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
2613 ConflictingDecls.push_back(FoundDecl);
2616 if (!ConflictingDecls.empty()) {
2618 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2620 Name = NameOrErr.get();
2622 return NameOrErr.takeError();
2626 Error Err = Error::success();
2630 return std::move(Err);
2633 if (GetImportedOrCreateDecl(ToAlias, D, Importer.
getToContext(), DC, Loc,
2634 Name, ToTemplateParameters, ToTemplatedDecl))
2637 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2643 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2654 return std::move(Err);
2664 return BeginLocOrErr.takeError();
2665 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2666 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2670 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2671 Name.getAsIdentifierInfo()))
2678 return ToStmtOrErr.takeError();
2680 ToLabel->
setStmt(*ToStmtOrErr);
2693 return std::move(Err);
2701 if (
Error Err = importInto(
2703 return std::move(Err);
2713 Importer.findDeclsInToCtx(DC, SearchName);
2714 for (
auto *FoundDecl : FoundDecls) {
2718 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2719 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2720 FoundDecl = Tag->getDecl();
2723 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2733 ConflictingDecls.push_back(FoundDecl);
2737 if (!ConflictingDecls.empty()) {
2739 SearchName, DC, IDNS, ConflictingDecls.data(),
2740 ConflictingDecls.size());
2742 Name = NameOrErr.get();
2744 return NameOrErr.takeError();
2748 Error Err = Error::success();
2754 return std::move(Err);
2758 if (GetImportedOrCreateDecl(
2760 Loc, Name.getAsIdentifierInfo(), PrevDecl, D->
isScoped(),
2769 addDeclToContexts(D, D2);
2775 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
2777 return ToInstOrErr.takeError();
2778 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
2781 return POIOrErr.takeError();
2787 return std::move(Err);
2793 bool IsFriendTemplate =
false;
2794 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2796 DCXX->getDescribedClassTemplate() &&
2797 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2807 return std::move(Err);
2815 if (
Error Err = importInto(
2817 return std::move(Err);
2827 Importer.findDeclsInToCtx(DC, SearchName);
2828 if (!FoundDecls.empty()) {
2835 for (
auto *FoundDecl : FoundDecls) {
2839 Decl *Found = FoundDecl;
2840 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2841 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2842 Found = Tag->getDecl();
2845 if (
auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2868 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2869 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2870 assert(FoundCXX &&
"Record type mismatch");
2876 return std::move(Err);
2882 ConflictingDecls.push_back(FoundDecl);
2886 if (!ConflictingDecls.empty() && SearchName) {
2888 SearchName, DC, IDNS, ConflictingDecls.data(),
2889 ConflictingDecls.size());
2891 Name = NameOrErr.get();
2893 return NameOrErr.takeError();
2899 return BeginLocOrErr.takeError();
2904 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2905 if (DCXX->isLambda()) {
2906 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
2908 return TInfoOrErr.takeError();
2909 if (GetImportedOrCreateSpecialDecl(
2911 DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
2912 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2914 ExpectedDecl CDeclOrErr =
import(DCXX->getLambdaContextDecl());
2916 return CDeclOrErr.takeError();
2918 DCXX->hasKnownLambdaInternalLinkage());
2920 DCXX->getDeviceLambdaManglingNumber());
2921 }
else if (DCXX->isInjectedClassName()) {
2924 const bool DelayTypeCreation =
true;
2925 if (GetImportedOrCreateDecl(
2927 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2928 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
2931 D2CXX, dyn_cast<CXXRecordDecl>(DC));
2933 if (GetImportedOrCreateDecl(D2CXX, D, Importer.
getToContext(),
2935 Name.getAsIdentifierInfo(),
2936 cast_or_null<CXXRecordDecl>(PrevDecl)))
2943 addDeclToContexts(D, D2);
2946 DCXX->getDescribedClassTemplate()) {
2948 if (
Error Err = importInto(ToDescribed, FromDescribed))
2949 return std::move(Err);
2951 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
2960 auto *Record = dyn_cast<CXXRecordDecl>(Found);
2961 if (Record && Record->isInjectedClassName()) {
2969 for (
auto *R : Redecls) {
2970 auto *RI = cast<CXXRecordDecl>(R);
2971 RI->setTypeForDecl(
nullptr);
2985 DCXX->getMemberSpecializationInfo()) {
2987 MemberInfo->getTemplateSpecializationKind();
2993 return ToInstOrErr.takeError();
2996 import(MemberInfo->getPointOfInstantiation()))
3000 return POIOrErr.takeError();
3004 if (GetImportedOrCreateDecl(D2, D, Importer.
getToContext(),
3006 Name.getAsIdentifierInfo(), PrevDecl))
3009 addDeclToContexts(D, D2);
3015 return BraceRangeOrErr.takeError();
3019 return QualifierLocOrErr.takeError();
3026 return std::move(Err);
3038 return std::move(Err);
3047 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3048 for (
auto *FoundDecl : FoundDecls) {
3052 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3054 return Importer.
MapImported(D, FoundEnumConstant);
3055 ConflictingDecls.push_back(FoundDecl);
3059 if (!ConflictingDecls.empty()) {
3061 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3063 Name = NameOrErr.get();
3065 return NameOrErr.takeError();
3071 return TypeOrErr.takeError();
3075 return InitOrErr.takeError();
3078 if (GetImportedOrCreateDecl(
3079 ToEnumerator, D, Importer.
getToContext(), cast<EnumDecl>(DC), Loc,
3080 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->
getInitVal()))
3081 return ToEnumerator;
3086 return ToEnumerator;
3093 return Error::success();
3095 for (
unsigned int I = 0; I < Num; ++I)
3098 ToTPLists[I] = *ToTPListOrErr;
3100 return ToTPListOrErr.takeError();
3102 return Error::success();
3110 return Error::success();
3117 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3119 return InstFDOrErr.takeError();
3125 return POIOrErr.takeError();
3127 return Error::success();
3131 auto FunctionAndArgsOrErr =
3133 if (!FunctionAndArgsOrErr)
3134 return FunctionAndArgsOrErr.takeError();
3137 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3141 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3142 if (FromTAArgsAsWritten)
3144 *FromTAArgsAsWritten, ToTAInfo))
3147 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3149 return POIOrErr.takeError();
3155 ToFD->setFunctionTemplateSpecialization(
3156 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3157 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3158 return Error::success();
3164 unsigned NumTemplates = FromInfo->getNumTemplates();
3165 for (
unsigned I = 0; I < NumTemplates; I++) {
3167 import(FromInfo->getTemplate(I)))
3168 TemplDecls.
addDecl(*ToFTDOrErr);
3170 return ToFTDOrErr.takeError();
3176 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
3178 FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()),
3183 TemplDecls, ToTAInfo);
3184 return Error::success();
3187 llvm_unreachable(
"All cases should be covered!");
3192 auto FunctionAndArgsOrErr =
3194 if (!FunctionAndArgsOrErr)
3195 return FunctionAndArgsOrErr.takeError();
3199 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3200 void *InsertPos =
nullptr;
3211 return ToBodyOrErr.takeError();
3213 return Error::success();
3238 if (
const auto *RDTempl = dyn_cast<ClassTemplateSpecializationDecl>(RD))
3239 return llvm::count_if(RDTempl->getTemplateArgs().asArray(),
3241 return hasTypeDeclaredInsideFunction(
3242 Arg.getAsType(), FD);
3251 assert(FromFPT &&
"Must be called on FunctionProtoType");
3254 if (
const auto *TypedefT = FromFPT->getReturnType()->getAs<
TypedefType>()) {
3276 auto RedeclIt = Redecls.begin();
3279 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3282 return ToRedeclOrErr.takeError();
3284 assert(*RedeclIt == D);
3292 return std::move(Err);
3307 if (!FoundFunctionOrErr)
3308 return FoundFunctionOrErr.takeError();
3309 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3310 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3312 FoundByLookup = FoundFunction;
3320 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3321 for (
auto *FoundDecl : FoundDecls) {
3325 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3330 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3332 FoundByLookup = FoundFunction;
3343 Importer.
ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3344 << Name << D->
getType() << FoundFunction->getType();
3345 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3346 << FoundFunction->getType();
3347 ConflictingDecls.push_back(FoundDecl);
3351 if (!ConflictingDecls.empty()) {
3353 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3355 Name = NameOrErr.get();
3357 return NameOrErr.takeError();
3367 if (FoundByLookup) {
3368 if (isa<CXXMethodDecl>(FoundByLookup)) {
3377 "Templated function mapped to non-templated?");
3393 return std::move(Err);
3404 bool UsedDifferentProtoType =
false;
3406 QualType FromReturnTy = FromFPT->getReturnType();
3414 UsedDifferentProtoType =
true;
3425 FromEPI = DefaultEPI;
3426 UsedDifferentProtoType =
true;
3429 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3434 Error Err = Error::success();
3440 auto TrailingRequiresClause =
3443 return std::move(Err);
3449 Parameters.push_back(*ToPOrErr);
3451 return ToPOrErr.takeError();
3456 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3458 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3460 return std::move(Err);
3462 if (FromConstructor->isInheritingConstructor()) {
3464 import(FromConstructor->getInheritedConstructor());
3465 if (!ImportedInheritedCtor)
3466 return ImportedInheritedCtor.takeError();
3467 ToInheritedConstructor = *ImportedInheritedCtor;
3469 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3470 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3471 ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->
UsesFPIntrin(),
3473 ToInheritedConstructor, TrailingRequiresClause))
3477 Error Err = Error::success();
3479 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3480 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3482 return std::move(Err);
3484 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3485 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3486 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3488 TrailingRequiresClause))
3495 dyn_cast<CXXConversionDecl>(D)) {
3497 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3499 return std::move(Err);
3500 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3501 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3502 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3506 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3507 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3508 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3509 ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3510 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3513 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3515 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3519 return std::move(Err);
3520 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3521 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart, ESpec,
3522 NameInfo, T, TInfo, ToEndLoc, Ctor))
3524 cast<CXXDeductionGuideDecl>(ToFunction)
3525 ->setIsCopyDeductionCandidate(Guide->isCopyDeductionCandidate());
3527 if (GetImportedOrCreateDecl(
3528 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart,
3536 if (FoundByLookup) {
3559 for (
auto *Param : Parameters) {
3560 Param->setOwningFunction(ToFunction);
3565 ToFunction->setParams(Parameters);
3572 for (
unsigned I = 0, N = Parameters.size(); I != N; ++I)
3573 ProtoLoc.setParam(I, Parameters[I]);
3579 auto ToFTOrErr =
import(FromFT);
3581 return ToFTOrErr.takeError();
3585 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3586 if (
unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3590 FromConstructor->inits(), CtorInitializers))
3591 return std::move(Err);
3594 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3595 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3596 ToCtor->setCtorInitializers(Memory);
3597 ToCtor->setNumCtorInitializers(NumInitializers);
3605 return std::move(Err);
3609 if (UsedDifferentProtoType) {
3611 ToFunction->
setType(*TyOrErr);
3613 return TyOrErr.takeError();
3617 return TSIOrErr.takeError();
3624 return std::move(Err);
3626 addDeclToContexts(D, ToFunction);
3628 if (
auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3631 return std::move(Err);
3634 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
3637 return ToRedeclOrErr.takeError();
3671 return std::move(Err);
3676 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3677 for (
auto *FoundDecl : FoundDecls) {
3678 if (
FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
3686 FoundField->getType())) {
3695 if (
ExpectedExpr ToInitializerOrErr =
import(FromInitializer)) {
3698 assert(FoundField->hasInClassInitializer() &&
3699 "Field should have an in-class initializer if it has an "
3700 "expression for it.");
3701 if (!FoundField->getInClassInitializer())
3702 FoundField->setInClassInitializer(*ToInitializerOrErr);
3704 return ToInitializerOrErr.takeError();
3711 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3712 << Name << D->
getType() << FoundField->getType();
3713 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3714 << FoundField->getType();
3720 Error Err = Error::success();
3727 return std::move(Err);
3728 const Type *ToCapturedVLAType =
nullptr;
3731 return std::move(Err);
3734 if (GetImportedOrCreateDecl(ToField, D, Importer.
getToContext(), DC,
3735 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3736 ToType, ToTInfo, ToBitWidth, D->
isMutable(),
3745 if (ToCapturedVLAType)
3758 return std::move(Err);
3763 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3764 for (
unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3765 if (
auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3773 FoundField->getType(),
3780 if (!Name && I < N-1)
3784 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3785 << Name << D->
getType() << FoundField->getType();
3786 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3787 << FoundField->getType();
3794 auto TypeOrErr =
import(D->
getType());
3796 return TypeOrErr.takeError();
3802 for (
auto *PI : D->
chain())
3804 NamedChain[i++] = *ToD;
3806 return ToD.takeError();
3810 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.
getToContext(), DC,
3811 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
3813 return ToIndirectField;
3818 return ToIndirectField;
3832 llvm::function_ref<T(
const FriendDecl *)> GetCanTypeOrDecl) {
3833 unsigned int FriendCount = 0;
3837 T TypeOrDecl = GetCanTypeOrDecl(FD);
3839 for (
const FriendDecl *FoundFriend : RD->friends()) {
3840 if (FoundFriend == FD) {
3841 FriendPosition = FriendCount;
3843 }
else if (!FoundFriend->getFriendDecl() == !FD->
getFriendDecl() &&
3844 GetCanTypeOrDecl(FoundFriend) == TypeOrDecl) {
3849 assert(FriendPosition &&
"Friend decl not found in own parent.");
3851 return {FriendCount, *FriendPosition};
3856 return getFriendCountAndPosition<QualType>(FD, [](
const FriendDecl *F) {
3858 return TSI->getType().getCanonicalType();
3859 llvm_unreachable(
"Wrong friend object type.");
3862 return getFriendCountAndPosition<Decl *>(FD, [](
const FriendDecl *F) {
3865 llvm_unreachable(
"Wrong friend object type.");
3873 return std::move(Err);
3878 const auto *RD = cast<CXXRecordDecl>(DC);
3879 FriendDecl *ImportedFriend = RD->getFirstFriend();
3882 while (ImportedFriend) {
3894 ImportedEquivalentFriends.push_back(ImportedFriend);
3896 ImportedFriend = ImportedFriend->getNextFriend();
3900 assert(ImportedEquivalentFriends.size() <= CountAndPosition.
TotalCount &&
3901 "Class with non-matching friends is imported, ODR check wrong?");
3902 if (ImportedEquivalentFriends.size() == CountAndPosition.
TotalCount)
3904 D, ImportedEquivalentFriends[CountAndPosition.
IndexOfDecl]);
3911 if (
Error Err = importInto(ToFriendD, FriendD))
3912 return std::move(Err);
3923 return TSIOrErr.takeError();
3928 for (
unsigned I = 0; I < D->NumTPLists; I++) {
3929 if (
auto ListOrErr =
import(FromTPLists[I]))
3930 ToTPLists[I] = *ListOrErr;
3932 return ListOrErr.takeError();
3937 return LocationOrErr.takeError();
3939 if (!FriendLocOrErr)
3940 return FriendLocOrErr.takeError();
3943 if (GetImportedOrCreateDecl(FrD, D, Importer.
getToContext(), DC,
3944 *LocationOrErr, ToFU,
3945 *FriendLocOrErr, ToTPLists))
3961 return std::move(Err);
3966 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3967 for (
auto *FoundDecl : FoundDecls) {
3968 if (
ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
3970 FoundIvar->getType())) {
3975 Importer.
ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
3976 << Name << D->
getType() << FoundIvar->getType();
3977 Importer.
ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3978 << FoundIvar->getType();
3984 Error Err = Error::success();
3990 return std::move(Err);
3993 if (GetImportedOrCreateDecl(
3994 ToIvar, D, Importer.
getToContext(), cast<ObjCContainerDecl>(DC),
3995 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3996 ToType, ToTypeSourceInfo,
4008 auto RedeclIt = Redecls.begin();
4011 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4014 return RedeclOrErr.takeError();
4016 assert(*RedeclIt == D);
4024 return std::move(Err);
4030 VarDecl *FoundByLookup =
nullptr;
4034 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4035 for (
auto *FoundDecl : FoundDecls) {
4039 if (
auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4043 FoundVar->getType())) {
4055 const VarDecl *FoundDInit =
nullptr;
4056 if (D->
getInit() && FoundVar->getAnyInitializer(FoundDInit))
4060 FoundByLookup = FoundVar;
4068 if (FoundArray && TArray) {
4069 if (isa<IncompleteArrayType>(FoundArray) &&
4070 isa<ConstantArrayType>(TArray)) {
4072 if (
auto TyOrErr =
import(D->
getType()))
4073 FoundVar->setType(*TyOrErr);
4075 return TyOrErr.takeError();
4077 FoundByLookup = FoundVar;
4079 }
else if (isa<IncompleteArrayType>(TArray) &&
4080 isa<ConstantArrayType>(FoundArray)) {
4081 FoundByLookup = FoundVar;
4086 Importer.
ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
4087 << Name << D->
getType() << FoundVar->getType();
4088 Importer.
ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4089 << FoundVar->getType();
4090 ConflictingDecls.push_back(FoundDecl);
4094 if (!ConflictingDecls.empty()) {
4096 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4098 Name = NameOrErr.get();
4100 return NameOrErr.takeError();
4104 Error Err = Error::success();
4110 return std::move(Err);
4113 if (
auto *FromDecomp = dyn_cast<DecompositionDecl>(D)) {
4117 return std::move(Err);
4119 if (GetImportedOrCreateDecl(
4120 ToDecomp, FromDecomp, Importer.
getToContext(), DC, ToInnerLocStart,
4126 if (GetImportedOrCreateDecl(ToVar, D, Importer.
getToContext(), DC,
4127 ToInnerLocStart, Loc,
4128 Name.getAsIdentifierInfo(), ToType,
4138 if (FoundByLookup) {
4147 return ToVTOrErr.takeError();
4151 return std::move(Err);
4156 addDeclToContexts(D, ToVar);
4159 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4162 return RedeclOrErr.takeError();
4173 Error Err = Error::success();
4178 return std::move(Err);
4182 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4183 ToLocation, ToDeclName.getAsIdentifierInfo(),
4198 return ToDefArgOrErr.takeError();
4202 if (
auto ToDefArgOrErr =
import(FromParam->
getDefaultArg()))
4205 return ToDefArgOrErr.takeError();
4208 return Error::success();
4213 Error Err = Error::success();
4218 return std::move(Err);
4227 Error Err = Error::success();
4234 return std::move(Err);
4237 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4238 ToInnerLocStart, ToLocation,
4239 ToDeclName.getAsIdentifierInfo(), ToType,
4248 return std::move(Err);
4268 return std::move(Err);
4272 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4273 for (
auto *FoundDecl : FoundDecls) {
4274 if (
auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4280 FoundMethod->getReturnType())) {
4281 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4283 << FoundMethod->getReturnType();
4284 Importer.
ToDiag(FoundMethod->getLocation(),
4285 diag::note_odr_objc_method_here)
4292 if (D->
param_size() != FoundMethod->param_size()) {
4293 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4295 << D->
param_size() << FoundMethod->param_size();
4296 Importer.
ToDiag(FoundMethod->getLocation(),
4297 diag::note_odr_objc_method_here)
4305 PEnd = D->
param_end(), FoundP = FoundMethod->param_begin();
4306 P != PEnd; ++
P, ++FoundP) {
4308 (*FoundP)->getType())) {
4309 Importer.
FromDiag((*P)->getLocation(),
4310 diag::warn_odr_objc_method_param_type_inconsistent)
4312 << (*P)->getType() << (*FoundP)->getType();
4313 Importer.
ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4314 << (*FoundP)->getType();
4322 if (D->
isVariadic() != FoundMethod->isVariadic()) {
4323 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4325 Importer.
ToDiag(FoundMethod->getLocation(),
4326 diag::note_odr_objc_method_here)
4337 Error Err = Error::success();
4340 auto ToReturnTypeSourceInfo =
4343 return std::move(Err);
4346 if (GetImportedOrCreateDecl(
4348 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4361 ToParams.push_back(*ToPOrErr);
4363 return ToPOrErr.takeError();
4367 for (
auto *ToParam : ToParams) {
4368 ToParam->setOwningFunction(ToMethod);
4376 return std::move(Err);
4400 return std::move(Err);
4404 Error Err = Error::success();
4410 return std::move(Err);
4413 if (GetImportedOrCreateDecl(
4416 ToLocation, Name.getAsIdentifierInfo(),
4417 ToColonLoc, ToTypeSourceInfo))
4431 return std::move(Err);
4437 return std::move(Err);
4445 Error Err = Error::success();
4451 return std::move(Err);
4453 if (GetImportedOrCreateDecl(ToCategory, D, Importer.
getToContext(), DC,
4456 Name.getAsIdentifierInfo(), ToInterface,
4469 return PListOrErr.takeError();
4478 FromProto != FromProtoEnd;
4479 ++FromProto, ++FromProtoLoc) {
4481 Protocols.push_back(*ToProtoOrErr);
4483 return ToProtoOrErr.takeError();
4485 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4486 ProtocolLocs.push_back(*ToProtoLocOrErr);
4488 return ToProtoLocOrErr.takeError();
4501 return std::move(Err);
4509 return ToImplOrErr.takeError();
4521 return Error::success();
4534 FromProto != FromProtoEnd;
4535 ++FromProto, ++FromProtoLoc) {
4537 Protocols.push_back(*ToProtoOrErr);
4539 return ToProtoOrErr.takeError();
4541 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4542 ProtocolLocs.push_back(*ToProtoLocOrErr);
4544 return ToProtoLocOrErr.takeError();
4557 return Error::success();
4565 if (Definition && Definition != D) {
4566 if (
ExpectedDecl ImportedDefOrErr =
import(Definition))
4567 return Importer.
MapImported(D, *ImportedDefOrErr);
4569 return ImportedDefOrErr.takeError();
4578 return std::move(Err);
4583 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4584 for (
auto *FoundDecl : FoundDecls) {
4588 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4595 if (!ToAtBeginLocOrErr)
4596 return ToAtBeginLocOrErr.takeError();
4598 if (GetImportedOrCreateDecl(ToProto, D, Importer.
getToContext(), DC,
4599 Name.getAsIdentifierInfo(), Loc,
4611 return std::move(Err);
4619 return std::move(Err);
4622 if (!ExternLocOrErr)
4623 return ExternLocOrErr.takeError();
4627 return LangLocOrErr.takeError();
4632 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.
getToContext(), DC,
4633 *ExternLocOrErr, *LangLocOrErr,
4635 return ToLinkageSpec;
4639 if (!RBraceLocOrErr)
4640 return RBraceLocOrErr.takeError();
4647 return ToLinkageSpec;
4658 return ToShadowOrErr.takeError();
4669 return std::move(Err);
4673 Error Err = Error::success();
4678 return std::move(Err);
4682 return std::move(Err);
4685 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
4686 ToUsingLoc, ToQualifierLoc, NameInfo,
4697 ToUsing, *ToPatternOrErr);
4699 return ToPatternOrErr.takeError();
4711 return std::move(Err);
4715 Error Err = Error::success();
4720 return std::move(Err);
4723 if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.
getToContext(), DC,
4724 ToUsingLoc, ToEnumLoc, Loc, ToEnumDecl))
4736 return ToPatternOrErr.takeError();
4748 return std::move(Err);
4753 if (!ToIntroducerOrErr)
4754 return ToIntroducerOrErr.takeError();
4758 return ToTargetOrErr.takeError();
4761 if (
auto *FromConstructorUsingShadow =
4762 dyn_cast<ConstructorUsingShadowDecl>(D)) {
4763 Error Err = Error::success();
4765 Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
4767 return std::move(Err);
4773 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
4775 cast<UsingDecl>(*ToIntroducerOrErr),
4776 Nominated ? Nominated : *ToTargetOrErr,
4777 FromConstructorUsingShadow->constructsVirtualBase()))
4780 if (GetImportedOrCreateDecl(ToShadow, D, Importer.
getToContext(), DC, Loc,
4781 Name, *ToIntroducerOrErr, *ToTargetOrErr))
4792 ToShadow, *ToPatternOrErr);
4796 return ToPatternOrErr.takeError();
4810 return std::move(Err);
4815 if (!ToComAncestorOrErr)
4816 return ToComAncestorOrErr.takeError();
4818 Error Err = Error::success();
4821 auto ToNamespaceKeyLocation =
4826 return std::move(Err);
4829 if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.
getToContext(), DC,
4831 ToNamespaceKeyLocation,
4834 ToNominatedNamespace, *ToComAncestorOrErr))
4849 return std::move(Err);
4853 auto ToInstantiatedFromUsingOrErr =
4855 if (!ToInstantiatedFromUsingOrErr)
4856 return ToInstantiatedFromUsingOrErr.takeError();
4859 return std::move(Err);
4862 if (GetImportedOrCreateDecl(ToUsingPack, D, Importer.
getToContext(), DC,
4863 cast<NamedDecl>(*ToInstantiatedFromUsingOrErr),
4867 addDeclToContexts(D, ToUsingPack);
4879 return std::move(Err);
4883 Error Err = Error::success();
4889 return std::move(Err);
4893 return std::move(Err);
4896 if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.
getToContext(), DC,
4897 ToUsingLoc, ToQualifierLoc, NameInfo,
4899 return ToUsingValue;
4905 return ToUsingValue;
4915 return std::move(Err);
4919 Error Err = Error::success();
4925 return std::move(Err);
4928 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
4929 ToUsingLoc, ToTypenameLoc,
4930 ToQualifierLoc, Loc, Name, ToEllipsisLoc))
4941 Decl* ToD =
nullptr;
4950 assert(ToD &&
"BuiltinTemplateDecl of unsupported kind!");
4961 if (
auto FromSuperOrErr =
import(FromSuper))
4962 FromSuper = *FromSuperOrErr;
4964 return FromSuperOrErr.takeError();
4968 if ((
bool)FromSuper != (
bool)ToSuper ||
4971 diag::warn_odr_objc_superclass_inconsistent)
4978 diag::note_odr_objc_missing_superclass);
4981 diag::note_odr_objc_superclass)
4985 diag::note_odr_objc_missing_superclass);
4991 return Error::success();
5002 return SuperTInfoOrErr.takeError();
5013 FromProto != FromProtoEnd;
5014 ++FromProto, ++FromProtoLoc) {
5016 Protocols.push_back(*ToProtoOrErr);
5018 return ToProtoOrErr.takeError();
5020 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5021 ProtocolLocs.push_back(*ToProtoLocOrErr);
5023 return ToProtoLocOrErr.takeError();
5034 auto ToCatOrErr =
import(Cat);
5036 return ToCatOrErr.takeError();
5045 return ToImplOrErr.takeError();
5052 return Error::success();
5061 for (
auto *fromTypeParam : *list) {
5062 if (
auto toTypeParamOrErr =
import(fromTypeParam))
5063 toTypeParams.push_back(*toTypeParamOrErr);
5065 return toTypeParamOrErr.takeError();
5068 auto LAngleLocOrErr =
import(list->getLAngleLoc());
5069 if (!LAngleLocOrErr)
5070 return LAngleLocOrErr.takeError();
5072 auto RAngleLocOrErr =
import(list->getRAngleLoc());
5073 if (!RAngleLocOrErr)
5074 return RAngleLocOrErr.takeError();
5087 if (Definition && Definition != D) {
5088 if (
ExpectedDecl ImportedDefOrErr =
import(Definition))
5089 return Importer.
MapImported(D, *ImportedDefOrErr);
5091 return ImportedDefOrErr.takeError();
5100 return std::move(Err);
5106 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5107 for (
auto *FoundDecl : FoundDecls) {
5111 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
5119 if (!AtBeginLocOrErr)
5120 return AtBeginLocOrErr.takeError();
5122 if (GetImportedOrCreateDecl(
5124 *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
5134 if (
auto ToPListOrErr =
5138 return ToPListOrErr.takeError();
5142 return std::move(Err);
5151 return std::move(Err);
5157 return std::move(Err);
5159 Error Err = Error::success();
5164 return std::move(Err);
5166 if (GetImportedOrCreateDecl(
5169 ToLocation, ToAtStartLoc, ToCategoryNameLoc))
5174 Category->setImplementation(ToImpl);
5179 return std::move(Err);
5189 return std::move(Err);
5194 return std::move(Err);
5202 return std::move(Err);
5204 Error Err = Error::success();
5211 return std::move(Err);
5213 if (GetImportedOrCreateDecl(Impl, D, Importer.
getToContext(),
5237 diag::warn_odr_objc_superclass_inconsistent)
5243 diag::note_odr_objc_superclass)
5247 diag::note_odr_objc_missing_superclass);
5250 diag::note_odr_objc_superclass)
5254 diag::note_odr_objc_missing_superclass);
5262 return std::move(Err);
5274 return std::move(Err);
5279 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5280 for (
auto *FoundDecl : FoundDecls) {