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"
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) {
294 if (FromD->isImplicit())
308 void addDeclToContexts(
Decl *FromD,
Decl *ToD) {
313 if (!FromD->getDescribedTemplate() &&
320 DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
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>
744template <
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();
763Error 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);
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();
980 ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
984 if (!ToLBracketLocOrErr)
985 return ToLBracketLocOrErr.takeError();
988 if (!ToRBracketLocOrErr)
989 return ToRBracketLocOrErr.takeError();
994 *ToRBracketLocOrErr);
997 if (!ToEllipsisLocOrErr)
998 return ToEllipsisLocOrErr.takeError();
1002 D.
getArrayIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
1003 *ToRBracketLocOrErr);
1013 return VarOrErr.takeError();
1018 return LocationOrErr.takeError();
1023 return std::move(Err);
1030template <
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();
1063using 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 WASM_TYPE(Name, Id, SingletonId) \
1102 case BuiltinType::Id: \
1103 return Importer.getToContext().SingletonId;
1104#include "clang/Basic/WebAssemblyReferenceTypes.def"
1105#define SHARED_SINGLETON_TYPE(Expansion)
1106#define BUILTIN_TYPE(Id, SingletonId) \
1107 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1108#include "clang/AST/BuiltinTypes.def"
1116 case BuiltinType::Char_U:
1125 case BuiltinType::Char_S:
1134 case BuiltinType::WChar_S:
1135 case BuiltinType::WChar_U:
1141 llvm_unreachable(
"Invalid BuiltinType Kind!");
1146 if (!ToOriginalTypeOrErr)
1147 return ToOriginalTypeOrErr.takeError();
1154 if (!ToElementTypeOrErr)
1155 return ToElementTypeOrErr.takeError();
1162 if (!ToPointeeTypeOrErr)
1163 return ToPointeeTypeOrErr.takeError();
1171 if (!ToPointeeTypeOrErr)
1172 return ToPointeeTypeOrErr.takeError();
1181 if (!ToPointeeTypeOrErr)
1182 return ToPointeeTypeOrErr.takeError();
1191 if (!ToPointeeTypeOrErr)
1192 return ToPointeeTypeOrErr.takeError();
1201 if (!ToPointeeTypeOrErr)
1202 return ToPointeeTypeOrErr.takeError();
1205 if (!ClassTypeOrErr)
1206 return ClassTypeOrErr.takeError();
1214 Error Err = Error::success();
1218 return std::move(Err);
1228 if (!ToElementTypeOrErr)
1229 return ToElementTypeOrErr.takeError();
1238 Error Err = Error::success();
1243 return std::move(Err);
1251 Error Err = Error::success();
1256 return std::move(Err);
1267 if (!ToElementTypeOrErr)
1268 return ToElementTypeOrErr.takeError();
1277 if (!ToElementTypeOrErr)
1278 return ToElementTypeOrErr.takeError();
1289 if (!ToReturnTypeOrErr)
1290 return ToReturnTypeOrErr.takeError();
1299 if (!ToReturnTypeOrErr)
1300 return ToReturnTypeOrErr.takeError();
1307 return TyOrErr.takeError();
1308 ArgTypes.push_back(*TyOrErr);
1316 return TyOrErr.takeError();
1317 ExceptionTypes.push_back(*TyOrErr);
1321 Error Err = Error::success();
1338 return std::move(Err);
1341 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1346 Error Err = Error::success();
1350 return std::move(Err);
1353 ToD, cast_or_null<TypeDecl>(ToPrevD));
1358 if (!ToInnerTypeOrErr)
1359 return ToInnerTypeOrErr.takeError();
1367 return ToDeclOrErr.takeError();
1374 if (!ToUnderlyingTypeOrErr)
1375 return ToUnderlyingTypeOrErr.takeError();
1383 return ToExprOrErr.takeError();
1389 if (!ToUnderlyingTypeOrErr)
1390 return ToUnderlyingTypeOrErr.takeError();
1398 return FoundOrErr.takeError();
1400 if (!UnderlyingOrErr)
1401 return UnderlyingOrErr.takeError();
1410 return ToExprOrErr.takeError();
1413 if (!ToUnderlyingTypeOrErr)
1414 return ToUnderlyingTypeOrErr.takeError();
1417 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1423 if (!ToBaseTypeOrErr)
1424 return ToBaseTypeOrErr.takeError();
1427 if (!ToUnderlyingTypeOrErr)
1428 return ToUnderlyingTypeOrErr.takeError();
1431 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->
getUTTKind());
1437 if (!ToDeducedTypeOrErr)
1438 return ToDeducedTypeOrErr.takeError();
1441 if (!ToTypeConstraintConcept)
1442 return ToTypeConstraintConcept.takeError();
1447 return std::move(Err);
1451 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1459 if (!ToTemplateNameOrErr)
1460 return ToTemplateNameOrErr.takeError();
1462 if (!ToDeducedTypeOrErr)
1463 return ToDeducedTypeOrErr.takeError();
1473 return ToDeclOrErr.takeError();
1477 const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
1478 assert(Ty && isa<InjectedClassNameType>(Ty));
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();
1524 return ReplacedOrErr.takeError();
1527 if (!ToReplacementTypeOrErr)
1528 return ToReplacementTypeOrErr.takeError();
1531 *ToReplacementTypeOrErr, *ReplacedOrErr, T->
getIndex(),
1539 return ReplacedOrErr.takeError();
1542 if (!ToArgumentPack)
1543 return ToArgumentPack.takeError();
1552 if (!ToTemplateOrErr)
1553 return ToTemplateOrErr.takeError();
1558 return std::move(Err);
1565 ToCanonType = *TyOrErr;
1567 return TyOrErr.takeError();
1577 if (!ToQualifierOrErr)
1578 return ToQualifierOrErr.takeError();
1581 if (!ToNamedTypeOrErr)
1582 return ToNamedTypeOrErr.takeError();
1585 if (!ToOwnedTagDeclOrErr)
1586 return ToOwnedTagDeclOrErr.takeError();
1591 *ToOwnedTagDeclOrErr);
1597 if (!ToPatternOrErr)
1598 return ToPatternOrErr.takeError();
1608 if (!ToQualifierOrErr)
1609 return ToQualifierOrErr.takeError();
1616 return std::move(Err);
1619 T->
getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1625 if (!ToQualifierOrErr)
1626 return ToQualifierOrErr.takeError();
1635 return TyOrErr.takeError();
1647 return ToDeclOrErr.takeError();
1654 if (!ToBaseTypeOrErr)
1655 return ToBaseTypeOrErr.takeError();
1660 TypeArgs.push_back(*TyOrErr);
1662 return TyOrErr.takeError();
1666 for (
auto *
P : T->
quals()) {
1668 Protocols.push_back(*ProtocolOrErr);
1670 return ProtocolOrErr.takeError();
1682 if (!ToPointeeTypeOrErr)
1683 return ToPointeeTypeOrErr.takeError();
1702 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1704 auto getLeafPointeeType = [](
const Type *T) {
1705 while (T->isPointerType() || T->isArrayType()) {
1706 T = T->getPointeeOrArrayElementType();
1712 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1713 auto *RT = dyn_cast<RecordType>(LeafT);
1714 if (RT && RT->getDecl() == D) {
1739 return Error::success();
1758 return Error::success();
1763 return Error::success();
1766 if (
Error Err = importInto(ToD, FromD))
1769 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1770 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1771 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1772 !ToRecord->getDefinition()) {
1777 return Error::success();
1780 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1781 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1782 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1787 return Error::success();
1790 return Error::success();
1805 return Error::success();
1811 return ToRangeOrErr.takeError();
1812 return Error::success();
1818 return LocOrErr.takeError();
1819 return Error::success();
1827 return ToTInfoOrErr.takeError();
1828 return Error::success();
1831 llvm_unreachable(
"Unknown name kind.");
1838 return ToDCOrErr.takeError();
1852 Error ChildErrors = Error::success();
1853 for (
auto *From : FromDC->
decls()) {
1860 if (ImportedOrErr) {
1861 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
1862 Decl *ImportedDecl = *ImportedOrErr;
1863 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
1864 if (FieldFrom && FieldTo) {
1875 if (!FromRecordDecl || !ToRecordDecl) {
1880 if (RecordFrom && RecordTo) {
1881 FromRecordDecl = RecordFrom->
getDecl();
1882 ToRecordDecl = RecordTo->getDecl();
1886 if (FromRecordDecl && ToRecordDecl) {
1897 ImportedOrErr.takeError());
1924 const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
1930 consumeError(std::move(ChildErrors));
1931 return ToDCOrErr.takeError();
1937 for (
auto *D : FromRD->decls()) {
1938 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) {
1939 assert(D &&
"DC contains a null decl");
1961 return ToDCOrErr.takeError();
1967 if (!ToLexicalDCOrErr)
1968 return ToLexicalDCOrErr.takeError();
1969 ToLexicalDC = *ToLexicalDCOrErr;
1973 return Error::success();
1979 "Import implicit methods to or from non-definition");
1982 if (FromM->isImplicit()) {
1985 return ToMOrErr.takeError();
1988 return Error::success();
1997 return ToTypedefOrErr.takeError();
1999 return Error::success();
2004 auto DefinitionCompleter = [To]() {
2023 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2025 ToCaptures.reserve(FromCXXRD->capture_size());
2026 for (
const auto &FromCapture : FromCXXRD->captures()) {
2027 if (
auto ToCaptureOrErr =
import(FromCapture))
2028 ToCaptures.push_back(*ToCaptureOrErr);
2030 return ToCaptureOrErr.takeError();
2032 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2039 DefinitionCompleter();
2043 return Error::success();
2058 auto DefinitionCompleterScopeExit =
2059 llvm::make_scope_exit(DefinitionCompleter);
2065 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2066 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2067 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2069 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2070 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2072 #define FIELD(Name, Width, Merge) \
2073 ToData.Name = FromData.Name;
2074 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2077 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2080 for (
const auto &Base1 : FromCXX->bases()) {
2083 return TyOrErr.takeError();
2086 if (Base1.isPackExpansion()) {
2087 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2088 EllipsisLoc = *LocOrErr;
2090 return LocOrErr.takeError();
2098 auto RangeOrErr =
import(Base1.getSourceRange());
2100 return RangeOrErr.takeError();
2102 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2104 return TSIOrErr.takeError();
2110 Base1.isBaseOfClass(),
2111 Base1.getAccessSpecifierAsWritten(),
2116 ToCXX->setBases(Bases.data(), Bases.size());
2124 return Error::success();
2129 return Error::success();
2133 return Error::success();
2137 return ToInitOrErr.takeError();
2148 return Error::success();
2156 return Error::success();
2167 return ToTypeOrErr.takeError();
2170 if (!ToPromotionTypeOrErr)
2171 return ToPromotionTypeOrErr.takeError();
2182 return Error::success();
2188 for (
const auto &Arg : FromArgs) {
2189 if (
auto ToOrErr =
import(Arg))
2190 ToArgs.push_back(*ToOrErr);
2192 return ToOrErr.takeError();
2195 return Error::success();
2201 return import(From);
2204template <
typename InContainerTy>
2207 for (
const auto &FromLoc : Container) {
2208 if (
auto ToLocOrErr =
import(FromLoc))
2211 return ToLocOrErr.takeError();
2213 return Error::success();
2253 return std::move(Err);
2258 return LocOrErr.takeError();
2261 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, *LocOrErr))
2284 return std::move(Err);
2289 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, Loc,
2290 Name.getAsIdentifierInfo()))
2293 Error Err = Error::success();
2298 return std::move(Err);
2302 addDeclToContexts(D, ToD);
2310 return LocOrErr.takeError();
2313 return ColonLocOrErr.takeError();
2318 return DCOrErr.takeError();
2323 DC, *LocOrErr, *ColonLocOrErr))
2337 return DCOrErr.takeError();
2341 Error Err = Error::success();
2347 return std::move(Err);
2350 if (GetImportedOrCreateDecl(
2351 ToD, D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2367 return std::move(Err);
2376 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2382 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2383 for (
auto *FoundDecl : FoundDecls) {
2387 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2388 MergeWithNamespace = FoundNS;
2389 ConflictingDecls.clear();
2393 ConflictingDecls.push_back(FoundDecl);
2396 if (!ConflictingDecls.empty()) {
2399 ConflictingDecls.size());
2401 Name = NameOrErr.get();
2403 return NameOrErr.takeError();
2409 return BeginLocOrErr.takeError();
2411 if (!RBraceLocOrErr)
2412 return RBraceLocOrErr.takeError();
2417 if (GetImportedOrCreateDecl(ToNamespace, D, Importer.
getToContext(), DC,
2418 D->
isInline(), *BeginLocOrErr, Loc,
2419 Name.getAsIdentifierInfo(),
2429 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2430 TU->setAnonymousNamespace(ToNamespace);
2432 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2438 return std::move(Err);
2450 return std::move(Err);
2456 Error Err = Error::success();
2463 return std::move(Err);
2468 if (GetImportedOrCreateDecl(
2469 ToD, D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2470 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2488 return std::move(Err);
2507 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2508 for (
auto *FoundDecl : FoundDecls) {
2511 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2516 QualType FoundUT = FoundTypedef->getUnderlyingType();
2530 if (FromR && FoundR &&
2541 ConflictingDecls.push_back(FoundDecl);
2546 if (!ConflictingDecls.empty()) {
2548 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2550 Name = NameOrErr.get();
2552 return NameOrErr.takeError();
2556 Error Err = Error::success();
2561 return std::move(Err);
2568 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2569 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2570 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2572 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2573 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2574 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2579 return std::move(Err);
2583 Importer.AddToLookupTable(ToTypedef);
2588 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) :
nullptr;
2611 return std::move(Err);
2621 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2622 for (
auto *FoundDecl : FoundDecls) {
2625 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
2627 ConflictingDecls.push_back(FoundDecl);
2630 if (!ConflictingDecls.empty()) {
2632 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2634 Name = NameOrErr.get();
2636 return NameOrErr.takeError();
2640 Error Err = Error::success();
2644 return std::move(Err);
2647 if (GetImportedOrCreateDecl(ToAlias, D, Importer.
getToContext(), DC, Loc,
2648 Name, ToTemplateParameters, ToTemplatedDecl))
2651 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2657 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2668 return std::move(Err);
2678 return BeginLocOrErr.takeError();
2679 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2680 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2684 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2685 Name.getAsIdentifierInfo()))
2692 return ToStmtOrErr.takeError();
2694 ToLabel->
setStmt(*ToStmtOrErr);
2707 return std::move(Err);
2715 if (
Error Err = importInto(
2717 return std::move(Err);
2727 Importer.findDeclsInToCtx(DC, SearchName);
2728 for (
auto *FoundDecl : FoundDecls) {
2732 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2733 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2734 FoundDecl = Tag->getDecl();
2737 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2747 ConflictingDecls.push_back(FoundDecl);
2751 if (!ConflictingDecls.empty()) {
2753 SearchName, DC, IDNS, ConflictingDecls.data(),
2754 ConflictingDecls.size());
2756 Name = NameOrErr.get();
2758 return NameOrErr.takeError();
2762 Error Err = Error::success();
2768 return std::move(Err);
2772 if (GetImportedOrCreateDecl(
2774 Loc, Name.getAsIdentifierInfo(), PrevDecl, D->
isScoped(),
2783 addDeclToContexts(D, D2);
2789 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
2791 return ToInstOrErr.takeError();
2792 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
2795 return POIOrErr.takeError();
2801 return std::move(Err);
2807 bool IsFriendTemplate =
false;
2808 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2810 DCXX->getDescribedClassTemplate() &&
2811 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2821 return std::move(Err);
2829 if (
Error Err = importInto(
2831 return std::move(Err);
2841 Importer.findDeclsInToCtx(DC, SearchName);
2842 if (!FoundDecls.empty()) {
2849 for (
auto *FoundDecl : FoundDecls) {
2853 Decl *Found = FoundDecl;
2854 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2855 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2856 Found = Tag->getDecl();
2859 if (
auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2882 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2883 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2884 assert(FoundCXX &&
"Record type mismatch");
2890 return std::move(Err);
2896 ConflictingDecls.push_back(FoundDecl);
2900 if (!ConflictingDecls.empty() && SearchName) {
2902 SearchName, DC, IDNS, ConflictingDecls.data(),
2903 ConflictingDecls.size());
2905 Name = NameOrErr.get();
2907 return NameOrErr.takeError();
2913 return BeginLocOrErr.takeError();
2918 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2919 if (DCXX->isLambda()) {
2920 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
2922 return TInfoOrErr.takeError();
2923 if (GetImportedOrCreateSpecialDecl(
2925 DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
2926 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2931 return CDeclOrErr.takeError();
2934 }
else if (DCXX->isInjectedClassName()) {
2937 const bool DelayTypeCreation =
true;
2938 if (GetImportedOrCreateDecl(
2940 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2941 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
2944 D2CXX, dyn_cast<CXXRecordDecl>(DC));
2946 if (GetImportedOrCreateDecl(D2CXX, D, Importer.
getToContext(),
2948 Name.getAsIdentifierInfo(),
2949 cast_or_null<CXXRecordDecl>(PrevDecl)))
2956 addDeclToContexts(D, D2);
2959 DCXX->getDescribedClassTemplate()) {
2961 if (
Error Err = importInto(ToDescribed, FromDescribed))
2962 return std::move(Err);
2964 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
2971 auto *Record = dyn_cast<CXXRecordDecl>(Found);
2972 if (Record && Record->isInjectedClassName()) {
2984 const Type *FrontTy =
2985 cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
2988 InjSpec = InjTy->getInjectedSpecializationType();
2991 for (
auto *R : Redecls) {
2992 auto *RI = cast<CXXRecordDecl>(R);
2993 if (R != Redecls.front() ||
2994 !isa<InjectedClassNameType>(RI->getTypeForDecl()))
2995 RI->setTypeForDecl(
nullptr);
3010 DCXX->getMemberSpecializationInfo()) {
3012 MemberInfo->getTemplateSpecializationKind();
3018 return ToInstOrErr.takeError();
3021 import(MemberInfo->getPointOfInstantiation()))
3025 return POIOrErr.takeError();
3029 if (GetImportedOrCreateDecl(D2, D, Importer.
getToContext(),
3031 Name.getAsIdentifierInfo(), PrevDecl))
3034 addDeclToContexts(D, D2);
3040 return BraceRangeOrErr.takeError();
3044 return QualifierLocOrErr.takeError();
3051 return std::move(Err);
3063 return std::move(Err);
3072 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3073 for (
auto *FoundDecl : FoundDecls) {
3077 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3079 return Importer.
MapImported(D, FoundEnumConstant);
3080 ConflictingDecls.push_back(FoundDecl);
3084 if (!ConflictingDecls.empty()) {
3086 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3088 Name = NameOrErr.get();
3090 return NameOrErr.takeError();
3096 return TypeOrErr.takeError();
3100 return InitOrErr.takeError();
3103 if (GetImportedOrCreateDecl(
3104 ToEnumerator, D, Importer.
getToContext(), cast<EnumDecl>(DC), Loc,
3105 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->
getInitVal()))
3106 return ToEnumerator;
3111 return ToEnumerator;
3118 return Error::success();
3120 for (
unsigned int I = 0; I < Num; ++I)
3123 ToTPLists[I] = *ToTPListOrErr;
3125 return ToTPListOrErr.takeError();
3127 return Error::success();
3135 return Error::success();
3141 return Error::success();
3147 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3149 return InstFDOrErr.takeError();
3155 return POIOrErr.takeError();
3157 return Error::success();
3161 auto FunctionAndArgsOrErr =
3163 if (!FunctionAndArgsOrErr)
3164 return FunctionAndArgsOrErr.takeError();
3167 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3171 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3172 if (FromTAArgsAsWritten)
3174 *FromTAArgsAsWritten, ToTAInfo))
3177 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3179 return POIOrErr.takeError();
3185 ToFD->setFunctionTemplateSpecialization(
3186 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3187 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3188 return Error::success();
3194 unsigned NumTemplates = FromInfo->getNumTemplates();
3195 for (
unsigned I = 0; I < NumTemplates; I++) {
3197 import(FromInfo->getTemplate(I)))
3198 TemplDecls.
addDecl(*ToFTDOrErr);
3200 return ToFTDOrErr.takeError();
3206 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
3208 FromInfo->getNumTemplateArgs()),
3213 TemplDecls, ToTAInfo);
3214 return Error::success();
3217 llvm_unreachable(
"All cases should be covered!");
3222 auto FunctionAndArgsOrErr =
3224 if (!FunctionAndArgsOrErr)
3225 return FunctionAndArgsOrErr.takeError();
3229 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3230 void *InsertPos =
nullptr;
3241 return ToBodyOrErr.takeError();
3243 return Error::success();
3249 const DeclContext *DCi = dyn_cast<DeclContext>(D);
3252 assert(DCi &&
"Declaration should have a context");
3266 ToProcess.push_back(S);
3267 while (!ToProcess.empty()) {
3268 const Stmt *CurrentS = ToProcess.pop_back_val();
3270 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS))
3271 if (
const Decl *D = DeclRef->getDecl())
3303class IsTypeDeclaredInsideVisitor
3304 :
public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3306 IsTypeDeclaredInsideVisitor(
const FunctionDecl *ParentDC)
3307 : ParentDC(ParentDC) {}
3313 if (std::optional<bool> Res = Visit(T.
getTypePtr()))
3318 if (std::optional<bool> Res = Visit(DsT.
getTypePtr()))
3326 std::optional<bool> VisitTagType(
const TagType *T) {
3327 if (
auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(T->
getDecl()))
3328 for (
const auto &Arg : Spec->getTemplateArgs().asArray())
3329 if (checkTemplateArgument(Arg))
3334 std::optional<bool> VisitPointerType(
const PointerType *T) {
3338 std::optional<bool> VisitReferenceType(
const ReferenceType *T) {
3342 std::optional<bool> VisitTypedefType(
const TypedefType *T) {
3348 std::optional<bool> VisitUsingType(
const UsingType *T) {
3359 if (checkTemplateArgument(Arg))
3374 "Variable array should not occur in deduced return type of a function");
3378 llvm_unreachable(
"Incomplete array should not occur in deduced return type "
3383 llvm_unreachable(
"Dependent array should not occur in deduced return type "
3408 if (checkTemplateArgument(PackArg))
3420 llvm_unreachable(
"Unknown TemplateArgument::ArgKind enum");
3428 assert(FromFPT &&
"Must be called on FunctionProtoType");
3430 QualType RetT = FromFPT->getReturnType();
3433 IsTypeDeclaredInsideVisitor Visitor(Def ? Def : D);
3434 return Visitor.CheckType(RetT);
3451 auto RedeclIt = Redecls.begin();
3454 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3457 return ToRedeclOrErr.takeError();
3459 assert(*RedeclIt == D);
3467 return std::move(Err);
3482 if (!FoundFunctionOrErr)
3483 return FoundFunctionOrErr.takeError();
3484 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3485 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3487 FoundByLookup = FoundFunction;
3495 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3496 for (
auto *FoundDecl : FoundDecls) {
3500 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3505 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3507 FoundByLookup = FoundFunction;
3518 Importer.
ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3519 << Name << D->
getType() << FoundFunction->getType();
3520 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3521 << FoundFunction->getType();
3522 ConflictingDecls.push_back(FoundDecl);
3526 if (!ConflictingDecls.empty()) {
3528 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3530 Name = NameOrErr.get();
3532 return NameOrErr.takeError();
3542 if (FoundByLookup) {
3543 if (isa<CXXMethodDecl>(FoundByLookup)) {
3552 "Templated function mapped to non-templated?");
3568 return std::move(Err);
3579 bool UsedDifferentProtoType =
false;
3581 QualType FromReturnTy = FromFPT->getReturnType();
3589 UsedDifferentProtoType =
true;
3600 FromEPI = DefaultEPI;
3601 UsedDifferentProtoType =
true;
3604 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3609 Error Err = Error::success();
3616 auto TrailingRequiresClause =
3619 return std::move(Err);
3625 Parameters.push_back(*ToPOrErr);
3627 return ToPOrErr.takeError();
3632 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3634 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3636 return std::move(Err);
3638 if (FromConstructor->isInheritingConstructor()) {
3640 import(FromConstructor->getInheritedConstructor());
3641 if (!ImportedInheritedCtor)
3642 return ImportedInheritedCtor.takeError();
3643 ToInheritedConstructor = *ImportedInheritedCtor;
3645 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3646 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3647 ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->
UsesFPIntrin(),
3649 ToInheritedConstructor, TrailingRequiresClause))
3653 Error Err = Error::success();
3655 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3656 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3658 return std::move(Err);
3660 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3661 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3662 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3664 TrailingRequiresClause))
3671 dyn_cast<CXXConversionDecl>(D)) {
3673 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3675 return std::move(Err);
3676 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3677 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3678 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3682 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3683 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3684 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3685 ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3686 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3689 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3691 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3695 return std::move(Err);
3696 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3697 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart, ESpec,
3698 NameInfo, T, TInfo, ToEndLoc, Ctor))
3700 cast<CXXDeductionGuideDecl>(ToFunction)
3701 ->setIsCopyDeductionCandidate(Guide->isCopyDeductionCandidate());
3703 if (GetImportedOrCreateDecl(
3704 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart,
3712 if (FoundByLookup) {
3738 for (
auto *Param : Parameters) {
3739 Param->setOwningFunction(ToFunction);
3744 ToFunction->setParams(Parameters);
3751 for (
unsigned I = 0, N = Parameters.size(); I != N; ++I)
3752 ProtoLoc.setParam(I, Parameters[I]);
3758 auto ToFTOrErr =
import(FromFT);
3760 return ToFTOrErr.takeError();
3764 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3765 if (
unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3769 FromConstructor->inits(), CtorInitializers))
3770 return std::move(Err);
3773 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3774 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3775 ToCtor->setCtorInitializers(Memory);
3776 ToCtor->setNumCtorInitializers(NumInitializers);
3782 return std::move(Err);
3788 return std::move(Err);
3792 if (UsedDifferentProtoType) {
3794 ToFunction->
setType(*TyOrErr);
3796 return TyOrErr.takeError();
3800 return TSIOrErr.takeError();
3805 addDeclToContexts(D, ToFunction);
3807 if (
auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3810 return std::move(Err);
3813 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
3816 return ToRedeclOrErr.takeError();
3850 return std::move(Err);
3855 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3856 for (
auto *FoundDecl : FoundDecls) {
3857 if (
FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
3865 FoundField->getType())) {
3874 if (
ExpectedExpr ToInitializerOrErr =
import(FromInitializer)) {
3877 assert(FoundField->hasInClassInitializer() &&
3878 "Field should have an in-class initializer if it has an "
3879 "expression for it.");
3880 if (!FoundField->getInClassInitializer())
3881 FoundField->setInClassInitializer(*ToInitializerOrErr);
3883 return ToInitializerOrErr.takeError();
3890 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3891 << Name << D->
getType() << FoundField->getType();
3892 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3893 << FoundField->getType();
3899 Error Err = Error::success();
3906 return std::move(Err);
3907 const Type *ToCapturedVLAType =
nullptr;
3910 return std::move(Err);
3913 if (GetImportedOrCreateDecl(ToField, D, Importer.
getToContext(), DC,
3914 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3915 ToType, ToTInfo, ToBitWidth, D->
isMutable(),
3922 Err = Importer.ImportAttrs(ToField, D);
3924 return std::move(Err);
3930 if (ToCapturedVLAType)
3943 return std::move(Err);
3948 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3949 for (
unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3950 if (
auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3958 FoundField->getType(),
3965 if (!Name && I < N-1)
3969 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3970 << Name << D->
getType() << FoundField->getType();
3971 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3972 << FoundField->getType();
3979 auto TypeOrErr =
import(D->
getType());
3981 return TypeOrErr.takeError();
3987 for (
auto *PI : D->
chain())
3989 NamedChain[i++] = *ToD;
3991 return ToD.takeError();
3995 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.
getToContext(), DC,
3996 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
3998 return ToIndirectField;
4003 return ToIndirectField;
4017 llvm::function_ref<T(
const FriendDecl *)> GetCanTypeOrDecl) {
4018 unsigned int FriendCount = 0;
4019 std::optional<unsigned int> FriendPosition;
4022 T TypeOrDecl = GetCanTypeOrDecl(FD);
4024 for (
const FriendDecl *FoundFriend : RD->friends()) {
4025 if (FoundFriend == FD) {
4026 FriendPosition = FriendCount;
4028 }
else if (!FoundFriend->getFriendDecl() == !FD->
getFriendDecl() &&
4029 GetCanTypeOrDecl(FoundFriend) == TypeOrDecl) {
4034 assert(FriendPosition &&
"Friend decl not found in own parent.");
4036 return {FriendCount, *FriendPosition};
4041 return getFriendCountAndPosition<QualType>(FD, [](
const FriendDecl *F) {
4043 return TSI->getType().getCanonicalType();
4044 llvm_unreachable(
"Wrong friend object type.");
4047 return getFriendCountAndPosition<Decl *>(FD, [](
const FriendDecl *F) {
4050 llvm_unreachable(
"Wrong friend object type.");
4058 return std::move(Err);
4063 const auto *RD = cast<CXXRecordDecl>(DC);
4064 FriendDecl *ImportedFriend = RD->getFirstFriend();
4067 while (ImportedFriend) {
4079 ImportedEquivalentFriends.push_back(ImportedFriend);
4081 ImportedFriend = ImportedFriend->getNextFriend();
4085 assert(ImportedEquivalentFriends.size() <= CountAndPosition.
TotalCount &&
4086 "Class with non-matching friends is imported, ODR check wrong?");
4087 if (ImportedEquivalentFriends.size() == CountAndPosition.
TotalCount)
4089 D, ImportedEquivalentFriends[CountAndPosition.
IndexOfDecl]);
4096 if (
Error Err = importInto(ToFriendD, FriendD))
4097 return std::move(Err);
4108 return TSIOrErr.takeError();
4113 for (
unsigned I = 0; I < D->NumTPLists; I++) {
4114 if (
auto ListOrErr =
import(FromTPLists[I]))
4115 ToTPLists[I] = *ListOrErr;
4117 return ListOrErr.takeError();
4122 return LocationOrErr.takeError();
4124 if (!FriendLocOrErr)
4125 return FriendLocOrErr.takeError();
4128 if (GetImportedOrCreateDecl(FrD, D, Importer.
getToContext(), DC,
4129 *LocationOrErr, ToFU,
4130 *FriendLocOrErr, ToTPLists))
4146 return std::move(Err);
4151 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4152 for (
auto *FoundDecl : FoundDecls) {
4153 if (
ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
4155 FoundIvar->getType())) {
4160 Importer.
ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
4161 << Name << D->
getType() << FoundIvar->getType();
4162 Importer.
ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
4163 << FoundIvar->getType();
4169 Error Err = Error::success();
4175 return std::move(Err);
4178 if (GetImportedOrCreateDecl(
4179 ToIvar, D, Importer.
getToContext(), cast<ObjCContainerDecl>(DC),
4180 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
4181 ToType, ToTypeSourceInfo,
4193 auto RedeclIt = Redecls.begin();
4196 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4199 return RedeclOrErr.takeError();
4201 assert(*RedeclIt == D);
4209 return std::move(Err);
4215 VarDecl *FoundByLookup =
nullptr;
4219 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4220 for (
auto *FoundDecl : FoundDecls) {
4224 if (
auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4228 FoundVar->getType())) {
4240 const VarDecl *FoundDInit =
nullptr;
4241 if (D->
getInit() && FoundVar->getAnyInitializer(FoundDInit))
4245 FoundByLookup = FoundVar;
4253 if (FoundArray && TArray) {
4254 if (isa<IncompleteArrayType>(FoundArray) &&
4255 isa<ConstantArrayType>(TArray)) {
4257 if (
auto TyOrErr =
import(D->
getType()))
4258 FoundVar->setType(*TyOrErr);
4260 return TyOrErr.takeError();
4262 FoundByLookup = FoundVar;
4264 }
else if (isa<IncompleteArrayType>(TArray) &&
4265 isa<ConstantArrayType>(FoundArray)) {
4266 FoundByLookup = FoundVar;
4271 Importer.
ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
4272 << Name << D->
getType() << FoundVar->getType();
4273 Importer.
ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4274 << FoundVar->getType();
4275 ConflictingDecls.push_back(FoundDecl);
4279 if (!ConflictingDecls.empty()) {
4281 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4283 Name = NameOrErr.get();
4285 return NameOrErr.takeError();
4289 Error Err = Error::success();
4295 return std::move(Err);
4298 if (
auto *FromDecomp = dyn_cast<DecompositionDecl>(D)) {
4302 return std::move(Err);
4304 if (GetImportedOrCreateDecl(
4305 ToDecomp, FromDecomp, Importer.
getToContext(), DC, ToInnerLocStart,
4311 if (GetImportedOrCreateDecl(ToVar, D, Importer.
getToContext(), DC,
4312 ToInnerLocStart, Loc,
4313 Name.getAsIdentifierInfo(), ToType,
4323 if (FoundByLookup) {
4332 return ToVTOrErr.takeError();
4336 return std::move(Err);
4341 addDeclToContexts(D, ToVar);
4344 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4347 return RedeclOrErr.takeError();
4358 Error Err = Error::success();
4363 return std::move(Err);
4367 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4368 ToLocation, ToDeclName.getAsIdentifierInfo(),
4383 return ToDefArgOrErr.takeError();
4387 if (
auto ToDefArgOrErr =
import(FromParam->
getDefaultArg()))
4390 return ToDefArgOrErr.takeError();
4393 return Error::success();
4398 Error Err = Error::success();
4403 return std::move(Err);
4412 Error Err = Error::success();
4419 return std::move(Err);
4422 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4423 ToInnerLocStart, ToLocation,
4424 ToDeclName.getAsIdentifierInfo(), ToType,
4433 return std::move(Err);
4453 return std::move(Err);
4457 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4458 for (
auto *FoundDecl : FoundDecls) {
4459 if (
auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4465 FoundMethod->getReturnType())) {
4466 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4468 << FoundMethod->getReturnType();
4469 Importer.
ToDiag(FoundMethod->getLocation(),
4470 diag::note_odr_objc_method_here)
4477 if (D->
param_size() != FoundMethod->param_size()) {
4478 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4480 << D->
param_size() << FoundMethod->param_size();
4481 Importer.
ToDiag(FoundMethod->getLocation(),
4482 diag::note_odr_objc_method_here)
4490 PEnd = D->
param_end(), FoundP = FoundMethod->param_begin();
4491 P != PEnd; ++
P, ++FoundP) {
4493 (*FoundP)->getType())) {
4494 Importer.
FromDiag((*P)->getLocation(),
4495 diag::warn_odr_objc_method_param_type_inconsistent)
4497 << (*P)->getType() << (*FoundP)->getType();
4498 Importer.
ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4499 << (*FoundP)->getType();
4507 if (D->
isVariadic() != FoundMethod->isVariadic()) {
4508 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4510 Importer.
ToDiag(FoundMethod->getLocation(),
4511 diag::note_odr_objc_method_here)
4522 Error Err = Error::success();
4525 auto ToReturnTypeSourceInfo =
4528 return std::move(Err);
4531 if (GetImportedOrCreateDecl(
4533 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4546 ToParams.push_back(*ToPOrErr);
4548 return ToPOrErr.takeError();
4552 for (
auto *ToParam : ToParams) {
4553 ToParam->setOwningFunction(ToMethod);
4561 return std::move(Err);
4585 return std::move(Err);
4589 Error Err = Error::success();
4595 return std::move(Err);
4598 if (GetImportedOrCreateDecl(
4601 ToLocation, Name.getAsIdentifierInfo(),
4602 ToColonLoc, ToTypeSourceInfo))
4605 Result->setLexicalDeclContext(LexicalDC);
4616 return std::move(Err);
4622 return std::move(Err);
4630 Error Err = Error::success();
4636 return std::move(Err);
4638 if (GetImportedOrCreateDecl(ToCategory, D, Importer.
getToContext(), DC,
4641 Name.getAsIdentifierInfo(), ToInterface,
4654 return PListOrErr.takeError();
4663 FromProto != FromProtoEnd;
4664 ++FromProto, ++FromProtoLoc) {
4666 Protocols.push_back(*ToProtoOrErr);
4668 return ToProtoOrErr.takeError();
4670 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4671 ProtocolLocs.push_back(*ToProtoLocOrErr);
4673 return ToProtoLocOrErr.takeError();
4686 return std::move(Err);
4694 return ToImplOrErr.takeError();
4706 return Error::success();
4719 FromProto != FromProtoEnd;
4720 ++FromProto, ++FromProtoLoc) {
4722 Protocols.push_back(*ToProtoOrErr);
4724 return ToProtoOrErr.takeError();
4726 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4727 ProtocolLocs.push_back(*ToProtoLocOrErr);
4729 return ToProtoLocOrErr.takeError();
4742 return Error::success();
4752 return Importer.
MapImported(D, *ImportedDefOrErr);
4754 return ImportedDefOrErr.takeError();
4763 return std::move(Err);
4768 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4769 for (
auto *FoundDecl : FoundDecls) {
4773 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4780 if (!ToAtBeginLocOrErr)
4781 return ToAtBeginLocOrErr.takeError();
4783 if (GetImportedOrCreateDecl(ToProto, D, Importer.
getToContext(), DC,
4784 Name.getAsIdentifierInfo(), Loc,
4796 return std::move(Err);
4804 return std::move(Err);
4807 if (!ExternLocOrErr)
4808 return ExternLocOrErr.takeError();
4812 return LangLocOrErr.takeError();
4817 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.
getToContext(), DC,
4818 *ExternLocOrErr, *LangLocOrErr,
4820 return ToLinkageSpec;
4824 if (!RBraceLocOrErr)
4825 return RBraceLocOrErr.takeError();
4832 return ToLinkageSpec;
4843 return ToShadowOrErr.takeError();
4854 return std::move(Err);
4858 Error Err = Error::success();
4863 return std::move(Err);
4867 return std::move(Err);
4870 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
4871 ToUsingLoc, ToQualifierLoc, NameInfo,
4882 ToUsing, *ToPatternOrErr);
4884 return ToPatternOrErr.takeError();
4896 return std::move(Err);
4900 Error Err = Error::success();
4906 return std::move(Err);
4909 if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.
getToContext(), DC,
4910 ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType))
4922 return ToPatternOrErr.takeError();