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(
371#define TYPE(Class, Base) \
372 ExpectedType Visit##Class##Type(const Class##Type *T);
373#include "clang/AST/TypeNodes.inc"
431 template <
typename InContainerTy>
435 template<
typename InContainerTy>
442 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
459 template <
typename T>
463 bool IgnoreTemplateParmDepth =
false);
655 Err = MaybeVal.takeError();
661 template<
typename IIter,
typename OIter>
663 using ItemT = std::remove_reference_t<
decltype(*Obegin)>;
664 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
667 return ToOrErr.takeError();
670 return Error::success();
677 template<
typename InContainerTy,
typename OutContainerTy>
679 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
681 InContainer.begin(), InContainer.end(), OutContainer.begin());
684 template<
typename InContainerTy,
typename OIter>
701template <
typename InContainerTy>
705 auto ToLAngleLocOrErr =
import(FromLAngleLoc);
706 if (!ToLAngleLocOrErr)
707 return ToLAngleLocOrErr.takeError();
708 auto ToRAngleLocOrErr =
import(FromRAngleLoc);
709 if (!ToRAngleLocOrErr)
710 return ToRAngleLocOrErr.takeError();
716 return Error::success();
720Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
731 return ImportTemplateArgumentListInfo(
732 From.LAngleLoc, From.RAngleLoc, From.arguments(),
Result);
744 if (Error Err = importInto(std::get<0>(
Result), FTSInfo->getTemplate()))
745 return std::move(Err);
750 return std::move(Err);
760 return std::move(Err);
763 if (!ToRequiresClause)
764 return ToRequiresClause.takeError();
767 if (!ToTemplateLocOrErr)
768 return ToTemplateLocOrErr.takeError();
770 if (!ToLAngleLocOrErr)
771 return ToLAngleLocOrErr.takeError();
773 if (!ToRAngleLocOrErr)
774 return ToRAngleLocOrErr.takeError();
795 return ToTypeOrErr.takeError();
803 return ToTypeOrErr.takeError();
810 return ToOrErr.takeError();
813 return ToTypeOrErr.takeError();
814 return TemplateArgument(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()),
821 return ToTypeOrErr.takeError();
828 if (!ToTemplateOrErr)
829 return ToTemplateOrErr.takeError();
837 if (!ToTemplateOrErr)
838 return ToTemplateOrErr.takeError();
848 return ToExpr.takeError();
854 return std::move(Err);
861 llvm_unreachable(
"Invalid template argument kind");
869 return ArgOrErr.takeError();
878 return E.takeError();
884 return TSIOrErr.takeError();
886 auto ToTemplateQualifierLocOrErr =
888 if (!ToTemplateQualifierLocOrErr)
889 return ToTemplateQualifierLocOrErr.takeError();
891 if (!ToTemplateNameLocOrErr)
892 return ToTemplateNameLocOrErr.takeError();
893 auto ToTemplateEllipsisLocOrErr =
895 if (!ToTemplateEllipsisLocOrErr)
896 return ToTemplateEllipsisLocOrErr.takeError();
899 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
909 size_t NumDecls = DG.
end() - DG.
begin();
911 ToDecls.reserve(NumDecls);
912 for (
Decl *FromD : DG) {
913 if (
auto ToDOrErr =
import(FromD))
914 ToDecls.push_back(*ToDOrErr);
916 return ToDOrErr.takeError();
931 return ToDotLocOrErr.takeError();
934 if (!ToFieldLocOrErr)
935 return ToFieldLocOrErr.takeError();
938 ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
942 if (!ToLBracketLocOrErr)
943 return ToLBracketLocOrErr.takeError();
946 if (!ToRBracketLocOrErr)
947 return ToRBracketLocOrErr.takeError();
952 *ToRBracketLocOrErr);
955 if (!ToEllipsisLocOrErr)
956 return ToEllipsisLocOrErr.takeError();
961 *ToRBracketLocOrErr);
966 Error Err = Error::success();
969 auto ToConceptNameLoc =
975 return std::move(Err);
980 return std::move(Err);
998 return VarOrErr.takeError();
1003 return LocationOrErr.takeError();
1008 return std::move(Err);
1015template <
typename T>
1017 if (Found->getLinkageInternal() != From->getLinkageInternal())
1020 if (From->hasExternalFormalLinkage())
1021 return Found->hasExternalFormalLinkage();
1024 if (From->isInAnonymousNamespace())
1025 return Found->isInAnonymousNamespace();
1027 return !Found->isInAnonymousNamespace() &&
1028 !Found->hasExternalFormalLinkage();
1048using namespace clang;
1058 if (!UnderlyingTypeOrErr)
1059 return UnderlyingTypeOrErr.takeError();
1066#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1067 case BuiltinType::Id: \
1068 return Importer.getToContext().SingletonId;
1069#include "clang/Basic/OpenCLImageTypes.def"
1070#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1071 case BuiltinType::Id: \
1072 return Importer.getToContext().Id##Ty;
1073#include "clang/Basic/OpenCLExtensionTypes.def"
1074#define SVE_TYPE(Name, Id, SingletonId) \
1075 case BuiltinType::Id: \
1076 return Importer.getToContext().SingletonId;
1077#include "clang/Basic/AArch64SVEACLETypes.def"
1078#define PPC_VECTOR_TYPE(Name, Id, Size) \
1079 case BuiltinType::Id: \
1080 return Importer.getToContext().Id##Ty;
1081#include "clang/Basic/PPCTypes.def"
1082#define RVV_TYPE(Name, Id, SingletonId) \
1083 case BuiltinType::Id: \
1084 return Importer.getToContext().SingletonId;
1085#include "clang/Basic/RISCVVTypes.def"
1086#define WASM_TYPE(Name, Id, SingletonId) \
1087 case BuiltinType::Id: \
1088 return Importer.getToContext().SingletonId;
1089#include "clang/Basic/WebAssemblyReferenceTypes.def"
1090#define SHARED_SINGLETON_TYPE(Expansion)
1091#define BUILTIN_TYPE(Id, SingletonId) \
1092 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1093#include "clang/AST/BuiltinTypes.def"
1101 case BuiltinType::Char_U:
1110 case BuiltinType::Char_S:
1119 case BuiltinType::WChar_S:
1120 case BuiltinType::WChar_U:
1126 llvm_unreachable(
"Invalid BuiltinType Kind!");
1131 if (!ToOriginalTypeOrErr)
1132 return ToOriginalTypeOrErr.takeError();
1139 if (!ToElementTypeOrErr)
1140 return ToElementTypeOrErr.takeError();
1147 if (!ToPointeeTypeOrErr)
1148 return ToPointeeTypeOrErr.takeError();
1156 if (!ToPointeeTypeOrErr)
1157 return ToPointeeTypeOrErr.takeError();
1166 if (!ToPointeeTypeOrErr)
1167 return ToPointeeTypeOrErr.takeError();
1176 if (!ToPointeeTypeOrErr)
1177 return ToPointeeTypeOrErr.takeError();
1186 if (!ToPointeeTypeOrErr)
1187 return ToPointeeTypeOrErr.takeError();
1190 if (!ClassTypeOrErr)
1191 return ClassTypeOrErr.takeError();
1199 Error Err = Error::success();
1203 return std::move(Err);
1213 if (!ToElementTypeOrErr)
1214 return ToElementTypeOrErr.takeError();
1223 Error Err = Error::success();
1228 return std::move(Err);
1234ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1236 Error Err = Error::success();
1241 return std::move(Err);
1250ExpectedType ASTNodeImporter::VisitDependentSizedExtVectorType(
1252 Error Err = Error::success();
1257 return std::move(Err);
1259 ToElementType, ToSizeExpr, ToAttrLoc);
1264 if (!ToElementTypeOrErr)
1265 return ToElementTypeOrErr.takeError();
1274 if (!ToElementTypeOrErr)
1275 return ToElementTypeOrErr.takeError();
1286 if (!ToReturnTypeOrErr)
1287 return ToReturnTypeOrErr.takeError();
1296 if (!ToReturnTypeOrErr)
1297 return ToReturnTypeOrErr.takeError();
1304 return TyOrErr.takeError();
1305 ArgTypes.push_back(*TyOrErr);
1313 return TyOrErr.takeError();
1314 ExceptionTypes.push_back(*TyOrErr);
1318 Error Err = Error::success();
1335 return std::move(Err);
1338 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1343 Error Err = Error::success();
1347 return std::move(Err);
1350 ToD, cast_or_null<TypeDecl>(ToPrevD));
1355 if (!ToInnerTypeOrErr)
1356 return ToInnerTypeOrErr.takeError();
1364 return ToDeclOrErr.takeError();
1371 if (!ToUnderlyingTypeOrErr)
1372 return ToUnderlyingTypeOrErr.takeError();
1380 return ToExprOrErr.takeError();
1386 if (!ToUnderlyingTypeOrErr)
1387 return ToUnderlyingTypeOrErr.takeError();
1395 return FoundOrErr.takeError();
1397 if (!UnderlyingOrErr)
1398 return UnderlyingOrErr.takeError();
1407 return ToExprOrErr.takeError();
1410 if (!ToUnderlyingTypeOrErr)
1411 return ToUnderlyingTypeOrErr.takeError();
1414 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1420 if (!ToBaseTypeOrErr)
1421 return ToBaseTypeOrErr.takeError();
1424 if (!ToUnderlyingTypeOrErr)
1425 return ToUnderlyingTypeOrErr.takeError();
1428 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->
getUTTKind());
1434 if (!ToDeducedTypeOrErr)
1435 return ToDeducedTypeOrErr.takeError();
1438 if (!ToTypeConstraintConcept)
1439 return ToTypeConstraintConcept.takeError();
1444 return std::move(Err);
1448 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1452ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1456 if (!ToTemplateNameOrErr)
1457 return ToTemplateNameOrErr.takeError();
1459 if (!ToDeducedTypeOrErr)
1460 return ToDeducedTypeOrErr.takeError();
1466ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1470 return ToDeclOrErr.takeError();
1474 const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
1475 assert(Ty && isa<InjectedClassNameType>(Ty));
1482 return ToDeclOrErr.takeError();
1490 return ToDeclOrErr.takeError();
1497 if (!ToModifiedTypeOrErr)
1498 return ToModifiedTypeOrErr.takeError();
1500 if (!ToEquivalentTypeOrErr)
1501 return ToEquivalentTypeOrErr.takeError();
1504 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1507ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1511 return ToDeclOrErr.takeError();
1517ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1521 return ReplacedOrErr.takeError();
1524 if (!ToReplacementTypeOrErr)
1525 return ToReplacementTypeOrErr.takeError();
1528 *ToReplacementTypeOrErr, *ReplacedOrErr, T->
getIndex(),
1532ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1536 return ReplacedOrErr.takeError();
1539 if (!ToArgumentPack)
1540 return ToArgumentPack.takeError();
1546ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1549 if (!ToTemplateOrErr)
1550 return ToTemplateOrErr.takeError();
1555 return std::move(Err);
1562 ToCanonType = *TyOrErr;
1564 return TyOrErr.takeError();
1574 if (!ToQualifierOrErr)
1575 return ToQualifierOrErr.takeError();
1578 if (!ToNamedTypeOrErr)
1579 return ToNamedTypeOrErr.takeError();
1582 if (!ToOwnedTagDeclOrErr)
1583 return ToOwnedTagDeclOrErr.takeError();
1588 *ToOwnedTagDeclOrErr);
1594 if (!ToPatternOrErr)
1595 return ToPatternOrErr.takeError();
1602ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1605 if (!ToQualifierOrErr)
1606 return ToQualifierOrErr.takeError();
1613 return std::move(Err);
1616 T->
getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1622 if (!ToQualifierOrErr)
1623 return ToQualifierOrErr.takeError();
1632 return TyOrErr.takeError();
1644 return ToDeclOrErr.takeError();
1651 if (!ToBaseTypeOrErr)
1652 return ToBaseTypeOrErr.takeError();
1657 TypeArgs.push_back(*TyOrErr);
1659 return TyOrErr.takeError();
1663 for (
auto *
P : T->
quals()) {
1665 Protocols.push_back(*ProtocolOrErr);
1667 return ProtocolOrErr.takeError();
1679 if (!ToPointeeTypeOrErr)
1680 return ToPointeeTypeOrErr.takeError();
1688 if (!ToUnderlyingTypeOrErr)
1689 return ToUnderlyingTypeOrErr.takeError();
1697 Error Err = Error::success();
1701 return std::move(Err);
1703 return Importer.getToContext().getAdjustedType(ToOriginalType,
1708 return Importer.getToContext().getBitIntType(T->
isUnsigned(),
1712ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType(
1714 Error Err = Error::success();
1715 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err, T->
getAttr());
1718 return std::move(Err);
1720 return Importer.getToContext().getBTFTagAttributedType(ToBTFAttr,
1724ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType(
1727 if (!ToElementTypeOrErr)
1728 return ToElementTypeOrErr.takeError();
1730 return Importer.getToContext().getConstantMatrixType(
1734ExpectedType clang::ASTNodeImporter::VisitDependentAddressSpaceType(
1736 Error Err = Error::success();
1741 return std::move(Err);
1743 return Importer.getToContext().getDependentAddressSpaceType(
1744 ToPointeeType, ToAddrSpaceExpr, ToAttrLoc);
1747ExpectedType clang::ASTNodeImporter::VisitDependentBitIntType(
1750 if (!ToNumBitsExprOrErr)
1751 return ToNumBitsExprOrErr.takeError();
1752 return Importer.getToContext().getDependentBitIntType(T->
isUnsigned(),
1753 *ToNumBitsExprOrErr);
1756ExpectedType clang::ASTNodeImporter::VisitDependentSizedMatrixType(
1758 Error Err = Error::success();
1764 return std::move(Err);
1766 return Importer.getToContext().getDependentSizedMatrixType(
1767 ToElementType, ToRowExpr, ToColumnExpr, ToAttrLoc);
1770ExpectedType clang::ASTNodeImporter::VisitDependentVectorType(
1772 Error Err = Error::success();
1777 return std::move(Err);
1779 return Importer.getToContext().getDependentVectorType(
1783ExpectedType clang::ASTNodeImporter::VisitObjCTypeParamType(
1787 return ToDeclOrErr.takeError();
1792 if (!ToProtocolOrErr)
1793 return ToProtocolOrErr.takeError();
1794 ToProtocols.push_back(*ToProtocolOrErr);
1797 return Importer.getToContext().getObjCTypeParamType(*ToDeclOrErr,
1803 if (!ToElementTypeOrErr)
1804 return ToElementTypeOrErr.takeError();
1827 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1829 auto getLeafPointeeType = [](
const Type *T) {
1837 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1838 auto *RT = dyn_cast<RecordType>(LeafT);
1839 if (RT && RT->getDecl() == D) {
1852 if (Error Err = importInto(Name, D->
getDeclName()))
1856 if (Error Err = importInto(Loc, D->
getLocation()))
1864 return Error::success();
1871 if (Error Err = importInto(Name, D->
getDeclName()))
1875 if (Error Err = importInto(Loc, D->
getLocation()))
1883 return Error::success();
1888 return Error::success();
1891 if (Error Err = importInto(ToD, FromD))
1894 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1895 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1896 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1897 !ToRecord->getDefinition()) {
1902 return Error::success();
1905 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1906 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1907 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1912 return Error::success();
1915 return Error::success();
1930 return Error::success();
1936 return ToRangeOrErr.takeError();
1937 return Error::success();
1943 return LocOrErr.takeError();
1944 return Error::success();
1952 return ToTInfoOrErr.takeError();
1953 return Error::success();
1956 llvm_unreachable(
"Unknown name kind.");
1963 return ToDCOrErr.takeError();
1977 auto MightNeedReordering = [](
const Decl *D) {
1978 return isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D);
1982 Error ChildErrors = Error::success();
1983 for (
auto *From : FromDC->
decls()) {
1984 if (!MightNeedReordering(From))
1993 if (!ImportedOrErr) {
1995 ImportedOrErr.takeError());
1998 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
1999 Decl *ImportedDecl = *ImportedOrErr;
2000 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
2001 if (FieldFrom && FieldTo) {
2033 consumeError(std::move(ChildErrors));
2034 return ToDCOrErr.takeError();
2040 for (
auto *D : FromDC->
decls()) {
2041 if (!MightNeedReordering(D))
2044 assert(D &&
"DC contains a null decl");
2047 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->
containsDecl(ToD));
2058 for (
auto *From : FromDC->
decls()) {
2059 if (MightNeedReordering(From))
2065 ImportedOrErr.takeError());
2085 if (!FromRecordDecl || !ToRecordDecl) {
2089 if (RecordFrom && RecordTo) {
2090 FromRecordDecl = RecordFrom->
getDecl();
2091 ToRecordDecl = RecordTo->getDecl();
2095 if (FromRecordDecl && ToRecordDecl) {
2101 return Error::success();
2108 return ToDCOrErr.takeError();
2114 if (!ToLexicalDCOrErr)
2115 return ToLexicalDCOrErr.takeError();
2116 ToLexicalDC = *ToLexicalDCOrErr;
2120 return Error::success();
2126 "Import implicit methods to or from non-definition");
2129 if (FromM->isImplicit()) {
2132 return ToMOrErr.takeError();
2135 return Error::success();
2144 return ToTypedefOrErr.takeError();
2146 return Error::success();
2151 auto DefinitionCompleter = [To]() {
2170 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2172 ToCaptures.reserve(FromCXXRD->capture_size());
2173 for (
const auto &FromCapture : FromCXXRD->captures()) {
2174 if (
auto ToCaptureOrErr =
import(FromCapture))
2175 ToCaptures.push_back(*ToCaptureOrErr);
2177 return ToCaptureOrErr.takeError();
2179 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2186 DefinitionCompleter();
2190 return Error::success();
2205 auto DefinitionCompleterScopeExit =
2206 llvm::make_scope_exit(DefinitionCompleter);
2212 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2213 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2214 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2216 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2217 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2219 #define FIELD(Name, Width, Merge) \
2220 ToData.Name = FromData.Name;
2221 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2224 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2227 for (
const auto &Base1 : FromCXX->bases()) {
2230 return TyOrErr.takeError();
2233 if (Base1.isPackExpansion()) {
2234 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2235 EllipsisLoc = *LocOrErr;
2237 return LocOrErr.takeError();
2245 auto RangeOrErr =
import(Base1.getSourceRange());
2247 return RangeOrErr.takeError();
2249 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2251 return TSIOrErr.takeError();
2257 Base1.isBaseOfClass(),
2258 Base1.getAccessSpecifierAsWritten(),
2263 ToCXX->setBases(Bases.data(), Bases.size());
2271 return Error::success();
2276 return Error::success();
2280 return Error::success();
2284 return ToInitOrErr.takeError();
2295 return Error::success();
2303 return Error::success();
2314 return ToTypeOrErr.takeError();
2317 if (!ToPromotionTypeOrErr)
2318 return ToPromotionTypeOrErr.takeError();
2329 return Error::success();
2335 for (
const auto &Arg : FromArgs) {
2336 if (
auto ToOrErr =
import(Arg))
2337 ToArgs.push_back(*ToOrErr);
2339 return ToOrErr.takeError();
2342 return Error::success();
2348 return import(From);
2351template <
typename InContainerTy>
2354 for (
const auto &FromLoc : Container) {
2355 if (
auto ToLocOrErr =
import(FromLoc))
2358 return ToLocOrErr.takeError();
2360 return Error::success();
2370 bool IgnoreTemplateParmDepth) {
2381 false, Complain,
false,
2382 IgnoreTemplateParmDepth);
2402 return std::move(Err);
2407 return LocOrErr.takeError();
2410 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, *LocOrErr))
2433 return std::move(Err);
2438 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, Loc,
2439 Name.getAsIdentifierInfo()))
2442 Error Err = Error::success();
2447 return std::move(Err);
2451 addDeclToContexts(D, ToD);
2459 return LocOrErr.takeError();
2462 return ColonLocOrErr.takeError();
2467 return DCOrErr.takeError();
2472 DC, *LocOrErr, *ColonLocOrErr))
2486 return DCOrErr.takeError();
2490 Error Err = Error::success();
2496 return std::move(Err);
2499 if (GetImportedOrCreateDecl(
2500 ToD, D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2516 return std::move(Err);
2525 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2531 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2532 for (
auto *FoundDecl : FoundDecls) {
2536 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2537 MergeWithNamespace = FoundNS;
2538 ConflictingDecls.clear();
2542 ConflictingDecls.push_back(FoundDecl);
2545 if (!ConflictingDecls.empty()) {
2548 ConflictingDecls.size());
2550 Name = NameOrErr.get();
2552 return NameOrErr.takeError();
2558 return BeginLocOrErr.takeError();
2560 if (!RBraceLocOrErr)
2561 return RBraceLocOrErr.takeError();
2566 if (GetImportedOrCreateDecl(ToNamespace, D, Importer.
getToContext(), DC,
2567 D->
isInline(), *BeginLocOrErr, Loc,
2568 Name.getAsIdentifierInfo(),
2578 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2579 TU->setAnonymousNamespace(ToNamespace);
2581 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2587 return std::move(Err);
2598 if (Error Err =
ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
2599 return std::move(Err);
2605 Error Err = Error::success();
2612 return std::move(Err);
2617 if (GetImportedOrCreateDecl(
2618 ToD, D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2619 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2637 return std::move(Err);
2656 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2657 for (
auto *FoundDecl : FoundDecls) {
2660 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2665 QualType FoundUT = FoundTypedef->getUnderlyingType();
2679 if (FromR && FoundR &&
2690 ConflictingDecls.push_back(FoundDecl);
2695 if (!ConflictingDecls.empty()) {
2697 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2699 Name = NameOrErr.get();
2701 return NameOrErr.takeError();
2705 Error Err = Error::success();
2710 return std::move(Err);
2717 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2718 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2719 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2721 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2722 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2723 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2728 return std::move(Err);
2732 Importer.AddToLookupTable(ToTypedef);
2737 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) :
nullptr;
2760 return std::move(Err);
2770 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2771 for (
auto *FoundDecl : FoundDecls) {
2774 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
2776 ConflictingDecls.push_back(FoundDecl);
2779 if (!ConflictingDecls.empty()) {
2781 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2783 Name = NameOrErr.get();
2785 return NameOrErr.takeError();
2789 Error Err = Error::success();
2793 return std::move(Err);
2796 if (GetImportedOrCreateDecl(ToAlias, D, Importer.
getToContext(), DC, Loc,
2797 Name, ToTemplateParameters, ToTemplatedDecl))
2800 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2806 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2817 return std::move(Err);
2827 return BeginLocOrErr.takeError();
2828 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2829 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2833 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2834 Name.getAsIdentifierInfo()))
2841 return ToStmtOrErr.takeError();
2843 ToLabel->
setStmt(*ToStmtOrErr);
2856 return std::move(Err);
2864 if (Error Err = importInto(
2866 return std::move(Err);
2876 Importer.findDeclsInToCtx(DC, SearchName);
2877 for (
auto *FoundDecl : FoundDecls) {
2881 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2882 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2883 FoundDecl = Tag->getDecl();
2886 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2896 ConflictingDecls.push_back(FoundDecl);
2900 if (!ConflictingDecls.empty()) {
2902 SearchName, DC, IDNS, ConflictingDecls.data(),
2903 ConflictingDecls.size());
2905 Name = NameOrErr.get();
2907 return NameOrErr.takeError();
2911 Error Err = Error::success();
2917 return std::move(Err);
2921 if (GetImportedOrCreateDecl(
2923 Loc, Name.getAsIdentifierInfo(), PrevDecl, D->
isScoped(),
2932 addDeclToContexts(D, D2);
2938 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
2940 return ToInstOrErr.takeError();
2941 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
2944 return POIOrErr.takeError();
2950 return std::move(Err);
2956 bool IsFriendTemplate =
false;
2957 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2959 DCXX->getDescribedClassTemplate() &&
2960 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2970 return std::move(Err);
2978 if (Error Err = importInto(
2980 return std::move(Err);
2987 bool DependentFriend = IsFriendTemplate && IsDependentContext;
2994 Importer.findDeclsInToCtx(DC, SearchName);
2995 if (!FoundDecls.empty()) {
3002 for (
auto *FoundDecl : FoundDecls) {
3006 Decl *Found = FoundDecl;
3007 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
3008 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
3009 Found = Tag->getDecl();
3012 if (
auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
3035 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
3036 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
3037 assert(FoundCXX &&
"Record type mismatch");
3043 return std::move(Err);
3049 ConflictingDecls.push_back(FoundDecl);
3053 if (!ConflictingDecls.empty() && SearchName) {
3055 SearchName, DC, IDNS, ConflictingDecls.data(),
3056 ConflictingDecls.size());
3058 Name = NameOrErr.get();
3060 return NameOrErr.takeError();
3066 return BeginLocOrErr.takeError();
3071 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
3072 if (DCXX->isLambda()) {
3073 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
3075 return TInfoOrErr.takeError();
3076 if (GetImportedOrCreateSpecialDecl(
3078 DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
3079 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
3084 return CDeclOrErr.takeError();
3087 }
else if (DCXX->isInjectedClassName()) {
3090 const bool DelayTypeCreation =
true;
3091 if (GetImportedOrCreateDecl(
3093 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
3094 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
3097 D2CXX, dyn_cast<CXXRecordDecl>(DC));
3099 if (GetImportedOrCreateDecl(D2CXX, D, Importer.
getToContext(),
3101 Name.getAsIdentifierInfo(),
3102 cast_or_null<CXXRecordDecl>(PrevDecl)))
3109 addDeclToContexts(D, D2);
3112 DCXX->getDescribedClassTemplate()) {
3114 if (Error Err = importInto(ToDescribed, FromDescribed))
3115 return std::move(Err);
3117 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
3124 auto *Record = dyn_cast<CXXRecordDecl>(Found);
3125 if (Record && Record->isInjectedClassName()) {
3137 const Type *FrontTy =
3138 cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
3141 InjSpec = InjTy->getInjectedSpecializationType();
3144 for (
auto *R : Redecls) {
3145 auto *RI = cast<CXXRecordDecl>(R);
3146 if (R != Redecls.front() ||
3147 !isa<InjectedClassNameType>(RI->getTypeForDecl()))
3148 RI->setTypeForDecl(
nullptr);
3163 DCXX->getMemberSpecializationInfo()) {
3165 MemberInfo->getTemplateSpecializationKind();
3171 return ToInstOrErr.takeError();
3174 import(MemberInfo->getPointOfInstantiation()))
3178 return POIOrErr.takeError();
3182 if (GetImportedOrCreateDecl(D2, D, Importer.
getToContext(),
3184 Name.getAsIdentifierInfo(), PrevDecl))
3187 addDeclToContexts(D, D2);
3193 return BraceRangeOrErr.takeError();
3197 return QualifierLocOrErr.takeError();
3204 return std::move(Err);
3216 return std::move(Err);
3225 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3226 for (
auto *FoundDecl : FoundDecls) {
3230 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3232 return Importer.
MapImported(D, FoundEnumConstant);
3233 ConflictingDecls.push_back(FoundDecl);
3237 if (!ConflictingDecls.empty()) {
3239 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3241 Name = NameOrErr.get();
3243 return NameOrErr.takeError();
3249 return TypeOrErr.takeError();
3253 return InitOrErr.takeError();
3256 if (GetImportedOrCreateDecl(
3257 ToEnumerator, D, Importer.
getToContext(), cast<EnumDecl>(DC), Loc,
3258 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->
getInitVal()))
3259 return ToEnumerator;
3264 return ToEnumerator;
3271 return Error::success();
3273 for (
unsigned int I = 0; I < Num; ++I)
3276 ToTPLists[I] = *ToTPListOrErr;
3278 return ToTPListOrErr.takeError();
3280 return Error::success();
3288 return Error::success();
3294 return Error::success();
3300 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3302 return InstFDOrErr.takeError();
3308 return POIOrErr.takeError();
3310 return Error::success();
3314 auto FunctionAndArgsOrErr =
3316 if (!FunctionAndArgsOrErr)
3317 return FunctionAndArgsOrErr.takeError();
3320 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3324 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3325 if (FromTAArgsAsWritten)
3327 *FromTAArgsAsWritten, ToTAInfo))
3330 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3332 return POIOrErr.takeError();
3338 ToFD->setFunctionTemplateSpecialization(
3339 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3340 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3341 return Error::success();
3349 Candidates.
addDecl(*ToFTDOrErr);
3351 return ToFTDOrErr.takeError();
3356 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3357 if (FromTAArgsAsWritten)
3364 FromTAArgsAsWritten ? &ToTAInfo :
nullptr);
3365 return Error::success();
3368 llvm_unreachable(
"All cases should be covered!");
3373 auto FunctionAndArgsOrErr =
3375 if (!FunctionAndArgsOrErr)
3376 return FunctionAndArgsOrErr.takeError();
3380 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3381 void *InsertPos =
nullptr;
3392 return ToBodyOrErr.takeError();
3394 return Error::success();
3400 const DeclContext *DCi = dyn_cast<DeclContext>(D);
3403 assert(DCi &&
"Declaration should have a context");
3417 ToProcess.push_back(S);
3418 while (!ToProcess.empty()) {
3419 const Stmt *CurrentS = ToProcess.pop_back_val();
3421 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS))
3422 if (
const Decl *D = DeclRef->getDecl())
3454class IsTypeDeclaredInsideVisitor
3455 :
public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3457 IsTypeDeclaredInsideVisitor(
const FunctionDecl *ParentDC)
3458 : ParentDC(ParentDC) {}
3464 if (std::optional<bool> Res = Visit(T.
getTypePtr()))
3469 if (std::optional<bool> Res = Visit(DsT.
getTypePtr()))
3477 std::optional<bool> VisitTagType(
const TagType *T) {
3478 if (
auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(T->
getDecl()))
3479 for (
const auto &Arg : Spec->getTemplateArgs().asArray())
3480 if (checkTemplateArgument(Arg))
3485 std::optional<bool> VisitPointerType(
const PointerType *T) {
3489 std::optional<bool> VisitReferenceType(
const ReferenceType *T) {
3493 std::optional<bool> VisitTypedefType(
const TypedefType *T) {
3499 std::optional<bool> VisitUsingType(
const UsingType *T) {
3510 if (checkTemplateArgument(Arg))
3533 "Variable array should not occur in deduced return type of a function");
3537 llvm_unreachable(
"Incomplete array should not occur in deduced return type "
3542 llvm_unreachable(
"Dependent array should not occur in deduced return type "
3567 if (checkTemplateArgument(PackArg))
3579 llvm_unreachable(
"Unknown TemplateArgument::ArgKind enum");
3589 assert(FromFPT &&
"Must be called on FunctionProtoType");
3591 QualType RetT = FromFPT->getReturnType();
3594 IsTypeDeclaredInsideVisitor Visitor(Def ? Def : D);
3595 return Visitor.CheckType(RetT);
3612 auto RedeclIt = Redecls.begin();
3615 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3618 return ToRedeclOrErr.takeError();
3620 assert(*RedeclIt == D);
3628 return std::move(Err);
3643 if (!FoundFunctionOrErr)
3644 return FoundFunctionOrErr.takeError();
3645 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3646 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3648 FoundByLookup = FoundFunction;
3656 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3657 for (
auto *FoundDecl : FoundDecls) {
3661 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3666 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3668 FoundByLookup = FoundFunction;
3679 Importer.
ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3680 << Name << D->
getType() << FoundFunction->getType();
3681 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3682 << FoundFunction->getType();
3683 ConflictingDecls.push_back(FoundDecl);
3687 if (!ConflictingDecls.empty()) {
3689 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3691 Name = NameOrErr.get();
3693 return NameOrErr.takeError();
3703 if (FoundByLookup) {
3704 if (isa<CXXMethodDecl>(FoundByLookup)) {
3713 "Templated function mapped to non-templated?");
3729 return std::move(Err);
3740 bool UsedDifferentProtoType =
false;
3742 QualType FromReturnTy = FromFPT->getReturnType();
3750 UsedDifferentProtoType =
true;
3761 FromEPI = DefaultEPI;
3762 UsedDifferentProtoType =
true;
3765 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3770 Error Err = Error::success();
3777 auto TrailingRequiresClause =
3780 return std::move(Err);
3786 Parameters.push_back(*ToPOrErr);
3788 return ToPOrErr.takeError();
3793 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3795 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3797 return std::move(Err);
3799 if (FromConstructor->isInheritingConstructor()) {
3801 import(FromConstructor->getInheritedConstructor());
3802 if (!ImportedInheritedCtor)
3803 return ImportedInheritedCtor.takeError();
3804 ToInheritedConstructor = *ImportedInheritedCtor;
3806 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3807 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3808 ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->
UsesFPIntrin(),
3810 ToInheritedConstructor, TrailingRequiresClause))
3814 Error Err = Error::success();
3816 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3817 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3819 return std::move(Err);
3821 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3822 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3823 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3825 TrailingRequiresClause))
3832 dyn_cast<CXXConversionDecl>(D)) {
3834 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3836 return std::move(Err);
3837 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3838 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3839 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3843 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3844 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3845 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3846 ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3847 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3850 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3852 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3856 return std::move(Err);
3857 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3858 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart, ESpec,
3859 NameInfo, T, TInfo, ToEndLoc, Ctor))
3861 cast<CXXDeductionGuideDecl>(ToFunction)
3862 ->setDeductionCandidateKind(Guide->getDeductionCandidateKind());
3864 if (GetImportedOrCreateDecl(
3865 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart,
3873 if (FoundByLookup) {
3899 for (
auto *Param : Parameters) {
3900 Param->setOwningFunction(ToFunction);
3905 ToFunction->setParams(Parameters);
3912 for (
unsigned I = 0, N = Parameters.size(); I != N; ++I)
3913 ProtoLoc.setParam(I, Parameters[I]);
3919 auto ToFTOrErr =
import(FromFT);
3921 return ToFTOrErr.takeError();
3925 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3926 if (
unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3930 FromConstructor->inits(), CtorInitializers))
3931 return std::move(Err);
3934 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3935 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3936 ToCtor->setCtorInitializers(Memory);
3937 ToCtor->setNumCtorInitializers(NumInitializers);
3943 return std::move(Err);
3945 if (
auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3948 return std::move(Err);
3954 return std::move(Err);
3958 if (UsedDifferentProtoType) {
3960 ToFunction->
setType(*TyOrErr);
3962 return TyOrErr.takeError();
3966 return TSIOrErr.takeError();
3971 addDeclToContexts(D, ToFunction);
3974 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
3977 return ToRedeclOrErr.takeError();
4011 return std::move(Err);
4016 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4017 for (
auto *FoundDecl : FoundDecls) {
4018 if (
FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
4026 FoundField->getType())) {
4035 if (
ExpectedExpr ToInitializerOrErr =
import(FromInitializer)) {
4038 assert(FoundField->hasInClassInitializer() &&
4039 "Field should have an in-class initializer if it has an "
4040 "expression for it.");
4041 if (!FoundField->getInClassInitializer())
4042 FoundField->setInClassInitializer(*ToInitializerOrErr);
4044 return ToInitializerOrErr.takeError();
4051 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
4052 << Name << D->
getType() << FoundField->getType();
4053 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4054 << FoundField->getType();
4060 Error Err = Error::success();
4066 return std::move(Err);
4067 const Type *ToCapturedVLAType =
nullptr;
4070 return std::move(Err);
4073 if (GetImportedOrCreateDecl(ToField, D, Importer.
getToContext(), DC,
4074 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
4075 ToType, ToTInfo, ToBitWidth, D->
isMutable(),
4082 Err = Importer.ImportAttrs(ToField, D);
4084 return std::move(Err);
4088 if (ToCapturedVLAType)
4095 return std::move(Err);
4096 if (ToInitializer) {
4098 if (AlreadyImported)
4099 assert(ToInitializer == AlreadyImported &&
4100 "Duplicate import of in-class initializer.");
4115 return std::move(Err);
4120 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4121 for (
unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4122 if (
auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
4130 FoundField->getType(),
4137 if (!Name && I < N-1)
4141 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
4142 << Name << D->
getType() << FoundField->getType();
4143 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4144 << FoundField->getType();
4151 auto TypeOrErr =
import(D->
getType());
4153 return TypeOrErr.takeError();
4159 for (
auto *PI : D->
chain())
4161 NamedChain[i++] = *ToD;
4163 return ToD.takeError();
4167 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.
getToContext(), DC,
4168 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
4170 return ToIndirectField;
4175 return ToIndirectField;
4205 unsigned int FriendCount = 0;
4206 std::optional<unsigned int> FriendPosition;
4209 for (
FriendDecl *FoundFriend : RD->friends()) {
4210 if (FoundFriend == FD) {
4211 FriendPosition = FriendCount;
4218 assert(FriendPosition &&
"Friend decl not found in own parent.");
4220 return {FriendCount, *FriendPosition};
4227 return std::move(Err);
4232 const auto *RD = cast<CXXRecordDecl>(DC);
4234 for (
FriendDecl *ImportedFriend : RD->friends())
4236 ImportedEquivalentFriends.push_back(ImportedFriend);
4241 assert(ImportedEquivalentFriends.size() <= CountAndPosition.
TotalCount &&
4242 "Class with non-matching friends is imported, ODR check wrong?");
4243 if (ImportedEquivalentFriends.size() == CountAndPosition.
TotalCount)
4245 D, ImportedEquivalentFriends[CountAndPosition.
IndexOfDecl]);
4252 if (Error Err = importInto(ToFriendD, FriendD))
4253 return std::move(Err);
4264 return TSIOrErr.takeError();
4269 for (
unsigned I = 0; I < D->NumTPLists; I++) {
4270 if (
auto ListOrErr =
import(FromTPLists[I]))
4271 ToTPLists[I] = *ListOrErr;
4273 return ListOrErr.takeError();
4278 return LocationOrErr.takeError();
4280 if (!FriendLocOrErr)
4281 return FriendLocOrErr.takeError();
4284 if (GetImportedOrCreateDecl(FrD, D, Importer.
getToContext(), DC,
4285 *LocationOrErr, ToFU,
4286 *FriendLocOrErr, ToTPLists))
4302 return std::move(Err);
4307 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4308 for (
auto *FoundDecl : FoundDecls) {
4309 if (
ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
4311 FoundIvar->getType())) {
4316 Importer.
ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
4317 << Name << D->
getType() << FoundIvar->getType();
4318 Importer.
ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
4319 << FoundIvar->getType();
4325 Error Err = Error::success();
4331 return std::move(Err);
4334 if (GetImportedOrCreateDecl(
4335 ToIvar, D, Importer.
getToContext(), cast<ObjCContainerDecl>(DC),
4336 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
4337 ToType, ToTypeSourceInfo,
4349 auto RedeclIt = Redecls.begin();
4352 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4355 return RedeclOrErr.takeError();
4357 assert(*RedeclIt == D);
4365 return std::move(Err);
4371 VarDecl *FoundByLookup =
nullptr;
4375 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4376 for (
auto *FoundDecl : FoundDecls) {
4380 if (
auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4384 FoundVar->getType())) {
4396 const VarDecl *FoundDInit =
nullptr;
4397 if (D->
getInit() && FoundVar->getAnyInitializer(FoundDInit))
4401 FoundByLookup = FoundVar;
4409 if (FoundArray && TArray) {
4410 if (isa<IncompleteArrayType>(FoundArray) &&
4411 isa<ConstantArrayType>(TArray)) {
4413 if (
auto TyOrErr =
import(D->
getType()))
4414 FoundVar->setType(*TyOrErr);
4416 return TyOrErr.takeError();
4418 FoundByLookup = FoundVar;
4420 }
else if (isa<IncompleteArrayType>(TArray) &&
4421 isa<ConstantArrayType>(FoundArray)) {
4422 FoundByLookup = FoundVar;
4427 Importer.
ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
4428 << Name << D->
getType() << FoundVar->getType();
4429 Importer.
ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4430 << FoundVar->getType();
4431 ConflictingDecls.push_back(FoundDecl);
4435 if (!ConflictingDecls.empty()) {
4437 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4439 Name = NameOrErr.get();
4441 return NameOrErr.takeError();
4445 Error Err = Error::success();
4451 return std::move(Err);
4454 if (
auto *FromDecomp = dyn_cast<DecompositionDecl>(D)) {
4458 return std::move(Err);
4460 if (GetImportedOrCreateDecl(
4461 ToDecomp, FromDecomp, Importer.
getToContext(), DC, ToInnerLocStart,
4467 if (GetImportedOrCreateDecl(ToVar, D, Importer.
getToContext(), DC,
4468 ToInnerLocStart, Loc,
4469 Name.getAsIdentifierInfo(), ToType,
4479 if (FoundByLookup) {
4488 return ToVTOrErr.takeError();
4495 return ToInstOrErr.takeError();
4496 if (
ExpectedSLoc POIOrErr =
import(MSI->getPointOfInstantiation()))
4499 return POIOrErr.takeError();
4503 return std::move(Err);
4508 addDeclToContexts(D, ToVar);
4511 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4514 return RedeclOrErr.takeError();
4525 Error Err = Error::success();
4530 return std::move(Err);
4534 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4535 ToLocation, ToDeclName.getAsIdentifierInfo(),
4552 return ToDefArgOrErr.takeError();
4556 if (
auto ToDefArgOrErr =
import(FromParam->
getDefaultArg()))
4559 return ToDefArgOrErr.takeError();
4562 return Error::success();
4567 Error Err = Error::success();
4572 return std::move(Err);
4581 Error Err = Error::success();
4588 return std::move(Err);
4591 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4592 ToInnerLocStart, ToLocation,
4593 ToDeclName.getAsIdentifierInfo(), ToType,
4602 return std::move(Err);
4622 return std::move(Err);
4626 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4627 for (
auto *FoundDecl : FoundDecls) {
4628 if (
auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4634 FoundMethod->getReturnType())) {
4635 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4637 << FoundMethod->getReturnType();
4638 Importer.
ToDiag(FoundMethod->getLocation(),
4639 diag::note_odr_objc_method_here)
4646 if (D->
param_size() != FoundMethod->param_size()) {
4647 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4649 << D->
param_size() << FoundMethod->param_size();
4650 Importer.
ToDiag(FoundMethod->getLocation(),
4651 diag::note_odr_objc_method_here)
4659 PEnd = D->
param_end(), FoundP = FoundMethod->param_begin();
4660 P != PEnd; ++
P, ++FoundP) {
4662 (*FoundP)->getType())) {
4663 Importer.
FromDiag((*P)->getLocation(),
4664 diag::warn_odr_objc_method_param_type_inconsistent)
4666 << (*P)->getType() << (*FoundP)->getType();
4667 Importer.
ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4668 << (*FoundP)->getType();
4676 if (D->
isVariadic() != FoundMethod->isVariadic()) {
4677 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4679 Importer.
ToDiag(FoundMethod->getLocation(),
4680 diag::note_odr_objc_method_here)
4691 Error Err = Error::success();
4694 auto ToReturnTypeSourceInfo =
4697 return std::move(Err);
4700 if (GetImportedOrCreateDecl(
4702 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4715 ToParams.push_back(*ToPOrErr);
4717 return ToPOrErr.takeError();
4721 for (
auto *ToParam : ToParams) {
4722 ToParam->setOwningFunction(ToMethod);
4730 return std::move(Err);
4754 return std::move(Err);
4758 Error Err = Error::success();
4764 return std::move(Err);
4767 if (GetImportedOrCreateDecl(
4770 ToLocation, Name.getAsIdentifierInfo(),
4771 ToColonLoc, ToTypeSourceInfo))
4777 return std::move(Err);
4778 Result->setTypeForDecl(ToTypeForDecl);
4779 Result->setLexicalDeclContext(LexicalDC);
4790 return std::move(Err);
4796 return std::move(Err);
4804 Error Err = Error::success();
4810 return std::move(Err);
4812 if (GetImportedOrCreateDecl(ToCategory, D, Importer.
getToContext(), DC,
4815 Name.getAsIdentifierInfo(), ToInterface,
4828 return PListOrErr.takeError();
4837 FromProto != FromProtoEnd;
4838 ++FromProto, ++FromProtoLoc) {
4840 Protocols.push_back(*ToProtoOrErr);
4842 return ToProtoOrErr.takeError();
4844 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4845 ProtocolLocs.push_back(*ToProtoLocOrErr);
4847 return ToProtoLocOrErr.takeError();
4860 return std::move(Err);
4868 return ToImplOrErr.takeError();
4880 return Error::success();
4893 FromProto != FromProtoEnd;
4894 ++FromProto, ++FromProtoLoc) {
4896 Protocols.push_back(*ToProtoOrErr);
4898 return ToProtoOrErr.takeError();
4900 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4901 ProtocolLocs.push_back(*ToProtoLocOrErr);
4903 return ToProtoLocOrErr.takeError();
4916 return Error::success();
4926 return Importer.
MapImported(D, *ImportedDefOrErr);
4928 return ImportedDefOrErr.takeError();
4937 return std::move(Err);
4942 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4943 for (
auto *FoundDecl : FoundDecls) {
4947 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4954 if (!ToAtBeginLocOrErr)
4955 return ToAtBeginLocOrErr.takeError();
4957 if (GetImportedOrCreateDecl(ToProto, D, Importer.
getToContext(), DC,
4958 Name.getAsIdentifierInfo(), Loc,
4970 return std::move(Err);
4978 return std::move(Err);
4981 if (!ExternLocOrErr)
4982 return ExternLocOrErr.takeError();
4986 return LangLocOrErr.takeError();
4991 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.
getToContext(), DC,
4992 *ExternLocOrErr, *LangLocOrErr,
4994 return ToLinkageSpec;
4998 if (!RBraceLocOrErr)
4999 return RBraceLocOrErr.takeError();
5006 return ToLinkageSpec;
5017 return ToShadowOrErr.takeError();
5028 return std::move(Err);
5032 Error Err = Error::success();
5037 return std::move(Err);
5041 return std::move(Err);
5044 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
5045 ToUsingLoc, ToQualifierLoc, NameInfo,
5056 ToUsing, *ToPatternOrErr);
5058 return ToPatternOrErr.takeError();
5070 return std::move(Err);