56#include "llvm/ADT/APSInt.h"
57#include "llvm/ADT/ArrayRef.h"
58#include "llvm/ADT/DenseMap.h"
59#include "llvm/ADT/STLExtras.h"
60#include "llvm/ADT/ScopeExit.h"
61#include "llvm/ADT/SmallVector.h"
62#include "llvm/Support/Casting.h"
63#include "llvm/Support/ErrorHandling.h"
64#include "llvm/Support/MemoryBuffer.h"
75 using llvm::make_error;
90 return "NameConflict";
92 return "UnsupportedConstruct";
94 return "Unknown error";
96 llvm_unreachable(
"Invalid error code.");
97 return "Invalid error code.";
103 llvm_unreachable(
"Function not implemented.");
114 Redecls.push_back(R);
117 std::reverse(Redecls.begin(), Redecls.end());
122 if (
auto *FD = dyn_cast<FunctionDecl>(D))
123 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
124 if (
auto *VD = dyn_cast<VarDecl>(D))
125 return getCanonicalForwardRedeclChain<VarDecl>(VD);
126 if (
auto *TD = dyn_cast<TagDecl>(D))
127 return getCanonicalForwardRedeclChain<TagDecl>(TD);
128 llvm_unreachable(
"Bad declaration kind");
149 bool const IgnoreChildErrors;
153 : FromDC(FromDC), IgnoreChildErrors(!
isa<
TagDecl>(FromDC)) {}
163 if (ChildErr && !IgnoreChildErrors)
164 ResultErr = joinErrors(std::move(ResultErr), std::move(ChildErr));
166 consumeError(std::move(ChildErr));
172 if (!IgnoreChildErrors || !FromDC)
180 public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
184 template <
typename ImportT>
185 [[nodiscard]] Error importInto(ImportT &To,
const ImportT &From) {
190 template <
typename ImportT>
191 [[nodiscard]] Error importInto(ImportT *&To, ImportT *From) {
192 auto ToOrErr = Importer.
Import(From);
194 To = cast_or_null<ImportT>(*ToOrErr);
195 return ToOrErr.takeError();
200 template <
typename T>
204 auto ToOrErr = Importer.
Import(From);
206 return ToOrErr.takeError();
207 return cast_or_null<T>(*ToOrErr);
210 template <
typename T>
211 auto import(
const T *From) {
212 return import(
const_cast<T *
>(From));
216 template <
typename T>
218 return Importer.
Import(From);
222 template <
typename T>
226 return import(*From);
233 template <
typename ToDeclT>
struct CallOverloadedCreateFun {
234 template <
typename... Args>
decltype(
auto)
operator()(Args &&... args) {
235 return ToDeclT::Create(std::forward<Args>(args)...);
245 template <
typename ToDeclT,
typename FromDeclT,
typename... Args>
246 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
251 CallOverloadedCreateFun<ToDeclT> OC;
252 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
253 std::forward<Args>(args)...);
260 template <
typename NewDeclT,
typename ToDeclT,
typename FromDeclT,
262 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
264 CallOverloadedCreateFun<NewDeclT> OC;
265 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
266 std::forward<Args>(args)...);
270 template <
typename ToDeclT,
typename CreateFunT,
typename FromDeclT,
273 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
274 FromDeclT *FromD, Args &&...args) {
282 ToD = CreateFun(std::forward<Args>(args)...);
285 Importer.SharedState->markAsNewDecl(ToD);
286 InitializeImportedDecl(FromD, ToD);
290 void InitializeImportedDecl(
Decl *FromD,
Decl *ToD) {
294 if (FromD->isImplicit())
308 void addDeclToContexts(
Decl *FromD,
Decl *ToD) {
313 if (!FromD->getDescribedTemplate() &&
320 DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
324 bool Visible =
false;
337 if (
auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
338 auto *ToNamed = cast<NamedDecl>(ToD);
340 FromDC->
lookup(FromNamed->getDeclName());
341 if (llvm::is_contained(FromLookup, FromNamed))
358 updateLookupTableForTemplateParameters(
371#define TYPE(Class, Base) \
372 ExpectedType Visit##Class##Type(const Class##Type *T);
373#include "clang/AST/TypeNodes.inc"
431 template <
typename InContainerTy>
435 template<
typename InContainerTy>
442 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
459 template <
typename T>
463 bool IgnoreTemplateParmDepth =
false);
655 Err = MaybeVal.takeError();
661 template<
typename IIter,
typename OIter>
663 using ItemT = std::remove_reference_t<
decltype(*Obegin)>;
664 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
667 return ToOrErr.takeError();
670 return Error::success();
677 template<
typename InContainerTy,
typename OutContainerTy>
679 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
681 InContainer.begin(), InContainer.end(), OutContainer.begin());
684 template<
typename InContainerTy,
typename OIter>
701template <
typename InContainerTy>
705 auto ToLAngleLocOrErr =
import(FromLAngleLoc);
706 if (!ToLAngleLocOrErr)
707 return ToLAngleLocOrErr.takeError();
708 auto ToRAngleLocOrErr =
import(FromRAngleLoc);
709 if (!ToRAngleLocOrErr)
710 return ToRAngleLocOrErr.takeError();
716 return Error::success();
720Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
731 return ImportTemplateArgumentListInfo(
732 From.LAngleLoc, From.RAngleLoc, From.arguments(),
Result);
744 if (Error Err = importInto(std::get<0>(
Result), FTSInfo->getTemplate()))
745 return std::move(Err);
750 return std::move(Err);
760 return std::move(Err);
763 if (!ToRequiresClause)
764 return ToRequiresClause.takeError();
767 if (!ToTemplateLocOrErr)
768 return ToTemplateLocOrErr.takeError();
770 if (!ToLAngleLocOrErr)
771 return ToLAngleLocOrErr.takeError();
773 if (!ToRAngleLocOrErr)
774 return ToRAngleLocOrErr.takeError();
795 return ToTypeOrErr.takeError();
803 return ToTypeOrErr.takeError();
810 return ToOrErr.takeError();
813 return ToTypeOrErr.takeError();
814 return TemplateArgument(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()),
821 return ToTypeOrErr.takeError();
829 return ToTypeOrErr.takeError();
832 return ToValueOrErr.takeError();
839 if (!ToTemplateOrErr)
840 return ToTemplateOrErr.takeError();
848 if (!ToTemplateOrErr)
849 return ToTemplateOrErr.takeError();
859 return ToExpr.takeError();
865 return std::move(Err);
872 llvm_unreachable(
"Invalid template argument kind");
880 return ArgOrErr.takeError();
889 return E.takeError();
895 return TSIOrErr.takeError();
897 auto ToTemplateQualifierLocOrErr =
899 if (!ToTemplateQualifierLocOrErr)
900 return ToTemplateQualifierLocOrErr.takeError();
902 if (!ToTemplateNameLocOrErr)
903 return ToTemplateNameLocOrErr.takeError();
904 auto ToTemplateEllipsisLocOrErr =
906 if (!ToTemplateEllipsisLocOrErr)
907 return ToTemplateEllipsisLocOrErr.takeError();
910 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
920 size_t NumDecls = DG.
end() - DG.
begin();
922 ToDecls.reserve(NumDecls);
923 for (
Decl *FromD : DG) {
924 if (
auto ToDOrErr =
import(FromD))
925 ToDecls.push_back(*ToDOrErr);
927 return ToDOrErr.takeError();
942 return ToDotLocOrErr.takeError();
945 if (!ToFieldLocOrErr)
946 return ToFieldLocOrErr.takeError();
949 ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
953 if (!ToLBracketLocOrErr)
954 return ToLBracketLocOrErr.takeError();
957 if (!ToRBracketLocOrErr)
958 return ToRBracketLocOrErr.takeError();
963 *ToRBracketLocOrErr);
966 if (!ToEllipsisLocOrErr)
967 return ToEllipsisLocOrErr.takeError();
972 *ToRBracketLocOrErr);
977 Error Err = Error::success();
980 auto ToConceptNameLoc =
986 return std::move(Err);
991 return std::move(Err);
1009 return VarOrErr.takeError();
1014 return LocationOrErr.takeError();
1019 return std::move(Err);
1026template <
typename T>
1028 if (Found->getLinkageInternal() != From->getLinkageInternal())
1031 if (From->hasExternalFormalLinkage())
1032 return Found->hasExternalFormalLinkage();
1035 if (From->isInAnonymousNamespace())
1036 return Found->isInAnonymousNamespace();
1038 return !Found->isInAnonymousNamespace() &&
1039 !Found->hasExternalFormalLinkage();
1059using namespace clang;
1069 if (!UnderlyingTypeOrErr)
1070 return UnderlyingTypeOrErr.takeError();
1077#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1078 case BuiltinType::Id: \
1079 return Importer.getToContext().SingletonId;
1080#include "clang/Basic/OpenCLImageTypes.def"
1081#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1082 case BuiltinType::Id: \
1083 return Importer.getToContext().Id##Ty;
1084#include "clang/Basic/OpenCLExtensionTypes.def"
1085#define SVE_TYPE(Name, Id, SingletonId) \
1086 case BuiltinType::Id: \
1087 return Importer.getToContext().SingletonId;
1088#include "clang/Basic/AArch64SVEACLETypes.def"
1089#define PPC_VECTOR_TYPE(Name, Id, Size) \
1090 case BuiltinType::Id: \
1091 return Importer.getToContext().Id##Ty;
1092#include "clang/Basic/PPCTypes.def"
1093#define RVV_TYPE(Name, Id, SingletonId) \
1094 case BuiltinType::Id: \
1095 return Importer.getToContext().SingletonId;
1096#include "clang/Basic/RISCVVTypes.def"
1097#define WASM_TYPE(Name, Id, SingletonId) \
1098 case BuiltinType::Id: \
1099 return Importer.getToContext().SingletonId;
1100#include "clang/Basic/WebAssemblyReferenceTypes.def"
1101#define SHARED_SINGLETON_TYPE(Expansion)
1102#define BUILTIN_TYPE(Id, SingletonId) \
1103 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1104#include "clang/AST/BuiltinTypes.def"
1112 case BuiltinType::Char_U:
1121 case BuiltinType::Char_S:
1130 case BuiltinType::WChar_S:
1131 case BuiltinType::WChar_U:
1137 llvm_unreachable(
"Invalid BuiltinType Kind!");
1142 if (!ToOriginalTypeOrErr)
1143 return ToOriginalTypeOrErr.takeError();
1150 if (!ToElementTypeOrErr)
1151 return ToElementTypeOrErr.takeError();
1158 if (!ToPointeeTypeOrErr)
1159 return ToPointeeTypeOrErr.takeError();
1167 if (!ToPointeeTypeOrErr)
1168 return ToPointeeTypeOrErr.takeError();
1177 if (!ToPointeeTypeOrErr)
1178 return ToPointeeTypeOrErr.takeError();
1187 if (!ToPointeeTypeOrErr)
1188 return ToPointeeTypeOrErr.takeError();
1197 if (!ToPointeeTypeOrErr)
1198 return ToPointeeTypeOrErr.takeError();
1201 if (!ClassTypeOrErr)
1202 return ClassTypeOrErr.takeError();
1210 Error Err = Error::success();
1214 return std::move(Err);
1224 if (!ToElementTypeOrErr)
1225 return ToElementTypeOrErr.takeError();
1234 Error Err = Error::success();
1239 return std::move(Err);
1245ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1247 Error Err = Error::success();
1252 return std::move(Err);
1261ExpectedType ASTNodeImporter::VisitDependentSizedExtVectorType(
1263 Error Err = Error::success();
1268 return std::move(Err);
1270 ToElementType, ToSizeExpr, ToAttrLoc);
1275 if (!ToElementTypeOrErr)
1276 return ToElementTypeOrErr.takeError();
1285 if (!ToElementTypeOrErr)
1286 return ToElementTypeOrErr.takeError();
1297 if (!ToReturnTypeOrErr)
1298 return ToReturnTypeOrErr.takeError();
1307 if (!ToReturnTypeOrErr)
1308 return ToReturnTypeOrErr.takeError();
1315 return TyOrErr.takeError();
1316 ArgTypes.push_back(*TyOrErr);
1324 return TyOrErr.takeError();
1325 ExceptionTypes.push_back(*TyOrErr);
1329 Error Err = Error::success();
1346 return std::move(Err);
1349 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1354 Error Err = Error::success();
1358 return std::move(Err);
1361 ToD, cast_or_null<TypeDecl>(ToPrevD));
1366 if (!ToInnerTypeOrErr)
1367 return ToInnerTypeOrErr.takeError();
1377 return Pattern.takeError();
1380 return Index.takeError();
1387 return ToDeclOrErr.takeError();
1394 if (!ToUnderlyingTypeOrErr)
1395 return ToUnderlyingTypeOrErr.takeError();
1403 return ToExprOrErr.takeError();
1409 if (!ToUnderlyingTypeOrErr)
1410 return ToUnderlyingTypeOrErr.takeError();
1418 return FoundOrErr.takeError();
1420 if (!UnderlyingOrErr)
1421 return UnderlyingOrErr.takeError();
1430 return ToExprOrErr.takeError();
1433 if (!ToUnderlyingTypeOrErr)
1434 return ToUnderlyingTypeOrErr.takeError();
1437 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1443 if (!ToBaseTypeOrErr)
1444 return ToBaseTypeOrErr.takeError();
1447 if (!ToUnderlyingTypeOrErr)
1448 return ToUnderlyingTypeOrErr.takeError();
1451 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->
getUTTKind());
1457 if (!ToDeducedTypeOrErr)
1458 return ToDeducedTypeOrErr.takeError();
1461 if (!ToTypeConstraintConcept)
1462 return ToTypeConstraintConcept.takeError();
1467 return std::move(Err);
1471 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1475ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1479 if (!ToTemplateNameOrErr)
1480 return ToTemplateNameOrErr.takeError();
1482 if (!ToDeducedTypeOrErr)
1483 return ToDeducedTypeOrErr.takeError();
1489ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1493 return ToDeclOrErr.takeError();
1497 const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
1498 assert(Ty && isa<InjectedClassNameType>(Ty));
1505 return ToDeclOrErr.takeError();
1513 return ToDeclOrErr.takeError();
1520 if (!ToModifiedTypeOrErr)
1521 return ToModifiedTypeOrErr.takeError();
1523 if (!ToEquivalentTypeOrErr)
1524 return ToEquivalentTypeOrErr.takeError();
1527 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1530ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1534 return ToDeclOrErr.takeError();
1540ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1544 return ReplacedOrErr.takeError();
1547 if (!ToReplacementTypeOrErr)
1548 return ToReplacementTypeOrErr.takeError();
1551 *ToReplacementTypeOrErr, *ReplacedOrErr, T->
getIndex(),
1555ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1559 return ReplacedOrErr.takeError();
1562 if (!ToArgumentPack)
1563 return ToArgumentPack.takeError();
1569ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1572 if (!ToTemplateOrErr)
1573 return ToTemplateOrErr.takeError();
1578 return std::move(Err);
1585 ToCanonType = *TyOrErr;
1587 return TyOrErr.takeError();
1597 if (!ToQualifierOrErr)
1598 return ToQualifierOrErr.takeError();
1601 if (!ToNamedTypeOrErr)
1602 return ToNamedTypeOrErr.takeError();
1605 if (!ToOwnedTagDeclOrErr)
1606 return ToOwnedTagDeclOrErr.takeError();
1611 *ToOwnedTagDeclOrErr);
1617 if (!ToPatternOrErr)
1618 return ToPatternOrErr.takeError();
1625ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1628 if (!ToQualifierOrErr)
1629 return ToQualifierOrErr.takeError();
1636 return std::move(Err);
1639 T->
getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1645 if (!ToQualifierOrErr)
1646 return ToQualifierOrErr.takeError();
1655 return TyOrErr.takeError();
1667 return ToDeclOrErr.takeError();
1674 if (!ToBaseTypeOrErr)
1675 return ToBaseTypeOrErr.takeError();
1680 TypeArgs.push_back(*TyOrErr);
1682 return TyOrErr.takeError();
1686 for (
auto *
P : T->
quals()) {
1688 Protocols.push_back(*ProtocolOrErr);
1690 return ProtocolOrErr.takeError();
1702 if (!ToPointeeTypeOrErr)
1703 return ToPointeeTypeOrErr.takeError();
1711 if (!ToUnderlyingTypeOrErr)
1712 return ToUnderlyingTypeOrErr.takeError();
1720 Error Err = Error::success();
1724 return std::move(Err);
1726 return Importer.getToContext().getAdjustedType(ToOriginalType,
1731 return Importer.getToContext().getBitIntType(T->
isUnsigned(),
1735ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType(
1737 Error Err = Error::success();
1738 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err, T->
getAttr());
1741 return std::move(Err);
1743 return Importer.getToContext().getBTFTagAttributedType(ToBTFAttr,
1747ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType(
1750 if (!ToElementTypeOrErr)
1751 return ToElementTypeOrErr.takeError();
1753 return Importer.getToContext().getConstantMatrixType(
1757ExpectedType clang::ASTNodeImporter::VisitDependentAddressSpaceType(
1759 Error Err = Error::success();
1764 return std::move(Err);
1766 return Importer.getToContext().getDependentAddressSpaceType(
1767 ToPointeeType, ToAddrSpaceExpr, ToAttrLoc);
1770ExpectedType clang::ASTNodeImporter::VisitDependentBitIntType(
1773 if (!ToNumBitsExprOrErr)
1774 return ToNumBitsExprOrErr.takeError();
1775 return Importer.getToContext().getDependentBitIntType(T->
isUnsigned(),
1776 *ToNumBitsExprOrErr);
1779ExpectedType clang::ASTNodeImporter::VisitDependentSizedMatrixType(
1781 Error Err = Error::success();
1787 return std::move(Err);
1789 return Importer.getToContext().getDependentSizedMatrixType(
1790 ToElementType, ToRowExpr, ToColumnExpr, ToAttrLoc);
1793ExpectedType clang::ASTNodeImporter::VisitDependentVectorType(
1795 Error Err = Error::success();
1800 return std::move(Err);
1802 return Importer.getToContext().getDependentVectorType(
1806ExpectedType clang::ASTNodeImporter::VisitObjCTypeParamType(
1810 return ToDeclOrErr.takeError();
1815 if (!ToProtocolOrErr)
1816 return ToProtocolOrErr.takeError();
1817 ToProtocols.push_back(*ToProtocolOrErr);
1820 return Importer.getToContext().getObjCTypeParamType(*ToDeclOrErr,
1826 if (!ToElementTypeOrErr)
1827 return ToElementTypeOrErr.takeError();
1850 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1852 auto getLeafPointeeType = [](
const Type *T) {
1860 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1861 auto *RT = dyn_cast<RecordType>(LeafT);
1862 if (RT && RT->getDecl() == D) {
1875 if (Error Err = importInto(Name, D->
getDeclName()))
1879 if (Error Err = importInto(Loc, D->
getLocation()))
1887 return Error::success();
1894 if (Error Err = importInto(Name, D->
getDeclName()))
1898 if (Error Err = importInto(Loc, D->
getLocation()))
1906 return Error::success();
1911 return Error::success();
1914 if (Error Err = importInto(ToD, FromD))
1917 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1918 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1919 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1920 !ToRecord->getDefinition()) {
1925 return Error::success();
1928 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1929 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1930 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1935 return Error::success();
1938 return Error::success();
1953 return Error::success();
1959 return ToRangeOrErr.takeError();
1960 return Error::success();
1966 return LocOrErr.takeError();
1967 return Error::success();
1975 return ToTInfoOrErr.takeError();
1976 return Error::success();
1979 llvm_unreachable(
"Unknown name kind.");
1986 return ToDCOrErr.takeError();
2000 auto MightNeedReordering = [](
const Decl *D) {
2001 return isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D);
2005 Error ChildErrors = Error::success();
2006 for (
auto *From : FromDC->
decls()) {
2007 if (!MightNeedReordering(From))
2016 if (!ImportedOrErr) {
2018 ImportedOrErr.takeError());
2021 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
2022 Decl *ImportedDecl = *ImportedOrErr;
2023 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
2024 if (FieldFrom && FieldTo) {
2056 consumeError(std::move(ChildErrors));
2057 return ToDCOrErr.takeError();
2060 if (
const auto *FromRD = dyn_cast<RecordDecl>(FromDC)) {
2064 for (
auto *D : FromRD->decls()) {
2065 if (!MightNeedReordering(D))
2068 assert(D &&
"DC contains a null decl");
2071 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->
containsDecl(ToD));
2083 for (
auto *From : FromDC->
decls()) {
2084 if (MightNeedReordering(From))
2090 ImportedOrErr.takeError());
2110 if (!FromRecordDecl || !ToRecordDecl) {
2114 if (RecordFrom && RecordTo) {
2115 FromRecordDecl = RecordFrom->
getDecl();
2116 ToRecordDecl = RecordTo->getDecl();
2120 if (FromRecordDecl && ToRecordDecl) {
2126 return Error::success();
2133 return ToDCOrErr.takeError();
2139 if (!ToLexicalDCOrErr)
2140 return ToLexicalDCOrErr.takeError();
2141 ToLexicalDC = *ToLexicalDCOrErr;
2145 return Error::success();
2151 "Import implicit methods to or from non-definition");
2154 if (FromM->isImplicit()) {
2157 return ToMOrErr.takeError();
2160 return Error::success();
2169 return ToTypedefOrErr.takeError();
2171 return Error::success();
2176 auto DefinitionCompleter = [To]() {
2195 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2197 ToCaptures.reserve(FromCXXRD->capture_size());
2198 for (
const auto &FromCapture : FromCXXRD->captures()) {
2199 if (
auto ToCaptureOrErr =
import(FromCapture))
2200 ToCaptures.push_back(*ToCaptureOrErr);
2202 return ToCaptureOrErr.takeError();
2204 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2211 DefinitionCompleter();
2215 return Error::success();
2230 auto DefinitionCompleterScopeExit =
2231 llvm::make_scope_exit(DefinitionCompleter);
2237 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2238 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2239 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2241 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2242 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2244 #define FIELD(Name, Width, Merge) \
2245 ToData.Name = FromData.Name;
2246 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2249 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2252 for (
const auto &Base1 : FromCXX->bases()) {
2255 return TyOrErr.takeError();
2258 if (Base1.isPackExpansion()) {
2259 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2260 EllipsisLoc = *LocOrErr;
2262 return LocOrErr.takeError();
2270 auto RangeOrErr =
import(Base1.getSourceRange());
2272 return RangeOrErr.takeError();
2274 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2276 return TSIOrErr.takeError();
2282 Base1.isBaseOfClass(),
2283 Base1.getAccessSpecifierAsWritten(),
2288 ToCXX->setBases(Bases.data(), Bases.size());
2296 return Error::success();
2301 return Error::success();
2305 return Error::success();
2309 return ToInitOrErr.takeError();
2320 return Error::success();
2328 return Error::success();
2339 return ToTypeOrErr.takeError();
2342 if (!ToPromotionTypeOrErr)
2343 return ToPromotionTypeOrErr.takeError();
2354 return Error::success();
2360 for (
const auto &Arg : FromArgs) {
2361 if (
auto ToOrErr =
import(Arg))
2362 ToArgs.push_back(*ToOrErr);
2364 return ToOrErr.takeError();
2367 return Error::success();
2373 return import(From);
2376template <
typename InContainerTy>
2379 for (
const auto &FromLoc : Container) {
2380 if (
auto ToLocOrErr =
import(FromLoc))
2383 return ToLocOrErr.takeError();
2385 return Error::success();
2395 bool IgnoreTemplateParmDepth) {
2406 false, Complain,
false,
2407 IgnoreTemplateParmDepth);
2427 return std::move(Err);
2432 return LocOrErr.takeError();
2435 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, *LocOrErr))
2458 return std::move(Err);
2463 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(), DC, Loc,
2464 Name.getAsIdentifierInfo()))
2467 Error Err = Error::success();
2472 return std::move(Err);
2476 addDeclToContexts(D, ToD);
2484 return LocOrErr.takeError();
2487 return ColonLocOrErr.takeError();
2492 return DCOrErr.takeError();
2497 DC, *LocOrErr, *ColonLocOrErr))
2511 return DCOrErr.takeError();
2515 Error Err = Error::success();
2521 return std::move(Err);
2524 if (GetImportedOrCreateDecl(
2525 ToD, D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2541 return std::move(Err);
2550 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2556 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2557 for (
auto *FoundDecl : FoundDecls) {
2561 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2562 MergeWithNamespace = FoundNS;
2563 ConflictingDecls.clear();
2567 ConflictingDecls.push_back(FoundDecl);
2570 if (!ConflictingDecls.empty()) {
2573 ConflictingDecls.size());
2575 Name = NameOrErr.get();
2577 return NameOrErr.takeError();
2583 return BeginLocOrErr.takeError();
2585 if (!RBraceLocOrErr)
2586 return RBraceLocOrErr.takeError();
2591 if (GetImportedOrCreateDecl(ToNamespace, D, Importer.
getToContext(), DC,
2592 D->
isInline(), *BeginLocOrErr, Loc,
2593 Name.getAsIdentifierInfo(),
2603 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2604 TU->setAnonymousNamespace(ToNamespace);
2606 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2612 return std::move(Err);
2623 if (Error Err =
ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
2624 return std::move(Err);
2630 Error Err = Error::success();
2637 return std::move(Err);
2642 if (GetImportedOrCreateDecl(
2643 ToD, D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2644 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2662 return std::move(Err);
2681 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2682 for (
auto *FoundDecl : FoundDecls) {
2685 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2690 QualType FoundUT = FoundTypedef->getUnderlyingType();
2704 if (FromR && FoundR &&
2715 ConflictingDecls.push_back(FoundDecl);
2720 if (!ConflictingDecls.empty()) {
2722 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2724 Name = NameOrErr.get();
2726 return NameOrErr.takeError();
2730 Error Err = Error::success();
2735 return std::move(Err);
2742 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2743 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2744 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2746 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2747 ToTypedef, D, Importer.
getToContext(), DC, ToBeginLoc, Loc,
2748 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2753 return std::move(Err);
2757 Importer.AddToLookupTable(ToTypedef);
2762 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) :
nullptr;
2785 return std::move(Err);
2795 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2796 for (
auto *FoundDecl : FoundDecls) {
2799 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) {
2802 ConflictingDecls.push_back(FoundDecl);
2806 if (!ConflictingDecls.empty()) {
2808 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2810 Name = NameOrErr.get();
2812 return NameOrErr.takeError();
2816 Error Err = Error::success();
2820 return std::move(Err);
2823 if (GetImportedOrCreateDecl(ToAlias, D, Importer.
getToContext(), DC, Loc,
2824 Name, ToTemplateParameters, ToTemplatedDecl))
2827 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2833 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2844 return std::move(Err);
2854 return BeginLocOrErr.takeError();
2855 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2856 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2860 if (GetImportedOrCreateDecl(ToLabel, D, Importer.
getToContext(), DC, Loc,
2861 Name.getAsIdentifierInfo()))
2868 return ToStmtOrErr.takeError();
2870 ToLabel->
setStmt(*ToStmtOrErr);
2883 return std::move(Err);
2891 if (Error Err = importInto(
2893 return std::move(Err);
2903 Importer.findDeclsInToCtx(DC, SearchName);
2904 for (
auto *FoundDecl : FoundDecls) {
2908 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2909 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
2910 FoundDecl = Tag->getDecl();
2913 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2923 ConflictingDecls.push_back(FoundDecl);
2927 if (!ConflictingDecls.empty()) {
2929 SearchName, DC, IDNS, ConflictingDecls.data(),
2930 ConflictingDecls.size());
2932 Name = NameOrErr.get();
2934 return NameOrErr.takeError();
2938 Error Err = Error::success();
2944 return std::move(Err);
2948 if (GetImportedOrCreateDecl(
2950 Loc, Name.getAsIdentifierInfo(), PrevDecl, D->
isScoped(),
2959 addDeclToContexts(D, D2);
2965 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
2967 return ToInstOrErr.takeError();
2968 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
2971 return POIOrErr.takeError();
2977 return std::move(Err);
2983 bool IsFriendTemplate =
false;
2984 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2986 DCXX->getDescribedClassTemplate() &&
2987 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2997 return std::move(Err);
3005 if (Error Err = importInto(
3007 return std::move(Err);
3014 bool DependentFriend = IsFriendTemplate && IsDependentContext;
3021 Importer.findDeclsInToCtx(DC, SearchName);
3022 if (!FoundDecls.empty()) {
3029 for (
auto *FoundDecl : FoundDecls) {
3033 Decl *Found = FoundDecl;
3034 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
3035 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
3036 Found = Tag->getDecl();
3039 if (
auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
3062 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
3063 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
3064 assert(FoundCXX &&
"Record type mismatch");
3070 return std::move(Err);
3076 ConflictingDecls.push_back(FoundDecl);
3080 if (!ConflictingDecls.empty() && SearchName) {
3082 SearchName, DC, IDNS, ConflictingDecls.data(),
3083 ConflictingDecls.size());
3085 Name = NameOrErr.get();
3087 return NameOrErr.takeError();
3093 return BeginLocOrErr.takeError();
3098 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
3099 if (DCXX->isLambda()) {
3100 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
3102 return TInfoOrErr.takeError();
3103 if (GetImportedOrCreateSpecialDecl(
3105 DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
3106 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
3111 return CDeclOrErr.takeError();
3114 }
else if (DCXX->isInjectedClassName()) {
3117 const bool DelayTypeCreation =
true;
3118 if (GetImportedOrCreateDecl(
3120 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
3121 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
3124 D2CXX, dyn_cast<CXXRecordDecl>(DC));
3126 if (GetImportedOrCreateDecl(D2CXX, D, Importer.
getToContext(),
3128 Name.getAsIdentifierInfo(),
3129 cast_or_null<CXXRecordDecl>(PrevDecl)))
3136 addDeclToContexts(D, D2);
3139 DCXX->getDescribedClassTemplate()) {
3141 if (Error Err = importInto(ToDescribed, FromDescribed))
3142 return std::move(Err);
3144 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
3151 auto *
Record = dyn_cast<CXXRecordDecl>(Found);
3164 const Type *FrontTy =
3165 cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
3168 InjSpec = InjTy->getInjectedSpecializationType();
3171 for (
auto *R : Redecls) {
3172 auto *RI = cast<CXXRecordDecl>(R);
3173 if (R != Redecls.front() ||
3174 !isa<InjectedClassNameType>(RI->getTypeForDecl()))
3175 RI->setTypeForDecl(
nullptr);
3190 DCXX->getMemberSpecializationInfo()) {
3192 MemberInfo->getTemplateSpecializationKind();
3198 return ToInstOrErr.takeError();
3201 import(MemberInfo->getPointOfInstantiation()))
3205 return POIOrErr.takeError();
3209 if (GetImportedOrCreateDecl(D2, D, Importer.
getToContext(),
3211 Name.getAsIdentifierInfo(), PrevDecl))
3214 addDeclToContexts(D, D2);
3220 return BraceRangeOrErr.takeError();
3224 return QualifierLocOrErr.takeError();
3231 return std::move(Err);
3243 return std::move(Err);
3252 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3253 for (
auto *FoundDecl : FoundDecls) {
3257 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3259 return Importer.
MapImported(D, FoundEnumConstant);
3260 ConflictingDecls.push_back(FoundDecl);
3264 if (!ConflictingDecls.empty()) {
3266 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3268 Name = NameOrErr.get();
3270 return NameOrErr.takeError();
3276 return TypeOrErr.takeError();
3280 return InitOrErr.takeError();
3283 if (GetImportedOrCreateDecl(
3284 ToEnumerator, D, Importer.
getToContext(), cast<EnumDecl>(DC), Loc,
3285 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->
getInitVal()))
3286 return ToEnumerator;
3291 return ToEnumerator;
3298 return Error::success();
3300 for (
unsigned int I = 0; I < Num; ++I)
3303 ToTPLists[I] = *ToTPListOrErr;
3305 return ToTPListOrErr.takeError();
3307 return Error::success();
3315 return Error::success();
3321 return Error::success();
3327 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3329 return InstFDOrErr.takeError();
3335 return POIOrErr.takeError();
3337 return Error::success();
3341 auto FunctionAndArgsOrErr =
3343 if (!FunctionAndArgsOrErr)
3344 return FunctionAndArgsOrErr.takeError();
3347 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3351 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3352 if (FromTAArgsAsWritten)
3354 *FromTAArgsAsWritten, ToTAInfo))
3357 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3359 return POIOrErr.takeError();
3365 ToFD->setFunctionTemplateSpecialization(
3366 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3367 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3368 return Error::success();
3376 Candidates.
addDecl(*ToFTDOrErr);
3378 return ToFTDOrErr.takeError();
3383 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3384 if (FromTAArgsAsWritten)
3391 FromTAArgsAsWritten ? &ToTAInfo :
nullptr);
3392 return Error::success();
3395 llvm_unreachable(
"All cases should be covered!");
3400 auto FunctionAndArgsOrErr =
3402 if (!FunctionAndArgsOrErr)
3403 return FunctionAndArgsOrErr.takeError();
3407 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3408 void *InsertPos =
nullptr;
3419 return ToBodyOrErr.takeError();
3421 return Error::success();
3427 const DeclContext *DCi = dyn_cast<DeclContext>(D);
3430 assert(DCi &&
"Declaration should have a context");
3444 ToProcess.push_back(S);
3445 while (!ToProcess.empty()) {
3446 const Stmt *CurrentS = ToProcess.pop_back_val();
3448 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS)) {
3449 if (
const Decl *D = DeclRef->getDecl())
3452 }
else if (
const auto *E =
3453 dyn_cast_or_null<SubstNonTypeTemplateParmExpr>(CurrentS)) {
3454 if (
const Decl *D = E->getAssociatedDecl())
3487class IsTypeDeclaredInsideVisitor
3488 :
public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3490 IsTypeDeclaredInsideVisitor(
const FunctionDecl *ParentDC)
3491 : ParentDC(ParentDC) {}
3497 if (std::optional<bool> Res = Visit(T.
getTypePtr()))
3502 if (std::optional<bool> Res = Visit(DsT.
getTypePtr()))
3510 std::optional<bool> VisitTagType(
const TagType *T) {
3511 if (
auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(T->
getDecl()))
3512 for (
const auto &Arg : Spec->getTemplateArgs().asArray())
3513 if (checkTemplateArgument(Arg))
3518 std::optional<bool> VisitPointerType(
const PointerType *T) {
3522 std::optional<bool> VisitReferenceType(
const ReferenceType *T) {
3526 std::optional<bool> VisitTypedefType(
const TypedefType *T) {
3532 std::optional<bool> VisitUsingType(
const UsingType *T) {
3543 if (checkTemplateArgument(Arg))
3566 "Variable array should not occur in deduced return type of a function");
3570 llvm_unreachable(
"Incomplete array should not occur in deduced return type "
3575 llvm_unreachable(
"Dependent array should not occur in deduced return type "
3602 if (checkTemplateArgument(PackArg))
3614 llvm_unreachable(
"Unknown TemplateArgument::ArgKind enum");
3624 assert(FromFPT &&
"Must be called on FunctionProtoType");
3626 QualType RetT = FromFPT->getReturnType();
3629 IsTypeDeclaredInsideVisitor Visitor(Def ? Def : D);
3630 return Visitor.CheckType(RetT);
3647 auto RedeclIt = Redecls.begin();
3650 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3653 return ToRedeclOrErr.takeError();
3655 assert(*RedeclIt == D);
3663 return std::move(Err);
3678 if (!FoundFunctionOrErr)
3679 return FoundFunctionOrErr.takeError();
3680 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3681 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3683 FoundByLookup = FoundFunction;
3691 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3692 for (
auto *FoundDecl : FoundDecls) {
3696 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3701 if (
Decl *Def = FindAndMapDefinition(D, FoundFunction))
3703 FoundByLookup = FoundFunction;
3714 Importer.
ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3715 << Name << D->
getType() << FoundFunction->getType();
3716 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3717 << FoundFunction->getType();
3718 ConflictingDecls.push_back(FoundDecl);
3722 if (!ConflictingDecls.empty()) {
3724 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3726 Name = NameOrErr.get();
3728 return NameOrErr.takeError();
3738 if (FoundByLookup) {
3739 if (isa<CXXMethodDecl>(FoundByLookup)) {
3748 "Templated function mapped to non-templated?");
3764 return std::move(Err);
3775 bool UsedDifferentProtoType =
false;
3777 QualType FromReturnTy = FromFPT->getReturnType();
3785 UsedDifferentProtoType =
true;
3796 FromEPI = DefaultEPI;
3797 UsedDifferentProtoType =
true;
3800 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3805 Error Err = Error::success();
3812 auto TrailingRequiresClause =
3815 return std::move(Err);
3821 Parameters.push_back(*ToPOrErr);
3823 return ToPOrErr.takeError();
3828 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3830 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3832 return std::move(Err);
3834 if (FromConstructor->isInheritingConstructor()) {
3836 import(FromConstructor->getInheritedConstructor());
3837 if (!ImportedInheritedCtor)
3838 return ImportedInheritedCtor.takeError();
3839 ToInheritedConstructor = *ImportedInheritedCtor;
3841 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3842 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3843 ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->
UsesFPIntrin(),
3845 ToInheritedConstructor, TrailingRequiresClause))
3849 Error Err = Error::success();
3851 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3852 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3854 return std::move(Err);
3856 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3857 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3858 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3860 TrailingRequiresClause))
3867 dyn_cast<CXXConversionDecl>(D)) {
3869 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3871 return std::move(Err);
3872 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3873 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3874 ToInnerLocStart, NameInfo, T, TInfo, D->
UsesFPIntrin(),
3878 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3879 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3880 ToFunction, D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3881 ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3882 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3885 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3887 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3891 return std::move(Err);
3892 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3893 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart, ESpec,
3894 NameInfo, T, TInfo, ToEndLoc, Ctor))
3896 cast<CXXDeductionGuideDecl>(ToFunction)
3897 ->setDeductionCandidateKind(Guide->getDeductionCandidateKind());
3899 if (GetImportedOrCreateDecl(
3900 ToFunction, D, Importer.
getToContext(), DC, ToInnerLocStart,
3908 if (FoundByLookup) {
3934 for (
auto *Param : Parameters) {
3935 Param->setOwningFunction(ToFunction);
3940 ToFunction->setParams(Parameters);
3947 for (
unsigned I = 0, N = Parameters.size(); I != N; ++I)
3948 ProtoLoc.setParam(I, Parameters[I]);
3954 auto ToFTOrErr =
import(FromFT);
3956 return ToFTOrErr.takeError();
3960 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3961 if (
unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3965 FromConstructor->inits(), CtorInitializers))
3966 return std::move(Err);
3969 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3970 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3971 ToCtor->setCtorInitializers(Memory);
3972 ToCtor->setNumCtorInitializers(NumInitializers);
3978 return std::move(Err);
3980 if (
auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3983 return std::move(Err);
3989 return std::move(Err);
3993 if (UsedDifferentProtoType) {
3995 ToFunction->
setType(*TyOrErr);
3997 return TyOrErr.takeError();
4001 return TSIOrErr.takeError();
4006 addDeclToContexts(D, ToFunction);
4009 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4012 return ToRedeclOrErr.takeError();
4046 return std::move(Err);
4051 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4052 for (
auto *FoundDecl : FoundDecls) {
4053 if (
FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
4061 FoundField->getType())) {
4070 if (
ExpectedExpr ToInitializerOrErr =
import(FromInitializer)) {
4073 assert(FoundField->hasInClassInitializer() &&
4074 "Field should have an in-class initializer if it has an "
4075 "expression for it.");
4076 if (!FoundField->getInClassInitializer())
4077 FoundField->setInClassInitializer(*ToInitializerOrErr);
4079 return ToInitializerOrErr.takeError();
4086 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
4087 << Name << D->
getType() << FoundField->getType();
4088 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4089 << FoundField->getType();
4095 Error Err = Error::success();
4101 return std::move(Err);
4102 const Type *ToCapturedVLAType =
nullptr;
4105 return std::move(Err);
4108 if (GetImportedOrCreateDecl(ToField, D, Importer.
getToContext(), DC,
4109 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
4110 ToType, ToTInfo, ToBitWidth, D->
isMutable(),
4117 Err = Importer.ImportAttrs(ToField, D);
4119 return std::move(Err);
4123 if (ToCapturedVLAType)
4130 return std::move(Err);
4131 if (ToInitializer) {
4133 if (AlreadyImported)
4134 assert(ToInitializer == AlreadyImported &&
4135 "Duplicate import of in-class initializer.");
4150 return std::move(Err);
4155 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4156 for (
unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4157 if (
auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
4165 FoundField->getType(),
4172 if (!Name && I < N-1)
4176 Importer.
ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
4177 << Name << D->
getType() << FoundField->getType();
4178 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4179 << FoundField->getType();
4186 auto TypeOrErr =
import(D->
getType());
4188 return TypeOrErr.takeError();
4194 for (
auto *PI : D->
chain())
4196 NamedChain[i++] = *ToD;
4198 return ToD.takeError();
4202 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.
getToContext(), DC,
4203 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
4205 return ToIndirectField;
4210 return ToIndirectField;
4240 unsigned int FriendCount = 0;
4241 std::optional<unsigned int> FriendPosition;
4244 for (
FriendDecl *FoundFriend : RD->friends()) {
4245 if (FoundFriend == FD) {
4246 FriendPosition = FriendCount;
4253 assert(FriendPosition &&
"Friend decl not found in own parent.");
4255 return {FriendCount, *FriendPosition};
4262 return std::move(Err);
4267 const auto *RD = cast<CXXRecordDecl>(DC);
4269 for (
FriendDecl *ImportedFriend : RD->friends())
4271 ImportedEquivalentFriends.push_back(ImportedFriend);
4276 assert(ImportedEquivalentFriends.size() <= CountAndPosition.
TotalCount &&
4277 "Class with non-matching friends is imported, ODR check wrong?");
4278 if (ImportedEquivalentFriends.size() == CountAndPosition.
TotalCount)
4280 D, ImportedEquivalentFriends[CountAndPosition.
IndexOfDecl]);
4287 if (Error Err = importInto(ToFriendD, FriendD))
4288 return std::move(Err);
4299 return TSIOrErr.takeError();
4304 for (
unsigned I = 0; I < D->NumTPLists; I++) {
4305 if (
auto ListOrErr =
import(FromTPLists[I]))
4306 ToTPLists[I] = *ListOrErr;
4308 return ListOrErr.takeError();
4313 return LocationOrErr.takeError();
4315 if (!FriendLocOrErr)
4316 return FriendLocOrErr.takeError();
4319 if (GetImportedOrCreateDecl(FrD, D, Importer.
getToContext(), DC,
4320 *LocationOrErr, ToFU,
4321 *FriendLocOrErr, ToTPLists))
4337 return std::move(Err);
4342 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4343 for (
auto *FoundDecl : FoundDecls) {
4344 if (
ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
4346 FoundIvar->getType())) {
4351 Importer.
ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
4352 << Name << D->
getType() << FoundIvar->getType();
4353 Importer.
ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
4354 << FoundIvar->getType();
4360 Error Err = Error::success();
4366 return std::move(Err);
4369 if (GetImportedOrCreateDecl(
4370 ToIvar, D, Importer.
getToContext(), cast<ObjCContainerDecl>(DC),
4371 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
4372 ToType, ToTypeSourceInfo,
4384 auto RedeclIt = Redecls.begin();
4387 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4390 return RedeclOrErr.takeError();
4392 assert(*RedeclIt == D);
4400 return std::move(Err);
4406 VarDecl *FoundByLookup =
nullptr;
4410 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4411 for (
auto *FoundDecl : FoundDecls) {
4415 if (
auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4419 FoundVar->getType())) {
4431 const VarDecl *FoundDInit =
nullptr;
4432 if (D->
getInit() && FoundVar->getAnyInitializer(FoundDInit))
4436 FoundByLookup = FoundVar;
4444 if (FoundArray && TArray) {
4445 if (isa<IncompleteArrayType>(FoundArray) &&
4446 isa<ConstantArrayType>(TArray)) {
4448 if (
auto TyOrErr =
import(D->
getType()))
4449 FoundVar->setType(*TyOrErr);
4451 return TyOrErr.takeError();
4453 FoundByLookup = FoundVar;
4455 }
else if (isa<IncompleteArrayType>(TArray) &&
4456 isa<ConstantArrayType>(FoundArray)) {
4457 FoundByLookup = FoundVar;
4462 Importer.
ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
4463 << Name << D->
getType() << FoundVar->getType();
4464 Importer.
ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4465 << FoundVar->getType();
4466 ConflictingDecls.push_back(FoundDecl);
4470 if (!ConflictingDecls.empty()) {
4472 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4474 Name = NameOrErr.get();
4476 return NameOrErr.takeError();
4480 Error Err = Error::success();
4486 return std::move(Err);
4489 if (
auto *FromDecomp = dyn_cast<DecompositionDecl>(D)) {
4493 return std::move(Err);
4495 if (GetImportedOrCreateDecl(
4496 ToDecomp, FromDecomp, Importer.
getToContext(), DC, ToInnerLocStart,
4502 if (GetImportedOrCreateDecl(ToVar, D, Importer.
getToContext(), DC,
4503 ToInnerLocStart, Loc,
4504 Name.getAsIdentifierInfo(), ToType,
4514 if (FoundByLookup) {
4523 return ToVTOrErr.takeError();
4530 return ToInstOrErr.takeError();
4531 if (
ExpectedSLoc POIOrErr =
import(MSI->getPointOfInstantiation()))
4534 return POIOrErr.takeError();
4538 return std::move(Err);
4543 addDeclToContexts(D, ToVar);
4546 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4549 return RedeclOrErr.takeError();
4560 Error Err = Error::success();
4565 return std::move(Err);
4569 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4570 ToLocation, ToDeclName.getAsIdentifierInfo(),
4587 return ToDefArgOrErr.takeError();
4591 if (
auto ToDefArgOrErr =
import(FromParam->
getDefaultArg()))
4594 return ToDefArgOrErr.takeError();
4597 return Error::success();
4602 Error Err = Error::success();
4607 return std::move(Err);
4616 Error Err = Error::success();
4623 return std::move(Err);
4626 if (GetImportedOrCreateDecl(ToParm, D, Importer.
getToContext(), DC,
4627 ToInnerLocStart, ToLocation,
4628 ToDeclName.getAsIdentifierInfo(), ToType,
4637 return std::move(Err);
4657 return std::move(Err);
4661 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4662 for (
auto *FoundDecl : FoundDecls) {
4663 if (
auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4669 FoundMethod->getReturnType())) {
4670 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4672 << FoundMethod->getReturnType();
4673 Importer.
ToDiag(FoundMethod->getLocation(),
4674 diag::note_odr_objc_method_here)
4681 if (D->
param_size() != FoundMethod->param_size()) {
4682 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4684 << D->
param_size() << FoundMethod->param_size();
4685 Importer.
ToDiag(FoundMethod->getLocation(),
4686 diag::note_odr_objc_method_here)
4694 PEnd = D->
param_end(), FoundP = FoundMethod->param_begin();
4695 P != PEnd; ++
P, ++FoundP) {
4697 (*FoundP)->getType())) {
4698 Importer.
FromDiag((*P)->getLocation(),
4699 diag::warn_odr_objc_method_param_type_inconsistent)
4701 << (*P)->getType() << (*FoundP)->getType();
4702 Importer.
ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4703 << (*FoundP)->getType();
4711 if (D->
isVariadic() != FoundMethod->isVariadic()) {
4712 Importer.
ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4714 Importer.
ToDiag(FoundMethod->getLocation(),
4715 diag::note_odr_objc_method_here)
4726 Error Err = Error::success();
4729 auto ToReturnTypeSourceInfo =
4732 return std::move(Err);
4735 if (GetImportedOrCreateDecl(
4737 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4750 ToParams.push_back(*ToPOrErr);
4752 return ToPOrErr.takeError();
4756 for (
auto *ToParam : ToParams) {
4757 ToParam->setOwningFunction(ToMethod);
4765 return std::move(Err);
4789 return std::move(Err);
4793 Error Err = Error::success();
4799 return std::move(Err);
4802 if (GetImportedOrCreateDecl(
4805 ToLocation, Name.getAsIdentifierInfo(),
4806 ToColonLoc, ToTypeSourceInfo))
4812 return std::move(Err);
4813 Result->setTypeForDecl(ToTypeForDecl);
4814 Result->setLexicalDeclContext(LexicalDC);
4825 return std::move(Err);
4831 return std::move(Err);
4839 Error Err = Error::success();
4845 return std::move(Err);
4847 if (GetImportedOrCreateDecl(ToCategory, D, Importer.
getToContext(), DC,
4850 Name.getAsIdentifierInfo(), ToInterface,
4863 return PListOrErr.takeError();
4872 FromProto != FromProtoEnd;
4873 ++FromProto, ++FromProtoLoc) {
4875 Protocols.push_back(*ToProtoOrErr);
4877 return ToProtoOrErr.takeError();
4879 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4880 ProtocolLocs.push_back(*ToProtoLocOrErr);
4882 return ToProtoLocOrErr.takeError();
4895 return std::move(Err);
4903 return ToImplOrErr.takeError();
4915 return Error::success();
4928 FromProto != FromProtoEnd;
4929 ++FromProto, ++FromProtoLoc) {
4931 Protocols.push_back(*ToProtoOrErr);
4933 return ToProtoOrErr.takeError();
4935 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
4936 ProtocolLocs.push_back(*ToProtoLocOrErr);
4938 return ToProtoLocOrErr.takeError();
4951 return Error::success();
4961 return Importer.
MapImported(D, *ImportedDefOrErr);
4963 return ImportedDefOrErr.takeError();
4972 return std::move(Err);
4977 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4978 for (
auto *FoundDecl : FoundDecls) {
4982 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4989 if (!ToAtBeginLocOrErr)
4990 return ToAtBeginLocOrErr.takeError();
4992 if (GetImportedOrCreateDecl(ToProto, D, Importer.
getToContext(), DC,
4993 Name.getAsIdentifierInfo(), Loc,
5005 return std::move(Err);
5013 return std::move(Err);
5016 if (!ExternLocOrErr)
5017 return ExternLocOrErr.takeError();
5021 return LangLocOrErr.takeError();
5026 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.
getToContext(), DC,
5027 *ExternLocOrErr, *LangLocOrErr,
5029 return ToLinkageSpec;
5033 if (!RBraceLocOrErr)
5034 return RBraceLocOrErr.takeError();
5041 return ToLinkageSpec;
5052 return ToShadowOrErr.takeError();
5063 return std::move(Err);
5067 Error Err = Error::success();
5072 return std::move(Err);
5076 return std::move(Err);
5079 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
5080 ToUsingLoc, ToQualifierLoc, NameInfo,
5091 ToUsing, *ToPatternOrErr);
5093 return ToPatternOrErr.takeError();
5105 return std::move(Err);
5109 Error Err = Error::success();
5115 return std::move(Err);
5118 if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.
getToContext(), DC,
5119 ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType))
5131 return ToPatternOrErr.takeError();
5143 return std::move(Err);
5148 if (!ToIntroducerOrErr)
5149 return ToIntroducerOrErr.takeError();
5153 return ToTargetOrErr.takeError();
5156 if (
auto *FromConstructorUsingShadow =
5157 dyn_cast<ConstructorUsingShadowDecl>(D)) {
5158 Error Err = Error::success();
5160 Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
5162 return std::move(Err);
5168 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
5170 cast<UsingDecl>(*ToIntroducerOrErr),
5171 Nominated ? Nominated : *ToTargetOrErr,
5172 FromConstructorUsingShadow->constructsVirtualBase()))
5175 if (GetImportedOrCreateDecl(ToShadow, D, Importer.
getToContext(), DC, Loc,
5176 Name, *ToIntroducerOrErr, *ToTargetOrErr))
5187 ToShadow, *ToPatternOrErr);
5191 return ToPatternOrErr.takeError();
5205 return std::move(Err);
5210 if (!ToComAncestorOrErr)
5211 return ToComAncestorOrErr.takeError();
5213 Error Err = Error::success();
5216 auto ToNamespaceKeyLocation =
5221 return std::move(Err);
5224 if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.
getToContext(), DC,
5226 ToNamespaceKeyLocation,
5229 ToNominatedNamespace, *ToComAncestorOrErr))
5244 return std::move(Err);
5248 auto ToInstantiatedFromUsingOrErr =
5250 if (!ToInstantiatedFromUsingOrErr)
5251 return ToInstantiatedFromUsingOrErr.takeError();
5254 return std::move(Err);
5257 if (GetImportedOrCreateDecl(ToUsingPack, D, Importer.
getToContext(), DC,
5258 cast<NamedDecl>(*ToInstantiatedFromUsingOrErr),
5262 addDeclToContexts(D, ToUsingPack);
5274 return std::move(Err);
5278 Error Err = Error::success();
5284 return std::move(Err);
5288 return std::move(Err);
5291 if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.
getToContext(), DC,
5292 ToUsingLoc, ToQualifierLoc, NameInfo,
5294 return ToUsingValue;
5300 return ToUsingValue;
5310 return std::move(Err);
5314 Error Err = Error::success();
5320 return std::move(Err);
5323 if (GetImportedOrCreateDecl(ToUsing, D, Importer.
getToContext(), DC,
5324 ToUsingLoc, ToTypenameLoc,
5325 ToQualifierLoc, Loc, Name, ToEllipsisLoc))
5336 Decl* ToD =
nullptr;
5345 assert(ToD &&
"BuiltinTemplateDecl of unsupported kind!");
5356 if (
auto FromSuperOrErr =
import(FromSuper))
5357 FromSuper = *FromSuperOrErr;
5359 return FromSuperOrErr.takeError();
5363 if ((
bool)FromSuper != (
bool)ToSuper ||
5366 diag::warn_odr_objc_superclass_inconsistent)
5373 diag::note_odr_objc_missing_superclass);
5376 diag::note_odr_objc_superclass)
5380 diag::note_odr_objc_missing_superclass);
5386 return Error::success();
5397 return SuperTInfoOrErr.takeError();
5408 FromProto != FromProtoEnd;
5409 ++FromProto, ++FromProtoLoc) {
5411 Protocols.push_back(*ToProtoOrErr);
5413 return ToProtoOrErr.takeError();
5415 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5416 ProtocolLocs.push_back(*ToProtoLocOrErr);
5418 return ToProtoLocOrErr.takeError();
5429 auto ToCatOrErr =
import(Cat);
5431 return ToCatOrErr.takeError();
5440 return ToImplOrErr.takeError();
5447 return Error::success();
5456 for (
auto *fromTypeParam : *list) {
5457 if (
auto toTypeParamOrErr =
import(fromTypeParam))
5458 toTypeParams.push_back(*toTypeParamOrErr);
5460 return toTypeParamOrErr.takeError();
5464 if (!LAngleLocOrErr)
5465 return LAngleLocOrErr.takeError();
5468 if (!RAngleLocOrErr)
5469 return RAngleLocOrErr.takeError();
5484 return Importer.
MapImported(D, *ImportedDefOrErr);
5486 return ImportedDefOrErr.takeError();
5495 return std::move(Err);
5501 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5502 for (
auto *FoundDecl : FoundDecls) {
5506 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
5514 if (!AtBeginLocOrErr)
5515 return AtBeginLocOrErr.takeError();
5517 if (GetImportedOrCreateDecl(
5519 *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
5529 if (
auto ToPListOrErr =
5533 return ToPListOrErr.takeError();
5537 return std::move(Err);
5546 return std::move(Err);
5552 return std::move(Err);
5554 Error Err = Error::success();
5559 return std::move(Err);
5561 if (GetImportedOrCreateDecl(
5564 ToLocation, ToAtStartLoc, ToCategoryNameLoc))
5569 Category->setImplementation(ToImpl);
5574 return std::move(Err);
5584 return std::move(Err);
5589 return std::move(Err);
5597 return std::move(Err);
5599 Error Err = Error::success();
5606 return std::move(Err);
5608 if (GetImportedOrCreateDecl(Impl, D, Importer.
getToContext(),
5632 diag::warn_odr_objc_superclass_inconsistent)
5638 diag::note_odr_objc_superclass)
5642 diag::note_odr_objc_missing_superclass);
5645 diag::note_odr_objc_superclass)
5649 diag::note_odr_objc_missing_superclass);
5657 return std::move(Err);
5669 return std::move(Err);
5674 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5675 for (
auto *FoundDecl : FoundDecls) {
5676 if (
auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
5684 FoundProp->getType())) {
5685 Importer.
ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent)
5686 << Name << D->
getType() << FoundProp->getType();
5687 Importer.
ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
5688 << FoundProp->getType();
5701 Error Err = Error::success();
5707 return std::move(Err);
5711 if (GetImportedOrCreateDecl(
5713 Name.getAsIdentifierInfo(), ToAtLoc,
5714 ToLParenLoc, ToType,
5726 return std::move(Err);
5746 return std::move(Err);
5750 return std::move(Err);
5752 auto *InImpl = cast<ObjCImplDecl>(LexicalDC);
5757 return std::move(Err);
5760 = InImpl->FindPropertyImplDecl(
Property->getIdentifier(),
5764 Error Err = Error::success();
5767 auto ToPropertyIvarDeclLoc =
5770 return std::move(Err);
5772 if (GetImportedOrCreateDecl(ToImpl, D, Importer.
getToContext(), DC,
5776 ToPropertyIvarDeclLoc))
5786 diag::warn_odr_objc_property_impl_kind_inconsistent)
5791 diag::note_odr_objc_property_impl_kind)
5802 diag::warn_odr_objc_synthesize_ivar_inconsistent)
5807 diag::note_odr_objc_synthesize_ivar_here)
5828 return BeginLocOrErr.takeError();
5832 return LocationOrErr.takeError();
5835 if (GetImportedOrCreateDecl(
5838 *BeginLocOrErr, *LocationOrErr,
5847 Error Err = Error::success();
5848 auto ToConceptRef =
importChecked(Err, TC->getConceptReference());
5849 auto ToIDC =
importChecked(Err, TC->getImmediatelyDeclaredConstraint());
5851 return std::move(Err);
5859 if (!ToDefaultArgOrErr)
5860 return ToDefaultArgOrErr.takeError();
5870 Error Err = Error::success();
5877 return std::move(Err);
5880 if (GetImportedOrCreateDecl(ToD, D, Importer.
getToContext(),
5882 ToInnerLocStart, ToLocation, D->
getDepth(),
5884 ToDeclName.getAsIdentifierInfo(), ToType,
5890 if (!ToDefaultArgOrErr)
5891 return ToDefaultArgOrErr.takeError();
5903 return NameOrErr.takeError();
5908 return LocationOrErr.takeError();
5912 if (!TemplateParamsOrErr)
5913 return TemplateParamsOrErr.takeError();
5916 if (GetImportedOrCreateDecl(
5920 (*NameOrErr).getAsIdentifierInfo(), *TemplateParamsOrErr))
5926 if (!ToDefaultArgOrErr)
5927 return ToDefaultArgOrErr.takeError();
5937 assert(D->getTemplatedDecl() &&
"Should be called on templates only");
5938 auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
5939 if (!ToTemplatedDef)
5941 auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
5942 return cast_or_null<T>(TemplateWithDef);
5953 return std::move(Err);
5967 bool DependentFriend = IsDependentFriend(D);
5974 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5975 for (
auto *FoundDecl : FoundDecls) {
5980 Decl *Found = FoundDecl;
5981 auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found);
5982 if (FoundTemplate) {
5987 bool IgnoreTemplateParmDepth =
5991 IgnoreTemplateParmDepth)) {
5992 if (DependentFriend || IsDependentFriend(FoundTemplate))
6000 FoundByLookup = FoundTemplate;
6005 ConflictingDecls.push_back(FoundDecl);
6009 if (!ConflictingDecls.empty()) {
6012 ConflictingDecls.size());
6014 Name = NameOrErr.get();
6016 return NameOrErr.takeError();
6023 if (!TemplateParamsOrErr)
6024 return TemplateParamsOrErr.takeError();
6028 if (Error Err = importInto(ToTemplated, FromTemplated))
6029 return std::move(Err);
6033 if (GetImportedOrCreateDecl(D2, D, Importer.
getToContext(), DC, Loc, Name,
6034 *TemplateParamsOrErr, ToTemplated))
6042 addDeclToContexts(D, D2);
6043 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
6045 if (FoundByLookup) {
6059 "Found decl must have its templated decl set");
6062 if (ToTemplated != PrevTemplated)
6076 return std::move(Err);
6081 return std::move(Err);
6087 return std::move(Err);
6090 void *InsertPos =
nullptr;
6093 dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
6101 return ToTPListOrErr.takeError();
6102 ToTPList = *ToTPListOrErr;
6116 for (
auto *FromField : D->
fields()) {
6117 auto ToOrErr =
import(FromField);
6119 return ToOrErr.takeError();
6125 auto ToOrErr =
import(FromM);
6127 return ToOrErr.takeError();
6135 return PrevDefinition;
6146 return BeginLocOrErr.takeError();
6149 return IdLocOrErr.takeError();
6158 return std::move(Err);
6161 if (Error Err = importInto(
6163 return std::move(Err);
6166 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
6168 *IdLocOrErr, ToTPList, ClassTemplate,
6169 llvm::ArrayRef(TemplateArgs.data(), TemplateArgs.size()), ToTAInfo,
6171 cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
6176 auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);
6183 PartSpec2->setInstantiatedFromMember(*ToInstOrErr);
6185 return ToInstOrErr.takeError();
6187 updateLookupTableForTemplateParameters(*ToTPList);
6189 if (GetImportedOrCreateDecl(
6191 *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
6215 return BraceRangeOrErr.takeError();
6221 return LocOrErr.takeError();
6224 if (
auto TInfoOrErr =
import(TSI))
6227 return TInfoOrErr.takeError();
6232 return LocOrErr.takeError();
6237 return LocOrErr.takeError();
6244 return POIOrErr.takeError();
6251 if (
auto CTDorErr =
import(CTD))
6254 auto *CTPSD = cast<ClassTemplatePartialSpecializationDecl *>(
P);
6255 auto CTPSDOrErr =
import(CTPSD);
6257 return CTPSDOrErr.takeError();
6260 for (
unsigned I = 0; I < DArgs.
size(); ++I) {
6262 if (
auto ArgOrErr =
import(DArg))
6263 D2ArgsVec[I] = *ArgOrErr;
6265 return ArgOrErr.takeError();
6275 return std::move(Err);
6287 return std::move(Err);
6293 "Variable templates cannot be declared at function scope");
6296 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6298 for (
auto *FoundDecl : FoundDecls) {
6302 if (
VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
6312 assert(FoundTemplate->getDeclContext()->isRecord() &&
6313 "Member variable template imported as non-member, "
6314 "inconsistent imported AST?");
6323 FoundByLookup = FoundTemplate;
6326 ConflictingDecls.push_back(FoundDecl);
6330 if (!ConflictingDecls.empty()) {
6333 ConflictingDecls.size());
6335 Name = NameOrErr.get();
6337 return NameOrErr.takeError();
6346 return TypeOrErr.takeError();
6350 if (Error Err = importInto(ToTemplated, DTemplated))
6351 return std::move(Err);
6355 if (!TemplateParamsOrErr)
6356 return TemplateParamsOrErr.takeError();
6359 if (GetImportedOrCreateDecl(ToVarTD, D, Importer.
getToContext(), DC, Loc,
6360 Name, *TemplateParamsOrErr, ToTemplated))
6369 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
6371 if (FoundByLookup) {
6375 auto *PrevTemplated =
6377 if (ToTemplated != PrevTemplated)
6392 auto RedeclIt = Redecls.begin();
6395 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
6398 return RedeclOrErr.takeError();
6400 assert(*RedeclIt == D);
6404 return std::move(Err);
6409 return std::move(Err);
6414 return BeginLocOrErr.takeError();
6418 return IdLocOrErr.takeError();
6424 return std::move(Err);
6427 void *InsertPos =
nullptr;
6430 if (FoundSpecialization) {
6438 "Member variable template specialization imported as non-member, "
6439 "inconsistent imported AST?");
6443 return Importer.
MapImported(D, FoundSpecialization);
6460 return std::move(Err);
6465 if (
auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
6468 const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
6472 return std::move(Err);
6474 auto ToTPListOrErr =
import(FromPartial->getTemplateParameters());
6476 return ToTPListOrErr.takeError();
6478 PartVarSpecDecl *ToPartial;
6479 if (GetImportedOrCreateDecl(ToPartial, D, Importer.
getToContext(), DC,
6480 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
6486 import(FromPartial->getInstantiatedFromMember()))
6487 ToPartial->setInstantiatedFromMember(*ToInstOrErr);
6489 return ToInstOrErr.takeError();
6491 if (FromPartial->isMemberSpecialization())
6492 ToPartial->setMemberSpecialization();
6500 if (GetImportedOrCreateDecl(D2, D, Importer.
getToContext(), DC,
6501 *BeginLocOrErr, *IdLocOrErr, VarTemplate,
6508 if (Error Err = importInto(T, D->
getType()))
6509 return std::move(Err);
6514 return TInfoOrErr.takeError();
6521 return POIOrErr.takeError();
6530 return LocOrErr.takeError();
6538 return std::move(Err);
6540 if (FoundSpecialization)
6545 addDeclToContexts(D, D2);
6548 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
6551 return RedeclOrErr.takeError();
6565 return std::move(Err);
6577 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6578 for (
auto *FoundDecl : FoundDecls) {
6582 if (
auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
6591 FoundByLookup = FoundTemplate;
6601 return ParamsOrErr.takeError();
6606 return std::move(Err);
6623 OldParamDC.reserve(Params->
size());
6624 llvm::transform(*Params, std::back_inserter(OldParamDC),
6628 if (GetImportedOrCreateDecl(ToFunc, D, Importer.
getToContext(), DC, Loc, Name,
6629 Params, TemplatedFD))
6635 ToFunc->setLexicalDeclContext(LexicalDC);
6636 addDeclToContexts(D, ToFunc);
6639 if (
LT && !OldParamDC.empty()) {
6640 for (
unsigned int I = 0; I < OldParamDC.size(); ++I)
6644 if (FoundByLookup) {
6649 "Found decl must have its templated decl set");
6650 auto *PrevTemplated =
6652 if (TemplatedFD != PrevTemplated)
6655 ToFunc->setPreviousDecl(Recent);
6666 Importer.
FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
6667 << S->getStmtClassName();
6676 for (
unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6680 Names.push_back(ToII);
6683 for (
unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6687 Names.push_back(ToII);
6691 for (
unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
6692 if (
auto ClobberOrErr =
import(S->getClobberStringLiteral(I)))
6693 Clobbers.push_back(*ClobberOrErr);
6695 return ClobberOrErr.takeError();
6700 for (
unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6701 if (
auto OutputOrErr =
import(S->getOutputConstraintLiteral(I)))
6702 Constraints.push_back(*OutputOrErr);
6704 return OutputOrErr.takeError();
6707 for (
unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6708 if (
auto InputOrErr =
import(S->getInputConstraintLiteral(I)))
6709 Constraints.push_back(*InputOrErr);
6711 return InputOrErr.takeError();
6717 return std::move(Err);
6721 return std::move(Err);
6724 S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6725 return std::move(Err);
6729 return AsmLocOrErr.takeError();
6730 auto AsmStrOrErr =
import(S->getAsmString());
6732 return AsmStrOrErr.takeError();
6733 ExpectedSLoc RParenLocOrErr =
import(S->getRParenLoc());
6734 if (!RParenLocOrErr)
6735 return RParenLocOrErr.takeError();
6748 S->getNumClobbers(),
6756 Error Err = Error::success();
6761 return std::move(Err);
6767 if (!ToSemiLocOrErr)
6768 return ToSemiLocOrErr.takeError();
6770 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6777 return std::move(Err);
6779 ExpectedSLoc ToLBracLocOrErr =
import(S->getLBracLoc());
6780 if (!ToLBracLocOrErr)
6781 return ToLBracLocOrErr.takeError();
6783 ExpectedSLoc ToRBracLocOrErr =
import(S->getRBracLoc());
6784 if (!ToRBracLocOrErr)
6785 return ToRBracLocOrErr.takeError();
6790 *ToLBracLocOrErr, *ToRBracLocOrErr);
6795 Error Err = Error::success();
6800 auto ToEllipsisLoc =
importChecked(Err, S->getEllipsisLoc());
6803 return std::move(Err);
6806 ToCaseLoc, ToEllipsisLoc, ToColonLoc);
6807 ToStmt->setSubStmt(ToSubStmt);
6814 Error Err = Error::success();
6819 return std::move(Err);
6822 ToDefaultLoc, ToColonLoc, ToSubStmt);
6827 Error Err = Error::success();
6832 return std::move(Err);
6835 ToIdentLoc, ToLabelDecl, ToSubStmt);
6840 if (!ToAttrLocOrErr)
6841 return ToAttrLocOrErr.takeError();
6845 return std::move(Err);
6847 if (!ToSubStmtOrErr)
6848 return ToSubStmtOrErr.takeError();
6851 Importer.
getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6856 Error Err = Error::success();
6859 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6867 return std::move(Err);
6870 ToInit, ToConditionVariable, ToCond, ToLParenLoc,
6871 ToRParenLoc, ToThen, ToElseLoc, ToElse);
6876 Error Err = Error::success();
6878 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6885 return std::move(Err);
6889 ToCond, ToLParenLoc, ToRParenLoc);
6890 ToStmt->setBody(ToBody);
6891 ToStmt->setSwitchLoc(ToSwitchLoc);
6895 for (
SwitchCase *SC = S->getSwitchCaseList(); SC !=
nullptr;
6896 SC = SC->getNextSwitchCase()) {
6899 return ToSCOrErr.takeError();
6900 if (LastChainedSwitchCase)
6903 ToStmt->setSwitchCaseList(*ToSCOrErr);
6904 LastChainedSwitchCase = *ToSCOrErr;
6912 Error Err = Error::success();
6913 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6920 return std::move(Err);
6923 ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
6928 Error Err = Error::success();
6935 return std::move(Err);
6938 ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
6943 Error Err = Error::success();
6946 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6953 return std::move(Err);
6957 ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
6963 Error Err = Error::success();
6968 return std::move(Err);
6971 ToLabel, ToGotoLoc, ToLabelLoc);
6976 Error Err = Error::success();
6981 return std::move(Err);
6984 ToGotoLoc, ToStarLoc, ToTarget);
6988 ExpectedSLoc ToContinueLocOrErr =
import(S->getContinueLoc());
6989 if (!ToContinueLocOrErr)
6990 return ToContinueLocOrErr.takeError();
6995 auto ToBreakLocOrErr =
import(S->getBreakLoc());
6996 if (!ToBreakLocOrErr)
6997 return ToBreakLocOrErr.takeError();
7003 Error Err = Error::success();
7006 auto ToNRVOCandidate =
importChecked(Err, S->getNRVOCandidate());
7008 return std::move(Err);
7016 Error Err = Error::success();
7018 auto ToExceptionDecl =
importChecked(Err, S->getExceptionDecl());
7019 auto ToHandlerBlock =
importChecked(Err, S->getHandlerBlock());
7021 return std::move(Err);
7024 ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
7030 return ToTryLocOrErr.takeError();
7032 ExpectedStmt ToTryBlockOrErr =
import(S->getTryBlock());
7033 if (!ToTryBlockOrErr)
7034 return ToTryBlockOrErr.takeError();
7037 for (
unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
7039 if (
auto ToHandlerOrErr =
import(FromHandler))
7040 ToHandlers[HI] = *ToHandlerOrErr;
7042 return ToHandlerOrErr.takeError();
7046 cast<CompoundStmt>(*ToTryBlockOrErr), ToHandlers);
7051 Error Err = Error::success();
7058 auto ToLoopVarStmt =
importChecked(Err, S->getLoopVarStmt());
7065 return std::move(Err);
7068 ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
7069 ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
7074 Error Err = Error::success();
7081 return std::move(Err);
7092 Error Err = Error::success();
7095 auto ToCatchParamDecl =
importChecked(Err, S->getCatchParamDecl());
7098 return std::move(Err);
7101 ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
7105 ExpectedSLoc ToAtFinallyLocOrErr =
import(S->getAtFinallyLoc());
7106 if (!ToAtFinallyLocOrErr)
7107 return ToAtFinallyLocOrErr.takeError();
7108 ExpectedStmt ToAtFinallyStmtOrErr =
import(S->getFinallyBody());
7109 if (!ToAtFinallyStmtOrErr)
7110 return ToAtFinallyStmtOrErr.takeError();
7112 *ToAtFinallyStmtOrErr);
7117 Error Err = Error::success();
7120 auto ToFinallyStmt =
importChecked(Err, S->getFinallyStmt());
7122 return std::move(Err);
7125 for (
unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
7127 if (
ExpectedStmt ToCatchStmtOrErr =
import(FromCatchStmt))
7128 ToCatchStmts[CI] = *ToCatchStmtOrErr;
7130 return ToCatchStmtOrErr.takeError();
7134 ToAtTryLoc, ToTryBody,
7135 ToCatchStmts.begin(), ToCatchStmts.size(),
7142 Error Err = Error::success();
7143 auto ToAtSynchronizedLoc =
importChecked(Err, S->getAtSynchronizedLoc());
7147 return std::move(Err);
7150 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
7154 ExpectedSLoc ToThrowLocOrErr =
import(S->getThrowLoc());
7155 if (!ToThrowLocOrErr)
7156 return ToThrowLocOrErr.takeError();
7157 ExpectedExpr ToThrowExprOrErr =
import(S->getThrowExpr());
7158 if (!ToThrowExprOrErr)
7159 return ToThrowExprOrErr.takeError();
7161 *ToThrowLocOrErr, *ToThrowExprOrErr);
7168 return ToAtLocOrErr.takeError();
7170 if (!ToSubStmtOrErr)
7171 return ToSubStmtOrErr.takeError();
7186 Error Err = Error::success();
7191 return std::move(Err);
7193 if (!ParentContextOrErr)
7194 return ParentContextOrErr.takeError();
7198 RParenLoc, *ParentContextOrErr);
7203 Error Err = Error::success();
7210 return std::move(Err);
7213 ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
7219 Error Err = Error::success();
7227 return std::move(Err);
7237 ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
7238 ToRParenLoc, CondIsTrue);
7242 Error Err = Error::success();
7249 return std::move(Err);
7257 Error Err = Error::success();
7265 ToSubExprs.resize(NumSubExprs);
7268 return std::move(Err);
7271 Importer.
getToContext(), ToSubExprs, ToType, ToBeginLoc, ToRParenLoc);
7277 return TypeOrErr.takeError();
7281 return BeginLocOrErr.takeError();
7288 Error Err = Error::success();
7290 Expr *ToControllingExpr =
nullptr;
7296 assert((ToControllingExpr || ToControllingType) &&
7297 "Either the controlling expr or type must be nonnull");
7301 return std::move(Err);
7306 return std::move(Err);
7311 return std::move(Err);
7315 if (ToControllingExpr) {
7317 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7322 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7327 if (ToControllingExpr) {
7329 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7334 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7341 Error Err = Error::success();
7346 return std::move(Err);
7355 Error Err = Error::success();
7362 return std::move(Err);
7368 return FoundDOrErr.takeError();
7369 ToFoundD = *FoundDOrErr;
7378 return std::move(Err);
7379 ToResInfo = &ToTAInfo;
7383 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
7387 ToE->setHadMultipleCandidates(
true);
7395 return TypeOrErr.takeError();
7403 return ToInitOrErr.takeError();
7406 if (!ToEqualOrColonLocOrErr)
7407 return ToEqualOrColonLocOrErr.takeError();
7413 ToIndexExprs[I - 1] = *ToArgOrErr;
7415 return ToArgOrErr.takeError();
7420 return std::move(Err);
7424 ToIndexExprs, *ToEqualOrColonLocOrErr,
7432 return ToTypeOrErr.takeError();
7435 if (!ToLocationOrErr)
7436 return ToLocationOrErr.takeError();
7439 *ToTypeOrErr, *ToLocationOrErr);
7445 return ToTypeOrErr.takeError();
7448 if (!ToLocationOrErr)
7449 return ToLocationOrErr.takeError();
7459 return ToTypeOrErr.takeError();
7462 if (!ToLocationOrErr)
7463 return ToLocationOrErr.takeError();
7467 *ToTypeOrErr, *ToLocationOrErr);
7471 auto ToTypeOrErr =
import(E->
getType());
7473 return ToTypeOrErr.takeError();
7476 if (!ToSubExprOrErr)
7477 return ToSubExprOrErr.takeError();
7480 *ToSubExprOrErr, *ToTypeOrErr);
7484 auto ToTypeOrErr =
import(E->
getType());
7486 return ToTypeOrErr.takeError();
7489 if (!ToLocationOrErr)
7490 return ToLocationOrErr.takeError();
7500 return ToTypeOrErr.takeError();
7503 if (!ToLocationOrErr)
7504 return ToLocationOrErr.takeError();
7513 return ToTypeOrErr.takeError();
7518 return std::move(Err);
7522 *ToTypeOrErr, ToLocations.data(), ToLocations.size());
7527 Error Err = Error::success();
7533 return std::move(Err);
7536 ToLParenLoc, ToTypeSourceInfo, ToType, E->
getValueKind(),
7542 Error Err = Error::success();
7547 return std::move(Err);
7553 return std::move(Err);
7557 ToBuiltinLoc, ToExprs, ToType, E->
getOp(), ToRParenLoc);
7561 Error Err = Error::success();
7567 return std::move(Err);
7570 ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
7573 Error Err = Error::success();
7577 return std::move(Err);
7582 Error Err = Error::success();
7587 return std::move(Err);
7590 ParenExpr(ToLParen, ToRParen, ToSubExpr);
7596 return std::move(Err);
7599 if (!ToLParenLocOrErr)
7600 return ToLParenLocOrErr.takeError();
7603 if (!ToRParenLocOrErr)
7604 return ToRParenLocOrErr.takeError();
7607 ToExprs, *ToRParenLocOrErr);
7611 Error Err = Error::success();
7617 return std::move(Err);
7620 StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
7625 Error Err = Error::success();
7630 return std::move(Err);
7634 UO->setType(ToType);
7635 UO->setSubExpr(ToSubExpr);
7637 UO->setOperatorLoc(ToOperatorLoc);
7648 Error Err = Error::success();
7653 return std::move(Err);
7658 if (!ToArgumentTypeInfoOrErr)
7659 return ToArgumentTypeInfoOrErr.takeError();
7662 E->
getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
7667 if (!ToArgumentExprOrErr)
7668 return ToArgumentExprOrErr.takeError();
7671 E->
getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
7675 Error Err = Error::success();
7681 return std::move(Err);
7690 Error Err = Error::success();
7698 return std::move(Err);
7701 ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
7707 Error Err = Error::success();
7717 return std::move(Err);
7720 ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
7727 Error Err = Error::success();
7730 return std::move(Err);
7737 Error Err = Error::success();
7739 auto ToQueriedTypeSourceInfo =
7745 return std::move(Err);
7749 ToDimensionExpression, ToEndLoc, ToType);
7753 Error Err = Error::success();
7759 return std::move(Err);
7767 Error Err = Error::success();
7772 return std::move(Err);
7779 Error Err = Error::success();
7785 return std::move(Err);
7794 Error Err = Error::success();
7799 auto ToComputationResultType =
7803 return std::move(Err);
7809 ToComputationLHSType, ToComputationResultType);
7816 if (
auto SpecOrErr =
import(*I))
7817 Path.push_back(*SpecOrErr);
7819 return SpecOrErr.takeError();
7827 return ToTypeOrErr.takeError();
7830 if (!ToSubExprOrErr)
7831 return ToSubExprOrErr.takeError();
7834 if (!ToBasePathOrErr)
7835 return ToBasePathOrErr.takeError();
7843 Error Err = Error::success();
7848 return std::move(Err);
7851 if (!ToBasePathOrErr)
7852 return ToBasePathOrErr.takeError();
7856 case Stmt::CStyleCastExprClass: {
7857 auto *CCE = cast<CStyleCastExpr>(E);
7858 ExpectedSLoc ToLParenLocOrErr =
import(CCE->getLParenLoc());
7859 if (!ToLParenLocOrErr)
7860 return ToLParenLocOrErr.takeError();
7861 ExpectedSLoc ToRParenLocOrErr =
import(CCE->getRParenLoc());
7862 if (!ToRParenLocOrErr)
7863 return ToRParenLocOrErr.takeError();
7866 ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
7867 *ToLParenLocOrErr, *ToRParenLocOrErr);
7870 case Stmt::CXXFunctionalCastExprClass: {
7871 auto *FCE = cast<CXXFunctionalCastExpr>(E);
7872 ExpectedSLoc ToLParenLocOrErr =
import(FCE->getLParenLoc());
7873 if (!ToLParenLocOrErr)
7874 return ToLParenLocOrErr.takeError();
7875 ExpectedSLoc ToRParenLocOrErr =
import(FCE->getRParenLoc());
7876 if (!ToRParenLocOrErr)
7877 return ToRParenLocOrErr.takeError();
7880 E->
getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
7881 *ToLParenLocOrErr, *ToRParenLocOrErr);
7884 case Stmt::ObjCBridgedCastExprClass: {
7885 auto *OCE = cast<ObjCBridgedCastExpr>(E);
7886 ExpectedSLoc ToLParenLocOrErr =
import(OCE->getLParenLoc());
7887 if (!ToLParenLocOrErr)
7888 return ToLParenLocOrErr.takeError();
7889 ExpectedSLoc ToBridgeKeywordLocOrErr =
import(OCE->getBridgeKeywordLoc());
7890 if (!ToBridgeKeywordLocOrErr)
7891 return ToBridgeKeywordLocOrErr.takeError();
7893 *ToLParenLocOrErr, OCE->getBridgeKind(), E->
getCastKind(),
7894 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
7896 case Stmt::BuiltinBitCastExprClass: {
7897 auto *BBC = cast<BuiltinBitCastExpr>(E);
7898 ExpectedSLoc ToKWLocOrErr =
import(BBC->getBeginLoc());
7900 return ToKWLocOrErr.takeError();
7901 ExpectedSLoc ToRParenLocOrErr =
import(BBC->getEndLoc());
7902 if (!ToRParenLocOrErr)
7903 return ToRParenLocOrErr.takeError();
7906 ToTypeInfoAsWritten, *ToKWLocOrErr, *ToRParenLocOrErr);
7909 llvm_unreachable(
"Cast expression of unsupported type!");
7922 Error Err = Error::success();
7926 return std::move(Err);
7935 auto ToBSOrErr =
import(FromNode.
getBase());
7937 return ToBSOrErr.takeError();
7942 auto ToFieldOrErr =
import(FromNode.
getField());
7944 return ToFieldOrErr.takeError();
7945 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
7950 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
7959 if (!ToIndexExprOrErr)
7960 return ToIndexExprOrErr.takeError();
7961 ToExprs[I] = *ToIndexExprOrErr;
7964 Error Err = Error::success();
7970 return std::move(Err);
7973 Importer.
getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
7974 ToExprs, ToRParenLoc);
7978 Error Err = Error::success();
7984 return std::move(Err);
7993 ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
7997 Error Err = Error::success();
8002 return std::move(Err);
8010 if (!ToUsedLocOrErr)
8011 return ToUsedLocOrErr.takeError();
8013 auto ToParamOrErr =
import(E->
getParam());
8015 return ToParamOrErr.takeError();
8018 if (!UsedContextOrErr)
8019 return UsedContextOrErr.takeError();
8029 std::optional<ParmVarDecl *> FromParam =
8031 assert(FromParam &&
"ParmVarDecl was not imported?");
8034 return std::move(Err);
8036 Expr *RewrittenInit =
nullptr;
8040 return ExprOrErr.takeError();
8041 RewrittenInit = ExprOrErr.get();
8044 *ToParamOrErr, RewrittenInit,
8050 Error Err = Error::success();
8055 return std::move(Err);
8058 ToType, ToTypeSourceInfo, ToRParenLoc);
8064 if (!ToSubExprOrErr)
8065 return ToSubExprOrErr.takeError();
8069 return ToDtorOrErr.takeError();
8079 Error Err = Error::success();
8085 return std::move(Err);
8089 return std::move(Err);
8092 Importer.
getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
8102 return std::move(Err);
8104 Error Err = Error::success();
8108 return std::move(Err);
8112 if (GetImportedOrCreateDecl(To, D, Temporary, ExtendingDecl,
8123 Error Err = Error::success();
8127 auto ToMaterializedDecl =
8130 return std::move(Err);
8132 if (!ToTemporaryExpr)
8133 ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
8137 ToMaterializedDecl);
8143 Error Err = Error::success();
8148 return std::move(Err);
8155 Error Err = Error::success();
8161 return std::move(Err);
8163 std::optional<unsigned> Length;
8170 ToPartialArguments))
8171 return std::move(Err);
8175 Importer.
getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
8176 Length, ToPartialArguments);
8181 Error Err = Error::success();
8188 auto ToAllocatedTypeSourceInfo =
8193 return std::move(Err);
8198 return std::move(Err);
8204 ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
8209 Error Err = Error::success();
8215 return std::move(Err);
8224 Error Err = Error::success();
8230 return std::move(Err);
8234 return std::move(Err);
8237 Importer.
getToContext(), ToType, ToLocation, ToConstructor,
8241 ToParenOrBraceRange);
8248 if (!ToSubExprOrErr)
8249 return ToSubExprOrErr.takeError();
8253 return std::move(Err);
8261 Error Err = Error::success();
8266 return std::move(Err);
8270 return std::move(Err);
8280 return ToTypeOrErr.takeError();
8283 if (!ToLocationOrErr)
8284 return ToLocationOrErr.takeError();
8293 return ToTypeOrErr.takeError();
8296 if (!ToLocationOrErr)
8297 return ToLocationOrErr.takeError();
8300 *ToTypeOrErr, *ToLocationOrErr);
8304 Error Err = Error::success();
8315 return std::move(Err);
8327 return std::move(Err);
8328 ResInfo = &ToTAInfo;
8332 ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8333 ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
8340 Error Err = Error::success();
8348 return std::move(Err);
8354 if (!ToDestroyedTypeLocOrErr)
8355 return ToDestroyedTypeLocOrErr.takeError();
8361 return ToTIOrErr.takeError();
8366 ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
8371 Error Err = Error::success();
8376 auto ToFirstQualifierFoundInScope =
8379 return std::move(Err);
8381 Expr *ToBase =
nullptr;
8384 ToBase = *ToBaseOrErr;
8386 return ToBaseOrErr.takeError();
8395 return std::move(Err);
8396 ResInfo = &ToTAInfo;
8401 return std::move(Err);
8407 return std::move(Err);
8411 ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
8412 ToMemberNameInfo, ResInfo);
8417 Error Err = Error::success();
8425 return std::move(Err);
8429 return std::move(Err);
8436 return std::move(Err);
8437 ResInfo = &ToTAInfo;
8441 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
8442 ToNameInfo, ResInfo);
8447 Error Err = Error::success();
8453 return std::move(Err);
8458 return std::move(Err);
8461 Importer.
getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
8468 if (!ToNamingClassOrErr)
8469 return ToNamingClassOrErr.takeError();
8472 if (!ToQualifierLocOrErr)
8473 return ToQualifierLocOrErr.takeError();
8475 Error Err = Error::success();
8479 return std::move(Err);
8484 return std::move(Err);
8487 for (
auto *D : E->
decls())
8488 if (
auto ToDOrErr =
import(D))
8489 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8491 return ToDOrErr.takeError();
8498 return std::move(Err);
8501 if (!ToTemplateKeywordLocOrErr)
8502 return ToTemplateKeywordLocOrErr.takeError();
8504 const bool KnownDependent =
8506 ExprDependence::TypeValue;
8508 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8509 *ToTemplateKeywordLocOrErr, ToNameInfo, E->
requiresADL(), &ToTAInfo,
8510 ToDecls.
begin(), ToDecls.
end(), KnownDependent);
8514 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8521 Error Err = Error::success();
8529 return std::move(Err);
8534 return std::move(Err);
8538 if (
auto ToDOrErr =
import(D))
8539 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8541 return ToDOrErr.takeError();
8549 return std::move(Err);
8550 ResInfo = &ToTAInfo;
8553 Expr *ToBase =
nullptr;
8556 ToBase = *ToBaseOrErr;
8558 return ToBaseOrErr.takeError();
8563 E->
isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8564 ToNameInfo, ResInfo, ToDecls.
begin(), ToDecls.
end());
8568 Error Err = Error::success();
8573 return std::move(Err);
8578 return std::move(Err);
8580 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
8582 Importer.
getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
8583 OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
8584 OCE->getADLCallKind());
8594 auto ToClassOrErr =
import(FromClass);
8596 return ToClassOrErr.takeError();
8601 return ToCallOpOrErr.takeError();
8605 return std::move(Err);
8607 Error Err = Error::success();
8612 return std::move(Err);
8623 Error Err = Error::success();
8628 return std::move(Err);
8632 return std::move(Err);
8636 ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
8643 return ToFillerOrErr.takeError();
8647 if (
auto ToFDOrErr =
import(FromFD))
8650 return ToFDOrErr.takeError();
8654 if (
auto ToSyntFormOrErr =
import(SyntForm))
8657 return ToSyntFormOrErr.takeError();
8671 return ToTypeOrErr.takeError();
8674 if (!ToSubExprOrErr)
8675 return ToSubExprOrErr.takeError();
8678 *ToTypeOrErr, *ToSubExprOrErr);
8683 Error Err = Error::success();
8688 return std::move(Err);
8696 Error Err = Error::success();
8701 return std::move(Err);
8704 ToType, ToCommonExpr, ToSubExpr);
8710 return ToTypeOrErr.takeError();
8716 if (!ToBeginLocOrErr)
8717 return ToBeginLocOrErr.takeError();
8719 auto ToFieldOrErr =
import(E->
getField());
8721 return ToFieldOrErr.takeError();
8724 if (!UsedContextOrErr)
8725 return UsedContextOrErr.takeError();
8729 "Field should have in-class initializer if there is a default init "
8730 "expression that uses it.");
8735 auto ToInClassInitializerOrErr =
8737 if (!ToInClassInitializerOrErr)
8738 return ToInClassInitializerOrErr.takeError();
8742 Expr *RewrittenInit =
nullptr;
8746 return ExprOrErr.takeError();
8747 RewrittenInit = ExprOrErr.get();
8751 ToField, *UsedContextOrErr, RewrittenInit);
8755 Error Err = Error::success();
8763 return std::move(Err);
8768 if (!ToBasePathOrErr)
8769 return ToBasePathOrErr.takeError();
8771 if (
auto CCE = dyn_cast<CXXStaticCastExpr>(E)) {
8773 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8774 ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
8776 }
else if (isa<CXXDynamicCastExpr>(E)) {
8778 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8779 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8780 }
else if (isa<CXXReinterpretCastExpr>(E)) {
8782 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8783 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8784 }
else if (isa<CXXConstCastExpr>(E)) {
8786 Importer.
getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
8787 ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8789 llvm_unreachable(
"Unknown cast type");
8790 return make_error<ASTImportError>();
8796 Error Err = Error::success();
8802 return std::move(Err);
8805 ToType, E->
getValueKind(), ToExprLoc, ToReplacement, ToAssociatedDecl,
8810 Error Err = Error::success();
8815 return std::move(Err);
8819 return std::move(Err);
8833 return ToTypeOrErr.takeError();
8836 if (!ToSourceRangeOrErr)
8837 return ToSourceRangeOrErr.takeError();
8842 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
8844 return ToTSIOrErr.takeError();
8848 if (!ToExprOperandOrErr)
8849 return ToExprOperandOrErr.takeError();
8852 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8856 Error Err = Error::success();
8867 return std::move(Err);
8876 Error ImportErrors = Error::success();
8878 if (
auto ImportedOrErr =
import(FromOverriddenMethod))
8880 (*ImportedOrErr)->getCanonicalDecl()));
8883 joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
8885 return ImportErrors;
8891 std::shared_ptr<ASTImporterSharedState> SharedState)
8892 : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
8893 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
8898 this->SharedState = std::make_shared<ASTImporterSharedState>();
8908 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
8909 "Try to get field index for non-field.");
8913 return std::nullopt;
8916 for (
const auto *D : Owner->decls()) {
8920 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
8924 llvm_unreachable(
"Field was not found in its parent context.");
8926 return std::nullopt;
8939 if (SharedState->getLookupTable()) {
8941 SharedState->getLookupTable()->lookup(ReDC, Name);
8945 FoundDeclsTy
Result(NoloadLookupResult.
begin(), NoloadLookupResult.
end());
8962void ASTImporter::AddToLookupTable(
Decl *ToD) {
8963 SharedState->addDeclToLookup(ToD);
8969 return Importer.
Visit(FromD);
8993 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
8994 ImportedTypes.find(FromT);
8995 if (Pos != ImportedTypes.end())
9002 return ToTOrErr.takeError();
9005 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
9007 return ToTOrErr->getTypePtr();
9016 return ToTyOrErr.takeError();
9029 return TOrErr.takeError();
9032 return BeginLocOrErr.takeError();
9041template <
typename T>
struct AttrArgImporter {
9042 AttrArgImporter(
const AttrArgImporter<T> &) =
delete;
9043 AttrArgImporter(AttrArgImporter<T> &&) =
default;
9044 AttrArgImporter<T> &operator=(
const AttrArgImporter<T> &) =
delete;
9045 AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) =
default;
9048 : To(I.importChecked(Err, From)) {}
9050 const T &value() {
return To; }
9061template <
typename T>
struct AttrArgArrayImporter {
9062 AttrArgArrayImporter(
const AttrArgArrayImporter<T> &) =
delete;
9063 AttrArgArrayImporter(AttrArgArrayImporter<T> &&) =
default;
9064 AttrArgArrayImporter<T> &operator=(
const AttrArgArrayImporter<T> &) =
delete;
9065 AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) =
default;
9068 const llvm::iterator_range<T *> &From,
9069 unsigned ArraySize) {
9072 To.reserve(ArraySize);
9076 T *value() {
return To.data(); }
9083 Error Err{Error::success()};
9084 Attr *ToAttr =
nullptr;
9089 AttrImporter(
ASTImporter &I) : Importer(I), NImporter(I) {}
9092 template <
typename T> T *castAttrAs() {
return cast<T>(ToAttr); }
9093 template <
typename T>
const T *castAttrAs()
const {
return cast<T>(ToAttr); }
9098 template <
class T> AttrArgImporter<T> importArg(
const T &From) {
9099 return AttrArgImporter<T>(NImporter, Err, From);
9105 template <
typename T>
9106 AttrArgArrayImporter<T> importArrayArg(
const llvm::iterator_range<T *> &From,
9107 unsigned ArraySize) {
9108 return AttrArgArrayImporter<T>(NImporter, Err, From, ArraySize);
9119 template <
typename T,
typename... Arg>
9120 void importAttr(
const T *FromAttr, Arg &&...ImportedArg) {
9121 static_assert(std::is_base_of<Attr, T>::value,
9122 "T should be subclass of Attr.");
9123 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9127 Importer.
Import(FromAttr->getScopeName());
9137 FromAttr->getParsedKind(), FromAttr->getForm());
9141 std::forward<Arg>(ImportedArg)..., ToI);
9145 if (
auto *ToInheritableAttr = dyn_cast<InheritableAttr>(ToAttr))
9146 ToInheritableAttr->setInherited(FromAttr->isInherited());
9152 void cloneAttr(
const Attr *FromAttr) {
9153 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9167 return std::move(Err);
9168 assert(ToAttr &&
"Attribute should be created.");
9175 AttrImporter AI(*
this);
9178 switch (FromAttr->
getKind()) {
9179 case attr::Aligned: {
9180 auto *From = cast<AlignedAttr>(FromAttr);
9181 if (From->isAlignmentExpr())
9182 AI.importAttr(From,
true, AI.importArg(From->getAlignmentExpr()).value());
9184 AI.importAttr(From,
false,
9185 AI.importArg(From->getAlignmentType()).value());
9189 case attr::AlignValue: {
9190 auto *From = cast<AlignValueAttr>(FromAttr);
9191 AI.importAttr(From, AI.importArg(From->getAlignment()).value());
9195 case attr::Format: {
9196 const auto *From = cast<FormatAttr>(FromAttr);
9197 AI.importAttr(From,
Import(From->getType()), From->getFormatIdx(),
9198 From->getFirstArg());
9202 case attr::EnableIf: {
9203 const auto *From = cast<EnableIfAttr>(FromAttr);
9204 AI.importAttr(From, AI.importArg(From->getCond()).value(),
9205 From->getMessage());
9209 case attr::AssertCapability: {
9210 const auto *From = cast<AssertCapabilityAttr>(FromAttr);
9212 AI.importArrayArg(From->args(), From->args_size()).value(),
9216 case attr::AcquireCapability: {
9217 const auto *From = cast<AcquireCapabilityAttr>(FromAttr);
9219 AI.importArrayArg(From->args(), From->args_size()).value(),
9223 case attr::TryAcquireCapability: {
9224 const auto *From = cast<TryAcquireCapabilityAttr>(FromAttr);
9225 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9226 AI.importArrayArg(From->args(), From->args_size()).value(),
9230 case attr::ReleaseCapability: {
9231 const auto *From = cast<ReleaseCapabilityAttr>(FromAttr);
9233 AI.importArrayArg(From->args(), From->args_size()).value(),
9237 case attr::RequiresCapability: {
9238 const auto *From = cast<RequiresCapabilityAttr>(FromAttr);
9240 AI.importArrayArg(From->args(), From->args_size()).value(),
9244 case attr::GuardedBy: {
9245 const auto *From = cast<GuardedByAttr>(FromAttr);
9246 AI.importAttr(From, AI.importArg(From->getArg()).value());
9249 case attr::PtGuardedBy: {
9250 const auto *From = cast<PtGuardedByAttr>(FromAttr);
9251 AI.importAttr(From, AI.importArg(From->getArg()).value());
9254 case attr::AcquiredAfter: {
9255 const auto *From = cast<AcquiredAfterAttr>(FromAttr);
9257 AI.importArrayArg(From->args(), From->args_size()).value(),
9261 case attr::AcquiredBefore: {
9262 const auto *From = cast<AcquiredBeforeAttr>(FromAttr);
9264 AI.importArrayArg(From->args(), From->args_size()).value(),
9268 case attr::AssertExclusiveLock: {
9269 const auto *From = cast<AssertExclusiveLockAttr>(FromAttr);
9271 AI.importArrayArg(From->args(), From->args_size()).value(),
9275 case attr::AssertSharedLock: {
9276 const auto *From = cast<AssertSharedLockAttr>(FromAttr);
9278 AI.importArrayArg(From->args(), From->args_size()).value(),
9282 case attr::ExclusiveTrylockFunction: {
9283 const auto *From = cast<ExclusiveTrylockFunctionAttr>(FromAttr);
9284 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9285 AI.importArrayArg(From->args(), From->args_size()).value(),
9289 case attr::SharedTrylockFunction: {
9290 const auto *From = cast<SharedTrylockFunctionAttr>(FromAttr);
9291 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9292 AI.importArrayArg(From->args(), From->args_size()).value(),
9296 case attr::LockReturned: {
9297 const auto *From = cast<LockReturnedAttr>(FromAttr);
9298 AI.importAttr(From, AI.importArg(From->getArg()).value());
9301 case attr::LocksExcluded: {
9302 const auto *From = cast<LocksExcludedAttr>(FromAttr);
9304 AI.importArrayArg(From->args(), From->args_size()).value(),
9308 case attr::CountedBy: {
9309 AI.cloneAttr(FromAttr);
9310 const auto *CBA = cast<CountedByAttr>(FromAttr);
9313 return SR.takeError();
9314 AI.castAttrAs<CountedByAttr>()->setCountedByFieldLoc(SR.get());
9322 AI.cloneAttr(FromAttr);
9327 return std::move(AI).getResult();
9331 return ImportedDecls.lookup(FromD);
9335 auto FromDPos = ImportedFromDecls.find(ToD);
9336 if (FromDPos == ImportedFromDecls.end())
9338 return FromDPos->second->getTranslationUnitDecl();
9341Error ASTImporter::ImportAttrs(
Decl *ToD,
Decl *FromD) {
9343 return Error::success();
9345 auto ToAttrOrErr =
Import(FromAttr);
9349 return ToAttrOrErr.takeError();
9351 return Error::success();
9359 ImportPath.
push(FromD);
9360 auto ImportPathBuilder =
9361 llvm::make_scope_exit([
this]() { ImportPath.
pop(); });
9366 return make_error<ASTImportError>(*Error);
9372 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9374 return make_error<ASTImportError>(*Error);
9391 auto Pos = ImportedDecls.find(FromD);
9392 if (Pos != ImportedDecls.end()) {
9395 auto *ToD = Pos->second;
9396 ImportedDecls.erase(Pos);
9408 auto PosF = ImportedFromDecls.find(ToD);
9409 if (PosF != ImportedFromDecls.end()) {
9414 SharedState->removeDeclFromLookup(ToD);
9415 ImportedFromDecls.erase(PosF);
9427 handleAllErrors(ToDOrErr.takeError(),
9431 if (Pos != ImportedDecls.end())
9432 SharedState->setImportDeclError(Pos->second, ErrOut);
9436 for (
const auto &Path : SavedImportPaths[FromD]) {
9439 Decl *PrevFromDi = FromD;
9440 for (
Decl *FromDi : Path) {
9442 if (FromDi == FromD)
9449 PrevFromDi = FromDi;
9453 auto Ii = ImportedDecls.find(FromDi);
9454 if (Ii != ImportedDecls.end())
9455 SharedState->setImportDeclError(Ii->second, ErrOut);
9460 SavedImportPaths.erase(FromD);
9463 return make_error<ASTImportError>(ErrOut);
9475 return make_error<ASTImportError>(*Err);
9481 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9483 return make_error<ASTImportError>(*Error);
9486 assert(ImportedDecls.count(FromD) != 0 &&
"Missing call to MapImported?");
9487 if (
auto Error = ImportAttrs(ToD, FromD))
9488 return std::move(Error);
9494 SavedImportPaths.erase(FromD);
9509 return ToDCOrErr.takeError();
9510 auto *ToDC = cast<DeclContext>(*ToDCOrErr);
9514 if (
auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
9515 auto *FromRecord = cast<RecordDecl>(FromDC);
9516 if (ToRecord->isCompleteDefinition())
9524 if (FromRecord->getASTContext().getExternalSource() &&
9525 !FromRecord->isCompleteDefinition())
9526 FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
9528 if (FromRecord->isCompleteDefinition())
9531 return std::move(Err);
9532 }
else if (
auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
9533 auto *FromEnum = cast<EnumDecl>(FromDC);
9534 if (ToEnum->isCompleteDefinition()) {
9536 }
else if (FromEnum->isCompleteDefinition()) {
9539 return std::move(Err);
9543 }
else if (
auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
9544 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
9545 if (ToClass->getDefinition()) {
9550 return std::move(Err);
9554 }
else if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
9555 auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
9556 if (ToProto->getDefinition()) {
9561 return std::move(Err);
9572 return cast_or_null<Expr>(*ToSOrErr);
9574 return ToSOrErr.takeError();
9582 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
9583 if (Pos != ImportedStmts.end())
9592 if (
auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
9593 auto *FromE = cast<Expr>(FromS);
9596 ToE->setValueKind(FromE->getValueKind());
9597 ToE->setObjectKind(FromE->getObjectKind());
9598 ToE->setDependence(FromE->getDependence());
9602 ImportedStmts[FromS] = *ToSOrErr;
9613 return std::move(Err);
9617 assert(FromNNS->
getAsIdentifier() &&
"NNS should contain identifier.");
9624 cast<NamespaceDecl>(*NSOrErr));
9626 return NSOrErr.takeError();
9631 cast<NamespaceAliasDecl>(*NSADOrErr));
9633 return NSADOrErr.takeError();
9641 cast<CXXRecordDecl>(*RDOrErr));
9643 return RDOrErr.takeError();
9653 return TyOrErr.takeError();
9657 llvm_unreachable(
"Invalid nested name specifier kind");
9669 NestedNames.push_back(NNS);
9675 while (!NestedNames.empty()) {
9676 NNS = NestedNames.pop_back_val();
9679 return std::move(Err);
9686 return std::move(Err);
9690 return std::move(Err);
9706 ToLocalBeginLoc, ToLocalEndLoc);
9713 return std::move(Err);
9733 if (!ToSourceRangeOrErr)
9734 return ToSourceRangeOrErr.takeError();
9737 ToSourceRangeOrErr->getBegin(),
9738 ToSourceRangeOrErr->getEnd());
9750 return TemplateName(cast<TemplateDecl>((*ToTemplateOrErr)->getCanonicalDecl()));
9752 return ToTemplateOrErr.takeError();
9757 for (
auto *I : *FromStorage) {
9758 if (
auto ToOrErr =
Import(I))
9759 ToTemplates.
addDecl(cast<NamedDecl>(*ToOrErr));
9761 return ToOrErr.takeError();
9771 return DeclNameOrErr.takeError();
9778 if (!QualifierOrErr)
9779 return QualifierOrErr.takeError();
9782 return TNOrErr.takeError();
9790 if (!QualifierOrErr)
9791 return QualifierOrErr.takeError();
9806 if (!ReplacementOrErr)
9807 return ReplacementOrErr.takeError();
9810 if (!AssociatedDeclOrErr)
9811 return AssociatedDeclOrErr.takeError();
9814 *ReplacementOrErr, *AssociatedDeclOrErr, Subst->
getIndex(),
9825 return ArgPackOrErr.takeError();
9828 if (!AssociatedDeclOrErr)
9829 return AssociatedDeclOrErr.takeError();
9832 *ArgPackOrErr, *AssociatedDeclOrErr, SubstPack->
getIndex(),
9838 return UsingOrError.takeError();
9839 return TemplateName(cast<UsingShadowDecl>(*UsingOrError));
9843 llvm_unreachable(
"Invalid template name kind");
9856 return ToFileIDOrErr.takeError();
9864 return std::move(Err);
9866 return std::move(Err);
9872 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
9873 if (Pos != ImportedFileIDs.end())
9886 return ToSpLoc.takeError();
9889 return ToExLocS.takeError();
9899 return ToExLocE.takeError();
9905 if (!IsBuiltin && !
Cache->BufferOverridden) {
9909 return ToIncludeLoc.takeError();
9920 if (
Cache->OrigEntry &&
Cache->OrigEntry->getDir()) {
9931 ToID = ToSM.
createFileID(*Entry, ToIncludeLocOrFakeLoc,
9938 std::optional<llvm::MemoryBufferRef> FromBuf =
9944 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
9945 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
9946 FromBuf->getBufferIdentifier());
9952 assert(ToID.
isValid() &&
"Unexpected invalid fileID was created.");
9954 ImportedFileIDs[FromID] = ToID;
9961 return ToExprOrErr.takeError();
9964 if (!LParenLocOrErr)
9965 return LParenLocOrErr.takeError();
9968 if (!RParenLocOrErr)
9969 return RParenLocOrErr.takeError();
9974 return ToTInfoOrErr.takeError();
9979 return std::move(Err);
9982 ToContext, *ToTInfoOrErr, From->
isBaseVirtual(), *LParenLocOrErr,
9983 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
9987 return ToFieldOrErr.takeError();
9990 if (!MemberLocOrErr)
9991 return MemberLocOrErr.takeError();
9994 ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
9995 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
9999 return ToIFieldOrErr.takeError();
10002 if (!MemberLocOrErr)
10003 return MemberLocOrErr.takeError();
10006 ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
10007 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10011 return ToTInfoOrErr.takeError();
10013 return new (ToContext)
10015 *ToExprOrErr, *RParenLocOrErr);
10018 return make_error<ASTImportError>();
10024 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
10025 if (Pos != ImportedCXXBaseSpecifiers.end())
10026 return Pos->second;
10029 if (!ToSourceRange)
10030 return ToSourceRange.takeError();
10033 return ToTSI.takeError();
10035 if (!ToEllipsisLoc)
10036 return ToEllipsisLoc.takeError();
10040 ImportedCXXBaseSpecifiers[BaseSpec] =
Imported;
10052 return ToOrErr.takeError();
10053 Decl *To = *ToOrErr;
10055 auto *FromDC = cast<DeclContext>(From);
10058 if (
auto *ToRecord = dyn_cast<RecordDecl>(To)) {
10059 if (!ToRecord->getDefinition()) {
10061 cast<RecordDecl>(FromDC), ToRecord,
10066 if (
auto *ToEnum = dyn_cast<EnumDecl>(To)) {
10067 if (!ToEnum->getDefinition()) {
10073 if (
auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
10074 if (!ToIFace->getDefinition()) {
10076 cast<ObjCInterfaceDecl>(FromDC), ToIFace,
10081 if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
10082 if (!ToProto->getDefinition()) {
10084 cast<ObjCProtocolDecl>(FromDC), ToProto,
10106 return ToSelOrErr.takeError();
10113 return ToTyOrErr.takeError();
10121 return ToTyOrErr.takeError();
10127 cast<TemplateDecl>(*ToTemplateOrErr));
10129 return ToTemplateOrErr.takeError();
10137 return ToTyOrErr.takeError();
10153 llvm_unreachable(
"Invalid DeclarationName Kind!");
10174 for (
unsigned I = 1, N = FromSel.
getNumArgs(); I < N; ++I)
10182 llvm::Error Err = llvm::Error::success();
10183 auto ImportLoop = [&](
const APValue *From,
APValue *To,
unsigned Size) {
10184 for (
unsigned Idx = 0; Idx < Size; Idx++) {
10189 switch (FromValue.
getKind()) {
10203 ImportLoop(((
const APValue::Vec *)(
const char *)&FromValue.Data)->Elts,
10210 ImportLoop(((
const APValue::Arr *)(
const char *)&FromValue.Data)->Elts,
10211 ((
const APValue::Arr *)(
const char *)&
Result.Data)->Elts,
10218 ((
const APValue::StructData *)(
const char *)&FromValue.Data)->Elts,
10219 ((
const APValue::StructData *)(
const char *)&
Result.Data)->Elts,
10227 return std::move(Err);
10228 Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
10232 Result.MakeAddrLabelDiff();
10236 return std::move(Err);
10237 Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
10238 cast<AddrLabelExpr>(ImpRHS));
10242 const Decl *ImpMemPtrDecl =
10245 return std::move(Err);
10247 Result.setMemberPointerUninit(
10248 cast<const ValueDecl>(ImpMemPtrDecl),
10252 Result.getMemberPointerPath();
10257 return std::move(Err);
10267 "in C++20 dynamic allocation are transient so they shouldn't "
10268 "appear in the AST");
10270 if (
const auto *E =
10272 FromElemTy = E->getType();
10275 return std::move(Err);
10285 return std::move(Err);
10297 return std::move(Err);
10311 for (
unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
10314 FromPath[LoopIdx].getAsBaseOrMember().getPointer();
10317 return std::move(Err);
10318 if (
auto *RD = dyn_cast<CXXRecordDecl>(
FromDecl))
10321 FromElemTy = cast<ValueDecl>(
FromDecl)->getType();
10323 ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
10328 FromPath[LoopIdx].getAsArrayIndex());
10336 return std::move(Err);
10344 unsigned NumDecls) {
10354 if (LastDiagFromFrom)
10357 LastDiagFromFrom =
false;
10362 if (!LastDiagFromFrom)
10365 LastDiagFromFrom =
true;
10370 if (
auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
10371 if (!ID->getDefinition())
10372 ID->startDefinition();
10374 else if (
auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
10375 if (!PD->getDefinition())
10376 PD->startDefinition();
10378 else if (
auto *TD = dyn_cast<TagDecl>(D)) {
10379 if (!TD->getDefinition() && !TD->isBeingDefined()) {
10380 TD->startDefinition();
10381 TD->setCompleteDefinition(
true);
10385 assert(0 &&
"CompleteDecl called on a Decl that can't be completed");
10390 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
10391 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
10392 "Try to import an already imported Decl");
10393 if (Pos != ImportedDecls.end())
10394 return Pos->second;
10395 ImportedDecls[From] = To;
10398 ImportedFromDecls[To] = From;
10403 AddToLookupTable(To);
10407std::optional<ASTImportError>
10409 auto Pos = ImportDeclErrors.find(FromD);
10410 if (Pos != ImportDeclErrors.end())
10411 return Pos->second;
10413 return std::nullopt;
10417 auto InsertRes = ImportDeclErrors.insert({From, Error});
10421 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
10426 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
10428 if (Pos != ImportedTypes.end()) {
10433 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.
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
llvm::APInt getValue() const
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 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 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)
bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D)
This function checks if the function has 'auto' return type that contains a reference (in any way) to...
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)
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)
Error ImportTemplateParameterLists(const DeclaratorDecl *FromD, DeclaratorDecl *ToD)
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)
SourceLocation getColonLoc() const
SourceLocation getQuestionLoc() const
Represents an access specifier followed by colon ':'.
SourceLocation getColonLoc() const
The location of the colon following the access specifier.
AddrLabelExpr - The GNU address of label extension, representing &&label.
SourceLocation getAmpAmpLoc() const
SourceLocation getLabelLoc() const
LabelDecl * getLabel() const
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
QualType getAdjustedType() const
QualType getOriginalType() const
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Represents a loop initializing the elements of an array.
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Expr * getSubExpr() const
Get the initializer to use for each array element.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getRBracketLoc() const
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
uint64_t getValue() const
SourceLocation getEndLoc() const LLVM_READONLY
ArrayTypeTrait getTrait() const
Expr * getDimensionExpression() const
TypeSourceInfo * getQueriedTypeSourceInfo() const
SourceLocation getBeginLoc() const LLVM_READONLY
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
unsigned getIndexTypeCVRQualifiers() 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,...
SourceLocation getRParenLoc() const
static unsigned getNumSubExprs(AtomicOp Op)
Determine the number of arguments the specified atomic builtin should have.
SourceLocation getBuiltinLoc() const
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
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.
QualType getModifiedType() const
QualType getEquivalentType() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
ConceptDecl * getTypeConstraintConcept() const
AutoTypeKeyword getKeyword() const
const BTFTypeTagAttr * getAttr() const
QualType getWrappedType() const
Represents a C++ declaration that introduces decls from somewhere else.
void addShadowDecl(UsingShadowDecl *S)
shadow_range shadows() const
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression which will be evaluated if the condition evaluates to true; th...
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
A builtin binary operation expression such as "x + y" or "x <= y".
SourceLocation getOperatorLoc() const
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
FPOptionsOverride getFPFeatures() const
A binding in a decomposition declaration.
ValueDecl * getDecomposedDecl() const
Get the decomposition declaration that this binding represents a decomposition of.
Expr * getBinding() const
Get the expression to which this declaration is bound.
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.
unsigned getNumBits() const
QualType getPointeeType() const
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...
BuiltinTemplateKind getBuiltinTemplateKind() const
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.
CXXTemporary * getTemporary()
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
const Expr * getSubExpr() const
A boolean literal, per ([C++ lex.bool] Boolean literals).
static CXXBoolLiteralExpr * Create(const ASTContext &C, bool Val, QualType Ty, SourceLocation Loc)
SourceLocation getLocation() const
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.
SourceRange getParenOrBraceRange() const
void setIsImmediateEscalating(bool Set)
bool isElidable() const
Whether this construction is elidable.
bool hadMultipleCandidates() const
Whether the referred constructor was resolved from an overloaded set having size greater than 1.
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.
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
bool isImmediateEscalating() const
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called.
SourceLocation getLocation() const
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
CXXConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
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]).
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
const ParmVarDecl * getParam() const
Expr * getRewrittenExpr()
const DeclContext * getUsedContext() const
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
bool hasRewrittenInit() const
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.
const DeclContext * getUsedContext() const
const Expr * getRewrittenExpr() const
Retrieve the initializing expression with evaluated immediate calls, if any.
bool hasRewrittenInit() const
FieldDecl * getField()
Get the field whose initializer will be used.
SourceLocation getBeginLoc() const
Represents a delete expression for memory deallocation and destructor calls, e.g.
FunctionDecl * getOperatorDelete() const
SourceLocation getBeginLoc() const
bool isGlobalDelete() const
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
bool isArrayFormAsWritten() const
Represents a C++ member access expression where the actual member referenced could not be resolved be...
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
SourceLocation getOperatorLoc() const
Retrieve the location of the '->' or '.' operator.
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)
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding the member name, if any.
const DeclarationNameInfo & getMemberNameInfo() const
Retrieve the name of the member that this expression refers to.
bool hasExplicitTemplateArgs() const
Determines whether this member expression actually had a C++ template argument list explicitly specif...
SourceLocation getMemberLoc() const
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
DeclarationName getMember() const
Retrieve the name of the member that this expression refers to.
NamedDecl * getFirstQualifierFoundInScope() const
Retrieve the first part of the nested-name-specifier that was found in the scope of the member access...
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the member name, with source location information.
bool isImplicitAccess() const
True if this is an implicit access, i.e.
ArrayRef< TemplateArgumentLoc > template_arguments() const
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.
UnresolvedLookupExpr * getCallee() const
std::optional< unsigned > getNumExpansions() const
SourceLocation getLParenLoc() const
SourceLocation getEllipsisLoc() const
SourceLocation getRParenLoc() const
BinaryOperatorKind getOperator() const
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.
bool constructsVBase() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
SourceLocation getLocation() const LLVM_READONLY
bool inheritedFromVBase() const
Determine whether the inherited constructor is inherited from a virtual base of the object we constru...
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.
SourceLocation getOperatorLoc() const
Retrieve the location of the cast operator keyword, e.g., static_cast.
SourceRange getAngleBrackets() const LLVM_READONLY
SourceLocation getRParenLoc() const
Retrieve the location of the closing parenthesis.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
SourceRange getDirectInitRange() const
llvm::iterator_range< arg_iterator > placement_arguments()
std::optional< Expr * > getArraySize()
This might return std::nullopt even if isArray() returns true, since there might not be an array size...
CXXNewInitializationStyle getInitializationStyle() const
The kind of initializer this new-expression has.
bool passAlignment() const
Indicates whether the required alignment should be implicitly passed to the allocation function.
FunctionDecl * getOperatorDelete() const
unsigned getNumPlacementArgs() const
TypeSourceInfo * getAllocatedTypeSourceInfo() const
SourceRange getSourceRange() const
SourceRange getTypeIdParens() const
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
FunctionDecl * getOperatorNew() const
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.
Expr * getInitializer()
The initializer of this new-expression.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
SourceLocation getEndLoc() const
Expr * getOperand() const
SourceLocation getBeginLoc() const
The null pointer literal (C++11 [lex.nullptr])
SourceLocation getLocation() const
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]).
TypeSourceInfo * getDestroyedTypeInfo() const
Retrieve the source location information for the type being destroyed.
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an '->' (otherwise,...
TypeSourceInfo * getScopeTypeInfo() const
Retrieve the scope type in a qualified pseudo-destructor expression.
IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
SourceLocation getTildeLoc() const
Retrieve the location of the '~'.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieves the nested-name-specifier that qualifies the type name, with source-location information.
SourceLocation getDestroyedTypeLoc() const
Retrieve the starting location of the type being destroyed.
SourceLocation getColonColonLoc() const
Retrieve the location of the '::' in a qualified pseudo-destructor expression.
SourceLocation getOperatorLoc() const
Retrieve the location of the '.' or '->' operator.
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)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
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.
Expr * getSemanticForm()
Get an equivalent semantic form for this expression.
bool isReversed() const
Determine whether this expression was rewritten in reverse form.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
TypeSourceInfo * getTypeSourceInfo() const
SourceLocation getRParenLoc() const
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)
TypeSourceInfo * getTypeSourceInfo() const
Represents a C++ temporary.
const CXXDestructorDecl * getDestructor() const
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)
SourceLocation getLocation() const
A C++ throw-expression (C++ [except.throw]).
const Expr * getSubExpr() const
SourceLocation getThrowLoc() const
bool isThrownVariableInScope() const
Determines whether the variable thrown by this expression (if any!) is within the innermost try block...
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...
bool isTypeOperand() const
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Expr * getExprOperand() const
SourceRange getSourceRange() const LLVM_READONLY
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
SourceLocation getLParenLoc() const
Retrieve the location of the left parentheses ('(') that precedes the argument list.
bool isListInitialization() const
Determine whether this expression models list-initialization.
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)
TypeSourceInfo * getTypeSourceInfo() const
Retrieve the type source information for the type being constructed.
SourceLocation getRParenLoc() const
Retrieve the location of the right parentheses (')') that follows the argument list.
unsigned getNumArgs() const
Retrieve the number of arguments.
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.
ADLCallKind getADLCallKind() const
FPOptionsOverride getFPFeatures() const
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
SourceLocation getRParenLoc() const
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()
CastKind getCastKind() const
FPOptionsOverride getFPFeatures() const
CharUnits - This is an opaque type for sizes expressed in character units.
SourceLocation getLocation() const
unsigned getValue() const
CharacterLiteralKind getKind() const
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.
SourceLocation getBuiltinLoc() const
bool isConditionDependent() const
bool isConditionTrue() const
isConditionTrue - Return whether the condition is true (i.e.
SourceLocation getRParenLoc() const
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...
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary class pattern.
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.
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
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...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
void setPointOfInstantiation(SourceLocation Loc)
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate members of the class templa...
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getInstantiatedFrom() const
If this class template specialization is an instantiation of a template (rather than an explicit spec...
void setExternLoc(SourceLocation Loc)
Sets the location of the extern 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,...
Complex values, per C99 6.2.5p11.
QualType getElementType() const
CompoundAssignOperator - For compound assignments (e.g.
QualType getComputationLHSType() const
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())
QualType getComputationResultType() const
CompoundLiteralExpr - [C99 6.5.2.5].
SourceLocation getLParenLoc() const
const Expr * getInitializer() const
TypeSourceInfo * getTypeSourceInfo() const
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.
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Represents the canonical version of C arrays with a specified constant size.
const llvm::APInt & getSize() const
const Expr * getSizeExpr() const
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
APValue getAPValueResult() const
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
unsigned getNumRows() const
Returns the number of rows in the matrix.
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...
SourceLocation getRParenLoc() const
getRParenLoc - Return the location of final right parenthesis.
SourceLocation getBuiltinLoc() const
getBuiltinLoc - Return the location of the __builtin_convertvector token.
TypeSourceInfo * getTypeSourceInfo() const
getTypeSourceInfo - Return the destination type.
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
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)
NamedDecl * getDecl() const
AccessSpecifier getAccess() const
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.
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
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.
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
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)
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
ArrayRef< TemplateArgumentLoc > template_arguments() const
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
bool hadMultipleCandidates() const
Returns true if this expression refers to a function that was resolved from an overloaded set having ...
SourceLocation getLocation() const
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
bool isImmediateEscalating() const
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.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
SourceLocation getEndLoc() const LLVM_READONLY
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 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)
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.
Represents a ValueDecl that came out of a declarator.
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
TemplateParameterList * getTemplateParameterList(unsigned index) const
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumTemplateParameterLists() const
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Represents the type decltype(expr) (C++11).
Expr * getUnderlyingExpr() const
QualType getUnderlyingType() const
A decomposition declaration.
Represents a C++17 deduced template specialization type.
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
Represents an extended address space qualifier where the input address space value is dependent.
Expr * getAddrSpaceExpr() const
QualType getPointeeType() const
SourceLocation getAttributeLoc() const
Expr * getNumBitsExpr() const
Represents a qualified type name for which the type name is dependent.
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
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)
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source location information.
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
ArrayRef< TemplateArgumentLoc > template_arguments() const
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
DeclarationName getDeclName() const
Retrieve the name that this expression refers to.
const DeclarationNameInfo & getNameInfo() const
Retrieve the name that this expression refers to.
Represents an array type in C++ whose size is a value-dependent expression.
SourceRange getBracketsRange() const
Expr * getSizeExpr() const
Represents an extended vector type where either the type or size is dependent.
Expr * getSizeExpr() const
SourceLocation getAttributeLoc() const
QualType getElementType() const
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Expr * getColumnExpr() const
Expr * getRowExpr() const
SourceLocation getAttributeLoc() const
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.
const IdentifierInfo * getIdentifier() const
ArrayRef< TemplateArgument > template_arguments() const
NestedNameSpecifier * getQualifier() const
Represents a vector type where either the type or size is dependent.
Expr * getSizeExpr() const
VectorKind getVectorKind() const
SourceLocation getAttributeLoc() const
QualType getElementType() const
Represents a single C99 designator.
unsigned getArrayIndex() const
bool isFieldDesignator() const
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.
bool isArrayRangeDesignator() const
static Designator CreateArrayDesignator(unsigned Index, SourceLocation LBracketLoc, SourceLocation RBracketLoc)
Creates an array designator.
bool isArrayDesignator() const
SourceLocation getFieldLoc() const
SourceLocation getRBracketLoc() const
const IdentifierInfo * getFieldName() const
SourceLocation getEllipsisLoc() const
SourceLocation getDotLoc() const
SourceLocation getLBracketLoc() const
Represents a C99 designated initializer expression.
Expr * getSubExpr(unsigned Idx) const
llvm::MutableArrayRef< Designator > designators()
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Expr * getInit() const
Retrieve the initializer value.
unsigned size() const
Returns the number of designators in this initializer.
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the '=' that precedes the initializer value itself, if present.
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression,...
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,...
TagDecl * getOwnedTagDecl() const
Return the (re)declaration of this type owned by this occurrence of this type, or nullptr if there is...
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Represents an empty-declaration.
An instance of this object exists for each enum constant that is defined.
llvm::APSInt getInitVal() const
const Expr * getInitExpr() const
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
void setIntegerType(QualType T)
Set the underlying integer type.
EnumDecl * getMostRecentDecl()
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
void completeDefinition(QualType NewType, QualType PromotionType, unsigned NumPositiveBits, unsigned NumNegativeBits)
When created, the EnumDecl corresponds to a forward-declared enum.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
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.
EnumDecl * getDecl() const
ExplicitCastExpr - An explicit cast written in the source code.
TypeSourceInfo * getTypeInfoAsWritten() const
getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to.
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...
bool cleanupsHaveSideEffects() const
ArrayRef< CleanupObject > getObjects() const
unsigned getNumObjects() const
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 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.
SourceLocation getBeginLoc() const LLVM_READONLY
Expr * getQueriedExpression() const
ExpressionTrait getTrait() const
SourceLocation getEndLoc() const LLVM_READONLY
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.
bool isMutable() const
Determines whether this field is mutable (C++ only).
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.
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
const VariableArrayType * getCapturedVLAType() const
Get the captured variable length array type.
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.
SourceLocation getLocation() const
Retrieve the location of the literal.
SourceLocation getLocation() const
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
llvm::APFloat getValue() const
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
SourceLocation getFriendLoc() const
Retrieves the location of the 'friend' keyword.
NamedDecl * getFriendDecl() const
If this friend declaration doesn't name a type, return the inner declaration.
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
const Expr * getSubExpr() const
Represents a function declaration or definition.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
ConstexprSpecKind getConstexprKind() const
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
bool UsesFPIntrin() const
Determine whether the function was declared in source context that requires constrained FP intrinsics...
SourceLocation getDefaultLoc() const
ArrayRef< ParmVarDecl * > parameters() const
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
bool hasWrittenPrototype() const
Whether this function has a written prototype.
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)
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
@ TK_MemberSpecialization
@ TK_DependentNonTemplate
@ TK_FunctionTemplateSpecialization
@ TK_DependentFunctionTemplateSpecialization
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool FriendConstraintRefersToEnclosingTemplate() const
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.
bool isDeletedAsWritten() const
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
FunctionDecl * getDefinition()
Get the definition for this declaration.
void setRangeEnd(SourceLocation E)
bool isDefaulted() const
Whether this function is defaulted.
FunctionDecl * getInstantiatedFromDecl() const
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
void setDefaulted(bool D=true)
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
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,...
DeclarationNameInfo getNameInfo() const
void setDeletedAsWritten(bool D=true)
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
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.
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary pattern.
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...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a C11 generic selection.
TypeSourceInfo * getControllingType()
Return the controlling type of this generic selection expression.
ArrayRef< Expr * > getAssocExprs() const
bool isExprPredicate() const
Whether this generic selection uses an expression as its controlling argument.
SourceLocation getGenericLoc() const
SourceLocation getRParenLoc() const
unsigned getResultIndex() const
The zero-based index of the result expression's generic association in the generic selection's associ...
SourceLocation getDefaultLoc() const
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.
bool isResultDependent() const
Whether this generic selection is result-dependent.
Expr * getControllingExpr()
Return the controlling expression of this generic selection expression.
ArrayRef< TypeSourceInfo * > getAssocTypeSourceInfos() const
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....
const Expr * getSubExpr() const
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)
ImplicitParamKind getParameterKind() const
Returns the implicit parameter kind.
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.
unsigned getChainingSize() const
ArrayRef< NamedDecl * > chain() const
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.
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
void setSyntacticForm(InitListExpr *Init)
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
unsigned getNumInits() const
SourceLocation getLBraceLoc() const
void setArrayFiller(Expr *filler)
InitListExpr * getSyntacticForm() const
bool hadArrayRangeDesignator() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
SourceLocation getRBraceLoc() const
void setInitializedFieldInUnion(FieldDecl *FD)
ArrayRef< Expr * > inits()
void sawArrayRangeDesignator(bool ARD=true)
The injected class name of a C++ class template or class template partial specialization.
CXXRecordDecl * getDecl() const
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'.
SourceLocation getLocation() const
Retrieve the location of the literal.
An lvalue reference type, per C++11 [dcl.ref].
Represents the declaration of a label.
LabelStmt * getStmt() const
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.
SourceLocation getEndLoc() const LLVM_READONLY
bool hasExplicitParameters() const
Determine whether this lambda has an explicit parameter list vs.
SourceRange getIntroducerRange() const
Retrieve the source range covering the lambda introducer, which contains the explicit capture list su...
unsigned capture_size() const
Determine the number of captures in this lambda.
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
bool hasExplicitResultType() const
Whether this lambda had its result type explicitly specified.
SourceLocation getCaptureDefaultLoc() const
Retrieve the location of this lambda's capture-default, if any.
llvm::iterator_range< capture_init_iterator > capture_inits()
Retrieve the initialization expressions for this lambda's captures.
LambdaCaptureDefault getCaptureDefault() const
Determine the default capture kind for this lambda.
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
unsigned getManglingNumber() const
Expr * getTemporaryExpr()
Retrieve the expression to which the temporary materialization conversion was applied.
ValueDecl * getExtendingDecl()
Represents a linkage specification.
void setRBraceLoc(SourceLocation L)
LinkageSpecLanguageIDs getLanguage() const
Return the language specified by this linkage specification.
SourceLocation getExternLoc() const
SourceLocation getRBraceLoc() const
bool hasBraces() const
Determines whether this linkage specification had braces in its syntactic form.
Represents the results of name lookup.
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
QualType getUnderlyingType() const
const IdentifierInfo * getMacroIdentifier() const
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
bool isBoundToLvalueReference() const
Determine whether this materialized temporary is bound to an lvalue reference; otherwise,...
LifetimeExtendedTemporaryDecl * getLifetimeExtendedTemporaryDecl()
QualType getElementType() const
Returns type of the elements being stored in the matrix.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ArrayRef< TemplateArgumentLoc > template_arguments() const
SourceLocation getOperatorLoc() const
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding the member name, if any.
NestedNameSpecifierLoc getQualifierLoc() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name,...
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
bool hasExplicitTemplateArgs() const
Determines whether the member name was followed by an explicit template argument list.
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why? This is only meaningful if the named memb...
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)
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
const Type * getClass() const
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.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a C++ namespace alias.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
SourceLocation getAliasLoc() const
Returns the location of the alias name, i.e.
SourceLocation getNamespaceLoc() const
Returns the location of the namespace keyword.
SourceLocation getTargetNameLoc() const
Returns the location of the identifier in the named namespace.
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Represent a C++ namespace.
SourceLocation getRBraceLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isInline() const
Returns true if this is an inline namespace declaration.
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
bool isNested() const
Returns true if this is a nested namespace declaration.
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.
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.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
void setDefaultArgument(Expr *DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
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.
ObjCCategoryImplDecl * getImplementation() const
ObjCInterfaceDecl * getClassInterface()
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameter list associated with this category or extension.
protocol_iterator protocol_end() const
SourceLocation getIvarLBraceLoc() const
SourceLocation getIvarRBraceLoc() const
protocol_loc_iterator protocol_loc_begin() const
protocol_iterator protocol_begin() const
void setImplementation(ObjCCategoryImplDecl *ImplD)
ObjCProtocolList::iterator protocol_iterator
SourceLocation getCategoryNameLoc() const
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
SourceLocation getCategoryNameLoc() const
ObjCCategoryDecl * getCategoryDecl() const
SourceLocation getAtStartLoc() const
Represents Objective-C's collection statement.
const ObjCInterfaceDecl * getClassInterface() const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
SourceLocation getIvarRBraceLoc() const
SourceLocation getSuperClassLoc() const
const ObjCInterfaceDecl * getSuperClass() const
SourceLocation getIvarLBraceLoc() 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.
bool isImplicitInterfaceDecl() const
isImplicitInterfaceDecl - check that this is an implicitly declared ObjCInterfaceDecl node.
ObjCTypeParamList * getTypeParamListAsWritten() const
Retrieve the type parameters written on this particular declaration of the class.
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.
bool isThisDeclarationADefinition() const
Determine whether this particular declaration of this class is actually also a definition.
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
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.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
ObjCIvarDecl - Represents an ObjC instance variable.
AccessControl getAccessControl() const
bool getSynthesize() const
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() const
ArrayRef< ParmVarDecl * > parameters() const
unsigned param_size() const
bool isPropertyAccessor() const
param_const_iterator param_end() const
param_const_iterator param_begin() const
SourceLocation getEndLoc() const LLVM_READONLY
TypeSourceInfo * getReturnTypeSourceInfo() const
bool isSynthesizedAccessorStub() const
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver's type.
void setMethodParams(ASTContext &C, ArrayRef< ParmVarDecl * > Params, ArrayRef< SourceLocation > SelLocs=std::nullopt)
Sets the method's parameters and selector source locations.
bool isInstanceMethod() const
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implicit parameters.
QualType getReturnType() const
ParmVarDecl *const * param_iterator
ObjCImplementationControl getImplementationControl() const
ObjCInterfaceDecl * getClassInterface()
void getSelectorLocs(SmallVectorImpl< SourceLocation > &SelLocs) const
Represents a pointer to an Objective C object.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Represents a class type in Objective C.
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
QualType getBaseType() const
Gets the base type of this object type.
Represents one property declaration in an Objective-C interface.
void setSetterName(Selector Sel, SourceLocation Loc=SourceLocation())
SourceLocation getGetterNameLoc() const
ObjCMethodDecl * getGetterMethodDecl() const
bool isInstanceProperty() const
ObjCMethodDecl * getSetterMethodDecl() const
SourceLocation getSetterNameLoc() const
SourceLocation getAtLoc() const
void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal)
ObjCIvarDecl * getPropertyIvarDecl() const
Selector getSetterName() const
TypeSourceInfo * getTypeSourceInfo() const
void setPropertyAttributesAsWritten(ObjCPropertyAttribute::Kind PRVal)
Selector getGetterName() const
void setPropertyIvarDecl(ObjCIvarDecl *Ivar)
SourceLocation getLParenLoc() const
void setSetterMethodDecl(ObjCMethodDecl *gDecl)
ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const
ObjCPropertyAttribute::Kind getPropertyAttributes() const
void setGetterName(Selector Sel, SourceLocation Loc=SourceLocation())
PropertyControl getPropertyImplementation() const
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
ObjCPropertyDecl * getPropertyDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
Represents an Objective-C protocol declaration.
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
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
ArrayRef< ObjCProtocolDecl * > getProtocols() const
Retrieve all of the protocol qualifiers.
Represents the declaration of an Objective-C type parameter.
unsigned getIndex() const
Retrieve the index into its type parameter list.
SourceLocation getColonLoc() const
Retrieve the location of the ':' separating the type parameter name from the explicitly-specified bou...
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
SourceLocation getVarianceLoc() const
Retrieve the location of the variance keyword.
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.
ObjCTypeParamDecl * getDecl() const
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Expr * getIndexExpr(unsigned Idx)
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
const OffsetOfNode & getComponent(unsigned Idx) const
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
TypeSourceInfo * getTypeSourceInfo() const
unsigned getNumExpressions() const
SourceLocation getRParenLoc() const
Return the location of the right parentheses.
unsigned getNumComponents() const
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.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
SourceLocation getLocation() const
Retrieve the location of this expression.
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
const DeclarationNameInfo & getNameInfo() const
Gets the full name info.
SourceLocation getNameLoc() const
Gets the location of the name.
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
llvm::iterator_range< decls_iterator > decls() const
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
DeclarationName getName() const
Gets the name looked up.
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
ArrayRef< TemplateArgumentLoc > template_arguments() const
A structure for storing the information associated with an overloaded template name.
Represents a C++11 pack expansion that produces a sequence of expressions.
Expr * getPattern()
Retrieve the pattern of the pack expansion.
std::optional< unsigned > getNumExpansions() const
Determine the number of expansions that will be produced when this pack expansion is instantiated,...
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that describes this pack expansion.
Represents a pack expansion of types.
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
std::optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
QualType getPattern() const
Expr * getIndexExpr() const
ParenExpr - This represents a parethesized expression, e.g.
SourceLocation getLParen() const
Get the location of the left parentheses '('.
const Expr * getSubExpr() const
SourceLocation getRParen() const
Get the location of the right parentheses ')'.
ArrayRef< Expr * > exprs()
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
unsigned getNumExprs() const
Return the number of expressions in this paren list.
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
Sugar for parentheses used when specifying types.
QualType getInnerType() const
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:
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
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)
bool isObjCMethodParameter() const
ObjCDeclQualifier getObjCDeclQualifier() const
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.
unsigned getFunctionScopeDepth() const
void setHasInheritedDefaultArg(bool I=true)
QualType getElementType() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
[C99 6.4.2.2] - A predefined identifier such as func.
SourceLocation getBeginLoc() const
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
bool isTransparent() const
PredefinedIdentKind getIdentKind() const
StringLiteral * getFunctionName()
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
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Represents a template name that was expressed as a qualified name.
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)
field_range fields() const
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.
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
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 * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
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.
QualType getPointeeTypeAsWritten() const
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, IdentifierInfo **IIV)
Can create any sort of selector.
Smart pointer class that efficiently represents Objective-C method names.
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
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Expr ** getSubExprs()
Retrieve the array of expressions.
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
SourceLocation getRParenLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
Represents an expression that computes the length of a parameter pack.
SourceLocation getPackLoc() const
Determine the location of the parameter pack.
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof... expression, such as is produced f...
ArrayRef< TemplateArgument > getPartialArguments() const
Get.
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, std::optional< unsigned > Length=std::nullopt, ArrayRef< TemplateArgument > PartialArgs=std::nullopt)
SourceLocation getOperatorLoc() const
Determine the location of the 'sizeof' keyword.
SourceLocation getRParenLoc() const
Determine the location of the right parenthesis.
NamedDecl * getPack() const
Retrieve the parameter pack.
unsigned getPackLength() const
Retrieve the length of the parameter pack.
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
SourceLocation getBeginLoc() const
const DeclContext * getParentContext() const
If the SourceLocExpr has been resolved return the subexpression representing the resolved value.
SourceLocation getEndLoc() const
SourceLocIdentKind getIdentKind() const
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
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.
SourceLocation getRParenLoc() const
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
CompoundStmt * getSubStmt()
unsigned getTemplateDepth() const
SourceLocation getRParenLoc() const
SourceLocation getLParenLoc() const
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Stmt - This represents one statement.
child_iterator child_begin()
StmtClass getStmtClass() const
child_iterator child_end()
const char * getStmtClassName() const
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
tokloc_iterator tokloc_begin() const
tokloc_iterator tokloc_end() const
StringLiteralKind getKind() const
StringRef getBytes() const
Allow access to clients that need the byte representation, such as ASTWriterStmt::VisitStringLiteral(...
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...
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
Represents a reference to a non-type template parameter that has been substituted with a template arg...
std::optional< unsigned > getPackIndex() const
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
bool isReferenceParameter() const
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
Expr * getReplacement() const
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.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
TemplateArgument getArgumentPack() const
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
Represents the result of substituting a type for a template type parameter.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
std::optional< unsigned > getPackIndex() const
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
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.
SourceRange getBraceRange() const
bool isBeingDefined() const
Return true if this decl is currently being defined.
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
TagKind getTagKind() const
void setBraceRange(SourceRange R)
void setCompleteDefinition(bool V=true)
True if this decl has its body fully specified.
TagDecl * getDecl() const
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.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
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.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
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...
ArrayRef< TemplateArgument > template_arguments() const
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Declaration of a template type parameter.
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the 'typename' keyword.
unsigned getIndex() const
Retrieve the index of the template parameter.
bool hasTypeConstraint() const
Determine whether this template parameter has a type-constraint.
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument's source information, if any.
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
void setDefaultArgument(TypeSourceInfo *DefArg)
Set the default argument for this template parameter.
bool isParameterPack() const
Returns whether this is a parameter pack.
unsigned getDepth() const
Retrieve the depth of the template parameter.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
TemplateTypeParmDecl * getDecl() const
bool isParameterPack() const
unsigned getIndex() const
unsigned getDepth() const
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.
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
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...
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
Expr * getUnderlyingExpr() const
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
QualType getUnmodifiedType() const
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.
ArrayRef< TypeSourceInfo * > getArgs() const
Retrieve the argument types.
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.
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
TypeTrait getTrait() const
Determine which type trait this expression uses.
SourceLocation getBeginLoc() const LLVM_READONLY
ExpectedType Visit(const Type *T)
Performs the operation associated with this visitor object.
ElaboratedTypeKeyword getKeyword() const
The base class of the type hierarchy.
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
bool isPointerType() const
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.
TypeSourceInfo * getTypeSourceInfo() const
QualType getUnderlyingType() const
TypedefNameDecl * getDecl() const
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
SourceLocation getRParenLoc() const
SourceLocation getOperatorLoc() const
bool isArgumentType() const
TypeSourceInfo * getArgumentTypeInfo() const
UnaryExprOrTypeTrait getKind() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Expr * getSubExpr() const
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
FPOptionsOverride getStoredFPFeatures() const
Get FPFeatures from trailing storage.
static UnaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
bool canOverflow() const
Returns true if the unary operator can cause an overflow.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
CXXRecordDecl * getNamingClass()
Gets the 'naming class' (in the sense of C++0x [class.access.base]p5) of the lookup.
bool isOverloaded() const
True if this lookup is overloaded.
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
SourceLocation getOperatorLoc() const
Retrieve the location of the '->' or '.' operator.
bool hasUnresolvedUsing() const
Determine whether the lookup results contain an unresolved using declaration.
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
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)
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
void addDecl(NamedDecl *D)
A set of unresolved declarations.
Represents the dependent type named by a dependently-scoped typename using declaration,...
UnresolvedUsingTypenameDecl * getDecl() const
Represents a dependent using declaration which was marked with typename.
SourceLocation getTypenameLoc() const
Returns the source location of the 'typename' keyword.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
SourceLocation getUsingLoc() const
Returns the source location of the 'using' keyword.
SourceLocation getEllipsisLoc() const
Get the location of the ellipsis if this is a pack expansion.
Represents a dependent using declaration which was not marked with typename.
SourceLocation getUsingLoc() const
Returns the source location of the 'using' keyword.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
DeclarationNameInfo getNameInfo() const
SourceLocation getEllipsisLoc() const
Get the location of the ellipsis if this is a pack expansion.
Represents a C++ using-declaration.
bool hasTypename() const
Return true if the using declaration has 'typename'.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
DeclarationNameInfo getNameInfo() const
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Represents C++ using-directive.
SourceLocation getUsingLoc() const
Return the location of the using keyword.
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
DeclContext * getCommonAncestor()
Returns the common ancestor context of this using-directive and its nominated namespace.
SourceLocation getNamespaceKeyLocation() const
Returns the location of the namespace keyword.
SourceLocation getIdentLocation() const
Returns the location of this using declaration's identifier.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Represents a C++ using-enum-declaration.
SourceLocation getEnumLoc() const
The source location of the 'enum' keyword.
TypeSourceInfo * getEnumType() const
SourceLocation getUsingLoc() const
The source location of the 'using' keyword.
Represents a pack of using declarations that a single using-declarator pack-expanded into.
NamedDecl * getInstantiatedFromUsingDecl() const
Get the using declaration from which this was instantiated.
ArrayRef< NamedDecl * > expansions() const
Get the set of using declarations that this pack expanded into.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
UsingShadowDecl * getFoundDecl() const
QualType getUnderlyingType() const
Represents a call to the builtin function __builtin_va_arg.
TypeSourceInfo * getWrittenTypeInfo() const
SourceLocation getBuiltinLoc() const
SourceLocation getRParenLoc() const
bool isMicrosoftABI() const
Returns whether this is really a Win64 ABI va_arg expression.
const Expr * getSubExpr() const
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.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
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,...
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
void setTSCSpec(ThreadStorageClassSpecifier TSC)
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
void setConstexpr(bool IC)
void setDescribedVarTemplate(VarTemplateDecl *Template)
StorageClass getStorageClass() const
Returns the storage class as written in the source.
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.
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary variable pattern.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
VarTemplateDecl * getMostRecentDecl()
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
void setPointOfInstantiation(SourceLocation Loc)
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
const ASTTemplateArgumentListInfo * getTemplateArgsInfo() const
VarTemplateSpecializationDecl * getMostRecentDecl()
Represents a C array with a specified size that is not an integer-constant-expression.
SourceRange getBracketsRange() const
Expr * getSizeExpr() const
Represents a GCC generic vector type.
unsigned getNumElements() const
VectorKind getVectorKind() const
QualType getElementType() const
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.
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