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.");
112 for (
auto *R :
D->getFirstDecl()->
redecls()) {
113 if (R !=
D->getFirstDecl())
114 Redecls.push_back(R);
116 Redecls.push_back(
D->getFirstDecl());
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())
302 if (
D->doesThisDeclarationHaveABody() &&
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>;
447 template <
typename DeclTy>
460 template <
typename T>
464 bool IgnoreTemplateParmDepth =
false);
656 Err = MaybeVal.takeError();
662 template<
typename IIter,
typename OIter>
664 using ItemT = std::remove_reference_t<
decltype(*Obegin)>;
665 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
668 return ToOrErr.takeError();
671 return Error::success();
678 template<
typename InContainerTy,
typename OutContainerTy>
680 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
682 InContainer.begin(), InContainer.end(), OutContainer.begin());
685 template<
typename InContainerTy,
typename OIter>
702template <
typename InContainerTy>
706 auto ToLAngleLocOrErr =
import(FromLAngleLoc);
707 if (!ToLAngleLocOrErr)
708 return ToLAngleLocOrErr.takeError();
709 auto ToRAngleLocOrErr =
import(FromRAngleLoc);
710 if (!ToRAngleLocOrErr)
711 return ToRAngleLocOrErr.takeError();
717 return Error::success();
721Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
732 return ImportTemplateArgumentListInfo(
733 From.LAngleLoc, From.RAngleLoc, From.arguments(),
Result);
745 if (Error Err = importInto(std::get<0>(
Result), FTSInfo->getTemplate()))
746 return std::move(Err);
751 return std::move(Err);
761 return std::move(Err);
764 if (!ToRequiresClause)
765 return ToRequiresClause.takeError();
768 if (!ToTemplateLocOrErr)
769 return ToTemplateLocOrErr.takeError();
771 if (!ToLAngleLocOrErr)
772 return ToLAngleLocOrErr.takeError();
774 if (!ToRAngleLocOrErr)
775 return ToRAngleLocOrErr.takeError();
796 return ToTypeOrErr.takeError();
804 return ToTypeOrErr.takeError();
811 return ToOrErr.takeError();
814 return ToTypeOrErr.takeError();
815 return TemplateArgument(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()),
822 return ToTypeOrErr.takeError();
830 return ToTypeOrErr.takeError();
833 return ToValueOrErr.takeError();
840 if (!ToTemplateOrErr)
841 return ToTemplateOrErr.takeError();
849 if (!ToTemplateOrErr)
850 return ToTemplateOrErr.takeError();
860 return ToExpr.takeError();
866 return std::move(Err);
873 llvm_unreachable(
"Invalid template argument kind");
881 return ArgOrErr.takeError();
890 return E.takeError();
896 return TSIOrErr.takeError();
898 auto ToTemplateQualifierLocOrErr =
900 if (!ToTemplateQualifierLocOrErr)
901 return ToTemplateQualifierLocOrErr.takeError();
903 if (!ToTemplateNameLocOrErr)
904 return ToTemplateNameLocOrErr.takeError();
905 auto ToTemplateEllipsisLocOrErr =
907 if (!ToTemplateEllipsisLocOrErr)
908 return ToTemplateEllipsisLocOrErr.takeError();
911 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
921 size_t NumDecls = DG.
end() - DG.
begin();
923 ToDecls.reserve(NumDecls);
924 for (
Decl *FromD : DG) {
925 if (
auto ToDOrErr =
import(FromD))
926 ToDecls.push_back(*ToDOrErr);
928 return ToDOrErr.takeError();
938 if (
D.isFieldDesignator()) {
943 return ToDotLocOrErr.takeError();
946 if (!ToFieldLocOrErr)
947 return ToFieldLocOrErr.takeError();
950 ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
953 ExpectedSLoc ToLBracketLocOrErr =
import(
D.getLBracketLoc());
954 if (!ToLBracketLocOrErr)
955 return ToLBracketLocOrErr.takeError();
957 ExpectedSLoc ToRBracketLocOrErr =
import(
D.getRBracketLoc());
958 if (!ToRBracketLocOrErr)
959 return ToRBracketLocOrErr.takeError();
961 if (
D.isArrayDesignator())
964 *ToRBracketLocOrErr);
966 ExpectedSLoc ToEllipsisLocOrErr =
import(
D.getEllipsisLoc());
967 if (!ToEllipsisLocOrErr)
968 return ToEllipsisLocOrErr.takeError();
970 assert(
D.isArrayRangeDesignator());
972 D.getArrayIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
973 *ToRBracketLocOrErr);
978 Error Err = Error::success();
981 auto ToConceptNameLoc =
987 return std::move(Err);
992 return std::move(Err);
1010 return VarOrErr.takeError();
1015 return LocationOrErr.takeError();
1020 return std::move(Err);
1027template <
typename T>
1029 if (
Found->getLinkageInternal() != From->getLinkageInternal())
1032 if (From->hasExternalFormalLinkage())
1033 return Found->hasExternalFormalLinkage();
1036 if (From->isInAnonymousNamespace())
1037 return Found->isInAnonymousNamespace();
1039 return !
Found->isInAnonymousNamespace() &&
1040 !
Found->hasExternalFormalLinkage();
1060using namespace clang;
1069 ExpectedType UnderlyingTypeOrErr =
import(
T->getValueType());
1070 if (!UnderlyingTypeOrErr)
1071 return UnderlyingTypeOrErr.takeError();
1077 switch (
T->getKind()) {
1078#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1079 case BuiltinType::Id: \
1080 return Importer.getToContext().SingletonId;
1081#include "clang/Basic/OpenCLImageTypes.def"
1082#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1083 case BuiltinType::Id: \
1084 return Importer.getToContext().Id##Ty;
1085#include "clang/Basic/OpenCLExtensionTypes.def"
1086#define SVE_TYPE(Name, Id, SingletonId) \
1087 case BuiltinType::Id: \
1088 return Importer.getToContext().SingletonId;
1089#include "clang/Basic/AArch64SVEACLETypes.def"
1090#define PPC_VECTOR_TYPE(Name, Id, Size) \
1091 case BuiltinType::Id: \
1092 return Importer.getToContext().Id##Ty;
1093#include "clang/Basic/PPCTypes.def"
1094#define RVV_TYPE(Name, Id, SingletonId) \
1095 case BuiltinType::Id: \
1096 return Importer.getToContext().SingletonId;
1097#include "clang/Basic/RISCVVTypes.def"
1098#define WASM_TYPE(Name, Id, SingletonId) \
1099 case BuiltinType::Id: \
1100 return Importer.getToContext().SingletonId;
1101#include "clang/Basic/WebAssemblyReferenceTypes.def"
1102#define AMDGPU_TYPE(Name, Id, SingletonId) \
1103 case BuiltinType::Id: \
1104 return Importer.getToContext().SingletonId;
1105#include "clang/Basic/AMDGPUTypes.def"
1106#define SHARED_SINGLETON_TYPE(Expansion)
1107#define BUILTIN_TYPE(Id, SingletonId) \
1108 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1109#include "clang/AST/BuiltinTypes.def"
1117 case BuiltinType::Char_U:
1126 case BuiltinType::Char_S:
1135 case BuiltinType::WChar_S:
1136 case BuiltinType::WChar_U:
1142 llvm_unreachable(
"Invalid BuiltinType Kind!");
1146 ExpectedType ToOriginalTypeOrErr =
import(
T->getOriginalType());
1147 if (!ToOriginalTypeOrErr)
1148 return ToOriginalTypeOrErr.takeError();
1154 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1155 if (!ToElementTypeOrErr)
1156 return ToElementTypeOrErr.takeError();
1163 if (!ToPointeeTypeOrErr)
1164 return ToPointeeTypeOrErr.takeError();
1172 if (!ToPointeeTypeOrErr)
1173 return ToPointeeTypeOrErr.takeError();
1181 ExpectedType ToPointeeTypeOrErr =
import(
T->getPointeeTypeAsWritten());
1182 if (!ToPointeeTypeOrErr)
1183 return ToPointeeTypeOrErr.takeError();
1191 ExpectedType ToPointeeTypeOrErr =
import(
T->getPointeeTypeAsWritten());
1192 if (!ToPointeeTypeOrErr)
1193 return ToPointeeTypeOrErr.takeError();
1202 if (!ToPointeeTypeOrErr)
1203 return ToPointeeTypeOrErr.takeError();
1206 if (!ClassTypeOrErr)
1207 return ClassTypeOrErr.takeError();
1215 Error Err = Error::success();
1219 return std::move(Err);
1222 ToElementType,
T->getSize(), ToSizeExpr,
T->getSizeModifier(),
1223 T->getIndexTypeCVRQualifiers());
1229 if (!ToArrayTypeOrErr)
1230 return ToArrayTypeOrErr.takeError();
1237 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1238 if (!ToElementTypeOrErr)
1239 return ToElementTypeOrErr.takeError();
1242 T->getSizeModifier(),
1243 T->getIndexTypeCVRQualifiers());
1248 Error Err = Error::success();
1253 return std::move(Err);
1255 ToElementType, ToSizeExpr,
T->getSizeModifier(),
1256 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1259ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1261 Error Err = Error::success();
1266 return std::move(Err);
1271 ToElementType, ToSizeExpr,
T->getSizeModifier(),
1272 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1275ExpectedType ASTNodeImporter::VisitDependentSizedExtVectorType(
1277 Error Err = Error::success();
1282 return std::move(Err);
1284 ToElementType, ToSizeExpr, ToAttrLoc);
1288 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1289 if (!ToElementTypeOrErr)
1290 return ToElementTypeOrErr.takeError();
1293 T->getNumElements(),
1294 T->getVectorKind());
1298 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1299 if (!ToElementTypeOrErr)
1300 return ToElementTypeOrErr.takeError();
1303 T->getNumElements());
1311 if (!ToReturnTypeOrErr)
1312 return ToReturnTypeOrErr.takeError();
1321 if (!ToReturnTypeOrErr)
1322 return ToReturnTypeOrErr.takeError();
1329 return TyOrErr.takeError();
1330 ArgTypes.push_back(*TyOrErr);
1338 return TyOrErr.takeError();
1339 ExceptionTypes.push_back(*TyOrErr);
1343 Error Err = Error::success();
1360 return std::move(Err);
1363 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1368 Error Err = Error::success();
1370 auto ToPrevD =
importChecked(Err,
T->getDecl()->getPreviousDecl());
1372 return std::move(Err);
1375 ToD, cast_or_null<TypeDecl>(ToPrevD));
1380 if (!ToInnerTypeOrErr)
1381 return ToInnerTypeOrErr.takeError();
1391 return Pattern.takeError();
1394 return Index.takeError();
1401 return ToDeclOrErr.takeError();
1408 if (!ToUnderlyingTypeOrErr)
1409 return ToUnderlyingTypeOrErr.takeError();
1417 return ToExprOrErr.takeError();
1422 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnmodifiedType());
1423 if (!ToUnderlyingTypeOrErr)
1424 return ToUnderlyingTypeOrErr.takeError();
1432 return FoundOrErr.takeError();
1434 if (!UnderlyingOrErr)
1435 return UnderlyingOrErr.takeError();
1444 return ToExprOrErr.takeError();
1446 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1447 if (!ToUnderlyingTypeOrErr)
1448 return ToUnderlyingTypeOrErr.takeError();
1451 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1457 if (!ToBaseTypeOrErr)
1458 return ToBaseTypeOrErr.takeError();
1460 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1461 if (!ToUnderlyingTypeOrErr)
1462 return ToUnderlyingTypeOrErr.takeError();
1465 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr,
T->getUTTKind());
1470 ExpectedType ToDeducedTypeOrErr =
import(
T->getDeducedType());
1471 if (!ToDeducedTypeOrErr)
1472 return ToDeducedTypeOrErr.takeError();
1474 ExpectedDecl ToTypeConstraintConcept =
import(
T->getTypeConstraintConcept());
1475 if (!ToTypeConstraintConcept)
1476 return ToTypeConstraintConcept.takeError();
1481 return std::move(Err);
1484 *ToDeducedTypeOrErr,
T->getKeyword(),
false,
1485 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1489ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1493 if (!ToTemplateNameOrErr)
1494 return ToTemplateNameOrErr.takeError();
1495 ExpectedType ToDeducedTypeOrErr =
import(
T->getDeducedType());
1496 if (!ToDeducedTypeOrErr)
1497 return ToDeducedTypeOrErr.takeError();
1503ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1507 return ToDeclOrErr.takeError();
1511 const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
1512 assert(isa_and_nonnull<InjectedClassNameType>(Ty));
1519 return ToDeclOrErr.takeError();
1527 return ToDeclOrErr.takeError();
1533 ExpectedType ToModifiedTypeOrErr =
import(
T->getModifiedType());
1534 if (!ToModifiedTypeOrErr)
1535 return ToModifiedTypeOrErr.takeError();
1536 ExpectedType ToEquivalentTypeOrErr =
import(
T->getEquivalentType());
1537 if (!ToEquivalentTypeOrErr)
1538 return ToEquivalentTypeOrErr.takeError();
1541 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1547 if (!ToWrappedTypeOrErr)
1548 return ToWrappedTypeOrErr.takeError();
1550 Error Err = Error::success();
1557 return ToDeclOrErr.takeError();
1558 CoupledDecls.emplace_back(*ToDeclOrErr, TI.isDeref());
1562 *ToWrappedTypeOrErr, CountExpr,
T->isCountInBytes(),
T->isOrNull(),
1563 ArrayRef(CoupledDecls.data(), CoupledDecls.size()));
1566ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1570 return ToDeclOrErr.takeError();
1573 T->getDepth(),
T->getIndex(),
T->isParameterPack(), *ToDeclOrErr);
1576ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1580 return ReplacedOrErr.takeError();
1582 ExpectedType ToReplacementTypeOrErr =
import(
T->getReplacementType());
1583 if (!ToReplacementTypeOrErr)
1584 return ToReplacementTypeOrErr.takeError();
1587 *ToReplacementTypeOrErr, *ReplacedOrErr,
T->getIndex(),
1591ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1595 return ReplacedOrErr.takeError();
1598 if (!ToArgumentPack)
1599 return ToArgumentPack.takeError();
1602 *ReplacedOrErr,
T->getIndex(),
T->getFinal(), *ToArgumentPack);
1605ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1607 auto ToTemplateOrErr =
import(
T->getTemplateName());
1608 if (!ToTemplateOrErr)
1609 return ToTemplateOrErr.takeError();
1614 return std::move(Err);
1621 ToCanonType = *TyOrErr;
1623 return TyOrErr.takeError();
1632 auto ToQualifierOrErr =
import(
T->getQualifier());
1633 if (!ToQualifierOrErr)
1634 return ToQualifierOrErr.takeError();
1637 if (!ToNamedTypeOrErr)
1638 return ToNamedTypeOrErr.takeError();
1641 if (!ToOwnedTagDeclOrErr)
1642 return ToOwnedTagDeclOrErr.takeError();
1647 *ToOwnedTagDeclOrErr);
1653 if (!ToPatternOrErr)
1654 return ToPatternOrErr.takeError();
1657 T->getNumExpansions(),
1661ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1663 auto ToQualifierOrErr =
import(
T->getQualifier());
1664 if (!ToQualifierOrErr)
1665 return ToQualifierOrErr.takeError();
1670 ToPack.reserve(
T->template_arguments().size());
1672 return std::move(Err);
1675 T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1680 auto ToQualifierOrErr =
import(
T->getQualifier());
1681 if (!ToQualifierOrErr)
1682 return ToQualifierOrErr.takeError();
1691 return TyOrErr.takeError();
1703 return ToDeclOrErr.takeError();
1710 if (!ToBaseTypeOrErr)
1711 return ToBaseTypeOrErr.takeError();
1714 for (
auto TypeArg :
T->getTypeArgsAsWritten()) {
1716 TypeArgs.push_back(*TyOrErr);
1718 return TyOrErr.takeError();
1722 for (
auto *
P :
T->quals()) {
1724 Protocols.push_back(*ProtocolOrErr);
1726 return ProtocolOrErr.takeError();
1732 T->isKindOfTypeAsWritten());
1738 if (!ToPointeeTypeOrErr)
1739 return ToPointeeTypeOrErr.takeError();
1746 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1747 if (!ToUnderlyingTypeOrErr)
1748 return ToUnderlyingTypeOrErr.takeError();
1756 Error Err = Error::success();
1757 QualType ToOriginalType = importChecked(Err,
T->getOriginalType());
1758 QualType ToAdjustedType = importChecked(Err,
T->getAdjustedType());
1760 return std::move(Err);
1762 return Importer.getToContext().getAdjustedType(ToOriginalType,
1767 return Importer.getToContext().getBitIntType(
T->isUnsigned(),
1771ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType(
1773 Error Err = Error::success();
1774 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err,
T->getAttr());
1775 QualType ToWrappedType = importChecked(Err,
T->getWrappedType());
1777 return std::move(Err);
1779 return Importer.getToContext().getBTFTagAttributedType(ToBTFAttr,
1783ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType(
1785 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1786 if (!ToElementTypeOrErr)
1787 return ToElementTypeOrErr.takeError();
1789 return Importer.getToContext().getConstantMatrixType(
1790 *ToElementTypeOrErr,
T->getNumRows(),
T->getNumColumns());
1793ExpectedType clang::ASTNodeImporter::VisitDependentAddressSpaceType(
1795 Error Err = Error::success();
1797 Expr *ToAddrSpaceExpr = importChecked(Err,
T->getAddrSpaceExpr());
1800 return std::move(Err);
1802 return Importer.getToContext().getDependentAddressSpaceType(
1803 ToPointeeType, ToAddrSpaceExpr, ToAttrLoc);
1806ExpectedType clang::ASTNodeImporter::VisitDependentBitIntType(
1808 ExpectedExpr ToNumBitsExprOrErr =
import(
T->getNumBitsExpr());
1809 if (!ToNumBitsExprOrErr)
1810 return ToNumBitsExprOrErr.takeError();
1811 return Importer.getToContext().getDependentBitIntType(
T->isUnsigned(),
1812 *ToNumBitsExprOrErr);
1815ExpectedType clang::ASTNodeImporter::VisitDependentSizedMatrixType(
1817 Error Err = Error::success();
1818 QualType ToElementType = importChecked(Err,
T->getElementType());
1819 Expr *ToRowExpr = importChecked(Err,
T->getRowExpr());
1820 Expr *ToColumnExpr = importChecked(Err,
T->getColumnExpr());
1823 return std::move(Err);
1825 return Importer.getToContext().getDependentSizedMatrixType(
1826 ToElementType, ToRowExpr, ToColumnExpr, ToAttrLoc);
1829ExpectedType clang::ASTNodeImporter::VisitDependentVectorType(
1831 Error Err = Error::success();
1832 QualType ToElementType = importChecked(Err,
T->getElementType());
1833 Expr *ToSizeExpr = importChecked(Err,
T->getSizeExpr());
1836 return std::move(Err);
1838 return Importer.getToContext().getDependentVectorType(
1839 ToElementType, ToSizeExpr, ToAttrLoc,
T->getVectorKind());
1842ExpectedType clang::ASTNodeImporter::VisitObjCTypeParamType(
1846 return ToDeclOrErr.takeError();
1851 if (!ToProtocolOrErr)
1852 return ToProtocolOrErr.takeError();
1853 ToProtocols.push_back(*ToProtocolOrErr);
1856 return Importer.getToContext().getObjCTypeParamType(*ToDeclOrErr,
1861 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1862 if (!ToElementTypeOrErr)
1863 return ToElementTypeOrErr.takeError();
1866 if (
T->isReadOnly())
1886 if (isa<RecordDecl>(
D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1888 auto getLeafPointeeType = [](
const Type *
T) {
1896 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1897 auto *RT = dyn_cast<RecordType>(LeafT);
1898 if (RT && RT->getDecl() ==
D) {
1911 if (Error Err = importInto(Name,
D->getDeclName()))
1923 return Error::success();
1930 if (Error Err = importInto(Name,
D->getDeclName()))
1942 return Error::success();
1947 return Error::success();
1950 if (Error Err = importInto(ToD, FromD))
1953 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1954 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1955 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1956 !ToRecord->getDefinition()) {
1961 return Error::success();
1964 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1965 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1966 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1971 return Error::success();
1974 return Error::success();
1989 return Error::success();
1995 return ToRangeOrErr.takeError();
1996 return Error::success();
2002 return LocOrErr.takeError();
2003 return Error::success();
2011 return ToTInfoOrErr.takeError();
2012 return Error::success();
2015 llvm_unreachable(
"Unknown name kind.");
2022 return ToDCOrErr.takeError();
2036 auto MightNeedReordering = [](
const Decl *
D) {
2037 return isa<FieldDecl>(
D) || isa<IndirectFieldDecl>(
D) || isa<FriendDecl>(
D);
2041 Error ChildErrors = Error::success();
2042 for (
auto *From : FromDC->
decls()) {
2043 if (!MightNeedReordering(From))
2052 if (!ImportedOrErr) {
2054 ImportedOrErr.takeError());
2057 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
2058 Decl *ImportedDecl = *ImportedOrErr;
2059 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
2060 if (FieldFrom && FieldTo) {
2092 consumeError(std::move(ChildErrors));
2093 return ToDCOrErr.takeError();
2096 if (
const auto *FromRD = dyn_cast<RecordDecl>(FromDC)) {
2100 for (
auto *
D : FromRD->decls()) {
2101 if (!MightNeedReordering(
D))
2104 assert(
D &&
"DC contains a null decl");
2107 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->
containsDecl(ToD));
2119 for (
auto *From : FromDC->
decls()) {
2120 if (MightNeedReordering(From))
2126 ImportedOrErr.takeError());
2146 if (!FromRecordDecl || !ToRecordDecl) {
2150 if (RecordFrom && RecordTo) {
2151 FromRecordDecl = RecordFrom->
getDecl();
2152 ToRecordDecl = RecordTo->getDecl();
2156 if (FromRecordDecl && ToRecordDecl) {
2162 return Error::success();
2169 return ToDCOrErr.takeError();
2175 if (!ToLexicalDCOrErr)
2176 return ToLexicalDCOrErr.takeError();
2177 ToLexicalDC = *ToLexicalDCOrErr;
2181 return Error::success();
2187 "Import implicit methods to or from non-definition");
2190 if (FromM->isImplicit()) {
2193 return ToMOrErr.takeError();
2196 return Error::success();
2205 return ToTypedefOrErr.takeError();
2207 return Error::success();
2212 auto DefinitionCompleter = [To]() {
2231 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2233 ToCaptures.reserve(FromCXXRD->capture_size());
2234 for (
const auto &FromCapture : FromCXXRD->captures()) {
2235 if (
auto ToCaptureOrErr =
import(FromCapture))
2236 ToCaptures.push_back(*ToCaptureOrErr);
2238 return ToCaptureOrErr.takeError();
2240 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2247 DefinitionCompleter();
2251 return Error::success();
2266 auto DefinitionCompleterScopeExit =
2267 llvm::make_scope_exit(DefinitionCompleter);
2273 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2274 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2275 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2277 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2278 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2280 #define FIELD(Name, Width, Merge) \
2281 ToData.Name = FromData.Name;
2282 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2285 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2288 for (
const auto &Base1 : FromCXX->bases()) {
2291 return TyOrErr.takeError();
2294 if (Base1.isPackExpansion()) {
2295 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2296 EllipsisLoc = *LocOrErr;
2298 return LocOrErr.takeError();
2306 auto RangeOrErr =
import(Base1.getSourceRange());
2308 return RangeOrErr.takeError();
2310 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2312 return TSIOrErr.takeError();
2318 Base1.isBaseOfClass(),
2319 Base1.getAccessSpecifierAsWritten(),
2324 ToCXX->setBases(Bases.data(), Bases.size());
2332 return Error::success();
2337 return Error::success();
2341 return Error::success();
2345 return ToInitOrErr.takeError();
2356 return Error::success();
2364 return Error::success();
2375 return ToTypeOrErr.takeError();
2378 if (!ToPromotionTypeOrErr)
2379 return ToPromotionTypeOrErr.takeError();
2390 return Error::success();
2396 for (
const auto &Arg : FromArgs) {
2397 if (
auto ToOrErr =
import(Arg))
2398 ToArgs.push_back(*ToOrErr);
2400 return ToOrErr.takeError();
2403 return Error::success();
2409 return import(From);
2412template <
typename InContainerTy>
2415 for (
const auto &FromLoc : Container) {
2416 if (
auto ToLocOrErr =
import(FromLoc))
2419 return ToLocOrErr.takeError();
2421 return Error::success();
2431 bool IgnoreTemplateParmDepth) {
2442 false, Complain,
false,
2443 IgnoreTemplateParmDepth);
2463 return std::move(Err);
2468 return LocOrErr.takeError();
2471 if (GetImportedOrCreateDecl(ToD,
D, Importer.
getToContext(), DC, *LocOrErr))
2494 return std::move(Err);
2500 Name.getAsIdentifierInfo()))
2503 Error Err = Error::success();
2508 return std::move(Err);
2512 addDeclToContexts(
D, ToD);
2520 return LocOrErr.takeError();
2521 auto ColonLocOrErr =
import(
D->getColonLoc());
2523 return ColonLocOrErr.takeError();
2528 return DCOrErr.takeError();
2533 DC, *LocOrErr, *ColonLocOrErr))
2547 return DCOrErr.takeError();
2551 Error Err = Error::success();
2557 return std::move(Err);
2560 if (GetImportedOrCreateDecl(
2561 ToD,
D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2562 ToRParenLoc,
D->isFailed()))
2577 return std::move(Err);
2586 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2592 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2593 for (
auto *FoundDecl : FoundDecls) {
2597 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2598 MergeWithNamespace = FoundNS;
2599 ConflictingDecls.clear();
2603 ConflictingDecls.push_back(FoundDecl);
2606 if (!ConflictingDecls.empty()) {
2609 ConflictingDecls.size());
2611 Name = NameOrErr.get();
2613 return NameOrErr.takeError();
2619 return BeginLocOrErr.takeError();
2621 if (!RBraceLocOrErr)
2622 return RBraceLocOrErr.takeError();
2627 if (GetImportedOrCreateDecl(ToNamespace,
D, Importer.
getToContext(), DC,
2628 D->isInline(), *BeginLocOrErr,
Loc,
2629 Name.getAsIdentifierInfo(),
2630 nullptr,
D->isNested()))
2639 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2640 TU->setAnonymousNamespace(ToNamespace);
2642 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2648 return std::move(Err);
2660 return std::move(Err);
2666 Error Err = Error::success();
2670 auto ToTargetNameLoc =
importChecked(Err,
D->getTargetNameLoc());
2673 return std::move(Err);
2678 if (GetImportedOrCreateDecl(
2679 ToD,
D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2680 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2698 return std::move(Err);
2717 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2718 for (
auto *FoundDecl : FoundDecls) {
2721 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2725 QualType FromUT =
D->getUnderlyingType();
2726 QualType FoundUT = FoundTypedef->getUnderlyingType();
2740 if (FromR && FoundR &&
2751 ConflictingDecls.push_back(FoundDecl);
2756 if (!ConflictingDecls.empty()) {
2758 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2760 Name = NameOrErr.get();
2762 return NameOrErr.takeError();
2766 Error Err = Error::success();
2768 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
2771 return std::move(Err);
2778 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2780 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2782 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2784 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2789 return std::move(Err);
2793 Importer.AddToLookupTable(ToTypedef);
2798 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(
D) :
nullptr;
2821 return std::move(Err);
2831 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2832 for (
auto *FoundDecl : FoundDecls) {
2835 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) {
2838 ConflictingDecls.push_back(FoundDecl);
2842 if (!ConflictingDecls.empty()) {
2844 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2846 Name = NameOrErr.get();
2848 return NameOrErr.takeError();
2852 Error Err = Error::success();
2853 auto ToTemplateParameters =
importChecked(Err,
D->getTemplateParameters());
2854 auto ToTemplatedDecl =
importChecked(Err,
D->getTemplatedDecl());
2856 return std::move(Err);
2860 Name, ToTemplateParameters, ToTemplatedDecl))
2863 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2869 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2880 return std::move(Err);
2887 if (
D->isGnuLocal()) {
2890 return BeginLocOrErr.takeError();
2892 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2897 Name.getAsIdentifierInfo()))
2904 return ToStmtOrErr.takeError();
2906 ToLabel->
setStmt(*ToStmtOrErr);
2919 return std::move(Err);
2926 if (!SearchName &&
D->getTypedefNameForAnonDecl()) {
2927 if (Error Err = importInto(
2928 SearchName,
D->getTypedefNameForAnonDecl()->getDeclName()))
2929 return std::move(Err);
2939 Importer.findDeclsInToCtx(DC, SearchName);
2940 for (
auto *FoundDecl : FoundDecls) {
2944 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2945 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2946 FoundDecl = Tag->getDecl();
2949 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2954 if (
D->isThisDeclarationADefinition() && FoundDef)
2959 ConflictingDecls.push_back(FoundDecl);
2968 if (SearchName && !ConflictingDecls.empty()) {
2970 SearchName, DC, IDNS, ConflictingDecls.data(),
2971 ConflictingDecls.size());
2973 Name = NameOrErr.get();
2975 return NameOrErr.takeError();
2979 Error Err = Error::success();
2985 return std::move(Err);
2989 if (GetImportedOrCreateDecl(
2991 Loc, Name.getAsIdentifierInfo(), PrevDecl,
D->isScoped(),
2992 D->isScopedUsingClassTag(),
D->isFixed()))
3000 addDeclToContexts(
D, D2);
3004 EnumDecl *FromInst =
D->getInstantiatedFromMemberEnum();
3006 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
3008 return ToInstOrErr.takeError();
3009 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
3012 return POIOrErr.takeError();
3016 if (
D->isCompleteDefinition())
3018 return std::move(Err);
3024 bool IsFriendTemplate =
false;
3025 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3027 DCXX->getDescribedClassTemplate() &&
3028 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
3038 return std::move(Err);
3045 if (!SearchName &&
D->getTypedefNameForAnonDecl()) {
3046 if (Error Err = importInto(
3047 SearchName,
D->getTypedefNameForAnonDecl()->getDeclName()))
3048 return std::move(Err);
3055 bool DependentFriend = IsFriendTemplate && IsDependentContext;
3062 Importer.findDeclsInToCtx(DC, SearchName);
3063 if (!FoundDecls.empty()) {
3066 if (
D->hasExternalLexicalStorage() && !
D->isCompleteDefinition())
3070 for (
auto *FoundDecl : FoundDecls) {
3075 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(
Found)) {
3076 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
3077 Found = Tag->getDecl();
3080 if (
auto *FoundRecord = dyn_cast<RecordDecl>(
Found)) {
3099 if (
D->isThisDeclarationADefinition() && FoundDef) {
3103 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3104 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
3105 assert(FoundCXX &&
"Record type mismatch");
3111 return std::move(Err);
3117 ConflictingDecls.push_back(FoundDecl);
3121 if (!ConflictingDecls.empty() && SearchName) {
3123 SearchName, DC, IDNS, ConflictingDecls.data(),
3124 ConflictingDecls.size());
3126 Name = NameOrErr.get();
3128 return NameOrErr.takeError();
3134 return BeginLocOrErr.takeError();
3139 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3140 if (DCXX->isLambda()) {
3141 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
3143 return TInfoOrErr.takeError();
3144 if (GetImportedOrCreateSpecialDecl(
3146 DC, *TInfoOrErr,
Loc, DCXX->getLambdaDependencyKind(),
3147 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
3152 return CDeclOrErr.takeError();
3155 }
else if (DCXX->isInjectedClassName()) {
3158 const bool DelayTypeCreation =
true;
3159 if (GetImportedOrCreateDecl(
3161 *BeginLocOrErr,
Loc, Name.getAsIdentifierInfo(),
3162 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
3165 D2CXX, dyn_cast<CXXRecordDecl>(DC));
3167 if (GetImportedOrCreateDecl(D2CXX,
D, Importer.
getToContext(),
3168 D->getTagKind(), DC, *BeginLocOrErr,
Loc,
3169 Name.getAsIdentifierInfo(),
3170 cast_or_null<CXXRecordDecl>(PrevDecl)))
3177 addDeclToContexts(
D, D2);
3180 DCXX->getDescribedClassTemplate()) {
3182 if (Error Err = importInto(ToDescribed, FromDescribed))
3183 return std::move(Err);
3185 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
3205 const Type *FrontTy =
3206 cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
3209 InjSpec = InjTy->getInjectedSpecializationType();
3212 for (
auto *R : Redecls) {
3213 auto *RI = cast<CXXRecordDecl>(R);
3214 if (R != Redecls.front() ||
3215 !isa<InjectedClassNameType>(RI->getTypeForDecl()))
3216 RI->setTypeForDecl(
nullptr);
3231 DCXX->getMemberSpecializationInfo()) {
3233 MemberInfo->getTemplateSpecializationKind();
3239 return ToInstOrErr.takeError();
3242 import(MemberInfo->getPointOfInstantiation()))
3246 return POIOrErr.takeError();
3251 D->getTagKind(), DC, *BeginLocOrErr,
Loc,
3252 Name.getAsIdentifierInfo(), PrevDecl))
3255 addDeclToContexts(
D, D2);
3258 if (
auto BraceRangeOrErr =
import(
D->getBraceRange()))
3261 return BraceRangeOrErr.takeError();
3262 if (
auto QualifierLocOrErr =
import(
D->getQualifierLoc()))
3265 return QualifierLocOrErr.takeError();
3267 if (
D->isAnonymousStructOrUnion())
3270 if (
D->isCompleteDefinition())
3272 return std::move(Err);
3284 return std::move(Err);
3293 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3294 for (
auto *FoundDecl : FoundDecls) {
3298 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3301 ConflictingDecls.push_back(FoundDecl);
3305 if (!ConflictingDecls.empty()) {
3307 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3309 Name = NameOrErr.get();
3311 return NameOrErr.takeError();
3317 return TypeOrErr.takeError();
3321 return InitOrErr.takeError();
3324 if (GetImportedOrCreateDecl(
3326 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr,
D->getInitVal()))
3327 return ToEnumerator;
3332 return ToEnumerator;
3335template <
typename DeclTy>
3338 unsigned int Num = FromD->getNumTemplateParameterLists();
3340 return Error::success();
3342 for (
unsigned int I = 0; I < Num; ++I)
3344 import(FromD->getTemplateParameterList(I)))
3345 ToTPLists[I] = *ToTPListOrErr;
3347 return ToTPListOrErr.takeError();
3348 ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3349 return Error::success();
3357 return Error::success();
3363 return Error::success();
3369 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3371 return InstFDOrErr.takeError();
3377 return POIOrErr.takeError();
3379 return Error::success();
3383 auto FunctionAndArgsOrErr =
3385 if (!FunctionAndArgsOrErr)
3386 return FunctionAndArgsOrErr.takeError();
3389 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3393 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3394 if (FromTAArgsAsWritten)
3396 *FromTAArgsAsWritten, ToTAInfo))
3399 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3401 return POIOrErr.takeError();
3407 ToFD->setFunctionTemplateSpecialization(
3408 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3409 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3410 return Error::success();
3418 Candidates.
addDecl(*ToFTDOrErr);
3420 return ToFTDOrErr.takeError();
3425 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3426 if (FromTAArgsAsWritten)
3433 FromTAArgsAsWritten ? &ToTAInfo :
nullptr);
3434 return Error::success();
3437 llvm_unreachable(
"All cases should be covered!");
3442 auto FunctionAndArgsOrErr =
3444 if (!FunctionAndArgsOrErr)
3445 return FunctionAndArgsOrErr.takeError();
3449 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3450 void *InsertPos =
nullptr;
3461 return ToBodyOrErr.takeError();
3463 return Error::success();
3472 assert(DCi &&
"Declaration should have a context");
3486 ToProcess.push_back(S);
3487 while (!ToProcess.empty()) {
3488 const Stmt *CurrentS = ToProcess.pop_back_val();
3490 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS)) {
3491 if (
const Decl *
D = DeclRef->getDecl())
3494 }
else if (
const auto *
E =
3495 dyn_cast_or_null<SubstNonTypeTemplateParmExpr>(CurrentS)) {
3496 if (
const Decl *
D =
E->getAssociatedDecl())
3529class IsTypeDeclaredInsideVisitor
3530 :
public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3532 IsTypeDeclaredInsideVisitor(
const FunctionDecl *ParentDC)
3533 : ParentDC(ParentDC) {}
3539 if (std::optional<bool> Res = Visit(
T.getTypePtr()))
3542 T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3544 if (std::optional<bool> Res = Visit(DsT.
getTypePtr()))
3547 DsT =
T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3552 std::optional<bool> VisitTagType(
const TagType *
T) {
3553 if (
auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(
T->getDecl()))
3554 for (
const auto &Arg : Spec->getTemplateArgs().asArray())
3555 if (checkTemplateArgument(Arg))
3560 std::optional<bool> VisitPointerType(
const PointerType *
T) {
3565 return CheckType(
T->getPointeeTypeAsWritten());
3568 std::optional<bool> VisitTypedefType(
const TypedefType *
T) {
3574 std::optional<bool> VisitUsingType(
const UsingType *
T) {
3575 if (
T->getFoundDecl() &&
3584 for (
const auto &Arg :
T->template_arguments())
3585 if (checkTemplateArgument(Arg))
3603 return CheckType(
T->getElementType());
3608 "Variable array should not occur in deduced return type of a function");
3612 llvm_unreachable(
"Incomplete array should not occur in deduced return type "
3617 llvm_unreachable(
"Dependent array should not occur in deduced return type "
3644 if (checkTemplateArgument(PackArg))
3656 llvm_unreachable(
"Unknown TemplateArgument::ArgKind enum");
3666 assert(FromFPT &&
"Must be called on FunctionProtoType");
3668 auto IsCXX11LambdaWithouTrailingReturn = [&]() {
3669 if (Importer.FromContext.
getLangOpts().CPlusPlus14)
3672 if (FromFPT->hasTrailingReturn())
3675 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
D))
3676 return cast<CXXRecordDecl>(MD->getDeclContext())->isLambda();
3681 QualType RetT = FromFPT->getReturnType();
3682 if (isa<AutoType>(RetT.
getTypePtr()) || IsCXX11LambdaWithouTrailingReturn()) {
3684 IsTypeDeclaredInsideVisitor Visitor(Def ? Def :
D);
3685 return Visitor.CheckType(RetT);
3702 auto RedeclIt = Redecls.begin();
3705 for (; RedeclIt != Redecls.end() && *RedeclIt !=
D; ++RedeclIt) {
3708 return ToRedeclOrErr.takeError();
3710 assert(*RedeclIt ==
D);
3718 return std::move(Err);
3730 if (
D->getTemplatedKind() ==
3733 if (!FoundFunctionOrErr)
3734 return FoundFunctionOrErr.takeError();
3735 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3736 if (
Decl *Def = FindAndMapDefinition(
D, FoundFunction))
3738 FoundByLookup = FoundFunction;
3746 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3747 for (
auto *FoundDecl : FoundDecls) {
3751 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3756 if (
Decl *Def = FindAndMapDefinition(
D, FoundFunction))
3758 FoundByLookup = FoundFunction;
3769 Importer.
ToDiag(
Loc, diag::warn_odr_function_type_inconsistent)
3770 << Name <<
D->getType() << FoundFunction->getType();
3771 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3772 << FoundFunction->getType();
3773 ConflictingDecls.push_back(FoundDecl);
3777 if (!ConflictingDecls.empty()) {
3779 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3781 Name = NameOrErr.get();
3783 return NameOrErr.takeError();
3793 if (FoundByLookup) {
3794 if (isa<CXXMethodDecl>(FoundByLookup)) {
3796 if (!
D->doesThisDeclarationHaveABody()) {
3798 D->getDescribedFunctionTemplate()) {
3803 "Templated function mapped to non-templated?");
3819 return std::move(Err);
3830 bool UsedDifferentProtoType =
false;
3832 QualType FromReturnTy = FromFPT->getReturnType();
3840 UsedDifferentProtoType =
true;
3851 FromEPI = DefaultEPI;
3852 UsedDifferentProtoType =
true;
3855 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3860 Error Err = Error::success();
3863 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
3867 auto TrailingRequiresClause =
3870 return std::move(Err);
3874 for (
auto *
P :
D->parameters()) {
3876 Parameters.push_back(*ToPOrErr);
3878 return ToPOrErr.takeError();
3883 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(
D)) {
3885 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3887 return std::move(Err);
3889 if (FromConstructor->isInheritingConstructor()) {
3891 import(FromConstructor->getInheritedConstructor());
3892 if (!ImportedInheritedCtor)
3893 return ImportedInheritedCtor.takeError();
3894 ToInheritedConstructor = *ImportedInheritedCtor;
3896 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3897 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3898 ToInnerLocStart, NameInfo,
T, TInfo, ESpec,
D->UsesFPIntrin(),
3899 D->isInlineSpecified(),
D->
isImplicit(),
D->getConstexprKind(),
3900 ToInheritedConstructor, TrailingRequiresClause))
3904 Error Err = Error::success();
3906 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3907 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3909 return std::move(Err);
3911 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3912 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3913 ToInnerLocStart, NameInfo,
T, TInfo,
D->UsesFPIntrin(),
3914 D->isInlineSpecified(),
D->
isImplicit(),
D->getConstexprKind(),
3915 TrailingRequiresClause))
3922 dyn_cast<CXXConversionDecl>(
D)) {
3924 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3926 return std::move(Err);
3927 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3928 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3929 ToInnerLocStart, NameInfo,
T, TInfo,
D->UsesFPIntrin(),
3930 D->isInlineSpecified(), ESpec,
D->getConstexprKind(),
3933 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(
D)) {
3934 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3935 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3936 ToInnerLocStart, NameInfo,
T, TInfo, Method->getStorageClass(),
3937 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3940 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(
D)) {
3942 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3946 return std::move(Err);
3947 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3948 ToFunction,
D, Importer.
getToContext(), DC, ToInnerLocStart, ESpec,
3949 NameInfo,
T, TInfo, ToEndLoc, Ctor))
3951 cast<CXXDeductionGuideDecl>(ToFunction)
3952 ->setDeductionCandidateKind(Guide->getDeductionCandidateKind());
3954 if (GetImportedOrCreateDecl(
3955 ToFunction,
D, Importer.
getToContext(), DC, ToInnerLocStart,
3956 NameInfo,
T, TInfo,
D->getStorageClass(),
D->UsesFPIntrin(),
3957 D->isInlineSpecified(),
D->hasWrittenPrototype(),
3958 D->getConstexprKind(), TrailingRequiresClause))
3963 if (FoundByLookup) {
3976 auto Imported =
import(Msg);
3978 return Imported.takeError();
3992 D->FriendConstraintRefersToEnclosingTemplate());
4002 for (
auto *Param : Parameters) {
4003 Param->setOwningFunction(ToFunction);
4008 ToFunction->setParams(Parameters);
4015 for (
unsigned I = 0, N = Parameters.size(); I != N; ++I)
4016 ProtoLoc.setParam(I, Parameters[I]);
4022 auto ToFTOrErr =
import(FromFT);
4024 return ToFTOrErr.takeError();
4028 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(
D)) {
4029 if (
unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
4033 FromConstructor->inits(), CtorInitializers))
4034 return std::move(Err);
4037 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
4038 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
4039 ToCtor->setCtorInitializers(Memory);
4040 ToCtor->setNumCtorInitializers(NumInitializers);
4046 return std::move(Err);
4048 if (
auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(
D))
4051 return std::move(Err);
4053 if (
D->doesThisDeclarationHaveABody()) {
4057 return std::move(Err);
4061 if (UsedDifferentProtoType) {
4063 ToFunction->
setType(*TyOrErr);
4065 return TyOrErr.takeError();
4069 return TSIOrErr.takeError();
4074 addDeclToContexts(
D, ToFunction);
4077 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4080 return ToRedeclOrErr.takeError();
4114 return std::move(Err);
4119 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4120 for (
auto *FoundDecl : FoundDecls) {
4121 if (
FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
4129 FoundField->getType())) {
4137 if (
Expr *FromInitializer =
D->getInClassInitializer()) {
4138 if (
ExpectedExpr ToInitializerOrErr =
import(FromInitializer)) {
4141 assert(FoundField->hasInClassInitializer() &&
4142 "Field should have an in-class initializer if it has an "
4143 "expression for it.");
4144 if (!FoundField->getInClassInitializer())
4145 FoundField->setInClassInitializer(*ToInitializerOrErr);
4147 return ToInitializerOrErr.takeError();
4154 Importer.
ToDiag(
Loc, diag::warn_odr_field_type_inconsistent)
4155 << Name <<
D->getType() << FoundField->getType();
4156 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4157 << FoundField->getType();
4163 Error Err = Error::success();
4167 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4169 return std::move(Err);
4170 const Type *ToCapturedVLAType =
nullptr;
4172 ToCapturedVLAType, cast_or_null<Type>(
D->getCapturedVLAType())))
4173 return std::move(Err);
4176 if (GetImportedOrCreateDecl(ToField,
D, Importer.
getToContext(), DC,
4177 ToInnerLocStart,
Loc, Name.getAsIdentifierInfo(),
4178 ToType, ToTInfo, ToBitWidth,
D->isMutable(),
4179 D->getInClassInitStyle()))
4185 Err = Importer.ImportAttrs(ToField,
D);
4187 return std::move(Err);
4191 if (ToCapturedVLAType)
4196 auto ToInitializer =
importChecked(Err,
D->getInClassInitializer());
4198 return std::move(Err);
4199 if (ToInitializer) {
4201 if (AlreadyImported)
4202 assert(ToInitializer == AlreadyImported &&
4203 "Duplicate import of in-class initializer.");
4218 return std::move(Err);
4223 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4224 for (
unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4225 if (
auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
4233 FoundField->getType(),
4240 if (!Name && I < N-1)
4244 Importer.
ToDiag(
Loc, diag::warn_odr_field_type_inconsistent)
4245 << Name <<
D->getType() << FoundField->getType();
4246 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4247 << FoundField->getType();
4254 auto TypeOrErr =
import(
D->getType());
4256 return TypeOrErr.takeError();
4262 for (
auto *PI :
D->chain())
4264 NamedChain[i++] = *ToD;
4266 return ToD.takeError();
4270 if (GetImportedOrCreateDecl(ToIndirectField,
D, Importer.
getToContext(), DC,
4271 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
4273 return ToIndirectField;
4278 return ToIndirectField;
4308 unsigned int FriendCount = 0;
4309 std::optional<unsigned int> FriendPosition;
4312 for (
FriendDecl *FoundFriend : RD->friends()) {
4313 if (FoundFriend == FD) {
4314 FriendPosition = FriendCount;
4321 assert(FriendPosition &&
"Friend decl not found in own parent.");
4323 return {FriendCount, *FriendPosition};
4330 return std::move(Err);
4335 const auto *RD = cast<CXXRecordDecl>(DC);
4337 for (
FriendDecl *ImportedFriend : RD->friends())
4339 ImportedEquivalentFriends.push_back(ImportedFriend);
4344 assert(ImportedEquivalentFriends.size() <= CountAndPosition.
TotalCount &&
4345 "Class with non-matching friends is imported, ODR check wrong?");
4346 if (ImportedEquivalentFriends.size() == CountAndPosition.
TotalCount)
4348 D, ImportedEquivalentFriends[CountAndPosition.
IndexOfDecl]);
4353 if (
NamedDecl *FriendD =
D->getFriendDecl()) {
4355 if (Error Err = importInto(ToFriendD, FriendD))
4356 return std::move(Err);
4364 if (
auto TSIOrErr =
import(
D->getFriendType()))
4367 return TSIOrErr.takeError();
4372 for (
unsigned I = 0; I <
D->NumTPLists; I++) {
4373 if (
auto ListOrErr =
import(FromTPLists[I]))
4374 ToTPLists[I] = *ListOrErr;
4376 return ListOrErr.takeError();
4381 return LocationOrErr.takeError();
4382 auto FriendLocOrErr =
import(
D->getFriendLoc());
4383 if (!FriendLocOrErr)
4384 return FriendLocOrErr.takeError();
4387 if (GetImportedOrCreateDecl(FrD,
D, Importer.
getToContext(), DC,
4388 *LocationOrErr, ToFU,
4389 *FriendLocOrErr, ToTPLists))
4405 return std::move(Err);
4410 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4411 for (
auto *FoundDecl : FoundDecls) {
4412 if (
ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
4414 FoundIvar->getType())) {
4419 Importer.
ToDiag(
Loc, diag::warn_odr_ivar_type_inconsistent)
4420 << Name <<
D->getType() << FoundIvar->getType();
4421 Importer.
ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
4422 << FoundIvar->getType();
4428 Error Err = Error::success();
4430 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4432 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4434 return std::move(Err);
4437 if (GetImportedOrCreateDecl(
4438 ToIvar,
D, Importer.
getToContext(), cast<ObjCContainerDecl>(DC),
4439 ToInnerLocStart,
Loc, Name.getAsIdentifierInfo(),
4440 ToType, ToTypeSourceInfo,
4441 D->getAccessControl(),ToBitWidth,
D->getSynthesize()))
4452 auto RedeclIt = Redecls.begin();
4455 for (; RedeclIt != Redecls.end() && *RedeclIt !=
D; ++RedeclIt) {
4458 return RedeclOrErr.takeError();
4460 assert(*RedeclIt ==
D);
4468 return std::move(Err);
4474 VarDecl *FoundByLookup =
nullptr;
4475 if (
D->isFileVarDecl()) {
4478 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4479 for (
auto *FoundDecl : FoundDecls) {
4483 if (
auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4487 FoundVar->getType())) {
4492 if (
D->isThisDeclarationADefinition() && FoundDef)
4499 const VarDecl *FoundDInit =
nullptr;
4500 if (
D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
4504 FoundByLookup = FoundVar;
4512 if (FoundArray && TArray) {
4513 if (isa<IncompleteArrayType>(FoundArray) &&
4514 isa<ConstantArrayType>(TArray)) {
4516 if (
auto TyOrErr =
import(
D->getType()))
4517 FoundVar->setType(*TyOrErr);
4519 return TyOrErr.takeError();
4521 FoundByLookup = FoundVar;
4523 }
else if (isa<IncompleteArrayType>(TArray) &&
4524 isa<ConstantArrayType>(FoundArray)) {
4525 FoundByLookup = FoundVar;
4530 Importer.
ToDiag(
Loc, diag::warn_odr_variable_type_inconsistent)
4531 << Name <<
D->getType() << FoundVar->getType();
4532 Importer.
ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4533 << FoundVar->getType();
4534 ConflictingDecls.push_back(FoundDecl);
4538 if (!ConflictingDecls.empty()) {
4540 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4542 Name = NameOrErr.get();
4544 return NameOrErr.takeError();
4548 Error Err = Error::success();
4550 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4551 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4554 return std::move(Err);
4557 if (
auto *FromDecomp = dyn_cast<DecompositionDecl>(
D)) {
4561 return std::move(Err);
4563 if (GetImportedOrCreateDecl(
4564 ToDecomp, FromDecomp, Importer.
getToContext(), DC, ToInnerLocStart,
4565 Loc, ToType, ToTypeSourceInfo,
D->getStorageClass(),
Bindings))
4570 if (GetImportedOrCreateDecl(ToVar,
D, Importer.
getToContext(), DC,
4571 ToInnerLocStart,
Loc,
4572 Name.getAsIdentifierInfo(), ToType,
4573 ToTypeSourceInfo,
D->getStorageClass()))
4581 if (
D->isInlineSpecified())
4586 if (FoundByLookup) {
4592 if (
D->getDescribedVarTemplate()) {
4593 auto ToVTOrErr =
import(
D->getDescribedVarTemplate());
4595 return ToVTOrErr.takeError();
4598 VarDecl *FromInst =
D->getInstantiatedFromStaticDataMember();
4602 return ToInstOrErr.takeError();
4603 if (
ExpectedSLoc POIOrErr =
import(MSI->getPointOfInstantiation()))
4606 return POIOrErr.takeError();
4610 return std::move(Err);
4612 if (
D->isConstexpr())
4615 addDeclToContexts(
D, ToVar);
4618 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4621 return RedeclOrErr.takeError();
4632 Error Err = Error::success();
4637 return std::move(Err);
4641 if (GetImportedOrCreateDecl(ToParm,
D, Importer.
getToContext(), DC,
4642 ToLocation, ToDeclName.getAsIdentifierInfo(),
4643 ToType,
D->getParameterKind()))
4659 return ToDefArgOrErr.takeError();
4663 if (
auto ToDefArgOrErr =
import(FromParam->
getDefaultArg()))
4666 return ToDefArgOrErr.takeError();
4669 return Error::success();
4674 Error Err = Error::success();
4679 return std::move(Err);
4688 Error Err = Error::success();
4691 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4693 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4695 return std::move(Err);
4698 if (GetImportedOrCreateDecl(ToParm,
D, Importer.
getToContext(), DC,
4699 ToInnerLocStart, ToLocation,
4700 ToDeclName.getAsIdentifierInfo(), ToType,
4701 ToTypeSourceInfo,
D->getStorageClass(),
4709 return std::move(Err);
4711 if (
D->isObjCMethodParameter()) {
4716 D->getFunctionScopeIndex());
4729 return std::move(Err);
4733 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4734 for (
auto *FoundDecl : FoundDecls) {
4735 if (
auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4736 if (FoundMethod->isInstanceMethod() !=
D->isInstanceMethod())
4741 FoundMethod->getReturnType())) {
4742 Importer.
ToDiag(
Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4743 <<
D->isInstanceMethod() << Name <<
D->getReturnType()
4744 << FoundMethod->getReturnType();
4745 Importer.
ToDiag(FoundMethod->getLocation(),
4746 diag::note_odr_objc_method_here)
4747 <<
D->isInstanceMethod() << Name;
4753 if (
D->param_size() != FoundMethod->param_size()) {
4754 Importer.
ToDiag(
Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4755 <<
D->isInstanceMethod() << Name
4756 <<
D->param_size() << FoundMethod->param_size();
4757 Importer.
ToDiag(FoundMethod->getLocation(),
4758 diag::note_odr_objc_method_here)
4759 <<
D->isInstanceMethod() << Name;
4766 PEnd =
D->param_end(), FoundP = FoundMethod->param_begin();
4767 P != PEnd; ++
P, ++FoundP) {
4769 (*FoundP)->getType())) {
4770 Importer.
FromDiag((*P)->getLocation(),
4771 diag::warn_odr_objc_method_param_type_inconsistent)
4772 <<
D->isInstanceMethod() << Name
4773 << (*P)->getType() << (*FoundP)->getType();
4774 Importer.
ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4775 << (*FoundP)->getType();
4783 if (
D->isVariadic() != FoundMethod->isVariadic()) {
4784 Importer.
ToDiag(
Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4785 <<
D->isInstanceMethod() << Name;
4786 Importer.
ToDiag(FoundMethod->getLocation(),
4787 diag::note_odr_objc_method_here)
4788 <<
D->isInstanceMethod() << Name;
4798 Error Err = Error::success();
4801 auto ToReturnTypeSourceInfo =
4804 return std::move(Err);
4807 if (GetImportedOrCreateDecl(
4809 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4810 D->isInstanceMethod(),
D->isVariadic(),
D->isPropertyAccessor(),
4811 D->isSynthesizedAccessorStub(),
D->
isImplicit(),
D->isDefined(),
4812 D->getImplementationControl(),
D->hasRelatedResultType()))
4820 for (
auto *FromP :
D->parameters()) {
4822 ToParams.push_back(*ToPOrErr);
4824 return ToPOrErr.takeError();
4828 for (
auto *ToParam : ToParams) {
4829 ToParam->setOwningFunction(ToMethod);
4834 D->getSelectorLocs(FromSelLocs);
4837 return std::move(Err);
4847 if (
D->getSelfDecl())
4861 return std::move(Err);
4865 Error Err = Error::success();
4869 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4871 return std::move(Err);
4874 if (GetImportedOrCreateDecl(
4876 ToVarianceLoc,
D->getIndex(),
4877 ToLocation, Name.getAsIdentifierInfo(),
4878 ToColonLoc, ToTypeSourceInfo))
4884 return std::move(Err);
4885 Result->setTypeForDecl(ToTypeForDecl);
4886 Result->setLexicalDeclContext(LexicalDC);
4897 return std::move(Err);
4902 if (Error Err = importInto(ToInterface,
D->getClassInterface()))
4903 return std::move(Err);
4911 Error Err = Error::success();
4913 auto ToCategoryNameLoc =
importChecked(Err,
D->getCategoryNameLoc());
4914 auto ToIvarLBraceLoc =
importChecked(Err,
D->getIvarLBraceLoc());
4915 auto ToIvarRBraceLoc =
importChecked(Err,
D->getIvarRBraceLoc());
4917 return std::move(Err);
4919 if (GetImportedOrCreateDecl(ToCategory,
D, Importer.
getToContext(), DC,
4922 Name.getAsIdentifierInfo(), ToInterface,
4935 return PListOrErr.takeError();
4941 =
D->protocol_loc_begin();
4943 FromProtoEnd =
D->protocol_end();
4944 FromProto != FromProtoEnd;
4945 ++FromProto, ++FromProtoLoc) {
4947 Protocols.push_back(*ToProtoOrErr);
4949 return ToProtoOrErr.takeError();
4951 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4952 ProtocolLocs.push_back(*ToProtoLocOrErr);
4954 return ToProtoLocOrErr.takeError();
4967 return std::move(Err);
4970 if (
D->getImplementation()) {
4972 import(
D->getImplementation()))
4975 return ToImplOrErr.takeError();
4987 return Error::success();
5000 FromProto != FromProtoEnd;
5001 ++FromProto, ++FromProtoLoc) {
5003 Protocols.push_back(*ToProtoOrErr);
5005 return ToProtoOrErr.takeError();
5007 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5008 ProtocolLocs.push_back(*ToProtoLocOrErr);
5010 return ToProtoLocOrErr.takeError();
5023 return Error::success();
5035 return ImportedDefOrErr.takeError();
5044 return std::move(Err);
5049 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5050 for (
auto *FoundDecl : FoundDecls) {
5054 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
5060 auto ToAtBeginLocOrErr =
import(
D->getAtStartLoc());
5061 if (!ToAtBeginLocOrErr)
5062 return ToAtBeginLocOrErr.takeError();
5064 if (GetImportedOrCreateDecl(ToProto,
D, Importer.
getToContext(), DC,
5065 Name.getAsIdentifierInfo(),
Loc,
5075 if (
D->isThisDeclarationADefinition())
5077 return std::move(Err);
5085 return std::move(Err);
5088 if (!ExternLocOrErr)
5089 return ExternLocOrErr.takeError();
5093 return LangLocOrErr.takeError();
5095 bool HasBraces =
D->hasBraces();
5098 if (GetImportedOrCreateDecl(ToLinkageSpec,
D, Importer.
getToContext(), DC,
5099 *ExternLocOrErr, *LangLocOrErr,
5100 D->getLanguage(), HasBraces))
5101 return ToLinkageSpec;
5105 if (!RBraceLocOrErr)
5106 return RBraceLocOrErr.takeError();
5113 return ToLinkageSpec;
5124 return ToShadowOrErr.takeError();
5135 return std::move(Err);
5139 Error Err = Error::success();
5144 return std::move(Err);
5148 return std::move(Err);
5151 if (GetImportedOrCreateDecl(ToUsing,
D, Importer.
getToContext(), DC,
5152 ToUsingLoc, ToQualifierLoc, NameInfo,
5163 ToUsing, *ToPatternOrErr);
5165 return ToPatternOrErr.takeError();
5177 return std::move(Err);
5181 Error Err = Error::success();
5187 return std::move(Err);
5190 if (GetImportedOrCreateDecl(ToUsingEnum,
D, Importer.
getToContext(), DC,
5191 ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType))
5203 return ToPatternOrErr.takeError();
5215 return std::move(Err);
5220 if (!ToIntroducerOrErr)
5221 return ToIntroducerOrErr.takeError();
5225 return ToTargetOrErr.takeError();
5228 if (
auto *FromConstructorUsingShadow =
5229 dyn_cast<ConstructorUsingShadowDecl>(
D)) {
5230 Error Err = Error::success();
5232 Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
5234 return std::move(Err);
5240 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
5242 cast<UsingDecl>(*ToIntroducerOrErr),
5243 Nominated ? Nominated : *ToTargetOrErr,
5244 FromConstructorUsingShadow->constructsVirtualBase()))
5248 Name, *ToIntroducerOrErr, *ToTargetOrErr))
5259 ToShadow, *ToPatternOrErr);
5263 return ToPatternOrErr.takeError();
5277 return std::move(Err);
5281 auto ToComAncestorOrErr = Importer.
ImportContext(
D->getCommonAncestor());
5282 if (!ToComAncestorOrErr)
5283 return ToComAncestorOrErr.takeError();
5285 Error Err = Error::success();
5286 auto ToNominatedNamespace =
importChecked(Err,
D->getNominatedNamespace());
5288 auto ToNamespaceKeyLocation =
5291 auto ToIdentLocation =
importChecked(Err,
D->getIdentLocation());
5293 return std::move(Err);
5296 if (GetImportedOrCreateDecl(ToUsingDir,
D, Importer.
getToContext(), DC,
5298 ToNamespaceKeyLocation,
5301 ToNominatedNamespace, *ToComAncestorOrErr))
5316 return std::move(Err);
5320 auto ToInstantiatedFromUsingOrErr =
5321 Importer.
Import(
D->getInstantiatedFromUsingDecl());
5322 if (!ToInstantiatedFromUsingOrErr)
5323 return ToInstantiatedFromUsingOrErr.takeError();
5326 return std::move(Err);
5329 if (GetImportedOrCreateDecl(ToUsingPack,
D, Importer.
getToContext(), DC,
5330 cast<NamedDecl>(*ToInstantiatedFromUsingOrErr),
5334 addDeclToContexts(
D, ToUsingPack);
5346 return std::move(Err);
5350 Error Err = Error::success();
5356 return std::move(Err);
5360 return std::move(Err);
5363 if (GetImportedOrCreateDecl(ToUsingValue,
D, Importer.
getToContext(), DC,
5364 ToUsingLoc, ToQualifierLoc, NameInfo,
5366 return ToUsingValue;
5372 return ToUsingValue;
5382 return std::move(Err);
5386 Error Err = Error::success();
5392 return std::move(Err);
5395 if (GetImportedOrCreateDecl(ToUsing,
D, Importer.
getToContext(), DC,
5396 ToUsingLoc, ToTypenameLoc,
5397 ToQualifierLoc,
Loc, Name, ToEllipsisLoc))
5408 Decl* ToD =
nullptr;
5409 switch (
D->getBuiltinTemplateKind()) {
5417 assert(ToD &&
"BuiltinTemplateDecl of unsupported kind!");
5428 if (
auto FromSuperOrErr =
import(FromSuper))
5429 FromSuper = *FromSuperOrErr;
5431 return FromSuperOrErr.takeError();
5435 if ((
bool)FromSuper != (
bool)ToSuper ||
5438 diag::warn_odr_objc_superclass_inconsistent)
5445 diag::note_odr_objc_missing_superclass);
5448 diag::note_odr_objc_superclass)
5452 diag::note_odr_objc_missing_superclass);
5458 return Error::success();
5469 return SuperTInfoOrErr.takeError();
5480 FromProto != FromProtoEnd;
5481 ++FromProto, ++FromProtoLoc) {
5483 Protocols.push_back(*ToProtoOrErr);
5485 return ToProtoOrErr.takeError();
5487 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5488 ProtocolLocs.push_back(*ToProtoLocOrErr);
5490 return ToProtoLocOrErr.takeError();
5501 auto ToCatOrErr =
import(Cat);
5503 return ToCatOrErr.takeError();
5512 return ToImplOrErr.takeError();
5519 return Error::success();
5528 for (
auto *fromTypeParam : *list) {
5529 if (
auto toTypeParamOrErr =
import(fromTypeParam))
5530 toTypeParams.push_back(*toTypeParamOrErr);
5532 return toTypeParamOrErr.takeError();
5536 if (!LAngleLocOrErr)
5537 return LAngleLocOrErr.takeError();
5540 if (!RAngleLocOrErr)
5541 return RAngleLocOrErr.takeError();
5558 return ImportedDefOrErr.takeError();
5567 return std::move(Err);
5573 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5574 for (
auto *FoundDecl : FoundDecls) {
5578 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
5586 if (!AtBeginLocOrErr)
5587 return AtBeginLocOrErr.takeError();
5589 if (GetImportedOrCreateDecl(
5591 *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
5593 nullptr,
Loc,
D->isImplicitInterfaceDecl()))
5601 if (
auto ToPListOrErr =
5605 return ToPListOrErr.takeError();
5607 if (
D->isThisDeclarationADefinition())
5609 return std::move(Err);
5617 if (Error Err = importInto(
Category,
D->getCategoryDecl()))
5618 return std::move(Err);
5624 return std::move(Err);
5626 Error Err = Error::success();
5629 auto ToCategoryNameLoc =
importChecked(Err,
D->getCategoryNameLoc());
5631 return std::move(Err);
5633 if (GetImportedOrCreateDecl(
5636 ToLocation, ToAtStartLoc, ToCategoryNameLoc))
5641 Category->setImplementation(ToImpl);
5646 return std::move(Err);
5655 if (Error Err = importInto(Iface,
D->getClassInterface()))
5656 return std::move(Err);
5660 if (Error Err = importInto(Super,
D->getSuperClass()))
5661 return std::move(Err);
5669 return std::move(Err);
5671 Error Err = Error::success();
5674 auto ToSuperClassLoc =
importChecked(Err,
D->getSuperClassLoc());
5675 auto ToIvarLBraceLoc =
importChecked(Err,
D->getIvarLBraceLoc());
5676 auto ToIvarRBraceLoc =
importChecked(Err,
D->getIvarRBraceLoc());
5678 return std::move(Err);
5680 if (GetImportedOrCreateDecl(Impl,
D, Importer.
getToContext(),
5704 diag::warn_odr_objc_superclass_inconsistent)
5710 diag::note_odr_objc_superclass)
5714 diag::note_odr_objc_missing_superclass);
5715 if (
D->getSuperClass())
5717 diag::note_odr_objc_superclass)
5718 <<
D->getSuperClass()->getDeclName();
5721 diag::note_odr_objc_missing_superclass);
5729 return std::move(Err);
5741 return std::move(Err);
5746 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5747 for (
auto *FoundDecl : FoundDecls) {
5748 if (
auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
5751 if (FoundProp->isInstanceProperty() !=
D->isInstanceProperty())
5756 FoundProp->getType())) {
5757 Importer.
ToDiag(
Loc, diag::warn_odr_objc_property_type_inconsistent)
5758 << Name <<
D->getType() << FoundProp->getType();
5759 Importer.
ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
5760 << FoundProp->getType();
5773 Error Err = Error::success();
5775 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
5779 return std::move(Err);
5783 if (GetImportedOrCreateDecl(
5785 Name.getAsIdentifierInfo(), ToAtLoc,
5786 ToLParenLoc, ToType,
5787 ToTypeSourceInfo,
D->getPropertyImplementation()))
5792 auto ToGetterNameLoc =
importChecked(Err,
D->getGetterNameLoc());
5793 auto ToSetterNameLoc =
importChecked(Err,
D->getSetterNameLoc());
5794 auto ToGetterMethodDecl =
importChecked(Err,
D->getGetterMethodDecl());
5795 auto ToSetterMethodDecl =
importChecked(Err,
D->getSetterMethodDecl());
5796 auto ToPropertyIvarDecl =
importChecked(Err,
D->getPropertyIvarDecl());
5798 return std::move(Err);
5805 D->getPropertyAttributesAsWritten());
5817 if (Error Err = importInto(
Property,
D->getPropertyDecl()))
5818 return std::move(Err);
5822 return std::move(Err);
5824 auto *InImpl = cast<ObjCImplDecl>(LexicalDC);
5828 if (Error Err = importInto(Ivar,
D->getPropertyIvarDecl()))
5829 return std::move(Err);
5832 = InImpl->FindPropertyImplDecl(
Property->getIdentifier(),
5836 Error Err = Error::success();
5839 auto ToPropertyIvarDeclLoc =
5842 return std::move(Err);
5844 if (GetImportedOrCreateDecl(ToImpl,
D, Importer.
getToContext(), DC,
5847 D->getPropertyImplementation(), Ivar,
5848 ToPropertyIvarDeclLoc))
5858 diag::warn_odr_objc_property_impl_kind_inconsistent)
5863 diag::note_odr_objc_property_impl_kind)
5864 <<
D->getPropertyDecl()->getDeclName()
5874 diag::warn_odr_objc_synthesize_ivar_inconsistent)
5878 Importer.
FromDiag(
D->getPropertyIvarDeclLoc(),
5879 diag::note_odr_objc_synthesize_ivar_here)
5880 <<
D->getPropertyIvarDecl()->getDeclName();
5900 return BeginLocOrErr.takeError();
5904 return LocationOrErr.takeError();
5907 if (GetImportedOrCreateDecl(
5910 *BeginLocOrErr, *LocationOrErr,
5911 D->getDepth(),
D->getIndex(), Importer.
Import(
D->getIdentifier()),
5913 D->hasTypeConstraint()))
5919 Error Err = Error::success();
5920 auto ToConceptRef =
importChecked(Err, TC->getConceptReference());
5921 auto ToIDC =
importChecked(Err, TC->getImmediatelyDeclaredConstraint());
5923 return std::move(Err);
5928 if (
D->hasDefaultArgument()) {
5930 import(
D->getDefaultArgument());
5931 if (!ToDefaultArgOrErr)
5932 return ToDefaultArgOrErr.takeError();
5942 Error Err = Error::success();
5946 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
5947 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
5949 return std::move(Err);
5952 if (GetImportedOrCreateDecl(ToD,
D, Importer.
getToContext(),
5954 ToInnerLocStart, ToLocation,
D->getDepth(),
5956 ToDeclName.getAsIdentifierInfo(), ToType,
5960 if (
D->hasDefaultArgument()) {
5962 import(
D->getDefaultArgument());
5963 if (!ToDefaultArgOrErr)
5964 return ToDefaultArgOrErr.takeError();
5974 auto NameOrErr =
import(
D->getDeclName());
5976 return NameOrErr.takeError();
5981 return LocationOrErr.takeError();
5984 auto TemplateParamsOrErr =
import(
D->getTemplateParameters());
5985 if (!TemplateParamsOrErr)
5986 return TemplateParamsOrErr.takeError();
5989 if (GetImportedOrCreateDecl(
5993 (*NameOrErr).getAsIdentifierInfo(),
D->wasDeclaredWithTypename(),
5994 *TemplateParamsOrErr))
5997 if (
D->hasDefaultArgument()) {
5999 import(
D->getDefaultArgument());
6000 if (!ToDefaultArgOrErr)
6001 return ToDefaultArgOrErr.takeError();
6011 assert(
D->getTemplatedDecl() &&
"Should be called on templates only");
6012 auto *ToTemplatedDef =
D->getTemplatedDecl()->getDefinition();
6013 if (!ToTemplatedDef)
6016 return cast_or_null<T>(TemplateWithDef);
6027 return std::move(Err);
6041 bool DependentFriend = IsDependentFriend(
D);
6048 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6049 for (
auto *FoundDecl : FoundDecls) {
6055 auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(
Found);
6056 if (FoundTemplate) {
6061 bool IgnoreTemplateParmDepth =
6065 IgnoreTemplateParmDepth)) {
6066 if (DependentFriend || IsDependentFriend(FoundTemplate))
6071 if (
D->isThisDeclarationADefinition() && TemplateWithDef)
6074 FoundByLookup = FoundTemplate;
6079 ConflictingDecls.push_back(FoundDecl);
6083 if (!ConflictingDecls.empty()) {
6086 ConflictingDecls.size());
6088 Name = NameOrErr.get();
6090 return NameOrErr.takeError();
6096 auto TemplateParamsOrErr =
import(
D->getTemplateParameters());
6097 if (!TemplateParamsOrErr)
6098 return TemplateParamsOrErr.takeError();
6102 if (Error Err = importInto(ToTemplated, FromTemplated))
6103 return std::move(Err);
6108 *TemplateParamsOrErr, ToTemplated))
6116 addDeclToContexts(
D, D2);
6117 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
6119 if (FoundByLookup) {
6133 "Found decl must have its templated decl set");
6136 if (ToTemplated != PrevTemplated)
6149 if (Error Err = importInto(ClassTemplate,
D->getSpecializedTemplate()))
6150 return std::move(Err);
6155 return std::move(Err);
6161 return std::move(Err);
6164 void *InsertPos =
nullptr;
6167 dyn_cast<ClassTemplatePartialSpecializationDecl>(
D);
6175 return ToTPListOrErr.takeError();
6176 ToTPList = *ToTPListOrErr;
6186 if (
D->isThisDeclarationADefinition() && PrevDefinition) {
6190 for (
auto *FromField :
D->fields()) {
6191 auto ToOrErr =
import(FromField);
6193 return ToOrErr.takeError();
6199 auto ToOrErr =
import(FromM);
6201 return ToOrErr.takeError();
6209 return PrevDefinition;
6220 return BeginLocOrErr.takeError();
6223 return IdLocOrErr.takeError();
6227 if (
const auto *ASTTemplateArgs =
D->getTemplateArgsAsWritten()) {
6229 return std::move(Err);
6236 if (Error Err = importInto(
6238 return std::move(Err);
6241 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
6242 D2,
D, Importer.
getToContext(),
D->getTagKind(), DC, *BeginLocOrErr,
6243 *IdLocOrErr, ToTPList, ClassTemplate,
6246 cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
6251 auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);
6258 PartSpec2->setInstantiatedFromMember(*ToInstOrErr);
6260 return ToInstOrErr.takeError();
6262 updateLookupTableForTemplateParameters(*ToTPList);
6264 if (GetImportedOrCreateDecl(
6266 *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
6287 if (
auto BraceRangeOrErr =
import(
D->getBraceRange()))
6290 return BraceRangeOrErr.takeError();
6293 return std::move(Err);
6296 if (
auto LocOrErr =
import(
D->getQualifierLoc()))
6299 return LocOrErr.takeError();
6301 if (
D->getTemplateArgsAsWritten())
6304 if (
auto LocOrErr =
import(
D->getTemplateKeywordLoc()))
6307 return LocOrErr.takeError();
6309 if (
auto LocOrErr =
import(
D->getExternKeywordLoc()))
6312 return LocOrErr.takeError();
6314 if (
D->getPointOfInstantiation().isValid()) {
6315 if (
auto POIOrErr =
import(
D->getPointOfInstantiation()))
6318 return POIOrErr.takeError();
6323 if (
auto P =
D->getInstantiatedFrom()) {
6325 if (
auto CTDorErr =
import(CTD))
6328 auto *CTPSD = cast<ClassTemplatePartialSpecializationDecl *>(
P);
6329 auto CTPSDOrErr =
import(CTPSD);
6331 return CTPSDOrErr.takeError();
6334 for (
unsigned I = 0; I < DArgs.
size(); ++I) {
6336 if (
auto ArgOrErr =
import(DArg))
6337 D2ArgsVec[I] = *ArgOrErr;
6339 return ArgOrErr.takeError();
6347 if (
D->isCompleteDefinition())
6349 return std::move(Err);
6361 return std::move(Err);
6367 "Variable templates cannot be declared at function scope");
6370 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6372 for (
auto *FoundDecl : FoundDecls) {
6376 if (
VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
6379 D->getTemplatedDecl()))
6386 assert(FoundTemplate->getDeclContext()->isRecord() &&
6387 "Member variable template imported as non-member, "
6388 "inconsistent imported AST?");
6391 if (!
D->isThisDeclarationADefinition())
6394 if (FoundDef &&
D->isThisDeclarationADefinition())
6397 FoundByLookup = FoundTemplate;
6400 ConflictingDecls.push_back(FoundDecl);
6404 if (!ConflictingDecls.empty()) {
6407 ConflictingDecls.size());
6409 Name = NameOrErr.get();
6411 return NameOrErr.takeError();
6414 VarDecl *DTemplated =
D->getTemplatedDecl();
6420 return TypeOrErr.takeError();
6424 if (Error Err = importInto(ToTemplated, DTemplated))
6425 return std::move(Err);
6428 auto TemplateParamsOrErr =
import(
D->getTemplateParameters());
6429 if (!TemplateParamsOrErr)
6430 return TemplateParamsOrErr.takeError();
6434 Name, *TemplateParamsOrErr, ToTemplated))
6443 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
6445 if (FoundByLookup) {
6449 auto *PrevTemplated =
6451 if (ToTemplated != PrevTemplated)
6466 auto RedeclIt = Redecls.begin();
6469 for (; RedeclIt != Redecls.end() && *RedeclIt !=
D; ++RedeclIt) {
6472 return RedeclOrErr.takeError();
6474 assert(*RedeclIt ==
D);
6477 if (Error Err = importInto(VarTemplate,
D->getSpecializedTemplate()))
6478 return std::move(Err);
6483 return std::move(Err);
6488 return BeginLocOrErr.takeError();
6492 return IdLocOrErr.takeError();
6498 return std::move(Err);
6501 void *InsertPos =
nullptr;
6504 if (FoundSpecialization) {
6512 "Member variable template specialization imported as non-member, "
6513 "inconsistent imported AST?");
6516 if (!
D->isThisDeclarationADefinition())
6521 if (FoundDef &&
D->isThisDeclarationADefinition())
6532 if (
const auto *Args =
D->getTemplateArgsAsWritten()) {
6534 return std::move(Err);
6539 if (
auto *FromPartial = dyn_cast<PartVarSpecDecl>(
D)) {
6540 auto ToTPListOrErr =
import(FromPartial->getTemplateParameters());
6542 return ToTPListOrErr.takeError();
6544 PartVarSpecDecl *ToPartial;
6545 if (GetImportedOrCreateDecl(ToPartial,
D, Importer.
getToContext(), DC,
6546 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
6548 D->getStorageClass(), TemplateArgs))
6552 import(FromPartial->getInstantiatedFromMember()))
6555 return ToInstOrErr.takeError();
6557 if (FromPartial->isMemberSpecialization())
6558 ToPartial->setMemberSpecialization();
6566 if (GetImportedOrCreateDecl(D2,
D, Importer.
getToContext(), DC,
6567 *BeginLocOrErr, *IdLocOrErr, VarTemplate,
6568 QualType(),
nullptr,
D->getStorageClass(),
6579 if (Error Err = importInto(
T,
D->getType()))
6580 return std::move(Err);
6583 auto TInfoOrErr =
import(
D->getTypeSourceInfo());
6585 return TInfoOrErr.takeError();
6588 if (
D->getPointOfInstantiation().isValid()) {
6589 if (
ExpectedSLoc POIOrErr =
import(
D->getPointOfInstantiation()))
6592 return POIOrErr.takeError();
6597 if (
D->getTemplateArgsAsWritten())
6600 if (
auto LocOrErr =
import(
D->getQualifierLoc()))
6603 return LocOrErr.takeError();
6605 if (
D->isConstexpr())
6611 return std::move(Err);
6613 if (FoundSpecialization)
6616 addDeclToContexts(
D, D2);
6619 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
6622 return RedeclOrErr.takeError();
6636 return std::move(Err);
6648 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6649 for (
auto *FoundDecl : FoundDecls) {
6653 if (
auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
6659 if (
D->isThisDeclarationADefinition() && TemplateWithDef)
6662 FoundByLookup = FoundTemplate;
6670 auto ParamsOrErr =
import(
D->getTemplateParameters());
6672 return ParamsOrErr.takeError();
6676 if (Error Err = importInto(TemplatedFD,
D->getTemplatedDecl()))
6677 return std::move(Err);
6694 OldParamDC.reserve(Params->
size());
6695 llvm::transform(*Params, std::back_inserter(OldParamDC),
6699 if (GetImportedOrCreateDecl(ToFunc,
D, Importer.
getToContext(), DC,
Loc, Name,
6700 Params, TemplatedFD))
6706 ToFunc->setLexicalDeclContext(LexicalDC);
6707 addDeclToContexts(
D, ToFunc);
6710 if (
LT && !OldParamDC.empty()) {
6711 for (
unsigned int I = 0; I < OldParamDC.size(); ++I)
6715 if (FoundByLookup) {
6720 "Found decl must have its templated decl set");
6721 auto *PrevTemplated =
6723 if (TemplatedFD != PrevTemplated)
6726 ToFunc->setPreviousDecl(Recent);
6737 Importer.
FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
6738 << S->getStmtClassName();
6747 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; I++) {
6751 Names.push_back(ToII);
6754 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; I++) {
6758 Names.push_back(ToII);
6762 for (
unsigned I = 0,
E = S->getNumClobbers(); I !=
E; I++) {
6763 if (
auto ClobberOrErr =
import(S->getClobberStringLiteral(I)))
6764 Clobbers.push_back(*ClobberOrErr);
6766 return ClobberOrErr.takeError();
6771 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; I++) {
6772 if (
auto OutputOrErr =
import(S->getOutputConstraintLiteral(I)))
6773 Constraints.push_back(*OutputOrErr);
6775 return OutputOrErr.takeError();
6778 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; I++) {
6779 if (
auto InputOrErr =
import(S->getInputConstraintLiteral(I)))
6780 Constraints.push_back(*InputOrErr);
6782 return InputOrErr.takeError();
6788 return std::move(Err);
6792 return std::move(Err);
6795 S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6796 return std::move(Err);
6800 return AsmLocOrErr.takeError();
6801 auto AsmStrOrErr =
import(S->getAsmString());
6803 return AsmStrOrErr.takeError();
6804 ExpectedSLoc RParenLocOrErr =
import(S->getRParenLoc());
6805 if (!RParenLocOrErr)
6806 return RParenLocOrErr.takeError();
6819 S->getNumClobbers(),
6827 Error Err = Error::success();
6832 return std::move(Err);
6838 if (!ToSemiLocOrErr)
6839 return ToSemiLocOrErr.takeError();
6841 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6848 return std::move(Err);
6850 ExpectedSLoc ToLBracLocOrErr =
import(S->getLBracLoc());
6851 if (!ToLBracLocOrErr)
6852 return ToLBracLocOrErr.takeError();
6854 ExpectedSLoc ToRBracLocOrErr =
import(S->getRBracLoc());
6855 if (!ToRBracLocOrErr)
6856 return ToRBracLocOrErr.takeError();
6861 *ToLBracLocOrErr, *ToRBracLocOrErr);
6866 Error Err = Error::success();
6871 auto ToEllipsisLoc =
importChecked(Err, S->getEllipsisLoc());
6874 return std::move(Err);
6877 ToCaseLoc, ToEllipsisLoc, ToColonLoc);
6878 ToStmt->setSubStmt(ToSubStmt);
6885 Error Err = Error::success();
6890 return std::move(Err);
6893 ToDefaultLoc, ToColonLoc, ToSubStmt);
6898 Error Err = Error::success();
6903 return std::move(Err);
6906 ToIdentLoc, ToLabelDecl, ToSubStmt);
6911 if (!ToAttrLocOrErr)
6912 return ToAttrLocOrErr.takeError();
6916 return std::move(Err);
6918 if (!ToSubStmtOrErr)
6919 return ToSubStmtOrErr.takeError();
6922 Importer.
getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6927 Error Err = Error::success();
6930 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6938 return std::move(Err);
6941 ToInit, ToConditionVariable, ToCond, ToLParenLoc,
6942 ToRParenLoc, ToThen, ToElseLoc, ToElse);
6947 Error Err = Error::success();
6949 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6956 return std::move(Err);
6960 ToCond, ToLParenLoc, ToRParenLoc);
6961 ToStmt->setBody(ToBody);
6962 ToStmt->setSwitchLoc(ToSwitchLoc);
6966 for (
SwitchCase *SC = S->getSwitchCaseList(); SC !=
nullptr;
6967 SC = SC->getNextSwitchCase()) {
6970 return ToSCOrErr.takeError();
6971 if (LastChainedSwitchCase)
6974 ToStmt->setSwitchCaseList(*ToSCOrErr);
6975 LastChainedSwitchCase = *ToSCOrErr;
6983 Error Err = Error::success();
6984 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6991 return std::move(Err);
6994 ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
6999 Error Err = Error::success();
7006 return std::move(Err);
7009 ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
7014 Error Err = Error::success();
7017 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7024 return std::move(Err);
7028 ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
7034 Error Err = Error::success();
7039 return std::move(Err);
7042 ToLabel, ToGotoLoc, ToLabelLoc);
7047 Error Err = Error::success();
7052 return std::move(Err);
7055 ToGotoLoc, ToStarLoc, ToTarget);
7059 ExpectedSLoc ToContinueLocOrErr =
import(S->getContinueLoc());
7060 if (!ToContinueLocOrErr)
7061 return ToContinueLocOrErr.takeError();
7066 auto ToBreakLocOrErr =
import(S->getBreakLoc());
7067 if (!ToBreakLocOrErr)
7068 return ToBreakLocOrErr.takeError();
7074 Error Err = Error::success();
7077 auto ToNRVOCandidate =
importChecked(Err, S->getNRVOCandidate());
7079 return std::move(Err);
7087 Error Err = Error::success();
7089 auto ToExceptionDecl =
importChecked(Err, S->getExceptionDecl());
7090 auto ToHandlerBlock =
importChecked(Err, S->getHandlerBlock());
7092 return std::move(Err);
7095 ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
7101 return ToTryLocOrErr.takeError();
7103 ExpectedStmt ToTryBlockOrErr =
import(S->getTryBlock());
7104 if (!ToTryBlockOrErr)
7105 return ToTryBlockOrErr.takeError();
7108 for (
unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
7110 if (
auto ToHandlerOrErr =
import(FromHandler))
7111 ToHandlers[HI] = *ToHandlerOrErr;
7113 return ToHandlerOrErr.takeError();
7117 cast<CompoundStmt>(*ToTryBlockOrErr), ToHandlers);
7122 Error Err = Error::success();
7129 auto ToLoopVarStmt =
importChecked(Err, S->getLoopVarStmt());
7136 return std::move(Err);
7139 ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
7140 ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
7145 Error Err = Error::success();
7152 return std::move(Err);
7163 Error Err = Error::success();
7166 auto ToCatchParamDecl =
importChecked(Err, S->getCatchParamDecl());
7169 return std::move(Err);
7172 ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
7176 ExpectedSLoc ToAtFinallyLocOrErr =
import(S->getAtFinallyLoc());
7177 if (!ToAtFinallyLocOrErr)
7178 return ToAtFinallyLocOrErr.takeError();
7179 ExpectedStmt ToAtFinallyStmtOrErr =
import(S->getFinallyBody());
7180 if (!ToAtFinallyStmtOrErr)
7181 return ToAtFinallyStmtOrErr.takeError();
7183 *ToAtFinallyStmtOrErr);
7188 Error Err = Error::success();
7191 auto ToFinallyStmt =
importChecked(Err, S->getFinallyStmt());
7193 return std::move(Err);
7196 for (
unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
7198 if (
ExpectedStmt ToCatchStmtOrErr =
import(FromCatchStmt))
7199 ToCatchStmts[CI] = *ToCatchStmtOrErr;
7201 return ToCatchStmtOrErr.takeError();
7205 ToAtTryLoc, ToTryBody,
7206 ToCatchStmts.begin(), ToCatchStmts.size(),
7213 Error Err = Error::success();
7214 auto ToAtSynchronizedLoc =
importChecked(Err, S->getAtSynchronizedLoc());
7218 return std::move(Err);
7221 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
7225 ExpectedSLoc ToThrowLocOrErr =
import(S->getThrowLoc());
7226 if (!ToThrowLocOrErr)
7227 return ToThrowLocOrErr.takeError();
7228 ExpectedExpr ToThrowExprOrErr =
import(S->getThrowExpr());
7229 if (!ToThrowExprOrErr)
7230 return ToThrowExprOrErr.takeError();
7232 *ToThrowLocOrErr, *ToThrowExprOrErr);
7239 return ToAtLocOrErr.takeError();
7241 if (!ToSubStmtOrErr)
7242 return ToSubStmtOrErr.takeError();
7257 Error Err = Error::success();
7262 return std::move(Err);
7263 auto ParentContextOrErr = Importer.
ImportContext(
E->getParentContext());
7264 if (!ParentContextOrErr)
7265 return ParentContextOrErr.takeError();
7269 RParenLoc, *ParentContextOrErr);
7274 Error Err = Error::success();
7277 auto ToWrittenTypeInfo =
importChecked(Err,
E->getWrittenTypeInfo());
7281 return std::move(Err);
7284 ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
7285 E->isMicrosoftABI());
7290 Error Err = Error::success();
7298 return std::move(Err);
7305 bool CondIsTrue = !
E->isConditionDependent() &&
E->isConditionTrue();
7308 ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
7309 ToRParenLoc, CondIsTrue);
7313 Error Err = Error::success();
7320 return std::move(Err);
7328 Error Err = Error::success();
7332 const unsigned NumSubExprs =
E->getNumSubExprs();
7336 ToSubExprs.resize(NumSubExprs);
7339 return std::move(Err);
7342 Importer.
getToContext(), ToSubExprs, ToType, ToBeginLoc, ToRParenLoc);
7348 return TypeOrErr.takeError();
7352 return BeginLocOrErr.takeError();
7359 Error Err = Error::success();
7361 Expr *ToControllingExpr =
nullptr;
7363 if (
E->isExprPredicate())
7367 assert((ToControllingExpr || ToControllingType) &&
7368 "Either the controlling expr or type must be nonnull");
7372 return std::move(Err);
7377 return std::move(Err);
7382 return std::move(Err);
7385 if (
E->isResultDependent()) {
7386 if (ToControllingExpr) {
7388 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7393 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7398 if (ToControllingExpr) {
7400 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7405 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7412 Error Err = Error::success();
7417 return std::move(Err);
7420 E->getIdentKind(),
E->isTransparent(),
7426 Error Err = Error::success();
7428 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
7433 return std::move(Err);
7436 if (
E->getDecl() !=
E->getFoundDecl()) {
7437 auto FoundDOrErr =
import(
E->getFoundDecl());
7439 return FoundDOrErr.takeError();
7440 ToFoundD = *FoundDOrErr;
7445 if (
E->hasExplicitTemplateArgs()) {
7448 E->template_arguments(), ToTAInfo))
7449 return std::move(Err);
7450 ToResInfo = &ToTAInfo;
7454 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
7455 E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
7457 if (
E->hadMultipleCandidates())
7458 ToE->setHadMultipleCandidates(
true);
7459 ToE->setIsImmediateEscalating(
E->isImmediateEscalating());
7466 return TypeOrErr.takeError();
7474 return ToInitOrErr.takeError();
7476 ExpectedSLoc ToEqualOrColonLocOrErr =
import(
E->getEqualOrColonLoc());
7477 if (!ToEqualOrColonLocOrErr)
7478 return ToEqualOrColonLocOrErr.takeError();
7482 for (
unsigned I = 1, N =
E->getNumSubExprs(); I < N; I++) {
7484 ToIndexExprs[I - 1] = *ToArgOrErr;
7486 return ToArgOrErr.takeError();
7491 return std::move(Err);
7495 ToIndexExprs, *ToEqualOrColonLocOrErr,
7496 E->usesGNUSyntax(), *ToInitOrErr);
7503 return ToTypeOrErr.takeError();
7506 if (!ToLocationOrErr)
7507 return ToLocationOrErr.takeError();
7510 *ToTypeOrErr, *ToLocationOrErr);
7516 return ToTypeOrErr.takeError();
7519 if (!ToLocationOrErr)
7520 return ToLocationOrErr.takeError();
7523 Importer.
getToContext(),
E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7530 return ToTypeOrErr.takeError();
7533 if (!ToLocationOrErr)
7534 return ToLocationOrErr.takeError();
7538 *ToTypeOrErr, *ToLocationOrErr);
7542 auto ToTypeOrErr =
import(
E->
getType());
7544 return ToTypeOrErr.takeError();
7547 if (!ToSubExprOrErr)
7548 return ToSubExprOrErr.takeError();
7551 *ToSubExprOrErr, *ToTypeOrErr);
7555 auto ToTypeOrErr =
import(
E->
getType());
7557 return ToTypeOrErr.takeError();
7560 if (!ToLocationOrErr)
7561 return ToLocationOrErr.takeError();
7564 Importer.
getToContext(),
E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
7571 return ToTypeOrErr.takeError();
7574 if (!ToLocationOrErr)
7575 return ToLocationOrErr.takeError();
7578 E->getValue(),
E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
7584 return ToTypeOrErr.takeError();
7588 E->tokloc_begin(),
E->tokloc_end(), ToLocations.begin()))
7589 return std::move(Err);
7593 *ToTypeOrErr, ToLocations.data(), ToLocations.size());
7598 Error Err = Error::success();
7600 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
7604 return std::move(Err);
7608 ToInitializer,
E->isFileScope());
7613 Error Err = Error::success();
7618 return std::move(Err);
7622 E->getSubExprs(),
E->getSubExprs() +
E->getNumSubExprs(),
7624 return std::move(Err);
7628 ToBuiltinLoc, ToExprs, ToType,
E->getOp(), ToRParenLoc);
7632 Error Err = Error::success();
7638 return std::move(Err);
7641 ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
7644 Error Err = Error::success();
7648 return std::move(Err);
7653 Error Err = Error::success();
7658 return std::move(Err);
7661 ParenExpr(ToLParen, ToRParen, ToSubExpr);
7667 return std::move(Err);
7670 if (!ToLParenLocOrErr)
7671 return ToLParenLocOrErr.takeError();
7674 if (!ToRParenLocOrErr)
7675 return ToRParenLocOrErr.takeError();
7678 ToExprs, *ToRParenLocOrErr);
7682 Error Err = Error::success();
7688 return std::move(Err);
7691 StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
7692 E->getTemplateDepth());
7696 Error Err = Error::success();
7701 return std::move(Err);
7704 E->hasStoredFPFeatures());
7705 UO->setType(ToType);
7706 UO->setSubExpr(ToSubExpr);
7707 UO->setOpcode(
E->getOpcode());
7708 UO->setOperatorLoc(ToOperatorLoc);
7709 UO->setCanOverflow(
E->canOverflow());
7710 if (
E->hasStoredFPFeatures())
7711 UO->setStoredFPFeatures(
E->getStoredFPFeatures());
7719 Error Err = Error::success();
7724 return std::move(Err);
7726 if (
E->isArgumentType()) {
7728 import(
E->getArgumentTypeInfo());
7729 if (!ToArgumentTypeInfoOrErr)
7730 return ToArgumentTypeInfoOrErr.takeError();
7733 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
7737 ExpectedExpr ToArgumentExprOrErr =
import(
E->getArgumentExpr());
7738 if (!ToArgumentExprOrErr)
7739 return ToArgumentExprOrErr.takeError();
7742 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
7746 Error Err = Error::success();
7752 return std::move(Err);
7755 Importer.
getToContext(), ToLHS, ToRHS,
E->getOpcode(), ToType,
7757 E->getFPFeatures());
7761 Error Err = Error::success();
7769 return std::move(Err);
7772 ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
7778 Error Err = Error::success();
7788 return std::move(Err);
7791 ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
7798 Error Err = Error::success();
7801 return std::move(Err);
7808 Error Err = Error::success();
7810 auto ToQueriedTypeSourceInfo =
7812 auto ToDimensionExpression =
importChecked(Err,
E->getDimensionExpression());
7816 return std::move(Err);
7819 ToBeginLoc,
E->getTrait(), ToQueriedTypeSourceInfo,
E->getValue(),
7820 ToDimensionExpression, ToEndLoc, ToType);
7824 Error Err = Error::success();
7826 auto ToQueriedExpression =
importChecked(Err,
E->getQueriedExpression());
7830 return std::move(Err);
7833 ToBeginLoc,
E->getTrait(), ToQueriedExpression,
E->getValue(),
7838 Error Err = Error::success();
7843 return std::move(Err);
7850 Error Err = Error::success();
7856 return std::move(Err);
7865 Error Err = Error::success();
7869 auto ToComputationLHSType =
importChecked(Err,
E->getComputationLHSType());
7870 auto ToComputationResultType =
7874 return std::move(Err);
7877 Importer.
getToContext(), ToLHS, ToRHS,
E->getOpcode(), ToType,
7880 ToComputationLHSType, ToComputationResultType);
7887 if (
auto SpecOrErr =
import(*I))
7888 Path.push_back(*SpecOrErr);
7890 return SpecOrErr.takeError();
7898 return ToTypeOrErr.takeError();
7901 if (!ToSubExprOrErr)
7902 return ToSubExprOrErr.takeError();
7905 if (!ToBasePathOrErr)
7906 return ToBasePathOrErr.takeError();
7909 Importer.
getToContext(), *ToTypeOrErr,
E->getCastKind(), *ToSubExprOrErr,
7914 Error Err = Error::success();
7917 auto ToTypeInfoAsWritten =
importChecked(Err,
E->getTypeInfoAsWritten());
7919 return std::move(Err);
7922 if (!ToBasePathOrErr)
7923 return ToBasePathOrErr.takeError();
7927 case Stmt::CStyleCastExprClass: {
7928 auto *CCE = cast<CStyleCastExpr>(
E);
7929 ExpectedSLoc ToLParenLocOrErr =
import(CCE->getLParenLoc());
7930 if (!ToLParenLocOrErr)
7931 return ToLParenLocOrErr.takeError();
7932 ExpectedSLoc ToRParenLocOrErr =
import(CCE->getRParenLoc());
7933 if (!ToRParenLocOrErr)
7934 return ToRParenLocOrErr.takeError();
7937 ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
7938 *ToLParenLocOrErr, *ToRParenLocOrErr);
7941 case Stmt::CXXFunctionalCastExprClass: {
7942 auto *FCE = cast<CXXFunctionalCastExpr>(
E);
7943 ExpectedSLoc ToLParenLocOrErr =
import(FCE->getLParenLoc());
7944 if (!ToLParenLocOrErr)
7945 return ToLParenLocOrErr.takeError();
7946 ExpectedSLoc ToRParenLocOrErr =
import(FCE->getRParenLoc());
7947 if (!ToRParenLocOrErr)
7948 return ToRParenLocOrErr.takeError();
7951 E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
7952 *ToLParenLocOrErr, *ToRParenLocOrErr);
7955 case Stmt::ObjCBridgedCastExprClass: {
7956 auto *OCE = cast<ObjCBridgedCastExpr>(
E);
7957 ExpectedSLoc ToLParenLocOrErr =
import(OCE->getLParenLoc());
7958 if (!ToLParenLocOrErr)
7959 return ToLParenLocOrErr.takeError();
7960 ExpectedSLoc ToBridgeKeywordLocOrErr =
import(OCE->getBridgeKeywordLoc());
7961 if (!ToBridgeKeywordLocOrErr)
7962 return ToBridgeKeywordLocOrErr.takeError();
7964 *ToLParenLocOrErr, OCE->getBridgeKind(),
E->getCastKind(),
7965 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
7967 case Stmt::BuiltinBitCastExprClass: {
7968 auto *BBC = cast<BuiltinBitCastExpr>(
E);
7969 ExpectedSLoc ToKWLocOrErr =
import(BBC->getBeginLoc());
7971 return ToKWLocOrErr.takeError();
7972 ExpectedSLoc ToRParenLocOrErr =
import(BBC->getEndLoc());
7973 if (!ToRParenLocOrErr)
7974 return ToRParenLocOrErr.takeError();
7977 ToTypeInfoAsWritten, *ToKWLocOrErr, *ToRParenLocOrErr);
7980 llvm_unreachable(
"Cast expression of unsupported type!");
7987 for (
int I = 0, N =
E->getNumComponents(); I < N; ++I) {
7993 Error Err = Error::success();
7997 return std::move(Err);
8006 auto ToBSOrErr =
import(FromNode.
getBase());
8008 return ToBSOrErr.takeError();
8013 auto ToFieldOrErr =
import(FromNode.
getField());
8015 return ToFieldOrErr.takeError();
8016 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
8021 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
8028 for (
int I = 0, N =
E->getNumExpressions(); I < N; ++I) {
8030 if (!ToIndexExprOrErr)
8031 return ToIndexExprOrErr.takeError();
8032 ToExprs[I] = *ToIndexExprOrErr;
8035 Error Err = Error::success();
8037 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8041 return std::move(Err);
8044 Importer.
getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
8045 ToExprs, ToRParenLoc);
8049 Error Err = Error::success();
8055 return std::move(Err);
8064 ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
8068 Error Err = Error::success();
8073 return std::move(Err);
8076 ToSubExpr, ToType, ToThrowLoc,
E->isThrownVariableInScope());
8081 if (!ToUsedLocOrErr)
8082 return ToUsedLocOrErr.takeError();
8084 auto ToParamOrErr =
import(
E->getParam());
8086 return ToParamOrErr.takeError();
8088 auto UsedContextOrErr = Importer.
ImportContext(
E->getUsedContext());
8089 if (!UsedContextOrErr)
8090 return UsedContextOrErr.takeError();
8100 std::optional<ParmVarDecl *> FromParam =
8102 assert(FromParam &&
"ParmVarDecl was not imported?");
8105 return std::move(Err);
8107 Expr *RewrittenInit =
nullptr;
8108 if (
E->hasRewrittenInit()) {
8111 return ExprOrErr.takeError();
8112 RewrittenInit = ExprOrErr.get();
8115 *ToParamOrErr, RewrittenInit,
8121 Error Err = Error::success();
8123 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8126 return std::move(Err);
8129 ToType, ToTypeSourceInfo, ToRParenLoc);
8135 if (!ToSubExprOrErr)
8136 return ToSubExprOrErr.takeError();
8138 auto ToDtorOrErr =
import(
E->getTemporary()->getDestructor());
8140 return ToDtorOrErr.takeError();
8150 Error Err = Error::success();
8153 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8154 auto ToParenOrBraceRange =
importChecked(Err,
E->getParenOrBraceRange());
8156 return std::move(Err);
8160 return std::move(Err);
8163 Importer.
getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
8164 ToParenOrBraceRange,
E->hadMultipleCandidates(),
8165 E->isListInitialization(),
E->isStdInitListInitialization(),
8166 E->requiresZeroInitialization());
8173 return std::move(Err);
8175 Error Err = Error::success();
8179 return std::move(Err);
8183 if (GetImportedOrCreateDecl(To,
D, Temporary, ExtendingDecl,
8184 D->getManglingNumber()))
8194 Error Err = Error::success();
8197 Err,
E->getLifetimeExtendedTemporaryDecl() ?
nullptr :
E->getSubExpr());
8198 auto ToMaterializedDecl =
8201 return std::move(Err);
8203 if (!ToTemporaryExpr)
8204 ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
8207 ToType, ToTemporaryExpr,
E->isBoundToLvalueReference(),
8208 ToMaterializedDecl);
8214 Error Err = Error::success();
8219 return std::move(Err);
8222 ToType, ToPattern, ToEllipsisLoc,
E->getNumExpansions());
8226 Error Err = Error::success();
8232 return std::move(Err);
8234 std::optional<unsigned> Length;
8236 Length =
E->getPackLength();
8239 if (
E->isPartiallySubstituted()) {
8241 ToPartialArguments))
8242 return std::move(Err);
8246 Importer.
getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
8247 Length, ToPartialArguments);
8252 Error Err = Error::success();
8254 auto ToOperatorDelete =
importChecked(Err,
E->getOperatorDelete());
8259 auto ToAllocatedTypeSourceInfo =
8262 auto ToDirectInitRange =
importChecked(Err,
E->getDirectInitRange());
8264 return std::move(Err);
8269 return std::move(Err);
8273 ToOperatorDelete,
E->passAlignment(),
E->doesUsualArrayDeleteWantSize(),
8274 ToPlacementArgs, ToTypeIdParens, ToArraySize,
E->getInitializationStyle(),
8275 ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
8280 Error Err = Error::success();
8282 auto ToOperatorDelete =
importChecked(Err,
E->getOperatorDelete());
8286 return std::move(Err);
8289 ToType,
E->isGlobalDelete(),
E->isArrayForm(),
E->isArrayFormAsWritten(),
8290 E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
8295 Error Err = Error::success();
8299 auto ToParenOrBraceRange =
importChecked(Err,
E->getParenOrBraceRange());
8301 return std::move(Err);
8305 return std::move(Err);
8308 Importer.
getToContext(), ToType, ToLocation, ToConstructor,
8309 E->isElidable(), ToArgs,
E->hadMultipleCandidates(),
8310 E->isListInitialization(),
E->isStdInitListInitialization(),
8311 E->requiresZeroInitialization(),
E->getConstructionKind(),
8312 ToParenOrBraceRange);
8319 if (!ToSubExprOrErr)
8320 return ToSubExprOrErr.takeError();
8324 return std::move(Err);
8327 Importer.
getToContext(), *ToSubExprOrErr,
E->cleanupsHaveSideEffects(),
8332 Error Err = Error::success();
8337 return std::move(Err);
8341 return std::move(Err);
8345 E->getFPFeatures());
8351 return ToTypeOrErr.takeError();
8354 if (!ToLocationOrErr)
8355 return ToLocationOrErr.takeError();
8358 *ToTypeOrErr,
E->isImplicit());
8364 return ToTypeOrErr.takeError();
8367 if (!ToLocationOrErr)
8368 return ToLocationOrErr.takeError();
8371 *ToTypeOrErr, *ToLocationOrErr);
8375 Error Err = Error::success();
8379 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8383 auto ToName =
importChecked(Err,
E->getMemberNameInfo().getName());
8384 auto ToLoc =
importChecked(Err,
E->getMemberNameInfo().getLoc());
8386 return std::move(Err);
8394 if (
E->hasExplicitTemplateArgs()) {
8397 E->template_arguments(), ToTAInfo))
8398 return std::move(Err);
8399 ResInfo = &ToTAInfo;
8403 ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8404 ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
8411 Error Err = Error::success();
8415 auto ToScopeTypeInfo =
importChecked(Err,
E->getScopeTypeInfo());
8416 auto ToColonColonLoc =
importChecked(Err,
E->getColonColonLoc());
8419 return std::move(Err);
8424 ExpectedSLoc ToDestroyedTypeLocOrErr =
import(
E->getDestroyedTypeLoc());
8425 if (!ToDestroyedTypeLocOrErr)
8426 return ToDestroyedTypeLocOrErr.takeError();
8429 if (
auto ToTIOrErr =
import(
E->getDestroyedTypeInfo()))
8432 return ToTIOrErr.takeError();
8436 Importer.
getToContext(), ToBase,
E->isArrow(), ToOperatorLoc,
8437 ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
8442 Error Err = Error::success();
8446 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8447 auto ToFirstQualifierFoundInScope =
8450 return std::move(Err);
8452 Expr *ToBase =
nullptr;
8453 if (!
E->isImplicitAccess()) {
8455 ToBase = *ToBaseOrErr;
8457 return ToBaseOrErr.takeError();
8462 if (
E->hasExplicitTemplateArgs()) {
8465 E->template_arguments(), ToTAInfo))
8466 return std::move(Err);
8467 ResInfo = &ToTAInfo;
8472 return std::move(Err);
8478 return std::move(Err);
8481 Importer.
getToContext(), ToBase, ToType,
E->isArrow(), ToOperatorLoc,
8482 ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
8483 ToMemberNameInfo, ResInfo);
8488 Error Err = Error::success();
8490 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8496 return std::move(Err);
8500 return std::move(Err);
8504 if (
E->hasExplicitTemplateArgs()) {
8507 return std::move(Err);
8508 ResInfo = &ToTAInfo;
8512 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
8513 ToNameInfo, ResInfo);
8518 Error Err = Error::success();
8522 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8524 return std::move(Err);
8529 return std::move(Err);
8532 Importer.
getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
8539 if (!ToNamingClassOrErr)
8540 return ToNamingClassOrErr.takeError();
8542 auto ToQualifierLocOrErr =
import(
E->getQualifierLoc());
8543 if (!ToQualifierLocOrErr)
8544 return ToQualifierLocOrErr.takeError();
8546 Error Err = Error::success();
8550 return std::move(Err);
8555 return std::move(Err);
8558 for (
auto *
D :
E->decls())
8559 if (
auto ToDOrErr =
import(
D))
8560 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8562 return ToDOrErr.takeError();
8564 if (
E->hasExplicitTemplateArgs()) {
8567 E->getLAngleLoc(),
E->getRAngleLoc(),
E->template_arguments(),
8569 return std::move(Err);
8571 ExpectedSLoc ToTemplateKeywordLocOrErr =
import(
E->getTemplateKeywordLoc());
8572 if (!ToTemplateKeywordLocOrErr)
8573 return ToTemplateKeywordLocOrErr.takeError();
8575 const bool KnownDependent =
8577 ExprDependence::TypeValue;
8579 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8580 *ToTemplateKeywordLocOrErr, ToNameInfo,
E->requiresADL(), &ToTAInfo,
8581 ToDecls.
begin(), ToDecls.
end(), KnownDependent);
8585 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8586 ToNameInfo,
E->requiresADL(), ToDecls.
begin(), ToDecls.
end(),
8592 Error Err = Error::success();
8596 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8600 return std::move(Err);
8605 return std::move(Err);
8608 for (
Decl *
D :
E->decls())
8609 if (
auto ToDOrErr =
import(
D))
8610 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8612 return ToDOrErr.takeError();
8616 if (
E->hasExplicitTemplateArgs()) {
8618 E->copyTemplateArgumentsInto(FromTAInfo);
8620 return std::move(Err);
8621 ResInfo = &ToTAInfo;
8624 Expr *ToBase =
nullptr;
8625 if (!
E->isImplicitAccess()) {
8627 ToBase = *ToBaseOrErr;
8629 return ToBaseOrErr.takeError();
8633 Importer.
getToContext(),
E->hasUnresolvedUsing(), ToBase, ToType,
8634 E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8635 ToNameInfo, ResInfo, ToDecls.
begin(), ToDecls.
end());
8639 Error Err = Error::success();
8644 return std::move(Err);
8646 unsigned NumArgs =
E->getNumArgs();
8649 return std::move(Err);
8651 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
E)) {
8653 Importer.
getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
8654 OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
8655 OCE->getADLCallKind());
8660 0,
E->getADLCallKind());
8665 auto ToClassOrErr =
import(FromClass);
8667 return ToClassOrErr.takeError();
8670 auto ToCallOpOrErr =
import(
E->getCallOperator());
8672 return ToCallOpOrErr.takeError();
8676 return std::move(Err);
8678 Error Err = Error::success();
8679 auto ToIntroducerRange =
importChecked(Err,
E->getIntroducerRange());
8680 auto ToCaptureDefaultLoc =
importChecked(Err,
E->getCaptureDefaultLoc());
8683 return std::move(Err);
8686 E->getCaptureDefault(), ToCaptureDefaultLoc,
8687 E->hasExplicitParameters(),
8688 E->hasExplicitResultType(), ToCaptureInits,
8694 Error Err = Error::success();
8699 return std::move(Err);
8703 return std::move(Err);
8707 ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
8710 if (
E->hasArrayFiller()) {
8711 if (
ExpectedExpr ToFillerOrErr =
import(
E->getArrayFiller()))
8714 return ToFillerOrErr.takeError();
8717 if (
FieldDecl *FromFD =
E->getInitializedFieldInUnion()) {
8718 if (
auto ToFDOrErr =
import(FromFD))
8721 return ToFDOrErr.takeError();
8725 if (
auto ToSyntFormOrErr =
import(SyntForm))
8728 return ToSyntFormOrErr.takeError();
8742 return ToTypeOrErr.takeError();
8745 if (!ToSubExprOrErr)
8746 return ToSubExprOrErr.takeError();
8749 *ToTypeOrErr, *ToSubExprOrErr);
8754 Error Err = Error::success();
8759 return std::move(Err);
8762 ToLocation, ToType, ToConstructor,
E->constructsVBase(),
8763 E->inheritedFromVBase());
8767 Error Err = Error::success();
8772 return std::move(Err);
8775 ToType, ToCommonExpr, ToSubExpr);
8781 return ToTypeOrErr.takeError();
8787 if (!ToBeginLocOrErr)
8788 return ToBeginLocOrErr.takeError();
8790 auto ToFieldOrErr =
import(
E->getField());
8792 return ToFieldOrErr.takeError();
8794 auto UsedContextOrErr = Importer.
ImportContext(
E->getUsedContext());
8795 if (!UsedContextOrErr)
8796 return UsedContextOrErr.takeError();
8800 "Field should have in-class initializer if there is a default init "
8801 "expression that uses it.");
8806 auto ToInClassInitializerOrErr =
8807 import(
E->getField()->getInClassInitializer());
8808 if (!ToInClassInitializerOrErr)
8809 return ToInClassInitializerOrErr.takeError();
8813 Expr *RewrittenInit =
nullptr;
8814 if (
E->hasRewrittenInit()) {
8817 return ExprOrErr.takeError();
8818 RewrittenInit = ExprOrErr.get();
8822 ToField, *UsedContextOrErr, RewrittenInit);
8826 Error Err = Error::success();
8829 auto ToTypeInfoAsWritten =
importChecked(Err,
E->getTypeInfoAsWritten());
8832 auto ToAngleBrackets =
importChecked(Err,
E->getAngleBrackets());
8834 return std::move(Err);
8839 if (!ToBasePathOrErr)
8840 return ToBasePathOrErr.takeError();
8842 if (
auto CCE = dyn_cast<CXXStaticCastExpr>(
E)) {
8844 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8845 ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
8847 }
else if (isa<CXXDynamicCastExpr>(
E)) {
8849 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8850 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8851 }
else if (isa<CXXReinterpretCastExpr>(
E)) {
8853 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8854 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8855 }
else if (isa<CXXConstCastExpr>(
E)) {
8857 Importer.
getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
8858 ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8860 llvm_unreachable(
"Unknown cast type");
8861 return make_error<ASTImportError>();
8867 Error Err = Error::success();
8870 auto ToAssociatedDecl =
importChecked(Err,
E->getAssociatedDecl());
8873 return std::move(Err);
8876 ToType,
E->
getValueKind(), ToExprLoc, ToReplacement, ToAssociatedDecl,
8877 E->getIndex(),
E->getPackIndex(),
E->isReferenceParameter());
8881 Error Err = Error::success();
8886 return std::move(Err);
8890 return std::move(Err);
8897 Importer.
getToContext(), ToType, ToBeginLoc,
E->getTrait(), ToArgs,
8904 return ToTypeOrErr.takeError();
8907 if (!ToSourceRangeOrErr)
8908 return ToSourceRangeOrErr.takeError();
8910 if (
E->isTypeOperand()) {
8911 if (
auto ToTSIOrErr =
import(
E->getTypeOperandSourceInfo()))
8913 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
8915 return ToTSIOrErr.takeError();
8918 ExpectedExpr ToExprOperandOrErr =
import(
E->getExprOperand());
8919 if (!ToExprOperandOrErr)
8920 return ToExprOperandOrErr.takeError();
8923 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8927 Error Err = Error::success();
8938 return std::move(Err);
8941 CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS,
E->getOperator(),
8942 ToEllipsisLoc, ToRHS, ToRParenLoc,
E->getNumExpansions());
8947 Error ImportErrors = Error::success();
8949 if (
auto ImportedOrErr =
import(FromOverriddenMethod))
8951 (*ImportedOrErr)->getCanonicalDecl()));
8954 joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
8956 return ImportErrors;
8962 std::shared_ptr<ASTImporterSharedState> SharedState)
8963 : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
8964 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
8969 this->SharedState = std::make_shared<ASTImporterSharedState>();
8979 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
8980 "Try to get field index for non-field.");
8984 return std::nullopt;
8987 for (
const auto *
D : Owner->decls()) {
8991 if (isa<FieldDecl>(*
D) || isa<IndirectFieldDecl>(*
D))
8995 llvm_unreachable(
"Field was not found in its parent context.");
8997 return std::nullopt;
9010 if (SharedState->getLookupTable()) {
9012 SharedState->getLookupTable()->lookup(ReDC, Name);
9016 FoundDeclsTy
Result(NoloadLookupResult.
begin(), NoloadLookupResult.
end());
9033void ASTImporter::AddToLookupTable(
Decl *ToD) {
9034 SharedState->addDeclToLookup(ToD);
9040 return Importer.
Visit(FromD);
9064 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9065 ImportedTypes.find(FromT);
9066 if (Pos != ImportedTypes.end())
9073 return ToTOrErr.takeError();
9076 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
9078 return ToTOrErr->getTypePtr();
9087 return ToTyOrErr.takeError();
9100 return TOrErr.takeError();
9103 return BeginLocOrErr.takeError();
9112template <
typename T>
struct AttrArgImporter {
9113 AttrArgImporter(
const AttrArgImporter<T> &) =
delete;
9114 AttrArgImporter(AttrArgImporter<T> &&) =
default;
9115 AttrArgImporter<T> &operator=(
const AttrArgImporter<T> &) =
delete;
9116 AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) =
default;
9119 : To(I.importChecked(Err, From)) {}
9121 const T &value() {
return To; }
9132template <
typename T>
struct AttrArgArrayImporter {
9133 AttrArgArrayImporter(
const AttrArgArrayImporter<T> &) =
delete;
9134 AttrArgArrayImporter(AttrArgArrayImporter<T> &&) =
default;
9135 AttrArgArrayImporter<T> &operator=(
const AttrArgArrayImporter<T> &) =
delete;
9136 AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) =
default;
9139 const llvm::iterator_range<T *> &From,
9140 unsigned ArraySize) {
9143 To.reserve(ArraySize);
9147 T *value() {
return To.data(); }
9154 Error Err{Error::success()};
9155 Attr *ToAttr =
nullptr;
9160 AttrImporter(
ASTImporter &I) : Importer(I), NImporter(I) {}
9163 template <
typename T>
T *castAttrAs() {
return cast<T>(ToAttr); }
9164 template <
typename T>
const T *castAttrAs()
const {
return cast<T>(ToAttr); }
9169 template <
class T> AttrArgImporter<T> importArg(
const T &From) {
9170 return AttrArgImporter<T>(NImporter, Err, From);
9176 template <
typename T>
9177 AttrArgArrayImporter<T> importArrayArg(
const llvm::iterator_range<T *> &From,
9178 unsigned ArraySize) {
9179 return AttrArgArrayImporter<T>(NImporter, Err, From, ArraySize);
9190 template <
typename T,
typename... Arg>
9191 void importAttr(
const T *FromAttr, Arg &&...ImportedArg) {
9192 static_assert(std::is_base_of<Attr, T>::value,
9193 "T should be subclass of Attr.");
9194 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9198 Importer.
Import(FromAttr->getScopeName());
9208 FromAttr->getParsedKind(), FromAttr->getForm());
9212 std::forward<Arg>(ImportedArg)..., ToI);
9216 if (
auto *ToInheritableAttr = dyn_cast<InheritableAttr>(ToAttr))
9217 ToInheritableAttr->setInherited(FromAttr->isInherited());
9223 void cloneAttr(
const Attr *FromAttr) {
9224 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9238 return std::move(Err);
9239 assert(ToAttr &&
"Attribute should be created.");
9246 AttrImporter AI(*
this);
9249 switch (FromAttr->
getKind()) {
9250 case attr::Aligned: {
9251 auto *From = cast<AlignedAttr>(FromAttr);
9252 if (From->isAlignmentExpr())
9253 AI.importAttr(From,
true, AI.importArg(From->getAlignmentExpr()).value());
9255 AI.importAttr(From,
false,
9256 AI.importArg(From->getAlignmentType()).value());
9260 case attr::AlignValue: {
9261 auto *From = cast<AlignValueAttr>(FromAttr);
9262 AI.importAttr(From, AI.importArg(From->getAlignment()).value());
9266 case attr::Format: {
9267 const auto *From = cast<FormatAttr>(FromAttr);
9268 AI.importAttr(From,
Import(From->getType()), From->getFormatIdx(),
9269 From->getFirstArg());
9273 case attr::EnableIf: {
9274 const auto *From = cast<EnableIfAttr>(FromAttr);
9275 AI.importAttr(From, AI.importArg(From->getCond()).value(),
9276 From->getMessage());
9280 case attr::AssertCapability: {
9281 const auto *From = cast<AssertCapabilityAttr>(FromAttr);
9283 AI.importArrayArg(From->args(), From->args_size()).value(),
9287 case attr::AcquireCapability: {
9288 const auto *From = cast<AcquireCapabilityAttr>(FromAttr);
9290 AI.importArrayArg(From->args(), From->args_size()).value(),
9294 case attr::TryAcquireCapability: {
9295 const auto *From = cast<TryAcquireCapabilityAttr>(FromAttr);
9296 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9297 AI.importArrayArg(From->args(), From->args_size()).value(),
9301 case attr::ReleaseCapability: {
9302 const auto *From = cast<ReleaseCapabilityAttr>(FromAttr);
9304 AI.importArrayArg(From->args(), From->args_size()).value(),
9308 case attr::RequiresCapability: {
9309 const auto *From = cast<RequiresCapabilityAttr>(FromAttr);
9311 AI.importArrayArg(From->args(), From->args_size()).value(),
9315 case attr::GuardedBy: {
9316 const auto *From = cast<GuardedByAttr>(FromAttr);
9317 AI.importAttr(From, AI.importArg(From->getArg()).value());
9320 case attr::PtGuardedBy: {
9321 const auto *From = cast<PtGuardedByAttr>(FromAttr);
9322 AI.importAttr(From, AI.importArg(From->getArg()).value());
9325 case attr::AcquiredAfter: {
9326 const auto *From = cast<AcquiredAfterAttr>(FromAttr);
9328 AI.importArrayArg(From->args(), From->args_size()).value(),
9332 case attr::AcquiredBefore: {
9333 const auto *From = cast<AcquiredBeforeAttr>(FromAttr);
9335 AI.importArrayArg(From->args(), From->args_size()).value(),
9339 case attr::AssertExclusiveLock: {
9340 const auto *From = cast<AssertExclusiveLockAttr>(FromAttr);
9342 AI.importArrayArg(From->args(), From->args_size()).value(),
9346 case attr::AssertSharedLock: {
9347 const auto *From = cast<AssertSharedLockAttr>(FromAttr);
9349 AI.importArrayArg(From->args(), From->args_size()).value(),
9353 case attr::ExclusiveTrylockFunction: {
9354 const auto *From = cast<ExclusiveTrylockFunctionAttr>(FromAttr);
9355 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9356 AI.importArrayArg(From->args(), From->args_size()).value(),
9360 case attr::SharedTrylockFunction: {
9361 const auto *From = cast<SharedTrylockFunctionAttr>(FromAttr);
9362 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9363 AI.importArrayArg(From->args(), From->args_size()).value(),
9367 case attr::LockReturned: {
9368 const auto *From = cast<LockReturnedAttr>(FromAttr);
9369 AI.importAttr(From, AI.importArg(From->getArg()).value());
9372 case attr::LocksExcluded: {
9373 const auto *From = cast<LocksExcludedAttr>(FromAttr);
9375 AI.importArrayArg(From->args(), From->args_size()).value(),
9383 AI.cloneAttr(FromAttr);
9388 return std::move(AI).getResult();
9392 return ImportedDecls.lookup(FromD);
9396 auto FromDPos = ImportedFromDecls.find(ToD);
9397 if (FromDPos == ImportedFromDecls.end())
9399 return FromDPos->second->getTranslationUnitDecl();
9402Error ASTImporter::ImportAttrs(
Decl *ToD,
Decl *FromD) {
9404 return Error::success();
9406 auto ToAttrOrErr =
Import(FromAttr);
9410 return ToAttrOrErr.takeError();
9412 return Error::success();
9420 ImportPath.
push(FromD);
9421 auto ImportPathBuilder =
9422 llvm::make_scope_exit([
this]() { ImportPath.
pop(); });
9427 return make_error<ASTImportError>(*Error);
9433 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9435 return make_error<ASTImportError>(*Error);
9452 auto Pos = ImportedDecls.find(FromD);
9453 if (Pos != ImportedDecls.end()) {
9456 auto *ToD = Pos->second;
9457 ImportedDecls.erase(Pos);
9469 auto PosF = ImportedFromDecls.find(ToD);
9470 if (PosF != ImportedFromDecls.end()) {
9475 SharedState->removeDeclFromLookup(ToD);
9476 ImportedFromDecls.erase(PosF);
9488 handleAllErrors(ToDOrErr.takeError(),
9492 if (Pos != ImportedDecls.end())
9493 SharedState->setImportDeclError(Pos->second, ErrOut);
9497 for (
const auto &
Path : SavedImportPaths[FromD]) {
9500 Decl *PrevFromDi = FromD;
9503 if (FromDi == FromD)
9510 PrevFromDi = FromDi;
9514 auto Ii = ImportedDecls.find(FromDi);
9515 if (Ii != ImportedDecls.end())
9516 SharedState->setImportDeclError(Ii->second, ErrOut);
9521 SavedImportPaths.erase(FromD);
9524 return make_error<ASTImportError>(ErrOut);
9536 return make_error<ASTImportError>(*Err);
9542 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9544 return make_error<ASTImportError>(*Error);
9547 assert(ImportedDecls.count(FromD) != 0 &&
"Missing call to MapImported?");
9548 if (
auto Error = ImportAttrs(ToD, FromD))
9549 return std::move(Error);
9555 SavedImportPaths.erase(FromD);
9570 return ToDCOrErr.takeError();
9571 auto *ToDC = cast<DeclContext>(*ToDCOrErr);
9575 if (
auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
9576 auto *FromRecord = cast<RecordDecl>(FromDC);
9577 if (ToRecord->isCompleteDefinition())
9585 if (FromRecord->getASTContext().getExternalSource() &&
9586 !FromRecord->isCompleteDefinition())
9587 FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
9589 if (FromRecord->isCompleteDefinition())
9592 return std::move(Err);
9593 }
else if (
auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
9594 auto *FromEnum = cast<EnumDecl>(FromDC);
9595 if (ToEnum->isCompleteDefinition()) {
9597 }
else if (FromEnum->isCompleteDefinition()) {
9600 return std::move(Err);
9604 }
else if (
auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
9605 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
9606 if (ToClass->getDefinition()) {
9611 return std::move(Err);
9615 }
else if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
9616 auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
9617 if (ToProto->getDefinition()) {
9622 return std::move(Err);
9633 return cast_or_null<Expr>(*ToSOrErr);
9635 return ToSOrErr.takeError();
9643 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
9644 if (Pos != ImportedStmts.end())
9653 if (
auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
9654 auto *FromE = cast<Expr>(FromS);
9657 ToE->setValueKind(FromE->getValueKind());
9658 ToE->setObjectKind(FromE->getObjectKind());
9659 ToE->setDependence(FromE->getDependence());
9663 ImportedStmts[FromS] = *ToSOrErr;
9674 return std::move(Err);
9678 assert(FromNNS->
getAsIdentifier() &&
"NNS should contain identifier.");
9685 cast<NamespaceDecl>(*NSOrErr));
9687 return NSOrErr.takeError();
9692 cast<NamespaceAliasDecl>(*NSADOrErr));
9694 return NSADOrErr.takeError();
9702 cast<CXXRecordDecl>(*RDOrErr));
9704 return RDOrErr.takeError();
9714 return TyOrErr.takeError();
9718 llvm_unreachable(
"Invalid nested name specifier kind");
9730 NestedNames.push_back(NNS);
9736 while (!NestedNames.empty()) {
9737 NNS = NestedNames.pop_back_val();
9740 return std::move(Err);
9747 return std::move(Err);
9751 return std::move(Err);
9767 ToLocalBeginLoc, ToLocalEndLoc);
9774 return std::move(Err);
9794 if (!ToSourceRangeOrErr)
9795 return ToSourceRangeOrErr.takeError();
9798 ToSourceRangeOrErr->getBegin(),
9799 ToSourceRangeOrErr->getEnd());
9811 return TemplateName(cast<TemplateDecl>((*ToTemplateOrErr)->getCanonicalDecl()));
9813 return ToTemplateOrErr.takeError();
9818 for (
auto *I : *FromStorage) {
9819 if (
auto ToOrErr =
Import(I))
9820 ToTemplates.
addDecl(cast<NamedDecl>(*ToOrErr));
9822 return ToOrErr.takeError();
9832 return DeclNameOrErr.takeError();
9839 if (!QualifierOrErr)
9840 return QualifierOrErr.takeError();
9843 return TNOrErr.takeError();
9851 if (!QualifierOrErr)
9852 return QualifierOrErr.takeError();
9867 if (!ReplacementOrErr)
9868 return ReplacementOrErr.takeError();
9871 if (!AssociatedDeclOrErr)
9872 return AssociatedDeclOrErr.takeError();
9875 *ReplacementOrErr, *AssociatedDeclOrErr, Subst->
getIndex(),
9886 return ArgPackOrErr.takeError();
9889 if (!AssociatedDeclOrErr)
9890 return AssociatedDeclOrErr.takeError();
9893 *ArgPackOrErr, *AssociatedDeclOrErr, SubstPack->
getIndex(),
9899 return UsingOrError.takeError();
9900 return TemplateName(cast<UsingShadowDecl>(*UsingOrError));
9904 llvm_unreachable(
"Invalid template name kind");
9917 return ToFileIDOrErr.takeError();
9925 return std::move(Err);
9927 return std::move(Err);
9933 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
9934 if (Pos != ImportedFileIDs.end())
9947 return ToSpLoc.takeError();
9950 return ToExLocS.takeError();
9960 return ToExLocE.takeError();
9966 if (!IsBuiltin && !
Cache->BufferOverridden) {
9970 return ToIncludeLoc.takeError();
9981 if (
Cache->OrigEntry &&
Cache->OrigEntry->getDir()) {
9992 ToID = ToSM.
createFileID(*Entry, ToIncludeLocOrFakeLoc,
9999 std::optional<llvm::MemoryBufferRef> FromBuf =
10005 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
10006 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
10007 FromBuf->getBufferIdentifier());
10013 assert(ToID.
isValid() &&
"Unexpected invalid fileID was created.");
10015 ImportedFileIDs[FromID] = ToID;
10022 return ToExprOrErr.takeError();
10025 if (!LParenLocOrErr)
10026 return LParenLocOrErr.takeError();
10029 if (!RParenLocOrErr)
10030 return RParenLocOrErr.takeError();
10035 return ToTInfoOrErr.takeError();
10040 return std::move(Err);
10043 ToContext, *ToTInfoOrErr, From->
isBaseVirtual(), *LParenLocOrErr,
10044 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
10048 return ToFieldOrErr.takeError();
10051 if (!MemberLocOrErr)
10052 return MemberLocOrErr.takeError();
10055 ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
10056 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10059 if (!ToIFieldOrErr)
10060 return ToIFieldOrErr.takeError();
10063 if (!MemberLocOrErr)
10064 return MemberLocOrErr.takeError();
10067 ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
10068 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10072 return ToTInfoOrErr.takeError();
10074 return new (ToContext)
10076 *ToExprOrErr, *RParenLocOrErr);
10079 return make_error<ASTImportError>();
10085 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
10086 if (Pos != ImportedCXXBaseSpecifiers.end())
10087 return Pos->second;
10090 if (!ToSourceRange)
10091 return ToSourceRange.takeError();
10094 return ToTSI.takeError();
10096 if (!ToEllipsisLoc)
10097 return ToEllipsisLoc.takeError();
10101 ImportedCXXBaseSpecifiers[BaseSpec] =
Imported;
10113 return ToOrErr.takeError();
10114 Decl *To = *ToOrErr;
10116 auto *FromDC = cast<DeclContext>(From);
10119 if (
auto *ToRecord = dyn_cast<RecordDecl>(To)) {
10120 if (!ToRecord->getDefinition()) {
10122 cast<RecordDecl>(FromDC), ToRecord,
10127 if (
auto *ToEnum = dyn_cast<EnumDecl>(To)) {
10128 if (!ToEnum->getDefinition()) {
10134 if (
auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
10135 if (!ToIFace->getDefinition()) {
10137 cast<ObjCInterfaceDecl>(FromDC), ToIFace,
10142 if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
10143 if (!ToProto->getDefinition()) {
10145 cast<ObjCProtocolDecl>(FromDC), ToProto,
10167 return ToSelOrErr.takeError();
10174 return ToTyOrErr.takeError();
10182 return ToTyOrErr.takeError();
10188 cast<TemplateDecl>(*ToTemplateOrErr));
10190 return ToTemplateOrErr.takeError();
10198 return ToTyOrErr.takeError();
10214 llvm_unreachable(
"Invalid DeclarationName Kind!");
10235 for (
unsigned I = 1, N = FromSel.
getNumArgs(); I < N; ++I)
10243 llvm::Error Err = llvm::Error::success();
10244 auto ImportLoop = [&](
const APValue *From,
APValue *To,
unsigned Size) {
10245 for (
unsigned Idx = 0; Idx < Size; Idx++) {
10250 switch (FromValue.
getKind()) {
10264 ImportLoop(((
const APValue::Vec *)(
const char *)&FromValue.Data)->Elts,
10271 ImportLoop(((
const APValue::Arr *)(
const char *)&FromValue.Data)->Elts,
10272 ((
const APValue::Arr *)(
const char *)&
Result.Data)->Elts,
10279 ((
const APValue::StructData *)(
const char *)&FromValue.Data)->Elts,
10280 ((
const APValue::StructData *)(
const char *)&
Result.Data)->Elts,
10288 return std::move(Err);
10289 Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
10293 Result.MakeAddrLabelDiff();
10297 return std::move(Err);
10298 Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
10299 cast<AddrLabelExpr>(ImpRHS));
10303 const Decl *ImpMemPtrDecl =
10306 return std::move(Err);
10308 Result.setMemberPointerUninit(
10309 cast<const ValueDecl>(ImpMemPtrDecl),
10313 Result.getMemberPointerPath();
10318 return std::move(Err);
10328 "in C++20 dynamic allocation are transient so they shouldn't "
10329 "appear in the AST");
10331 if (
const auto *
E =
10336 return std::move(Err);
10346 return std::move(Err);
10358 return std::move(Err);
10372 for (
unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
10375 FromPath[LoopIdx].getAsBaseOrMember().getPointer();
10378 return std::move(Err);
10379 if (
auto *RD = dyn_cast<CXXRecordDecl>(
FromDecl))
10382 FromElemTy = cast<ValueDecl>(
FromDecl)->getType();
10384 ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
10389 FromPath[LoopIdx].getAsArrayIndex());
10397 return std::move(Err);
10405 unsigned NumDecls) {
10415 if (LastDiagFromFrom)
10418 LastDiagFromFrom =
false;
10423 if (!LastDiagFromFrom)
10426 LastDiagFromFrom =
true;
10431 if (
auto *ID = dyn_cast<ObjCInterfaceDecl>(
D)) {
10432 if (!ID->getDefinition())
10433 ID->startDefinition();
10435 else if (
auto *PD = dyn_cast<ObjCProtocolDecl>(
D)) {
10436 if (!PD->getDefinition())
10437 PD->startDefinition();
10439 else if (
auto *TD = dyn_cast<TagDecl>(
D)) {
10440 if (!TD->getDefinition() && !TD->isBeingDefined()) {
10441 TD->startDefinition();
10442 TD->setCompleteDefinition(
true);
10446 assert(0 &&
"CompleteDecl called on a Decl that can't be completed");
10451 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
10452 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
10453 "Try to import an already imported Decl");
10454 if (Pos != ImportedDecls.end())
10455 return Pos->second;
10456 ImportedDecls[From] = To;
10459 ImportedFromDecls[To] = From;
10464 AddToLookupTable(To);
10468std::optional<ASTImportError>
10470 auto Pos = ImportDeclErrors.find(FromD);
10471 if (Pos != ImportDeclErrors.end())
10472 return Pos->second;
10474 return std::nullopt;
10478 auto InsertRes = ImportDeclErrors.insert({From, Error});
10482 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
10487 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
10489 if (Pos != ImportedTypes.end()) {
10494 llvm::consumeError(ToFromOrErr.takeError());
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
static FriendCountAndPosition getFriendCountAndPosition(ASTImporter &Importer, FriendDecl *FD)
static bool IsEquivalentFriend(ASTImporter &Importer, FriendDecl *FD1, FriendDecl *FD2)
static auto getTemplateDefinition(T *D) -> T *
static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D)
static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To, ASTImporter &Importer)
static StructuralEquivalenceKind getStructuralEquivalenceKind(const ASTImporter &Importer)
Defines enum values for all the target-independent builtin functions.
enum clang::sema::@1651::IndirectLocalPathEntry::EntryKind Kind
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::FileManager interface and associated types.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
llvm::SmallVector< std::pair< const MemRegion *, SVal >, 4 > Bindings
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the Objective-C statement AST node classes.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
const NamedDecl * FromDecl
unsigned getVersion() const
QualType getTypeInfoType() const
static LValueBase getTypeInfo(TypeInfoLValue LV, QualType TypeInfo)
unsigned getCallIndex() const
A non-discriminated union of a base, field, or array index.
static LValuePathEntry ArrayIndex(uint64_t Index)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
const LValueBase getLValueBase() const
ArrayRef< LValuePathEntry > getLValuePath() const
const FieldDecl * getUnionField() const
unsigned getStructNumFields() const
llvm::PointerIntPair< const Decl *, 1, bool > BaseOrMemberType
A FieldDecl or CXXRecordDecl, along with a flag indicating whether we mean a virtual or non-virtual b...
ValueKind getKind() const
bool isLValueOnePastTheEnd() const
bool isMemberPointerToDerivedMember() const
unsigned getArrayInitializedElts() const
unsigned getStructNumBases() const
bool hasLValuePath() const
const ValueDecl * getMemberPointerDecl() const
APValue & getUnionValue()
const AddrLabelExpr * getAddrLabelDiffRHS() const
CharUnits & getLValueOffset()
unsigned getVectorLength() const
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
unsigned getArraySize() const
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
@ None
There is no such object (it's outside its lifetime).
bool isNullPointer() const
const AddrLabelExpr * getAddrLabelDiffLHS() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
QualType getParenType(QualType NamedType) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, ConceptDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgumentLoc > Args) const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of another (possibly unresolved) using decl,...
DeclarationNameTable DeclarationNames
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
QualType getRecordType(const RecordDecl *Decl) const
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
QualType getCountAttributedType(QualType T, Expr *CountExpr, bool CountInBytes, bool OrNull, ArrayRef< TypeCoupledDeclRefInfo > DependentDecls) const
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
TemplateName getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex) const
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
SelectorTable & Selectors
QualType getMacroQualifiedType(QualType UnderlyingTy, const IdentifierInfo *MacroII) const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst, UsingEnumDecl *Pattern)
Remember that the using enum decl Inst is an instantiation of the using enum decl Pattern of a class ...
UsingEnumDecl * getInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst)
If the given using-enum decl Inst is an instantiation of another using-enum decl, return it.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *ParmDecl=nullptr) const
Retrieve the template type parameter type for a template parameter or parameter pack with the given d...
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl, unsigned Index, bool Final, const TemplateArgument &ArgPack)
Retrieve a.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
CanQualType UnsignedCharTy
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted=false, ArrayRef< QualType > Expansions={}, int Index=-1) const
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
DiagnosticsEngine & getDiagnostics() const
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index, bool Final) const
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
BuiltinTemplateDecl * getTypePackElementDecl() const
QualType getTypeOfType(QualType QT, TypeOfKind Kind) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex) const
Retrieve a substitution-result type.
unsigned char getFixedPointScale(QualType Ty) const
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
QualType getTypeOfExprType(Expr *E, TypeOfKind Kind) const
C23 feature and GCC extension.
std::error_code convertToErrorCode() const override
void log(llvm::raw_ostream &OS) const override
std::string toString() const
@ Unknown
Not supported node or case.
@ UnsupportedConstruct
Naming ambiguity (likely ODR violation).
void update(NamedDecl *ND, DeclContext *OldDC)
void updateForced(NamedDecl *ND, DeclContext *OldDC)
bool hasCycleAtBack() const
Returns true if the last element can be found earlier in the path.
VecTy copyCycleAtBack() const
Returns the copy of the cycle.
Imports selected nodes from one AST context into another context, merging AST nodes where appropriate...
ASTContext & getFromContext() const
Retrieve the context that AST nodes are being imported from.
NonEquivalentDeclSet & getNonEquivalentDecls()
Return the set of declarations that we know are not equivalent.
ASTContext & getToContext() const
Retrieve the context that AST nodes are being imported into.
DiagnosticBuilder ToDiag(SourceLocation Loc, unsigned DiagID)
Report a diagnostic in the "to" context.
Decl * MapImported(Decl *From, Decl *To)
Store and assign the imported declaration to its counterpart.
TranslationUnitDecl * GetFromTU(Decl *ToD)
Return the translation unit from where the declaration was imported.
llvm::Expected< DeclContext * > ImportContext(DeclContext *FromDC)
Import the given declaration context from the "from" AST context into the "to" AST context.
llvm::Error ImportDefinition(Decl *From)
Import the definition of the given declaration, including all of the declarations it contains.
virtual Expected< DeclarationName > HandleNameConflict(DeclarationName Name, DeclContext *DC, unsigned IDNS, NamedDecl **Decls, unsigned NumDecls)
Cope with a name conflict when importing a declaration into the given context.
virtual bool returnWithErrorInTest()
Used only in unittests to verify the behaviour of the error handling.
std::optional< DeclT * > getImportedFromDecl(const DeclT *ToD) const
Return the declaration in the "from" context from which the declaration in the "to" context was impor...
void RegisterImportedDecl(Decl *FromD, Decl *ToD)
std::optional< ASTImportError > getImportDeclErrorIfAny(Decl *FromD) const
Return if import of the given declaration has failed and if yes the kind of the problem.
friend class ASTNodeImporter
static std::optional< unsigned > getFieldIndex(Decl *F)
Determine the index of a field in its parent record.
llvm::Error importInto(ImportT &To, const ImportT &From)
Import the given object, returns the result.
virtual Decl * GetOriginalDecl(Decl *To)
Called by StructuralEquivalenceContext.
virtual void Imported(Decl *From, Decl *To)
Subclasses can override this function to observe all of the From -> To declaration mappings as they a...
DiagnosticBuilder FromDiag(SourceLocation Loc, unsigned DiagID)
Report a diagnostic in the "from" context.
bool IsStructurallyEquivalent(QualType From, QualType To, bool Complain=true)
Determine whether the given types are structurally equivalent.
virtual Expected< Decl * > ImportImpl(Decl *From)
Can be overwritten by subclasses to implement their own import logic.
bool isMinimalImport() const
Whether the importer will perform a minimal import, creating to-be-completed forward declarations whe...
ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, ASTContext &FromContext, FileManager &FromFileManager, bool MinimalImport, std::shared_ptr< ASTImporterSharedState > SharedState=nullptr)
llvm::Expected< ExprWithCleanups::CleanupObject > Import(ExprWithCleanups::CleanupObject From)
Import cleanup objects owned by ExprWithCleanup.
virtual void CompleteDecl(Decl *D)
Called for ObjCInterfaceDecl, ObjCProtocolDecl, and TagDecl.
Decl * GetAlreadyImportedOrNull(const Decl *FromD) const
Return the copy of the given declaration in the "to" context if it has already been imported from the...
void setImportDeclError(Decl *From, ASTImportError Error)
Mark (newly) imported declaration with error.
ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D)
ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E)
ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E)
ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D)
ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E)
ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D)
ExpectedDecl VisitFunctionDecl(FunctionDecl *D)
ExpectedDecl VisitParmVarDecl(ParmVarDecl *D)
ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E)
ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E)
ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D)
ExpectedDecl VisitUsingDecl(UsingDecl *D)
ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D)
ExpectedStmt VisitStmt(Stmt *S)
ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D)
ExpectedDecl VisitFieldDecl(FieldDecl *D)
Error ImportFieldDeclDefinition(const FieldDecl *From, const FieldDecl *To)
Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD=nullptr)
ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E)
ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E)
ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S)
ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D)
ExpectedStmt VisitShuffleVectorExpr(ShuffleVectorExpr *E)
ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D)
ExpectedDecl VisitRecordDecl(RecordDecl *D)
ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E)
ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D)
Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin)
ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S)
T importChecked(Error &Err, const T &From)
ExpectedStmt VisitVAArgExpr(VAArgExpr *E)
ExpectedStmt VisitDefaultStmt(DefaultStmt *S)
ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D)
ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E)
ExpectedDecl VisitLabelDecl(LabelDecl *D)
ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E)
ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S)
ExpectedStmt VisitUnaryOperator(UnaryOperator *E)
Error ImportTemplateParameterLists(const DeclTy *FromD, DeclTy *ToD)
Error ImportDeclContext(DeclContext *FromDC, bool ForceImport=false)
ExpectedStmt VisitContinueStmt(ContinueStmt *S)
ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E)
ExpectedDecl VisitVarDecl(VarDecl *D)
ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E)
ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D)
Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To)
ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E)
ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E)
ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D)
ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D)
ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E)
ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE)
ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E)
ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D)
ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E)
ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D)
Expected< InheritedConstructor > ImportInheritedConstructor(const InheritedConstructor &From)
ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E)
Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc)
Error ImportDefinition(RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind=IDK_Default)
ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S)
ExpectedStmt VisitConstantExpr(ConstantExpr *E)
ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E)
ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E)
ExpectedDecl VisitDecl(Decl *D)
bool hasSameVisibilityContextAndLinkage(T *Found, T *From)
ExpectedStmt VisitParenExpr(ParenExpr *E)
ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S)
ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E)
ExpectedStmt VisitInitListExpr(InitListExpr *E)
Expected< FunctionTemplateAndArgsTy > ImportFunctionTemplateWithTemplateArgsFromSpecialization(FunctionDecl *FromFD)
ExpectedStmt VisitReturnStmt(ReturnStmt *S)
ExpectedStmt VisitAtomicExpr(AtomicExpr *E)
ExpectedStmt VisitConditionalOperator(ConditionalOperator *E)
ExpectedStmt VisitChooseExpr(ChooseExpr *E)
ExpectedStmt VisitCompoundStmt(CompoundStmt *S)
Expected< TemplateArgument > ImportTemplateArgument(const TemplateArgument &From)
ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E)
ExpectedStmt VisitCaseStmt(CaseStmt *S)
ExpectedStmt VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E)
ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E)
ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D)
ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E)
ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E)
ExpectedStmt VisitLambdaExpr(LambdaExpr *LE)
ExpectedStmt VisitBinaryOperator(BinaryOperator *E)
ExpectedStmt VisitCallExpr(CallExpr *E)
ExpectedStmt VisitDeclStmt(DeclStmt *S)
ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E)
ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E)
Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin)
ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D)
ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D)
Expected< CXXCastPath > ImportCastPath(CastExpr *E)
Expected< APValue > ImportAPValue(const APValue &FromValue)
ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D)
ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E)
ExpectedDecl VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D)
ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E)
ExpectedDecl VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D)
ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias)
ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D)
ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D)
ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D)
Expected< ObjCTypeParamList * > ImportObjCTypeParamList(ObjCTypeParamList *list)
ExpectedDecl VisitUsingPackDecl(UsingPackDecl *D)
ExpectedStmt VisitWhileStmt(WhileStmt *S)
ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D)
ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E)
ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S)
ExpectedDecl VisitFriendDecl(FriendDecl *D)
Error ImportContainerChecked(const InContainerTy &InContainer, OutContainerTy &OutContainer)
ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E)
ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E)
bool IsStructuralMatch(Decl *From, Decl *To, bool Complain=true, bool IgnoreTemplateParmDepth=false)
ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E)
ExpectedStmt VisitForStmt(ForStmt *S)
ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E)
ExpectedDecl VisitEnumDecl(EnumDecl *D)
ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D)
ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E)
ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E)
ExpectedStmt VisitSwitchStmt(SwitchStmt *S)
ExpectedType VisitType(const Type *T)
ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D)
ExpectedDecl ImportUsingShadowDecls(BaseUsingDecl *D, BaseUsingDecl *ToSI)
ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E)
ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E)
ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D)
ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E)
ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D)
ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E)
ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E)
ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D)
Error ImportTemplateArguments(ArrayRef< TemplateArgument > FromArgs, SmallVectorImpl< TemplateArgument > &ToArgs)
ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D)
ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E)
ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D)
ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D)
ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E)
ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E)
Error ImportTemplateArgumentListInfo(const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo)
ExpectedStmt VisitDoStmt(DoStmt *S)
ExpectedStmt VisitNullStmt(NullStmt *S)
ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E)
ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D)
Error ImportOverriddenMethods(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod)
ExpectedStmt VisitStringLiteral(StringLiteral *E)
Error ImportDeclarationNameLoc(const DeclarationNameInfo &From, DeclarationNameInfo &To)
ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E)
bool hasReturnTypeDeclaredInside(FunctionDecl *D)
This function checks if the given function has a return type that contains a reference (in any way) t...
ASTNodeImporter(ASTImporter &Importer)
std::tuple< FunctionTemplateDecl *, TemplateArgsTy > FunctionTemplateAndArgsTy
ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D)
ExpectedStmt VisitMemberExpr(MemberExpr *E)
ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E)
Error ImportInitializer(VarDecl *From, VarDecl *To)
ImportDefinitionKind
What we should import from the definition.
@ IDK_Everything
Import everything.
@ IDK_Default
Import the default subset of the definition, which might be nothing (if minimal import is set) or mig...
@ IDK_Basic
Import only the bare bones needed to establish a valid DeclContext.
ExpectedDecl VisitTypedefDecl(TypedefDecl *D)
ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D)
ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E)
ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D)
ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E)
ExpectedStmt VisitIfStmt(IfStmt *S)
ExpectedStmt VisitLabelStmt(LabelStmt *S)
ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E)
ExpectedStmt VisitConvertVectorExpr(ConvertVectorExpr *E)
ExpectedDecl VisitUsingEnumDecl(UsingEnumDecl *D)
ExpectedStmt VisitGotoStmt(GotoStmt *S)
ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E)
ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S)
ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S)
ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D)
ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S)
ExpectedDecl VisitImportDecl(ImportDecl *D)
Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD)
ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E)
ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E)
ExpectedDecl VisitEmptyDecl(EmptyDecl *D)
ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E)
ExpectedStmt VisitExpr(Expr *E)
Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam, ParmVarDecl *ToParam)
ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E)
ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S)
ExpectedStmt VisitAttributedStmt(AttributedStmt *S)
ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S)
ExpectedStmt VisitParenListExpr(ParenListExpr *E)
Expected< FunctionDecl * > FindFunctionTemplateSpecialization(FunctionDecl *FromFD)
ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D)
ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S)
Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD)
ExpectedStmt VisitStmtExpr(StmtExpr *E)
ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E)
bool shouldForceImportDeclContext(ImportDefinitionKind IDK)
ExpectedDecl VisitBindingDecl(BindingDecl *D)
ExpectedStmt VisitBreakStmt(BreakStmt *S)
Represents an access specifier followed by colon ':'.
AddrLabelExpr - The GNU address of label extension, representing &&label.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Represents a loop initializing the elements of an array.
Represents a constant array type that does not decay to a pointer when used as a function parameter.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
A structure for storing the information associated with a name that has been assumed to be a template...
DeclarationName getDeclName() const
Get the name of the template.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Attr - This represents one attribute.
attr::Kind getKind() const
void setPackExpansion(bool PE)
Attr * clone(ASTContext &C) const
SourceRange getRange() const
void setRange(SourceRange R)
void setAttrName(const IdentifierInfo *AttrNameII)
const IdentifierInfo * getAttrName() const
Represents an attribute applied to a statement.
static AttributedStmt * Create(const ASTContext &C, SourceLocation Loc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
An attributed type is a type to which a type attribute has been applied.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Represents a C++ declaration that introduces decls from somewhere else.
void addShadowDecl(UsingShadowDecl *S)
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
A binding in a decomposition declaration.
void setBinding(QualType DeclaredType, Expr *Binding)
Set the binding for this BindingDecl, along with its declared type (which should be a possibly-cv-qua...
void setDecomposedDecl(ValueDecl *Decomposed)
Set the decomposed variable for this BindingDecl.
A fixed int type of a specified bitwidth.
BreakStmt - This represents a break.
Represents a C++2a __builtin_bit_cast(T, v) expression.
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
This class is used for builtin types like 'int'.
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
Represents a base class of a C++ class.
AccessSpecifier getAccessSpecifierAsWritten() const
Retrieves the access specifier as written in the source code (which may mean that no access specifier...
SourceLocation getEllipsisLoc() const
For a pack expansion, determine the location of the ellipsis.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
TypeSourceInfo * getTypeSourceInfo() const
Retrieves the type and source location of the base class.
bool isBaseOfClass() const
Determine whether this base class is a base of a class declared with the 'class' keyword (vs.
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Represents binding an expression to a temporary.
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
A boolean literal, per ([C++ lex.bool] Boolean literals).
static CXXBoolLiteralExpr * Create(const ASTContext &C, bool Val, QualType Ty, SourceLocation Loc)
CXXCatchStmt - This represents a C++ catch block.
static CXXConstCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Represents a call to a C++ constructor.
void setIsImmediateEscalating(bool Set)
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
Represents a C++ base or member initializer.
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
bool isDelegatingInitializer() const
Determine whether this initializer is creating a delegating constructor.
Expr * getInit() const
Get the initializer.
SourceLocation getRParenLoc() const
SourceLocation getEllipsisLoc() const
SourceLocation getLParenLoc() const
bool isPackExpansion() const
Determine whether this initializer is a pack expansion.
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
bool isMemberInitializer() const
Determine whether this initializer is initializing a non-static data member.
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
bool isIndirectMemberInitializer() const
SourceLocation getMemberLocation() const
IndirectFieldDecl * getIndirectMember() const
bool isBaseVirtual() const
Returns whether the base is virtual or not.
Represents a C++ deduction guide declaration.
A default argument (C++ [dcl.fct.default]).
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
A use of a default initializer in a constructor or in aggregate initialization.
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)
Field is the non-static data member whose default initializer is used by this expression.
Represents a delete expression for memory deallocation and destructor calls, e.g.
Represents a C++ member access expression where the actual member referenced could not be resolved be...
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a C++ destructor within a class.
void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg)
static CXXDynamicCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Represents a folding of a pack over an operator.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, SourceLocation RPLoc)
Represents a call to an inherited base class constructor from an inheriting constructor.
Represents a call to a member function that may be written either with member call syntax (e....
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
Represents a static or instance method of a struct/union/class.
void addOverriddenMethod(const CXXMethodDecl *MD)
overridden_method_range overridden_methods() const
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Abstract class common to all of the C++ "named"/"keyword" casts.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, ArrayRef< Expr * > PlacementArgs, SourceRange TypeIdParens, std::optional< Expr * > ArraySize, CXXNewInitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
The null pointer literal (C++11 [lex.nullptr])
static CXXOperatorCallExpr * Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, ADLCallKind UsesADL=NotADL)
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Represents a C++ struct/union/class.
CXXRecordDecl * getMostRecentDecl()
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
method_range methods() const
CXXRecordDecl * getDefinition() const
static CXXRecordDecl * CreateLambda(const ASTContext &C, DeclContext *DC, TypeSourceInfo *Info, SourceLocation Loc, unsigned DependencyKind, bool IsGeneric, LambdaCaptureDefault CaptureDefault)
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
void setDescribedClassTemplate(ClassTemplateDecl *Template)
void setLambdaNumbering(LambdaNumbering Numbering)
Set the mangling numbers and context declaration for a lambda class.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
CXXRecordDecl * getPreviousDecl()
static CXXReinterpretCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
A rewritten comparison expression that was originally written using operator syntax.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Represents a C++ functional cast expression that builds a temporary object.
static CXXTemporaryObjectExpr * Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, ArrayRef< Expr * > Args, SourceRange ParenOrBraceRange, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization)
Represents a C++ temporary.
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Represents the this expression in C++.
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
A C++ throw-expression (C++ [except.throw]).
CXXTryStmt - A C++ try block, including all handlers.
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, CompoundStmt *tryBlock, ArrayRef< Stmt * > handlers)
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
CaseStmt - Represent a case statement.
static CaseStmt * Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs, SourceLocation caseLoc, SourceLocation ellipsisLoc, SourceLocation colonLoc)
Build a case statement.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CharUnits - This is an opaque type for sizes expressed in character units.
How to handle import errors that occur when import of a child declaration of a DeclContext fails.
bool ignoreChildErrorOnParent(Decl *FromChildD) const
Determine if import failure of a child does not cause import failure of its parent.
ChildErrorHandlingStrategy(const Decl *FromD)
void handleChildImportResult(Error &ResultErr, Error &&ChildErr)
Process the import result of a child (of the current declaration).
ChildErrorHandlingStrategy(const DeclContext *FromDC)
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Declaration of a class template.
void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
ClassTemplateDecl * getMostRecentDecl()
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
QualType getInjectedSpecializationType() const
Retrieves the injected specialization type for this partial specialization.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a class template specialization, which refers to a class template with a given set of temp...
void setPointOfInstantiation(SourceLocation Loc)
void setExternKeywordLoc(SourceLocation Loc)
Sets the location of the extern keyword.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
Complex values, per C99 6.2.5p11.
CompoundAssignOperator - For compound assignments (e.g.
static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
A reference to a concept and its template args, as it appears in the code.
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
NamedDecl * getFoundDecl() const
const DeclarationNameInfo & getConceptNameInfo() const
ConceptDecl * getNamedConcept() const
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
SourceLocation getTemplateKWLoc() const
ConditionalOperator - The ?: ternary operator.
Represents the canonical version of C arrays with a specified constant size.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Represents a concrete matrix type with constant number of rows and columns.
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
ContinueStmt - This represents a continue.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
Represents a pointer type decayed from an array or function type.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDeclInternal(Decl *D)
Add the declaration D into this context, but suppress searches for external declarations with the sam...
bool containsDeclAndLoad(Decl *D) const
Checks whether a declaration is in this context.
void removeDecl(Decl *D)
Removes a declaration from this context.
lookup_result noload_lookup(DeclarationName Name)
Find the declarations with the given name that are visible within this context; don't attempt to retr...
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
void localUncachedLookup(DeclarationName Name, SmallVectorImpl< NamedDecl * > &Results)
A simplistic name lookup mechanism that performs name lookup into this declaration context without co...
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
A reference to a declared variable, function, enum, etc.
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
A simple visitor class that helps create declaration visitors.
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration.
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isParameterPack() const
Whether this declaration is a parameter pack.
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_None
Not a friend object.
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
const char * getDeclKindName() const
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
@ IDNS_NonMemberOperator
This declaration is a C++ operator declared in a non-class context.
@ IDNS_TagFriend
This declaration is a friend class.
@ IDNS_Ordinary
Ordinary names.
@ IDNS_ObjCProtocol
Objective C @protocol.
@ IDNS_Namespace
Namespaces, declared with 'namespace foo {}'.
@ IDNS_OrdinaryFriend
This declaration is a friend function.
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
void setImplicit(bool I=true)
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
bool isInAnonymousNamespace() const
SourceLocation getBeginLoc() const LLVM_READONLY
TranslationUnitDecl * getTranslationUnitDecl()
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setLexicalDeclContext(DeclContext *DC)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name.
const IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it.
static DeclarationName getUsingDirectiveName()
Returns the name for all C++ using-directives.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
@ CXXConversionFunctionName
QualType getCXXNameType() const
If this name is one of the C++ names (of a constructor, destructor, or conversion function),...
Selector getObjCSelector() const
Get the Objective-C selector stored in this declaration name.
NameKind getNameKind() const
Determine what kind of name this is.
bool isEmpty() const
Evaluates true when this declaration name is empty.
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Represents the type decltype(expr) (C++11).
A decomposition declaration.
Represents a C++17 deduced template specialization type.
Represents an extended address space qualifier where the input address space value is dependent.
Represents a qualified type name for which the type name is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents an array type in C++ whose size is a value-dependent expression.
Represents an extended vector type where either the type or size is dependent.
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Represents a dependent template name that cannot be resolved prior to template instantiation.
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Represents a template specialization type whose template cannot be resolved, e.g.
Represents a vector type where either the type or size is dependent.
Represents a single C99 designator.
static Designator CreateArrayRangeDesignator(unsigned Index, SourceLocation LBracketLoc, SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
Creates a GNU array-range designator.
static Designator CreateFieldDesignator(const IdentifierInfo *FieldName, SourceLocation DotLoc, SourceLocation FieldLoc)
Creates a field designator.
static Designator CreateArrayDesignator(unsigned Index, SourceLocation LBracketLoc, SourceLocation RBracketLoc)
Creates an array designator.
Represents a C99 designated initializer expression.
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
A little helper class used to produce diagnostics.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
void notePriorDiagnosticFrom(const DiagnosticsEngine &Other)
Note that the prior diagnostic was emitted by some other DiagnosticsEngine, and we may be attaching a...
DoStmt - This represents a 'do/while' stmt.
Symbolic representation of a dynamic allocation.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
Represents an empty-declaration.
An instance of this object exists for each enum constant that is defined.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
void setIntegerType(QualType T)
Set the underlying integer type.
EnumDecl * getMostRecentDecl()
void completeDefinition(QualType NewType, QualType PromotionType, unsigned NumPositiveBits, unsigned NumNegativeBits)
When created, the EnumDecl corresponds to a forward-declared enum.
EnumDecl * getDefinition() const
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
QualType getPromotionType() const
Return the integer type that enumerators should promote to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
ExplicitCastExpr - An explicit cast written in the source code.
Store information needed for an explicit specifier.
ExplicitSpecKind getKind() const
const Expr * getExpr() const
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
llvm::PointerUnion< BlockDecl *, CompoundLiteralExpr * > CleanupObject
The type of objects that are kept in the cleanup.
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
ExprDependence getDependence() const
An expression trait intrinsic.
ExtVectorType - Extended vector type.
virtual void CompleteType(TagDecl *Tag)
Gives the external AST source an opportunity to complete an incomplete type.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
void setCapturedVLAType(const VariableArrayType *VLAType)
Set the captured variable length array type for this field.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Implements support for file system lookup, file system caching, and directory search management.
OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Get a FileEntryRef if it exists, without doing anything on error.
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
ForStmt - This represents a 'for (init;cond;inc)' stmt.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Represents a function declaration or definition.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
ArrayRef< ParmVarDecl * > parameters() const
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
void setDefaultLoc(SourceLocation NewLoc)
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
@ TK_MemberSpecialization
@ TK_DependentNonTemplate
@ TK_FunctionTemplateSpecialization
@ TK_DependentFunctionTemplateSpecialization
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
void setInstantiatedFromDecl(FunctionDecl *FD)
Specify that this function declaration was instantiated from a FunctionDecl FD.
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
void setRangeEnd(SourceLocation E)
FunctionDecl * getInstantiatedFromDecl() const
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
void setDefaulted(bool D=true)
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
void setExplicitlyDefaulted(bool ED=true)
State that this function is explicitly defaulted.
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > exceptions() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getMostRecentDecl()
ExtInfo getExtInfo() const
QualType getReturnType() const
This represents a GCC inline-assembly statement extension.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Represents a C11 generic selection.
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression accepting an expression predicate.
GotoStmt - This represents a direct goto.
One of these records is kept for each identifier that is lexed.
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
void setBuiltinID(unsigned ID)
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
IfStmt - This represents an if/then/else.
static IfStmt * Create(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL, SourceLocation RPL, Stmt *Then, SourceLocation EL=SourceLocation(), Stmt *Else=nullptr)
Create an IfStmt.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Represents an implicitly-generated value initialization of an object of a given type.
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
IndirectGotoStmt - This represents an indirect goto.
Description of a constructor that was inherited from a base class.
CXXConstructorDecl * getConstructor() const
ConstructorUsingShadowDecl * getShadowDecl() const
Describes an C or C++ initializer list.
void setSyntacticForm(InitListExpr *Init)
void setArrayFiller(Expr *filler)
void setInitializedFieldInUnion(FieldDecl *FD)
void sawArrayRangeDesignator(bool ARD=true)
The injected class name of a C++ class template or class template partial specialization.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
An lvalue reference type, per C++11 [dcl.ref].
Represents the declaration of a label.
void setStmt(LabelStmt *T)
LabelStmt - Represents a label, which has a substatement.
Describes the capture of a variable or of this, or of a C++1y init-capture.
bool capturesVariable() const
Determine whether this capture handles a variable.
bool isPackExpansion() const
Determine whether this capture is a pack expansion, which captures a function parameter pack.
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis for a capture that is a pack expansion.
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
ValueDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
bool isImplicit() const
Determine whether this was an implicit capture (not written between the square brackets introducing t...
SourceLocation getLocation() const
Retrieve the source location of the capture.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
static LambdaExpr * Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange, LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc, bool ExplicitParams, bool ExplicitResultType, ArrayRef< Expr * > CaptureInits, SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack)
Construct a new lambda expression.
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
Represents a linkage specification.
void setRBraceLoc(SourceLocation L)
Represents the results of name lookup.
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
A pointer to member type per C++ 8.3.3 - Pointers to members.
Provides information a specialization of a member of a class template, which may be a member function...
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
This represents a decl that may have a name.
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a C++ namespace alias.
Represent a C++ namespace.
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace that inhabits this namespace, if any.
void setRBraceLoc(SourceLocation L)
Class that aids in the construction of nested-name-specifiers along with source-location information ...
A C++ nested-name-specifier augmented with source location information.
SourceLocation getLocalEndLoc() const
Retrieve the location of the end of this component of the nested-name-specifier.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
SpecifierKind
The kind of specifier that completes this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
static NestedNameSpecifier * SuperSpecifier(const ASTContext &Context, CXXRecordDecl *RD)
Returns the nested name specifier representing the __super scope for the given CXXRecordDecl.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
NullStmt - This is the null statement ";": C99 6.8.3p3.
Represents Objective-C's @catch statement.
Represents Objective-C's @finally statement.
Represents Objective-C's @synchronized statement.
Represents Objective-C's @throw statement.
Represents Objective-C's @try ... @catch ... @finally statement.
static ObjCAtTryStmt * Create(const ASTContext &Context, SourceLocation atTryLoc, Stmt *atTryStmt, Stmt **CatchStmts, unsigned NumCatchStmts, Stmt *atFinallyStmt)
Represents Objective-C's @autoreleasepool Statement.
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...
ObjCCategoryDecl - Represents a category declaration.
void setTypeParamList(ObjCTypeParamList *TPL)
Set the type parameters of this category.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
void setImplementation(ObjCCategoryImplDecl *ImplD)
ObjCProtocolList::iterator protocol_iterator
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
Represents Objective-C's collection statement.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
const ObjCInterfaceDecl * getSuperClass() const
Represents an ObjC class declaration.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
ObjCCategoryDecl * FindCategoryDeclaration(const IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
protocol_loc_iterator protocol_loc_begin() const
void setImplementation(ObjCImplementationDecl *ImplD)
known_categories_range known_categories() const
void setSuperClass(TypeSourceInfo *superClass)
protocol_iterator protocol_end() const
SourceLocation getSuperClassLoc() const
Retrieve the starting location of the superclass.
void setTypeParamList(ObjCTypeParamList *TPL)
Set the type parameters of this class.
ObjCProtocolList::iterator protocol_iterator
ObjCImplementationDecl * getImplementation() const
protocol_iterator protocol_begin() const
void startDefinition()
Starts the definition of this Objective-C class, taking it from a forward declaration (@class) to a d...
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCInterfaceDecl * getSuperClass() const
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
TypeSourceInfo * getSuperClassTInfo() const
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCMethodDecl - Represents an instance or class method declaration.
void setMethodParams(ASTContext &C, ArrayRef< ParmVarDecl * > Params, ArrayRef< SourceLocation > SelLocs=std::nullopt)
Sets the method's parameters and selector source locations.
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implicit parameters.
ParmVarDecl *const * param_iterator
ObjCInterfaceDecl * getClassInterface()
Represents a pointer to an Objective C object.
Represents a class type in Objective C.
Represents one property declaration in an Objective-C interface.
void setSetterName(Selector Sel, SourceLocation Loc=SourceLocation())
void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal)
void setPropertyAttributesAsWritten(ObjCPropertyAttribute::Kind PRVal)
void setPropertyIvarDecl(ObjCIvarDecl *Ivar)
void setSetterMethodDecl(ObjCMethodDecl *gDecl)
void setGetterName(Selector Sel, SourceLocation Loc=SourceLocation())
void setGetterMethodDecl(ObjCMethodDecl *gDecl)
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
ObjCIvarDecl * getPropertyIvarDecl() const
SourceLocation getPropertyIvarDeclLoc() const
Kind getPropertyImplementation() const
Represents an Objective-C protocol declaration.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
void startDefinition()
Starts the definition of this Objective-C protocol.
ObjCProtocolList::iterator protocol_iterator
protocol_iterator protocol_begin() const
protocol_iterator protocol_end() const
protocol_loc_iterator protocol_loc_begin() const
Represents the declaration of an Objective-C type parameter.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
SourceLocation getRAngleLoc() const
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
SourceLocation getLAngleLoc() const
Represents a type parameter type in Objective C.
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
Helper class for OffsetOfExpr.
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
FieldDecl * getField() const
For a field offsetof node, returns the field.
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
@ Array
An index into an array.
@ Identifier
A field in a dependent type, known only by its name.
@ Base
An implicit indirection through a C++ base class, when the field found is in a base class.
SourceLocation getBeginLoc() const LLVM_READONLY
Kind getKind() const
Determine what kind of offsetof node this is.
SourceLocation getEndLoc() const LLVM_READONLY
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
A structure for storing the information associated with an overloaded template name.
Represents a C++11 pack expansion that produces a sequence of expressions.
Represents a pack expansion of types.
ParenExpr - This represents a parenthesized expression, e.g.
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
bool isKNRPromoted() const
True if the value passed to this parameter must undergo K&R-style default argument promotion:
void setObjCDeclQualifier(ObjCDeclQualifier QTVal)
void setDefaultArg(Expr *defarg)
SourceLocation getExplicitObjectParamThisLoc() const
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
void setUninstantiatedDefaultArg(Expr *arg)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
void setObjCMethodScopeInfo(unsigned parameterIndex)
bool hasInheritedDefaultArg() const
void setKNRPromoted(bool promoted)
void setExplicitObjectParameterLoc(SourceLocation Loc)
Expr * getUninstantiatedDefaultArg()
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
void setHasInheritedDefaultArg(bool I=true)
PointerType - C99 6.7.5.1 - Pointer Declarators.
[C99 6.4.2.2] - A predefined identifier such as func.
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
Stores the type being destroyed by a pseudo-destructor expression.
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
QualType getCanonicalType() const
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Represents a template name as written in source code.
TemplateName getUnderlyingTemplate() const
Return the underlying template name.
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
bool hasTemplateKeyword() const
Whether the template name was prefixed by the "template" keyword.
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool isLambda() const
Determine whether this record is a class describing a lambda function object.
void setAnonymousStructOrUnion(bool Anon)
RecordDecl * getMostRecentDecl()
virtual void completeDefinition()
Note that the definition of this type is now complete.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Provides common interface for the Decls that can be redeclared.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Base for LValueReferenceType and RValueReferenceType.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
static ReturnStmt * Create(const ASTContext &Ctx, SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
Create a return statement.
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Smart pointer class that efficiently represents Objective-C method names.
const IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
bool isNull() const
Determine whether this is the empty selector.
unsigned getNumArgs() const
static std::enable_if_t< std::is_base_of_v< Attr, AttrInfo >, SourceLocation > getAttrLoc(const AttrInfo &AL)
A helper function to provide Attribute Location for the Attr types AND the ParsedAttr.
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Represents an expression that computes the length of a parameter pack.
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, std::optional< unsigned > Length=std::nullopt, ArrayRef< TemplateArgument > PartialArgs=std::nullopt)
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
Encodes a location in the source.
This class handles loading and caching of source files into memory.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
bool isWrittenInBuiltinFile(SourceLocation Loc) const
Returns whether Loc is located in a <built-in> file.
FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
SourceLocation getComposedLoc(FileID FID, unsigned Offset) const
Form a SourceLocation from a FileID and Offset pair.
FileManager & getFileManager() const
FileID getMainFileID() const
Returns the FileID of the main source file.
unsigned getFileIDSize(FileID FID) const
The size of the SLocEntry that FID represents.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file.
SourceLocation createExpansionLoc(SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned Length, bool ExpansionIsTokenRange=true, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)
Creates an expansion SLocEntry for a macro use.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
SourceLocation createMacroArgExpansionLoc(SourceLocation SpellingLoc, SourceLocation ExpansionLoc, unsigned Length)
Creates an expansion SLocEntry for the substitution of an argument into a function-like macro's body.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
One instance of this struct is kept for every file loaded or used.
Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded,...
SourceLocation getExpansionLocStart() const
bool isExpansionTokenRange() const
SourceLocation getSpellingLoc() const
bool isMacroArgExpansion() const
SourceLocation getExpansionLocEnd() const
const ContentCache & getContentCache() const
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
SourceLocation getIncludeLoc() const
This is a discriminated union of FileInfo and ExpansionInfo.
const FileInfo & getFile() const
const ExpansionInfo & getExpansion() const
Represents a C++11 static_assert declaration.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
child_iterator child_begin()
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
child_iterator child_end()
const char * getStmtClassName() const
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
Represents a reference to a non-type template parameter that has been substituted with a template arg...
A structure for storing an already-substituted template template parameter pack.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
TemplateArgument getArgumentPack() const
Retrieve the template template argument pack with which this parameter was substituted.
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
A structure for storing the information associated with a substituted template template parameter.
TemplateName getReplacement() const
std::optional< unsigned > getPackIndex() const
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
Represents the result of substituting a set of types for a template type parameter pack.
Represents the result of substituting a type for a template type parameter.
void setNextSwitchCase(SwitchCase *SC)
SwitchStmt - This represents a 'switch' stmt.
static SwitchStmt * Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a switch statement.
Represents the declaration of a struct/union/class/enum.
bool isBeingDefined() const
Return true if this decl is currently being defined.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
void setBraceRange(SourceRange R)
void setCompleteDefinition(bool V=true)
True if this decl has its body fully specified.
A convenient class for passing around template argument information.
SourceLocation getRAngleLoc() const
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
SourceLocation getLAngleLoc() const
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Location wrapper for a TemplateArgument.
TemplateArgumentLocInfo getLocInfo() const
const TemplateArgument & getArgument() const
Represents a template argument.
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
QualType getParamTypeForDecl() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
std::optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce,...
QualType getAsType() const
Retrieve the type for a type template argument.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
QualType getIntegralType() const
Retrieve the type of the integral value.
bool getIsDefaulted() const
If returns 'true', this TemplateArgument corresponds to a default template parameter.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template declarations that this template name refers to,...
AssumedTemplateStorage * getAsAssumedTemplateName() const
Retrieve information on a name that has been assumed to be a template-name in order to permit a call ...
@ UsingTemplate
A template name that refers to a template declaration found through a specific using shadow declarati...
@ OverloadedTemplate
A set of overloaded template declarations.
@ Template
A single template declaration.
@ DependentTemplate
A dependent template name that has not been resolved to a template (or set of templates).
@ SubstTemplateTemplateParm
A template template parameter that has been substituted for some other template name.
@ SubstTemplateTemplateParmPack
A template template parameter pack that has been substituted for a template template argument pack,...
@ QualifiedTemplate
A qualified template name, where the qualification is kept to describe the source code as written.
@ AssumedTemplate
An unqualified-id that has been assumed to name a function template that will be found by ADL.
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
SourceLocation getTemplateLoc() const
Represents a type template specialization; the template must be a class template, a type alias templa...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
Declaration of a template type parameter.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter.
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
TypeAliasTemplateDecl * getDescribedAliasTemplate() const
Declaration of an alias template.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
Symbolic representation of typeid(T) for some type T.
const Type * getType() const
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
ExpectedType Visit(const Type *T)
Performs the operation associated with this visitor object.
The base class of the type hierarchy.
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
bool isPointerType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
QualType getCanonicalTypeInternal() const
const char * getTypeClassName() const
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Base class for declarations which introduce a typedef-name.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
static UnaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
static UnresolvedMemberExpr * Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
void addDecl(NamedDecl *D)
A set of unresolved declarations.
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represents a dependent using declaration which was marked with typename.
Represents a dependent using declaration which was not marked with typename.
Represents a C++ using-declaration.
Represents C++ using-directive.
Represents a C++ using-enum-declaration.
Represents a pack of using declarations that a single using-declarator pack-expanded into.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represents a call to the builtin function __builtin_va_arg.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
EvaluatedStmt * getEvaluatedStmt() const
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form,...
void setInlineSpecified()
void setTSCSpec(ThreadStorageClassSpecifier TSC)
const Expr * getInit() const
void setConstexpr(bool IC)
void setDescribedVarTemplate(VarTemplateDecl *Template)
void setImplicitlyInline()
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
VarTemplateDecl * getMostRecentDecl()
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
Represents a variable template specialization, which refers to a variable template with a given set o...
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setPointOfInstantiation(SourceLocation Loc)
VarTemplateSpecializationDecl * getMostRecentDecl()
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
WhileStmt - This represents a 'while' stmt.
static WhileStmt * Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body, SourceLocation WL, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a while statement.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
StructuralEquivalenceKind
Whether to perform a normal or minimal equivalence check.
CanThrowResult
Possible results from evaluation of a noexcept expression.
void updateFlags(const Decl *From, Decl *To)
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ Property
The type of a property.
@ Result
The result type of a method or function.
@ BTK__type_pack_element
This names the __type_pack_element BuiltinTemplateDecl.
@ BTK__make_integer_seq
This names the __make_integer_seq BuiltinTemplateDecl.
CastKind
CastKind - The kind of operation required for a conversion.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
const FunctionProtoType * T
llvm::SmallVector< Decl *, 2 > getCanonicalForwardRedeclChain(Decl *D)
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Used as return type of getFriendCountAndPosition.
unsigned int IndexOfDecl
Index of the specific FriendDecl.
unsigned int TotalCount
Number of similar looking friends.
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
Information about how a lambda is numbered within its context.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setCXXOperatorNameRange(SourceRange R)
setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword).
SourceRange getCXXOperatorNameRange() const
getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword).
TypeSourceInfo * getNamedTypeInfo() const
getNamedTypeInfo - Returns the source type info associated to the name.
SourceLocation getCXXLiteralOperatorNameLoc() const
getCXXLiteralOperatorNameLoc - Returns the location of the literal operator name (not the operator ke...
Structure used to store a statement, the constant value to which it was evaluated (if any),...
bool HasConstantDestruction
Whether this variable is known to have constant destruction.
bool HasConstantInitialization
Whether this variable is known to have constant initialization.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
RefQualifierKind RefQualifier
unsigned HasTrailingReturn
FunctionType::ExtInfo ExtInfo
bool IsEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
Location information for a TemplateArgument.
SourceLocation getTemplateEllipsisLoc() const
NestedNameSpecifierLoc getTemplateQualifierLoc() const
TypeSourceInfo * getAsTypeSourceInfo() const
SourceLocation getTemplateNameLoc() const