56#include "llvm/ADT/ArrayRef.h"
57#include "llvm/ADT/DenseMap.h"
58#include "llvm/ADT/STLExtras.h"
59#include "llvm/ADT/ScopeExit.h"
60#include "llvm/ADT/SmallVector.h"
61#include "llvm/Support/ErrorHandling.h"
62#include "llvm/Support/MemoryBuffer.h"
73 using llvm::make_error;
88 return "NameConflict";
90 return "UnsupportedConstruct";
92 return "Unknown error";
94 llvm_unreachable(
"Invalid error code.");
95 return "Invalid error code.";
101 llvm_unreachable(
"Function not implemented.");
110 for (
auto *R :
D->getFirstDecl()->
redecls()) {
111 if (R !=
D->getFirstDecl())
112 Redecls.push_back(R);
114 Redecls.push_back(
D->getFirstDecl());
115 std::reverse(Redecls.begin(), Redecls.end());
120 if (
auto *FD = dyn_cast<FunctionDecl>(
D))
121 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
122 if (
auto *VD = dyn_cast<VarDecl>(
D))
123 return getCanonicalForwardRedeclChain<VarDecl>(VD);
124 if (
auto *TD = dyn_cast<TagDecl>(
D))
125 return getCanonicalForwardRedeclChain<TagDecl>(TD);
126 llvm_unreachable(
"Bad declaration kind");
147 bool const IgnoreChildErrors;
151 : FromDC(FromDC), IgnoreChildErrors(!
isa<
TagDecl>(FromDC)) {}
161 if (ChildErr && !IgnoreChildErrors)
162 ResultErr = joinErrors(std::move(ResultErr), std::move(ChildErr));
164 consumeError(std::move(ChildErr));
170 if (!IgnoreChildErrors || !FromDC)
178 public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
182 template <
typename ImportT>
183 [[nodiscard]] Error importInto(ImportT &To,
const ImportT &From) {
188 template <
typename ImportT>
189 [[nodiscard]] Error importInto(ImportT *&To, ImportT *From) {
190 auto ToOrErr = Importer.
Import(From);
192 To = cast_or_null<ImportT>(*ToOrErr);
193 return ToOrErr.takeError();
198 template <
typename T>
202 auto ToOrErr = Importer.
Import(From);
204 return ToOrErr.takeError();
205 return cast_or_null<T>(*ToOrErr);
208 template <
typename T>
209 auto import(
const T *From) {
210 return import(
const_cast<T *
>(From));
214 template <
typename T>
216 return Importer.
Import(From);
220 template <
typename T>
224 return import(*From);
231 template <
typename ToDeclT>
struct CallOverloadedCreateFun {
232 template <
typename... Args>
decltype(
auto)
operator()(Args &&... args) {
233 return ToDeclT::Create(std::forward<Args>(args)...);
243 template <
typename ToDeclT,
typename FromDeclT,
typename... Args>
244 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
249 CallOverloadedCreateFun<ToDeclT> OC;
250 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
251 std::forward<Args>(args)...);
258 template <
typename NewDeclT,
typename ToDeclT,
typename FromDeclT,
260 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
262 CallOverloadedCreateFun<NewDeclT> OC;
263 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
264 std::forward<Args>(args)...);
268 template <
typename ToDeclT,
typename CreateFunT,
typename FromDeclT,
271 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
272 FromDeclT *FromD, Args &&...args) {
280 ToD = CreateFun(std::forward<Args>(args)...);
283 Importer.SharedState->markAsNewDecl(ToD);
284 InitializeImportedDecl(FromD, ToD);
288 void InitializeImportedDecl(
Decl *FromD,
Decl *ToD) {
292 if (FromD->isImplicit())
300 if (
D->doesThisDeclarationHaveABody() &&
306 void addDeclToContexts(
Decl *FromD,
Decl *ToD) {
311 if (!FromD->getDescribedTemplate() &&
318 DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
322 bool Visible =
false;
335 if (
auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
336 auto *ToNamed = cast<NamedDecl>(ToD);
338 FromDC->
lookup(FromNamed->getDeclName());
339 if (llvm::is_contained(FromLookup, FromNamed))
356 updateLookupTableForTemplateParameters(
360 template <
typename TemplateParmDeclT>
361 Error importTemplateParameterDefaultArgument(
const TemplateParmDeclT *
D,
362 TemplateParmDeclT *ToD) {
363 if (
D->hasDefaultArgument()) {
364 if (
D->defaultArgumentWasInherited()) {
366 import(
D->getDefaultArgStorage().getInheritedFrom());
367 if (!ToInheritedFromOrErr)
368 return ToInheritedFromOrErr.takeError();
369 TemplateParmDeclT *ToInheritedFrom = *ToInheritedFromOrErr;
370 if (!ToInheritedFrom->hasDefaultArgument()) {
374 import(
D->getDefaultArgStorage()
376 ->getDefaultArgument());
377 if (!ToInheritedDefaultArgOrErr)
378 return ToInheritedDefaultArgOrErr.takeError();
379 ToInheritedFrom->setDefaultArgument(Importer.
getToContext(),
380 *ToInheritedDefaultArgOrErr);
382 ToD->setInheritedDefaultArgument(ToD->getASTContext(),
386 import(
D->getDefaultArgument());
387 if (!ToDefaultArgOrErr)
388 return ToDefaultArgOrErr.takeError();
391 if (!ToD->hasDefaultArgument())
396 return Error::success();
408#define TYPE(Class, Base) \
409 ExpectedType Visit##Class##Type(const Class##Type *T);
410#include "clang/AST/TypeNodes.inc"
468 template <
typename InContainerTy>
472 template<
typename InContainerTy>
479 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
484 template <
typename DeclTy>
497 template <
typename T>
501 bool IgnoreTemplateParmDepth =
false);
693 Err = MaybeVal.takeError();
699 template<
typename IIter,
typename OIter>
701 using ItemT = std::remove_reference_t<
decltype(*Obegin)>;
702 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
705 return ToOrErr.takeError();
708 return Error::success();
715 template<
typename InContainerTy,
typename OutContainerTy>
717 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
719 InContainer.begin(), InContainer.end(), OutContainer.begin());
722 template<
typename InContainerTy,
typename OIter>
739template <
typename InContainerTy>
743 auto ToLAngleLocOrErr =
import(FromLAngleLoc);
744 if (!ToLAngleLocOrErr)
745 return ToLAngleLocOrErr.takeError();
746 auto ToRAngleLocOrErr =
import(FromRAngleLoc);
747 if (!ToRAngleLocOrErr)
748 return ToRAngleLocOrErr.takeError();
754 return Error::success();
758Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
769 return ImportTemplateArgumentListInfo(
770 From.LAngleLoc, From.RAngleLoc, From.arguments(),
Result);
782 if (Error Err = importInto(std::get<0>(
Result), FTSInfo->getTemplate()))
783 return std::move(Err);
788 return std::move(Err);
798 return std::move(Err);
801 if (!ToRequiresClause)
802 return ToRequiresClause.takeError();
805 if (!ToTemplateLocOrErr)
806 return ToTemplateLocOrErr.takeError();
808 if (!ToLAngleLocOrErr)
809 return ToLAngleLocOrErr.takeError();
811 if (!ToRAngleLocOrErr)
812 return ToRAngleLocOrErr.takeError();
833 return ToTypeOrErr.takeError();
841 return ToTypeOrErr.takeError();
848 return ToOrErr.takeError();
851 return ToTypeOrErr.takeError();
852 return TemplateArgument(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()),
859 return ToTypeOrErr.takeError();
867 return ToTypeOrErr.takeError();
870 return ToValueOrErr.takeError();
877 if (!ToTemplateOrErr)
878 return ToTemplateOrErr.takeError();
886 if (!ToTemplateOrErr)
887 return ToTemplateOrErr.takeError();
897 return ToExpr.takeError();
903 return std::move(Err);
910 llvm_unreachable(
"Invalid template argument kind");
918 return ArgOrErr.takeError();
927 return E.takeError();
933 return TSIOrErr.takeError();
935 auto ToTemplateQualifierLocOrErr =
937 if (!ToTemplateQualifierLocOrErr)
938 return ToTemplateQualifierLocOrErr.takeError();
940 if (!ToTemplateNameLocOrErr)
941 return ToTemplateNameLocOrErr.takeError();
942 auto ToTemplateEllipsisLocOrErr =
944 if (!ToTemplateEllipsisLocOrErr)
945 return ToTemplateEllipsisLocOrErr.takeError();
948 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
958 size_t NumDecls = DG.
end() - DG.
begin();
960 ToDecls.reserve(NumDecls);
961 for (
Decl *FromD : DG) {
962 if (
auto ToDOrErr =
import(FromD))
963 ToDecls.push_back(*ToDOrErr);
965 return ToDOrErr.takeError();
975 if (
D.isFieldDesignator()) {
980 return ToDotLocOrErr.takeError();
983 if (!ToFieldLocOrErr)
984 return ToFieldLocOrErr.takeError();
987 ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
990 ExpectedSLoc ToLBracketLocOrErr =
import(
D.getLBracketLoc());
991 if (!ToLBracketLocOrErr)
992 return ToLBracketLocOrErr.takeError();
994 ExpectedSLoc ToRBracketLocOrErr =
import(
D.getRBracketLoc());
995 if (!ToRBracketLocOrErr)
996 return ToRBracketLocOrErr.takeError();
998 if (
D.isArrayDesignator())
1000 *ToLBracketLocOrErr,
1001 *ToRBracketLocOrErr);
1003 ExpectedSLoc ToEllipsisLocOrErr =
import(
D.getEllipsisLoc());
1004 if (!ToEllipsisLocOrErr)
1005 return ToEllipsisLocOrErr.takeError();
1007 assert(
D.isArrayRangeDesignator());
1009 D.getArrayIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
1010 *ToRBracketLocOrErr);
1015 Error Err = Error::success();
1018 auto ToConceptNameLoc =
1024 return std::move(Err);
1027 if (ASTTemplateArgs)
1029 return std::move(Err);
1047 return VarOrErr.takeError();
1052 return LocationOrErr.takeError();
1057 return std::move(Err);
1064template <
typename T>
1066 if (
Found->getLinkageInternal() != From->getLinkageInternal())
1069 if (From->hasExternalFormalLinkage())
1070 return Found->hasExternalFormalLinkage();
1073 if (From->isInAnonymousNamespace())
1074 return Found->isInAnonymousNamespace();
1076 return !
Found->isInAnonymousNamespace() &&
1077 !
Found->hasExternalFormalLinkage();
1097using namespace clang;
1106 ExpectedType UnderlyingTypeOrErr =
import(
T->getValueType());
1107 if (!UnderlyingTypeOrErr)
1108 return UnderlyingTypeOrErr.takeError();
1114 switch (
T->getKind()) {
1115#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1116 case BuiltinType::Id: \
1117 return Importer.getToContext().SingletonId;
1118#include "clang/Basic/OpenCLImageTypes.def"
1119#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1120 case BuiltinType::Id: \
1121 return Importer.getToContext().Id##Ty;
1122#include "clang/Basic/OpenCLExtensionTypes.def"
1123#define SVE_TYPE(Name, Id, SingletonId) \
1124 case BuiltinType::Id: \
1125 return Importer.getToContext().SingletonId;
1126#include "clang/Basic/AArch64SVEACLETypes.def"
1127#define PPC_VECTOR_TYPE(Name, Id, Size) \
1128 case BuiltinType::Id: \
1129 return Importer.getToContext().Id##Ty;
1130#include "clang/Basic/PPCTypes.def"
1131#define RVV_TYPE(Name, Id, SingletonId) \
1132 case BuiltinType::Id: \
1133 return Importer.getToContext().SingletonId;
1134#include "clang/Basic/RISCVVTypes.def"
1135#define WASM_TYPE(Name, Id, SingletonId) \
1136 case BuiltinType::Id: \
1137 return Importer.getToContext().SingletonId;
1138#include "clang/Basic/WebAssemblyReferenceTypes.def"
1139#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
1140 case BuiltinType::Id: \
1141 return Importer.getToContext().SingletonId;
1142#include "clang/Basic/AMDGPUTypes.def"
1143#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1144 case BuiltinType::Id: \
1145 return Importer.getToContext().SingletonId;
1146#include "clang/Basic/HLSLIntangibleTypes.def"
1147#define SHARED_SINGLETON_TYPE(Expansion)
1148#define BUILTIN_TYPE(Id, SingletonId) \
1149 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1150#include "clang/AST/BuiltinTypes.def"
1158 case BuiltinType::Char_U:
1167 case BuiltinType::Char_S:
1176 case BuiltinType::WChar_S:
1177 case BuiltinType::WChar_U:
1183 llvm_unreachable(
"Invalid BuiltinType Kind!");
1187 ExpectedType ToOriginalTypeOrErr =
import(
T->getOriginalType());
1188 if (!ToOriginalTypeOrErr)
1189 return ToOriginalTypeOrErr.takeError();
1195 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1196 if (!ToElementTypeOrErr)
1197 return ToElementTypeOrErr.takeError();
1204 if (!ToPointeeTypeOrErr)
1205 return ToPointeeTypeOrErr.takeError();
1213 if (!ToPointeeTypeOrErr)
1214 return ToPointeeTypeOrErr.takeError();
1222 ExpectedType ToPointeeTypeOrErr =
import(
T->getPointeeTypeAsWritten());
1223 if (!ToPointeeTypeOrErr)
1224 return ToPointeeTypeOrErr.takeError();
1232 ExpectedType ToPointeeTypeOrErr =
import(
T->getPointeeTypeAsWritten());
1233 if (!ToPointeeTypeOrErr)
1234 return ToPointeeTypeOrErr.takeError();
1243 if (!ToPointeeTypeOrErr)
1244 return ToPointeeTypeOrErr.takeError();
1247 if (!ClassTypeOrErr)
1248 return ClassTypeOrErr.takeError();
1256 Error Err = Error::success();
1260 return std::move(Err);
1263 ToElementType,
T->getSize(), ToSizeExpr,
T->getSizeModifier(),
1264 T->getIndexTypeCVRQualifiers());
1270 if (!ToArrayTypeOrErr)
1271 return ToArrayTypeOrErr.takeError();
1278 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1279 if (!ToElementTypeOrErr)
1280 return ToElementTypeOrErr.takeError();
1283 T->getSizeModifier(),
1284 T->getIndexTypeCVRQualifiers());
1289 Error Err = Error::success();
1294 return std::move(Err);
1296 ToElementType, ToSizeExpr,
T->getSizeModifier(),
1297 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1300ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1302 Error Err = Error::success();
1307 return std::move(Err);
1312 ToElementType, ToSizeExpr,
T->getSizeModifier(),
1313 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1316ExpectedType ASTNodeImporter::VisitDependentSizedExtVectorType(
1318 Error Err = Error::success();
1323 return std::move(Err);
1325 ToElementType, ToSizeExpr, ToAttrLoc);
1329 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1330 if (!ToElementTypeOrErr)
1331 return ToElementTypeOrErr.takeError();
1334 T->getNumElements(),
1335 T->getVectorKind());
1339 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1340 if (!ToElementTypeOrErr)
1341 return ToElementTypeOrErr.takeError();
1344 T->getNumElements());
1352 if (!ToReturnTypeOrErr)
1353 return ToReturnTypeOrErr.takeError();
1362 if (!ToReturnTypeOrErr)
1363 return ToReturnTypeOrErr.takeError();
1370 return TyOrErr.takeError();
1371 ArgTypes.push_back(*TyOrErr);
1379 return TyOrErr.takeError();
1380 ExceptionTypes.push_back(*TyOrErr);
1384 Error Err = Error::success();
1401 return std::move(Err);
1404 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1409 Error Err = Error::success();
1411 auto ToPrevD =
importChecked(Err,
T->getDecl()->getPreviousDecl());
1413 return std::move(Err);
1416 ToD, cast_or_null<TypeDecl>(ToPrevD));
1421 if (!ToInnerTypeOrErr)
1422 return ToInnerTypeOrErr.takeError();
1432 return Pattern.takeError();
1435 return Index.takeError();
1442 return ToDeclOrErr.takeError();
1449 if (!ToUnderlyingTypeOrErr)
1450 return ToUnderlyingTypeOrErr.takeError();
1458 return ToExprOrErr.takeError();
1463 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnmodifiedType());
1464 if (!ToUnderlyingTypeOrErr)
1465 return ToUnderlyingTypeOrErr.takeError();
1473 return FoundOrErr.takeError();
1475 if (!UnderlyingOrErr)
1476 return UnderlyingOrErr.takeError();
1485 return ToExprOrErr.takeError();
1487 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1488 if (!ToUnderlyingTypeOrErr)
1489 return ToUnderlyingTypeOrErr.takeError();
1492 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1498 if (!ToBaseTypeOrErr)
1499 return ToBaseTypeOrErr.takeError();
1501 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1502 if (!ToUnderlyingTypeOrErr)
1503 return ToUnderlyingTypeOrErr.takeError();
1506 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr,
T->getUTTKind());
1511 ExpectedType ToDeducedTypeOrErr =
import(
T->getDeducedType());
1512 if (!ToDeducedTypeOrErr)
1513 return ToDeducedTypeOrErr.takeError();
1515 ExpectedDecl ToTypeConstraintConcept =
import(
T->getTypeConstraintConcept());
1516 if (!ToTypeConstraintConcept)
1517 return ToTypeConstraintConcept.takeError();
1522 return std::move(Err);
1525 *ToDeducedTypeOrErr,
T->getKeyword(),
false,
1526 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1530ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1534 if (!ToTemplateNameOrErr)
1535 return ToTemplateNameOrErr.takeError();
1536 ExpectedType ToDeducedTypeOrErr =
import(
T->getDeducedType());
1537 if (!ToDeducedTypeOrErr)
1538 return ToDeducedTypeOrErr.takeError();
1544ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1548 return ToDeclOrErr.takeError();
1552 const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
1553 assert(isa_and_nonnull<InjectedClassNameType>(Ty));
1560 return ToDeclOrErr.takeError();
1568 return ToDeclOrErr.takeError();
1574 ExpectedType ToModifiedTypeOrErr =
import(
T->getModifiedType());
1575 if (!ToModifiedTypeOrErr)
1576 return ToModifiedTypeOrErr.takeError();
1577 ExpectedType ToEquivalentTypeOrErr =
import(
T->getEquivalentType());
1578 if (!ToEquivalentTypeOrErr)
1579 return ToEquivalentTypeOrErr.takeError();
1582 T->getAttrKind(), *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr,
1589 if (!ToWrappedTypeOrErr)
1590 return ToWrappedTypeOrErr.takeError();
1592 Error Err = Error::success();
1599 return ToDeclOrErr.takeError();
1600 CoupledDecls.emplace_back(*ToDeclOrErr, TI.isDeref());
1604 *ToWrappedTypeOrErr, CountExpr,
T->isCountInBytes(),
T->isOrNull(),
1605 ArrayRef(CoupledDecls.data(), CoupledDecls.size()));
1608ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1612 return ToDeclOrErr.takeError();
1615 T->getDepth(),
T->getIndex(),
T->isParameterPack(), *ToDeclOrErr);
1618ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1622 return ReplacedOrErr.takeError();
1624 ExpectedType ToReplacementTypeOrErr =
import(
T->getReplacementType());
1625 if (!ToReplacementTypeOrErr)
1626 return ToReplacementTypeOrErr.takeError();
1629 *ToReplacementTypeOrErr, *ReplacedOrErr,
T->getIndex(),
T->getPackIndex(),
1630 T->getSubstitutionFlag());
1633ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1637 return ReplacedOrErr.takeError();
1640 if (!ToArgumentPack)
1641 return ToArgumentPack.takeError();
1644 *ReplacedOrErr,
T->getIndex(),
T->getFinal(), *ToArgumentPack);
1647ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1649 auto ToTemplateOrErr =
import(
T->getTemplateName());
1650 if (!ToTemplateOrErr)
1651 return ToTemplateOrErr.takeError();
1656 return std::move(Err);
1663 ToCanonType = *TyOrErr;
1665 return TyOrErr.takeError();
1674 auto ToQualifierOrErr =
import(
T->getQualifier());
1675 if (!ToQualifierOrErr)
1676 return ToQualifierOrErr.takeError();
1679 if (!ToNamedTypeOrErr)
1680 return ToNamedTypeOrErr.takeError();
1683 if (!ToOwnedTagDeclOrErr)
1684 return ToOwnedTagDeclOrErr.takeError();
1689 *ToOwnedTagDeclOrErr);
1695 if (!ToPatternOrErr)
1696 return ToPatternOrErr.takeError();
1699 T->getNumExpansions(),
1703ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1705 auto ToQualifierOrErr =
import(
T->getQualifier());
1706 if (!ToQualifierOrErr)
1707 return ToQualifierOrErr.takeError();
1712 ToPack.reserve(
T->template_arguments().size());
1714 return std::move(Err);
1717 T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1722 auto ToQualifierOrErr =
import(
T->getQualifier());
1723 if (!ToQualifierOrErr)
1724 return ToQualifierOrErr.takeError();
1733 return TyOrErr.takeError();
1745 return ToDeclOrErr.takeError();
1752 if (!ToBaseTypeOrErr)
1753 return ToBaseTypeOrErr.takeError();
1756 for (
auto TypeArg :
T->getTypeArgsAsWritten()) {
1758 TypeArgs.push_back(*TyOrErr);
1760 return TyOrErr.takeError();
1764 for (
auto *
P :
T->quals()) {
1766 Protocols.push_back(*ProtocolOrErr);
1768 return ProtocolOrErr.takeError();
1774 T->isKindOfTypeAsWritten());
1780 if (!ToPointeeTypeOrErr)
1781 return ToPointeeTypeOrErr.takeError();
1788 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1789 if (!ToUnderlyingTypeOrErr)
1790 return ToUnderlyingTypeOrErr.takeError();
1798 Error Err = Error::success();
1799 QualType ToOriginalType = importChecked(Err,
T->getOriginalType());
1800 QualType ToAdjustedType = importChecked(Err,
T->getAdjustedType());
1802 return std::move(Err);
1804 return Importer.getToContext().getAdjustedType(ToOriginalType,
1809 return Importer.getToContext().getBitIntType(
T->isUnsigned(),
1813ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType(
1815 Error Err = Error::success();
1816 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err,
T->getAttr());
1817 QualType ToWrappedType = importChecked(Err,
T->getWrappedType());
1819 return std::move(Err);
1821 return Importer.getToContext().getBTFTagAttributedType(ToBTFAttr,
1825ExpectedType clang::ASTNodeImporter::VisitHLSLAttributedResourceType(
1827 Error Err = Error::success();
1829 QualType ToWrappedType = importChecked(Err,
T->getWrappedType());
1830 QualType ToContainedType = importChecked(Err,
T->getContainedType());
1832 return std::move(Err);
1834 return Importer.getToContext().getHLSLAttributedResourceType(
1835 ToWrappedType, ToContainedType, ToAttrs);
1838ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType(
1840 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1841 if (!ToElementTypeOrErr)
1842 return ToElementTypeOrErr.takeError();
1844 return Importer.getToContext().getConstantMatrixType(
1845 *ToElementTypeOrErr,
T->getNumRows(),
T->getNumColumns());
1848ExpectedType clang::ASTNodeImporter::VisitDependentAddressSpaceType(
1850 Error Err = Error::success();
1852 Expr *ToAddrSpaceExpr = importChecked(Err,
T->getAddrSpaceExpr());
1855 return std::move(Err);
1857 return Importer.getToContext().getDependentAddressSpaceType(
1858 ToPointeeType, ToAddrSpaceExpr, ToAttrLoc);
1861ExpectedType clang::ASTNodeImporter::VisitDependentBitIntType(
1863 ExpectedExpr ToNumBitsExprOrErr =
import(
T->getNumBitsExpr());
1864 if (!ToNumBitsExprOrErr)
1865 return ToNumBitsExprOrErr.takeError();
1866 return Importer.getToContext().getDependentBitIntType(
T->isUnsigned(),
1867 *ToNumBitsExprOrErr);
1870ExpectedType clang::ASTNodeImporter::VisitDependentSizedMatrixType(
1872 Error Err = Error::success();
1873 QualType ToElementType = importChecked(Err,
T->getElementType());
1874 Expr *ToRowExpr = importChecked(Err,
T->getRowExpr());
1875 Expr *ToColumnExpr = importChecked(Err,
T->getColumnExpr());
1878 return std::move(Err);
1880 return Importer.getToContext().getDependentSizedMatrixType(
1881 ToElementType, ToRowExpr, ToColumnExpr, ToAttrLoc);
1884ExpectedType clang::ASTNodeImporter::VisitDependentVectorType(
1886 Error Err = Error::success();
1887 QualType ToElementType = importChecked(Err,
T->getElementType());
1888 Expr *ToSizeExpr = importChecked(Err,
T->getSizeExpr());
1891 return std::move(Err);
1893 return Importer.getToContext().getDependentVectorType(
1894 ToElementType, ToSizeExpr, ToAttrLoc,
T->getVectorKind());
1897ExpectedType clang::ASTNodeImporter::VisitObjCTypeParamType(
1901 return ToDeclOrErr.takeError();
1906 if (!ToProtocolOrErr)
1907 return ToProtocolOrErr.takeError();
1908 ToProtocols.push_back(*ToProtocolOrErr);
1911 return Importer.getToContext().getObjCTypeParamType(*ToDeclOrErr,
1916 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1917 if (!ToElementTypeOrErr)
1918 return ToElementTypeOrErr.takeError();
1921 if (
T->isReadOnly())
1941 if (isa<RecordDecl>(
D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1943 auto getLeafPointeeType = [](
const Type *
T) {
1951 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1952 auto *RT = dyn_cast<RecordType>(LeafT);
1953 if (RT && RT->getDecl() ==
D) {
1966 if (Error Err = importInto(Name,
D->getDeclName()))
1978 return Error::success();
1985 if (Error Err = importInto(Name,
D->getDeclName()))
1997 return Error::success();
2002 return Error::success();
2005 if (Error Err = importInto(ToD, FromD))
2008 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
2009 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
2010 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
2011 !ToRecord->getDefinition()) {
2016 return Error::success();
2019 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
2020 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
2021 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2026 return Error::success();
2029 return Error::success();
2044 return Error::success();
2050 return ToRangeOrErr.takeError();
2051 return Error::success();
2057 return LocOrErr.takeError();
2058 return Error::success();
2066 return ToTInfoOrErr.takeError();
2067 return Error::success();
2070 llvm_unreachable(
"Unknown name kind.");
2077 return ToDCOrErr.takeError();
2091 auto MightNeedReordering = [](
const Decl *
D) {
2092 return isa<FieldDecl>(
D) || isa<IndirectFieldDecl>(
D) || isa<FriendDecl>(
D);
2096 Error ChildErrors = Error::success();
2097 for (
auto *From : FromDC->
decls()) {
2098 if (!MightNeedReordering(From))
2107 if (!ImportedOrErr) {
2109 ImportedOrErr.takeError());
2112 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
2113 Decl *ImportedDecl = *ImportedOrErr;
2114 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
2115 if (FieldFrom && FieldTo) {
2147 consumeError(std::move(ChildErrors));
2148 return ToDCOrErr.takeError();
2151 if (
const auto *FromRD = dyn_cast<RecordDecl>(FromDC)) {
2155 for (
auto *
D : FromRD->decls()) {
2156 if (!MightNeedReordering(
D))
2159 assert(
D &&
"DC contains a null decl");
2162 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->
containsDecl(ToD));
2174 for (
auto *From : FromDC->
decls()) {
2175 if (MightNeedReordering(From))
2181 ImportedOrErr.takeError());
2201 if (!FromRecordDecl || !ToRecordDecl) {
2205 if (RecordFrom && RecordTo) {
2206 FromRecordDecl = RecordFrom->
getDecl();
2207 ToRecordDecl = RecordTo->getDecl();
2211 if (FromRecordDecl && ToRecordDecl) {
2217 return Error::success();
2224 return ToDCOrErr.takeError();
2230 if (!ToLexicalDCOrErr)
2231 return ToLexicalDCOrErr.takeError();
2232 ToLexicalDC = *ToLexicalDCOrErr;
2236 return Error::success();
2242 "Import implicit methods to or from non-definition");
2245 if (FromM->isImplicit()) {
2248 return ToMOrErr.takeError();
2251 return Error::success();
2260 return ToTypedefOrErr.takeError();
2262 return Error::success();
2267 auto DefinitionCompleter = [To]() {
2286 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2288 ToCaptures.reserve(FromCXXRD->capture_size());
2289 for (
const auto &FromCapture : FromCXXRD->captures()) {
2290 if (
auto ToCaptureOrErr =
import(FromCapture))
2291 ToCaptures.push_back(*ToCaptureOrErr);
2293 return ToCaptureOrErr.takeError();
2295 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2302 DefinitionCompleter();
2306 return Error::success();
2321 auto DefinitionCompleterScopeExit =
2322 llvm::make_scope_exit(DefinitionCompleter);
2328 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2329 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2330 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2332 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2333 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2335 #define FIELD(Name, Width, Merge) \
2336 ToData.Name = FromData.Name;
2337 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2340 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2343 for (
const auto &Base1 : FromCXX->bases()) {
2346 return TyOrErr.takeError();
2349 if (Base1.isPackExpansion()) {
2350 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2351 EllipsisLoc = *LocOrErr;
2353 return LocOrErr.takeError();
2361 auto RangeOrErr =
import(Base1.getSourceRange());
2363 return RangeOrErr.takeError();
2365 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2367 return TSIOrErr.takeError();
2373 Base1.isBaseOfClass(),
2374 Base1.getAccessSpecifierAsWritten(),
2379 ToCXX->setBases(Bases.data(), Bases.size());
2387 return Error::success();
2392 return Error::success();
2396 return Error::success();
2400 return ToInitOrErr.takeError();
2411 return Error::success();
2419 return Error::success();
2430 return ToTypeOrErr.takeError();
2433 if (!ToPromotionTypeOrErr)
2434 return ToPromotionTypeOrErr.takeError();
2445 return Error::success();
2451 for (
const auto &Arg : FromArgs) {
2452 if (
auto ToOrErr =
import(Arg))
2453 ToArgs.push_back(*ToOrErr);
2455 return ToOrErr.takeError();
2458 return Error::success();
2464 return import(From);
2467template <
typename InContainerTy>
2470 for (
const auto &FromLoc : Container) {
2471 if (
auto ToLocOrErr =
import(FromLoc))
2474 return ToLocOrErr.takeError();
2476 return Error::success();
2486 bool IgnoreTemplateParmDepth) {
2497 false, Complain,
false,
2498 IgnoreTemplateParmDepth);
2499 return Ctx.IsEquivalent(From, To);
2518 return std::move(Err);
2523 return LocOrErr.takeError();
2526 if (GetImportedOrCreateDecl(ToD,
D, Importer.
getToContext(), DC, *LocOrErr))
2549 return std::move(Err);
2555 Name.getAsIdentifierInfo()))
2558 Error Err = Error::success();
2563 return std::move(Err);
2567 addDeclToContexts(
D, ToD);
2575 return LocOrErr.takeError();
2576 auto ColonLocOrErr =
import(
D->getColonLoc());
2578 return ColonLocOrErr.takeError();
2583 return DCOrErr.takeError();
2588 DC, *LocOrErr, *ColonLocOrErr))
2602 return DCOrErr.takeError();
2606 Error Err = Error::success();
2612 return std::move(Err);
2615 if (GetImportedOrCreateDecl(
2616 ToD,
D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2617 ToRParenLoc,
D->isFailed()))
2632 return std::move(Err);
2641 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2647 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2648 for (
auto *FoundDecl : FoundDecls) {
2652 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2653 MergeWithNamespace = FoundNS;
2654 ConflictingDecls.clear();
2658 ConflictingDecls.push_back(FoundDecl);
2661 if (!ConflictingDecls.empty()) {
2664 ConflictingDecls.size());
2666 Name = NameOrErr.get();
2668 return NameOrErr.takeError();
2674 return BeginLocOrErr.takeError();
2676 if (!RBraceLocOrErr)
2677 return RBraceLocOrErr.takeError();
2682 if (GetImportedOrCreateDecl(ToNamespace,
D, Importer.
getToContext(), DC,
2683 D->isInline(), *BeginLocOrErr,
Loc,
2684 Name.getAsIdentifierInfo(),
2685 nullptr,
D->isNested()))
2694 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2695 TU->setAnonymousNamespace(ToNamespace);
2697 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2703 return std::move(Err);
2715 return std::move(Err);
2721 Error Err = Error::success();
2725 auto ToTargetNameLoc =
importChecked(Err,
D->getTargetNameLoc());
2728 return std::move(Err);
2733 if (GetImportedOrCreateDecl(
2734 ToD,
D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2735 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2753 return std::move(Err);
2772 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2773 for (
auto *FoundDecl : FoundDecls) {
2776 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2780 QualType FromUT =
D->getUnderlyingType();
2781 QualType FoundUT = FoundTypedef->getUnderlyingType();
2795 if (FromR && FoundR &&
2806 ConflictingDecls.push_back(FoundDecl);
2811 if (!ConflictingDecls.empty()) {
2813 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2815 Name = NameOrErr.get();
2817 return NameOrErr.takeError();
2821 Error Err = Error::success();
2823 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
2826 return std::move(Err);
2833 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2835 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2837 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2839 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2844 return std::move(Err);
2848 Importer.AddToLookupTable(ToTypedef);
2853 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(
D) :
nullptr;
2876 return std::move(Err);
2886 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2887 for (
auto *FoundDecl : FoundDecls) {
2890 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) {
2893 ConflictingDecls.push_back(FoundDecl);
2897 if (!ConflictingDecls.empty()) {
2899 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2901 Name = NameOrErr.get();
2903 return NameOrErr.takeError();
2907 Error Err = Error::success();
2908 auto ToTemplateParameters =
importChecked(Err,
D->getTemplateParameters());
2909 auto ToTemplatedDecl =
importChecked(Err,
D->getTemplatedDecl());
2911 return std::move(Err);
2915 Name, ToTemplateParameters, ToTemplatedDecl))
2918 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2924 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2935 return std::move(Err);
2942 if (
D->isGnuLocal()) {
2945 return BeginLocOrErr.takeError();
2947 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2952 Name.getAsIdentifierInfo()))
2959 return ToStmtOrErr.takeError();
2961 ToLabel->
setStmt(*ToStmtOrErr);
2974 return std::move(Err);
2981 if (!SearchName &&
D->getTypedefNameForAnonDecl()) {
2982 if (Error Err = importInto(
2983 SearchName,
D->getTypedefNameForAnonDecl()->getDeclName()))
2984 return std::move(Err);
2994 Importer.findDeclsInToCtx(DC, SearchName);
2995 for (
auto *FoundDecl : FoundDecls) {
2999 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
3000 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
3001 FoundDecl = Tag->getDecl();
3004 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
3009 if (
D->isThisDeclarationADefinition() && FoundDef)
3014 ConflictingDecls.push_back(FoundDecl);
3023 if (SearchName && !ConflictingDecls.empty()) {
3025 SearchName, DC, IDNS, ConflictingDecls.data(),
3026 ConflictingDecls.size());
3028 Name = NameOrErr.get();
3030 return NameOrErr.takeError();
3034 Error Err = Error::success();
3040 return std::move(Err);
3044 if (GetImportedOrCreateDecl(
3046 Loc, Name.getAsIdentifierInfo(), PrevDecl,
D->isScoped(),
3047 D->isScopedUsingClassTag(),
D->isFixed()))
3055 addDeclToContexts(
D, D2);
3059 EnumDecl *FromInst =
D->getInstantiatedFromMemberEnum();
3061 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
3063 return ToInstOrErr.takeError();
3064 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
3067 return POIOrErr.takeError();
3071 if (
D->isCompleteDefinition())
3073 return std::move(Err);
3079 bool IsFriendTemplate =
false;
3080 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3082 DCXX->getDescribedClassTemplate() &&
3083 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
3093 return std::move(Err);
3100 if (!SearchName &&
D->getTypedefNameForAnonDecl()) {
3101 if (Error Err = importInto(
3102 SearchName,
D->getTypedefNameForAnonDecl()->getDeclName()))
3103 return std::move(Err);
3110 bool DependentFriend = IsFriendTemplate && IsDependentContext;
3117 Importer.findDeclsInToCtx(DC, SearchName);
3118 if (!FoundDecls.empty()) {
3121 if (
D->hasExternalLexicalStorage() && !
D->isCompleteDefinition())
3125 for (
auto *FoundDecl : FoundDecls) {
3130 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(
Found)) {
3131 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
3132 Found = Tag->getDecl();
3135 if (
auto *FoundRecord = dyn_cast<RecordDecl>(
Found)) {
3154 if (
D->isThisDeclarationADefinition() && FoundDef) {
3158 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3159 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
3160 assert(FoundCXX &&
"Record type mismatch");
3166 return std::move(Err);
3173 ConflictingDecls.push_back(FoundDecl);
3177 if (!ConflictingDecls.empty() && SearchName) {
3179 SearchName, DC, IDNS, ConflictingDecls.data(),
3180 ConflictingDecls.size());
3182 Name = NameOrErr.get();
3184 return NameOrErr.takeError();
3190 return BeginLocOrErr.takeError();
3195 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3196 if (DCXX->isLambda()) {
3197 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
3199 return TInfoOrErr.takeError();
3200 if (GetImportedOrCreateSpecialDecl(
3202 DC, *TInfoOrErr,
Loc, DCXX->getLambdaDependencyKind(),
3203 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
3208 return CDeclOrErr.takeError();
3211 }
else if (DCXX->isInjectedClassName()) {
3214 const bool DelayTypeCreation =
true;
3215 if (GetImportedOrCreateDecl(
3217 *BeginLocOrErr,
Loc, Name.getAsIdentifierInfo(),
3218 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
3221 D2CXX, dyn_cast<CXXRecordDecl>(DC));
3223 if (GetImportedOrCreateDecl(D2CXX,
D, Importer.
getToContext(),
3224 D->getTagKind(), DC, *BeginLocOrErr,
Loc,
3225 Name.getAsIdentifierInfo(),
3226 cast_or_null<CXXRecordDecl>(PrevDecl)))
3233 addDeclToContexts(
D, D2);
3236 DCXX->getDescribedClassTemplate()) {
3238 if (Error Err = importInto(ToDescribed, FromDescribed))
3239 return std::move(Err);
3241 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
3261 const Type *FrontTy =
3262 cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
3265 InjSpec = InjTy->getInjectedSpecializationType();
3268 for (
auto *R : Redecls) {
3269 auto *RI = cast<CXXRecordDecl>(R);
3270 if (R != Redecls.front() ||
3271 !isa<InjectedClassNameType>(RI->getTypeForDecl()))
3272 RI->setTypeForDecl(
nullptr);
3287 DCXX->getMemberSpecializationInfo()) {
3289 MemberInfo->getTemplateSpecializationKind();
3295 return ToInstOrErr.takeError();
3298 import(MemberInfo->getPointOfInstantiation()))
3302 return POIOrErr.takeError();
3307 D->getTagKind(), DC, *BeginLocOrErr,
Loc,
3308 Name.getAsIdentifierInfo(), PrevDecl))
3311 addDeclToContexts(
D, D2);
3314 if (
auto BraceRangeOrErr =
import(
D->getBraceRange()))
3317 return BraceRangeOrErr.takeError();
3318 if (
auto QualifierLocOrErr =
import(
D->getQualifierLoc()))
3321 return QualifierLocOrErr.takeError();
3323 if (
D->isAnonymousStructOrUnion())
3326 if (
D->isCompleteDefinition())
3328 return std::move(Err);
3340 return std::move(Err);
3349 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3350 for (
auto *FoundDecl : FoundDecls) {
3354 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3357 ConflictingDecls.push_back(FoundDecl);
3361 if (!ConflictingDecls.empty()) {
3363 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3365 Name = NameOrErr.get();
3367 return NameOrErr.takeError();
3373 return TypeOrErr.takeError();
3377 return InitOrErr.takeError();
3380 if (GetImportedOrCreateDecl(
3382 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr,
D->getInitVal()))
3383 return ToEnumerator;
3388 return ToEnumerator;
3391template <
typename DeclTy>
3394 unsigned int Num = FromD->getNumTemplateParameterLists();
3396 return Error::success();
3398 for (
unsigned int I = 0; I <
Num; ++I)
3400 import(FromD->getTemplateParameterList(I)))
3401 ToTPLists[I] = *ToTPListOrErr;
3403 return ToTPListOrErr.takeError();
3404 ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3405 return Error::success();
3413 return Error::success();
3419 return Error::success();
3425 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3427 return InstFDOrErr.takeError();
3433 return POIOrErr.takeError();
3435 return Error::success();
3439 auto FunctionAndArgsOrErr =
3441 if (!FunctionAndArgsOrErr)
3442 return FunctionAndArgsOrErr.takeError();
3445 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3449 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3450 if (FromTAArgsAsWritten)
3452 *FromTAArgsAsWritten, ToTAInfo))
3455 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3457 return POIOrErr.takeError();
3463 ToFD->setFunctionTemplateSpecialization(
3464 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3465 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3466 return Error::success();
3474 Candidates.
addDecl(*ToFTDOrErr);
3476 return ToFTDOrErr.takeError();
3481 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3482 if (FromTAArgsAsWritten)
3489 FromTAArgsAsWritten ? &ToTAInfo :
nullptr);
3490 return Error::success();
3493 llvm_unreachable(
"All cases should be covered!");
3498 auto FunctionAndArgsOrErr =
3500 if (!FunctionAndArgsOrErr)
3501 return FunctionAndArgsOrErr.takeError();
3505 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3506 void *InsertPos =
nullptr;
3517 return ToBodyOrErr.takeError();
3519 return Error::success();
3528 assert(DCi &&
"Declaration should have a context");
3542 ToProcess.push_back(S);
3543 while (!ToProcess.empty()) {
3544 const Stmt *CurrentS = ToProcess.pop_back_val();
3546 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS)) {
3547 if (
const Decl *
D = DeclRef->getDecl())
3550 }
else if (
const auto *
E =
3551 dyn_cast_or_null<SubstNonTypeTemplateParmExpr>(CurrentS)) {
3552 if (
const Decl *
D =
E->getAssociatedDecl())
3585class IsTypeDeclaredInsideVisitor
3586 :
public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3588 IsTypeDeclaredInsideVisitor(
const FunctionDecl *ParentDC)
3589 : ParentDC(ParentDC) {}
3595 if (std::optional<bool> Res = Visit(
T.getTypePtr()))
3598 T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3600 if (std::optional<bool> Res = Visit(DsT.
getTypePtr()))
3603 DsT =
T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3608 std::optional<bool> VisitTagType(
const TagType *
T) {
3609 if (
auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(
T->getDecl()))
3610 for (
const auto &Arg : Spec->getTemplateArgs().asArray())
3611 if (checkTemplateArgument(Arg))
3616 std::optional<bool> VisitPointerType(
const PointerType *
T) {
3621 return CheckType(
T->getPointeeTypeAsWritten());
3624 std::optional<bool> VisitTypedefType(
const TypedefType *
T) {
3630 std::optional<bool> VisitUsingType(
const UsingType *
T) {
3631 if (
T->getFoundDecl() &&
3640 for (
const auto &Arg :
T->template_arguments())
3641 if (checkTemplateArgument(Arg))
3648 return CheckType(
T->getBaseType());
3663 return CheckType(
T->getElementType());
3668 "Variable array should not occur in deduced return type of a function");
3672 llvm_unreachable(
"Incomplete array should not occur in deduced return type "
3677 llvm_unreachable(
"Dependent array should not occur in deduced return type "
3704 if (checkTemplateArgument(PackArg))
3716 llvm_unreachable(
"Unknown TemplateArgument::ArgKind enum");
3726 assert(FromFPT &&
"Must be called on FunctionProtoType");
3728 auto IsCXX11Lambda = [&]() {
3729 if (Importer.FromContext.
getLangOpts().CPlusPlus14)
3732 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
D))
3733 return cast<CXXRecordDecl>(MD->getDeclContext())->isLambda();
3738 QualType RetT = FromFPT->getReturnType();
3739 if (isa<AutoType>(RetT.
getTypePtr()) || IsCXX11Lambda()) {
3741 IsTypeDeclaredInsideVisitor Visitor(Def ? Def :
D);
3742 return Visitor.CheckType(RetT);
3759 auto RedeclIt = Redecls.begin();
3762 for (; RedeclIt != Redecls.end() && *RedeclIt !=
D; ++RedeclIt) {
3765 return ToRedeclOrErr.takeError();
3767 assert(*RedeclIt ==
D);
3775 return std::move(Err);
3787 if (
D->getTemplatedKind() ==
3790 if (!FoundFunctionOrErr)
3791 return FoundFunctionOrErr.takeError();
3792 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3793 if (
Decl *Def = FindAndMapDefinition(
D, FoundFunction))
3795 FoundByLookup = FoundFunction;
3803 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3804 for (
auto *FoundDecl : FoundDecls) {
3808 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3813 if (
Decl *Def = FindAndMapDefinition(
D, FoundFunction))
3815 FoundByLookup = FoundFunction;
3826 Importer.
ToDiag(
Loc, diag::warn_odr_function_type_inconsistent)
3827 << Name <<
D->getType() << FoundFunction->getType();
3828 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3829 << FoundFunction->getType();
3830 ConflictingDecls.push_back(FoundDecl);
3834 if (!ConflictingDecls.empty()) {
3836 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3838 Name = NameOrErr.get();
3840 return NameOrErr.takeError();
3850 if (FoundByLookup) {
3851 if (isa<CXXMethodDecl>(FoundByLookup)) {
3853 if (!
D->doesThisDeclarationHaveABody()) {
3855 D->getDescribedFunctionTemplate()) {
3860 "Templated function mapped to non-templated?");
3876 return std::move(Err);
3887 bool UsedDifferentProtoType =
false;
3889 QualType FromReturnTy = FromFPT->getReturnType();
3897 UsedDifferentProtoType =
true;
3908 FromEPI = DefaultEPI;
3909 UsedDifferentProtoType =
true;
3912 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3917 Error Err = Error::success();
3920 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
3924 auto TrailingRequiresClause =
3927 return std::move(Err);
3931 for (
auto *
P :
D->parameters()) {
3933 Parameters.push_back(*ToPOrErr);
3935 return ToPOrErr.takeError();
3940 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(
D)) {
3942 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3944 return std::move(Err);
3946 if (FromConstructor->isInheritingConstructor()) {
3948 import(FromConstructor->getInheritedConstructor());
3949 if (!ImportedInheritedCtor)
3950 return ImportedInheritedCtor.takeError();
3951 ToInheritedConstructor = *ImportedInheritedCtor;
3953 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3954 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3955 ToInnerLocStart, NameInfo,
T, TInfo, ESpec,
D->UsesFPIntrin(),
3956 D->isInlineSpecified(),
D->
isImplicit(),
D->getConstexprKind(),
3957 ToInheritedConstructor, TrailingRequiresClause))
3961 Error Err = Error::success();
3963 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3964 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3966 return std::move(Err);
3968 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3969 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3970 ToInnerLocStart, NameInfo,
T, TInfo,
D->UsesFPIntrin(),
3971 D->isInlineSpecified(),
D->
isImplicit(),
D->getConstexprKind(),
3972 TrailingRequiresClause))
3979 dyn_cast<CXXConversionDecl>(
D)) {
3981 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3983 return std::move(Err);
3984 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3985 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3986 ToInnerLocStart, NameInfo,
T, TInfo,
D->UsesFPIntrin(),
3987 D->isInlineSpecified(), ESpec,
D->getConstexprKind(),
3990 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(
D)) {
3991 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3992 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3993 ToInnerLocStart, NameInfo,
T, TInfo, Method->getStorageClass(),
3994 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3997 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(
D)) {
3999 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
4003 return std::move(Err);
4004 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
4005 ToFunction,
D, Importer.
getToContext(), DC, ToInnerLocStart, ESpec,
4006 NameInfo,
T, TInfo, ToEndLoc, Ctor))
4008 cast<CXXDeductionGuideDecl>(ToFunction)
4009 ->setDeductionCandidateKind(Guide->getDeductionCandidateKind());
4011 if (GetImportedOrCreateDecl(
4012 ToFunction,
D, Importer.
getToContext(), DC, ToInnerLocStart,
4013 NameInfo,
T, TInfo,
D->getStorageClass(),
D->UsesFPIntrin(),
4014 D->isInlineSpecified(),
D->hasWrittenPrototype(),
4015 D->getConstexprKind(), TrailingRequiresClause))
4020 if (FoundByLookup) {
4033 auto Imported =
import(Msg);
4035 return Imported.takeError();
4049 D->FriendConstraintRefersToEnclosingTemplate());
4059 for (
auto *Param : Parameters) {
4060 Param->setOwningFunction(ToFunction);
4065 ToFunction->setParams(Parameters);
4072 for (
unsigned I = 0, N = Parameters.size(); I != N; ++I)
4073 ProtoLoc.setParam(I, Parameters[I]);
4079 auto ToFTOrErr =
import(FromFT);
4081 return ToFTOrErr.takeError();
4085 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(
D)) {
4086 if (
unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
4090 FromConstructor->inits(), CtorInitializers))
4091 return std::move(Err);
4094 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
4095 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
4096 ToCtor->setCtorInitializers(Memory);
4097 ToCtor->setNumCtorInitializers(NumInitializers);
4103 return std::move(Err);
4105 if (
auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(
D))
4108 return std::move(Err);
4110 if (
D->doesThisDeclarationHaveABody()) {
4114 return std::move(Err);
4118 if (UsedDifferentProtoType) {
4120 ToFunction->
setType(*TyOrErr);
4122 return TyOrErr.takeError();
4126 return TSIOrErr.takeError();
4131 addDeclToContexts(
D, ToFunction);
4134 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4137 return ToRedeclOrErr.takeError();
4171 return std::move(Err);
4176 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4177 for (
auto *FoundDecl : FoundDecls) {
4178 if (
FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
4186 FoundField->getType())) {
4194 if (
Expr *FromInitializer =
D->getInClassInitializer()) {
4195 if (
ExpectedExpr ToInitializerOrErr =
import(FromInitializer)) {
4198 assert(FoundField->hasInClassInitializer() &&
4199 "Field should have an in-class initializer if it has an "
4200 "expression for it.");
4201 if (!FoundField->getInClassInitializer())
4202 FoundField->setInClassInitializer(*ToInitializerOrErr);
4204 return ToInitializerOrErr.takeError();
4211 Importer.
ToDiag(
Loc, diag::warn_odr_field_type_inconsistent)
4212 << Name <<
D->getType() << FoundField->getType();
4213 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4214 << FoundField->getType();
4220 Error Err = Error::success();
4224 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4226 return std::move(Err);
4227 const Type *ToCapturedVLAType =
nullptr;
4229 ToCapturedVLAType, cast_or_null<Type>(
D->getCapturedVLAType())))
4230 return std::move(Err);
4233 if (GetImportedOrCreateDecl(ToField,
D, Importer.
getToContext(), DC,
4234 ToInnerLocStart,
Loc, Name.getAsIdentifierInfo(),
4235 ToType, ToTInfo, ToBitWidth,
D->isMutable(),
4236 D->getInClassInitStyle()))
4242 if (ToCapturedVLAType)
4247 auto ToInitializer =
importChecked(Err,
D->getInClassInitializer());
4249 return std::move(Err);
4250 if (ToInitializer) {
4252 if (AlreadyImported)
4253 assert(ToInitializer == AlreadyImported &&
4254 "Duplicate import of in-class initializer.");
4269 return std::move(Err);
4274 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4275 for (
unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4276 if (
auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
4284 FoundField->getType(),
4291 if (!Name && I < N-1)
4295 Importer.
ToDiag(
Loc, diag::warn_odr_field_type_inconsistent)
4296 << Name <<
D->getType() << FoundField->getType();
4297 Importer.
ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4298 << FoundField->getType();
4305 auto TypeOrErr =
import(
D->getType());
4307 return TypeOrErr.takeError();
4313 for (
auto *PI :
D->chain())
4315 NamedChain[i++] = *ToD;
4317 return ToD.takeError();
4321 if (GetImportedOrCreateDecl(ToIndirectField,
D, Importer.
getToContext(), DC,
4322 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
4324 return ToIndirectField;
4329 return ToIndirectField;
4354 return Ctx.IsEquivalent(FD1, FD2);
4359 unsigned int FriendCount = 0;
4360 std::optional<unsigned int> FriendPosition;
4363 for (
FriendDecl *FoundFriend : RD->friends()) {
4364 if (FoundFriend == FD) {
4365 FriendPosition = FriendCount;
4372 assert(FriendPosition &&
"Friend decl not found in own parent.");
4374 return {FriendCount, *FriendPosition};
4381 return std::move(Err);
4386 const auto *RD = cast<CXXRecordDecl>(DC);
4388 for (
FriendDecl *ImportedFriend : RD->friends())
4390 ImportedEquivalentFriends.push_back(ImportedFriend);
4395 assert(ImportedEquivalentFriends.size() <= CountAndPosition.
TotalCount &&
4396 "Class with non-matching friends is imported, ODR check wrong?");
4397 if (ImportedEquivalentFriends.size() == CountAndPosition.
TotalCount)
4399 D, ImportedEquivalentFriends[CountAndPosition.
IndexOfDecl]);
4404 if (
NamedDecl *FriendD =
D->getFriendDecl()) {
4406 if (Error Err = importInto(ToFriendD, FriendD))
4407 return std::move(Err);
4415 if (
auto TSIOrErr =
import(
D->getFriendType()))
4418 return TSIOrErr.takeError();
4423 for (
unsigned I = 0; I <
D->NumTPLists; I++) {
4424 if (
auto ListOrErr =
import(FromTPLists[I]))
4425 ToTPLists[I] = *ListOrErr;
4427 return ListOrErr.takeError();
4432 return LocationOrErr.takeError();
4433 auto FriendLocOrErr =
import(
D->getFriendLoc());
4434 if (!FriendLocOrErr)
4435 return FriendLocOrErr.takeError();
4436 auto EllipsisLocOrErr =
import(
D->getEllipsisLoc());
4437 if (!EllipsisLocOrErr)
4438 return EllipsisLocOrErr.takeError();
4441 if (GetImportedOrCreateDecl(FrD,
D, Importer.
getToContext(), DC,
4442 *LocationOrErr, ToFU, *FriendLocOrErr,
4443 *EllipsisLocOrErr, ToTPLists))
4459 return std::move(Err);
4464 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4465 for (
auto *FoundDecl : FoundDecls) {
4466 if (
ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
4468 FoundIvar->getType())) {
4473 Importer.
ToDiag(
Loc, diag::warn_odr_ivar_type_inconsistent)
4474 << Name <<
D->getType() << FoundIvar->getType();
4475 Importer.
ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
4476 << FoundIvar->getType();
4482 Error Err = Error::success();
4484 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4486 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4488 return std::move(Err);
4491 if (GetImportedOrCreateDecl(
4492 ToIvar,
D, Importer.
getToContext(), cast<ObjCContainerDecl>(DC),
4493 ToInnerLocStart,
Loc, Name.getAsIdentifierInfo(),
4494 ToType, ToTypeSourceInfo,
4495 D->getAccessControl(),ToBitWidth,
D->getSynthesize()))
4506 auto RedeclIt = Redecls.begin();
4509 for (; RedeclIt != Redecls.end() && *RedeclIt !=
D; ++RedeclIt) {
4512 return RedeclOrErr.takeError();
4514 assert(*RedeclIt ==
D);
4522 return std::move(Err);
4528 VarDecl *FoundByLookup =
nullptr;
4529 if (
D->isFileVarDecl()) {
4532 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4533 for (
auto *FoundDecl : FoundDecls) {
4537 if (
auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4541 FoundVar->getType())) {
4546 if (
D->isThisDeclarationADefinition() && FoundDef)
4553 const VarDecl *FoundDInit =
nullptr;
4554 if (
D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
4558 FoundByLookup = FoundVar;
4566 if (FoundArray && TArray) {
4567 if (isa<IncompleteArrayType>(FoundArray) &&
4568 isa<ConstantArrayType>(TArray)) {
4570 if (
auto TyOrErr =
import(
D->getType()))
4571 FoundVar->setType(*TyOrErr);
4573 return TyOrErr.takeError();
4575 FoundByLookup = FoundVar;
4577 }
else if (isa<IncompleteArrayType>(TArray) &&
4578 isa<ConstantArrayType>(FoundArray)) {
4579 FoundByLookup = FoundVar;
4584 Importer.
ToDiag(
Loc, diag::warn_odr_variable_type_inconsistent)
4585 << Name <<
D->getType() << FoundVar->getType();
4586 Importer.
ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4587 << FoundVar->getType();
4588 ConflictingDecls.push_back(FoundDecl);
4592 if (!ConflictingDecls.empty()) {
4594 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4596 Name = NameOrErr.get();
4598 return NameOrErr.takeError();
4602 Error Err = Error::success();
4604 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4605 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4608 return std::move(Err);
4611 if (
auto *FromDecomp = dyn_cast<DecompositionDecl>(
D)) {
4615 return std::move(Err);
4617 if (GetImportedOrCreateDecl(
4618 ToDecomp, FromDecomp, Importer.
getToContext(), DC, ToInnerLocStart,
4619 Loc, ToType, ToTypeSourceInfo,
D->getStorageClass(),
Bindings))
4624 if (GetImportedOrCreateDecl(ToVar,
D, Importer.
getToContext(), DC,
4625 ToInnerLocStart,
Loc,
4626 Name.getAsIdentifierInfo(), ToType,
4627 ToTypeSourceInfo,
D->getStorageClass()))
4635 if (
D->isInlineSpecified())
4640 if (FoundByLookup) {
4646 if (
D->getDescribedVarTemplate()) {
4647 auto ToVTOrErr =
import(
D->getDescribedVarTemplate());
4649 return ToVTOrErr.takeError();
4652 VarDecl *FromInst =
D->getInstantiatedFromStaticDataMember();
4656 return ToInstOrErr.takeError();
4657 if (
ExpectedSLoc POIOrErr =
import(MSI->getPointOfInstantiation()))
4660 return POIOrErr.takeError();
4664 return std::move(Err);
4666 if (
D->isConstexpr())
4669 addDeclToContexts(
D, ToVar);
4672 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4675 return RedeclOrErr.takeError();
4686 Error Err = Error::success();
4691 return std::move(Err);
4695 if (GetImportedOrCreateDecl(ToParm,
D, Importer.
getToContext(), DC,
4696 ToLocation, ToDeclName.getAsIdentifierInfo(),
4697 ToType,
D->getParameterKind()))
4708 return LocOrErr.takeError();
4717 return ToDefArgOrErr.takeError();
4721 if (
auto ToDefArgOrErr =
import(FromParam->
getDefaultArg()))
4724 return ToDefArgOrErr.takeError();
4727 return Error::success();
4732 Error Err = Error::success();
4737 return std::move(Err);
4746 Error Err = Error::success();
4749 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
4751 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4753 return std::move(Err);
4756 if (GetImportedOrCreateDecl(ToParm,
D, Importer.
getToContext(), DC,
4757 ToInnerLocStart, ToLocation,
4758 ToDeclName.getAsIdentifierInfo(), ToType,
4759 ToTypeSourceInfo,
D->getStorageClass(),
4767 return std::move(Err);
4769 if (
D->isObjCMethodParameter()) {
4774 D->getFunctionScopeIndex());
4787 return std::move(Err);
4791 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4792 for (
auto *FoundDecl : FoundDecls) {
4793 if (
auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4794 if (FoundMethod->isInstanceMethod() !=
D->isInstanceMethod())
4799 FoundMethod->getReturnType())) {
4800 Importer.
ToDiag(
Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4801 <<
D->isInstanceMethod() << Name <<
D->getReturnType()
4802 << FoundMethod->getReturnType();
4803 Importer.
ToDiag(FoundMethod->getLocation(),
4804 diag::note_odr_objc_method_here)
4805 <<
D->isInstanceMethod() << Name;
4811 if (
D->param_size() != FoundMethod->param_size()) {
4812 Importer.
ToDiag(
Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4813 <<
D->isInstanceMethod() << Name
4814 <<
D->param_size() << FoundMethod->param_size();
4815 Importer.
ToDiag(FoundMethod->getLocation(),
4816 diag::note_odr_objc_method_here)
4817 <<
D->isInstanceMethod() << Name;
4824 PEnd =
D->param_end(), FoundP = FoundMethod->param_begin();
4825 P != PEnd; ++
P, ++FoundP) {
4827 (*FoundP)->getType())) {
4828 Importer.
FromDiag((*P)->getLocation(),
4829 diag::warn_odr_objc_method_param_type_inconsistent)
4830 <<
D->isInstanceMethod() << Name
4831 << (*P)->getType() << (*FoundP)->getType();
4832 Importer.
ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4833 << (*FoundP)->getType();
4841 if (
D->isVariadic() != FoundMethod->isVariadic()) {
4842 Importer.
ToDiag(
Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4843 <<
D->isInstanceMethod() << Name;
4844 Importer.
ToDiag(FoundMethod->getLocation(),
4845 diag::note_odr_objc_method_here)
4846 <<
D->isInstanceMethod() << Name;
4856 Error Err = Error::success();
4859 auto ToReturnTypeSourceInfo =
4862 return std::move(Err);
4865 if (GetImportedOrCreateDecl(
4867 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4868 D->isInstanceMethod(),
D->isVariadic(),
D->isPropertyAccessor(),
4869 D->isSynthesizedAccessorStub(),
D->
isImplicit(),
D->isDefined(),
4870 D->getImplementationControl(),
D->hasRelatedResultType()))
4878 for (
auto *FromP :
D->parameters()) {
4880 ToParams.push_back(*ToPOrErr);
4882 return ToPOrErr.takeError();
4886 for (
auto *ToParam : ToParams) {
4887 ToParam->setOwningFunction(ToMethod);
4892 D->getSelectorLocs(FromSelLocs);
4895 return std::move(Err);
4905 if (
D->getSelfDecl())
4919 return std::move(Err);
4923 Error Err = Error::success();
4927 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
4929 return std::move(Err);
4932 if (GetImportedOrCreateDecl(
4934 ToVarianceLoc,
D->getIndex(),
4935 ToLocation, Name.getAsIdentifierInfo(),
4936 ToColonLoc, ToTypeSourceInfo))
4942 return std::move(Err);
4943 Result->setTypeForDecl(ToTypeForDecl);
4944 Result->setLexicalDeclContext(LexicalDC);
4955 return std::move(Err);
4960 if (Error Err = importInto(ToInterface,
D->getClassInterface()))
4961 return std::move(Err);
4969 Error Err = Error::success();
4971 auto ToCategoryNameLoc =
importChecked(Err,
D->getCategoryNameLoc());
4972 auto ToIvarLBraceLoc =
importChecked(Err,
D->getIvarLBraceLoc());
4973 auto ToIvarRBraceLoc =
importChecked(Err,
D->getIvarRBraceLoc());
4975 return std::move(Err);
4977 if (GetImportedOrCreateDecl(ToCategory,
D, Importer.
getToContext(), DC,
4980 Name.getAsIdentifierInfo(), ToInterface,
4993 return PListOrErr.takeError();
4999 =
D->protocol_loc_begin();
5001 FromProtoEnd =
D->protocol_end();
5002 FromProto != FromProtoEnd;
5003 ++FromProto, ++FromProtoLoc) {
5005 Protocols.push_back(*ToProtoOrErr);
5007 return ToProtoOrErr.takeError();
5009 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5010 ProtocolLocs.push_back(*ToProtoLocOrErr);
5012 return ToProtoLocOrErr.takeError();
5025 return std::move(Err);
5028 if (
D->getImplementation()) {
5030 import(
D->getImplementation()))
5033 return ToImplOrErr.takeError();
5045 return Error::success();
5058 FromProto != FromProtoEnd;
5059 ++FromProto, ++FromProtoLoc) {
5061 Protocols.push_back(*ToProtoOrErr);
5063 return ToProtoOrErr.takeError();
5065 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5066 ProtocolLocs.push_back(*ToProtoLocOrErr);
5068 return ToProtoLocOrErr.takeError();
5081 return Error::success();
5093 return ImportedDefOrErr.takeError();
5102 return std::move(Err);
5107 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5108 for (
auto *FoundDecl : FoundDecls) {
5112 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
5118 auto ToAtBeginLocOrErr =
import(
D->getAtStartLoc());
5119 if (!ToAtBeginLocOrErr)
5120 return ToAtBeginLocOrErr.takeError();
5122 if (GetImportedOrCreateDecl(ToProto,
D, Importer.
getToContext(), DC,
5123 Name.getAsIdentifierInfo(),
Loc,
5133 if (
D->isThisDeclarationADefinition())
5135 return std::move(Err);
5143 return std::move(Err);
5146 if (!ExternLocOrErr)
5147 return ExternLocOrErr.takeError();
5151 return LangLocOrErr.takeError();
5153 bool HasBraces =
D->hasBraces();
5156 if (GetImportedOrCreateDecl(ToLinkageSpec,
D, Importer.
getToContext(), DC,
5157 *ExternLocOrErr, *LangLocOrErr,
5158 D->getLanguage(), HasBraces))
5159 return ToLinkageSpec;
5163 if (!RBraceLocOrErr)
5164 return RBraceLocOrErr.takeError();
5171 return ToLinkageSpec;
5182 return ToShadowOrErr.takeError();
5193 return std::move(Err);
5197 Error Err = Error::success();
5202 return std::move(Err);
5206 return std::move(Err);
5209 if (GetImportedOrCreateDecl(ToUsing,
D, Importer.
getToContext(), DC,
5210 ToUsingLoc, ToQualifierLoc, NameInfo,
5221 ToUsing, *ToPatternOrErr);
5223 return ToPatternOrErr.takeError();
5235 return std::move(Err);
5239 Error Err = Error::success();
5245 return std::move(Err);
5248 if (GetImportedOrCreateDecl(ToUsingEnum,
D, Importer.
getToContext(), DC,
5249 ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType))
5261 return ToPatternOrErr.takeError();
5273 return std::move(Err);
5278 if (!ToIntroducerOrErr)
5279 return ToIntroducerOrErr.takeError();
5283 return ToTargetOrErr.takeError();
5286 if (
auto *FromConstructorUsingShadow =
5287 dyn_cast<ConstructorUsingShadowDecl>(
D)) {
5288 Error Err = Error::success();
5290 Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
5292 return std::move(Err);
5298 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
5300 cast<UsingDecl>(*ToIntroducerOrErr),
5301 Nominated ? Nominated : *ToTargetOrErr,
5302 FromConstructorUsingShadow->constructsVirtualBase()))
5306 Name, *ToIntroducerOrErr, *ToTargetOrErr))
5317 ToShadow, *ToPatternOrErr);
5321 return ToPatternOrErr.takeError();
5335 return std::move(Err);
5339 auto ToComAncestorOrErr = Importer.
ImportContext(
D->getCommonAncestor());
5340 if (!ToComAncestorOrErr)
5341 return ToComAncestorOrErr.takeError();
5343 Error Err = Error::success();
5344 auto ToNominatedNamespace =
importChecked(Err,
D->getNominatedNamespace());
5346 auto ToNamespaceKeyLocation =
5349 auto ToIdentLocation =
importChecked(Err,
D->getIdentLocation());
5351 return std::move(Err);
5354 if (GetImportedOrCreateDecl(ToUsingDir,
D, Importer.
getToContext(), DC,
5356 ToNamespaceKeyLocation,
5359 ToNominatedNamespace, *ToComAncestorOrErr))
5374 return std::move(Err);
5378 auto ToInstantiatedFromUsingOrErr =
5379 Importer.
Import(
D->getInstantiatedFromUsingDecl());
5380 if (!ToInstantiatedFromUsingOrErr)
5381 return ToInstantiatedFromUsingOrErr.takeError();
5384 return std::move(Err);
5387 if (GetImportedOrCreateDecl(ToUsingPack,
D, Importer.
getToContext(), DC,
5388 cast<NamedDecl>(*ToInstantiatedFromUsingOrErr),
5392 addDeclToContexts(
D, ToUsingPack);
5404 return std::move(Err);
5408 Error Err = Error::success();
5414 return std::move(Err);
5418 return std::move(Err);
5421 if (GetImportedOrCreateDecl(ToUsingValue,
D, Importer.
getToContext(), DC,
5422 ToUsingLoc, ToQualifierLoc, NameInfo,
5424 return ToUsingValue;
5430 return ToUsingValue;
5440 return std::move(Err);
5444 Error Err = Error::success();
5450 return std::move(Err);
5453 if (GetImportedOrCreateDecl(ToUsing,
D, Importer.
getToContext(), DC,
5454 ToUsingLoc, ToTypenameLoc,
5455 ToQualifierLoc,
Loc, Name, ToEllipsisLoc))
5466 Decl* ToD =
nullptr;
5467 switch (
D->getBuiltinTemplateKind()) {
5478 assert(ToD &&
"BuiltinTemplateDecl of unsupported kind!");
5489 if (
auto FromSuperOrErr =
import(FromSuper))
5490 FromSuper = *FromSuperOrErr;
5492 return FromSuperOrErr.takeError();
5496 if ((
bool)FromSuper != (
bool)ToSuper ||
5499 diag::warn_odr_objc_superclass_inconsistent)
5506 diag::note_odr_objc_missing_superclass);
5509 diag::note_odr_objc_superclass)
5513 diag::note_odr_objc_missing_superclass);
5519 return Error::success();
5530 return SuperTInfoOrErr.takeError();
5541 FromProto != FromProtoEnd;
5542 ++FromProto, ++FromProtoLoc) {
5544 Protocols.push_back(*ToProtoOrErr);
5546 return ToProtoOrErr.takeError();
5548 if (
ExpectedSLoc ToProtoLocOrErr =
import(*FromProtoLoc))
5549 ProtocolLocs.push_back(*ToProtoLocOrErr);
5551 return ToProtoLocOrErr.takeError();
5562 auto ToCatOrErr =
import(Cat);
5564 return ToCatOrErr.takeError();
5573 return ToImplOrErr.takeError();
5580 return Error::success();
5589 for (
auto *fromTypeParam : *list) {
5590 if (
auto toTypeParamOrErr =
import(fromTypeParam))
5591 toTypeParams.push_back(*toTypeParamOrErr);
5593 return toTypeParamOrErr.takeError();
5597 if (!LAngleLocOrErr)
5598 return LAngleLocOrErr.takeError();
5601 if (!RAngleLocOrErr)
5602 return RAngleLocOrErr.takeError();
5619 return ImportedDefOrErr.takeError();
5628 return std::move(Err);
5634 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5635 for (
auto *FoundDecl : FoundDecls) {
5639 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
5647 if (!AtBeginLocOrErr)
5648 return AtBeginLocOrErr.takeError();
5650 if (GetImportedOrCreateDecl(
5652 *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
5654 nullptr,
Loc,
D->isImplicitInterfaceDecl()))
5662 if (
auto ToPListOrErr =
5666 return ToPListOrErr.takeError();
5668 if (
D->isThisDeclarationADefinition())
5670 return std::move(Err);
5678 if (Error Err = importInto(
Category,
D->getCategoryDecl()))
5679 return std::move(Err);
5685 return std::move(Err);
5687 Error Err = Error::success();
5690 auto ToCategoryNameLoc =
importChecked(Err,
D->getCategoryNameLoc());
5692 return std::move(Err);
5694 if (GetImportedOrCreateDecl(
5697 ToLocation, ToAtStartLoc, ToCategoryNameLoc))
5702 Category->setImplementation(ToImpl);
5707 return std::move(Err);
5716 if (Error Err = importInto(Iface,
D->getClassInterface()))
5717 return std::move(Err);
5721 if (Error Err = importInto(Super,
D->getSuperClass()))
5722 return std::move(Err);
5730 return std::move(Err);
5732 Error Err = Error::success();
5735 auto ToSuperClassLoc =
importChecked(Err,
D->getSuperClassLoc());
5736 auto ToIvarLBraceLoc =
importChecked(Err,
D->getIvarLBraceLoc());
5737 auto ToIvarRBraceLoc =
importChecked(Err,
D->getIvarRBraceLoc());
5739 return std::move(Err);
5741 if (GetImportedOrCreateDecl(Impl,
D, Importer.
getToContext(),
5765 diag::warn_odr_objc_superclass_inconsistent)
5771 diag::note_odr_objc_superclass)
5775 diag::note_odr_objc_missing_superclass);
5776 if (
D->getSuperClass())
5778 diag::note_odr_objc_superclass)
5779 <<
D->getSuperClass()->getDeclName();
5782 diag::note_odr_objc_missing_superclass);
5790 return std::move(Err);
5802 return std::move(Err);
5807 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5808 for (
auto *FoundDecl : FoundDecls) {
5809 if (
auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
5812 if (FoundProp->isInstanceProperty() !=
D->isInstanceProperty())
5817 FoundProp->getType())) {
5818 Importer.
ToDiag(
Loc, diag::warn_odr_objc_property_type_inconsistent)
5819 << Name <<
D->getType() << FoundProp->getType();
5820 Importer.
ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
5821 << FoundProp->getType();
5834 Error Err = Error::success();
5836 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
5840 return std::move(Err);
5844 if (GetImportedOrCreateDecl(
5846 Name.getAsIdentifierInfo(), ToAtLoc,
5847 ToLParenLoc, ToType,
5848 ToTypeSourceInfo,
D->getPropertyImplementation()))
5853 auto ToGetterNameLoc =
importChecked(Err,
D->getGetterNameLoc());
5854 auto ToSetterNameLoc =
importChecked(Err,
D->getSetterNameLoc());
5855 auto ToGetterMethodDecl =
importChecked(Err,
D->getGetterMethodDecl());
5856 auto ToSetterMethodDecl =
importChecked(Err,
D->getSetterMethodDecl());
5857 auto ToPropertyIvarDecl =
importChecked(Err,
D->getPropertyIvarDecl());
5859 return std::move(Err);
5866 D->getPropertyAttributesAsWritten());
5878 if (Error Err = importInto(
Property,
D->getPropertyDecl()))
5879 return std::move(Err);
5883 return std::move(Err);
5885 auto *InImpl = cast<ObjCImplDecl>(LexicalDC);
5889 if (Error Err = importInto(Ivar,
D->getPropertyIvarDecl()))
5890 return std::move(Err);
5893 = InImpl->FindPropertyImplDecl(
Property->getIdentifier(),
5897 Error Err = Error::success();
5900 auto ToPropertyIvarDeclLoc =
5903 return std::move(Err);
5905 if (GetImportedOrCreateDecl(ToImpl,
D, Importer.
getToContext(), DC,
5908 D->getPropertyImplementation(), Ivar,
5909 ToPropertyIvarDeclLoc))
5919 diag::warn_odr_objc_property_impl_kind_inconsistent)
5924 diag::note_odr_objc_property_impl_kind)
5925 <<
D->getPropertyDecl()->getDeclName()
5935 diag::warn_odr_objc_synthesize_ivar_inconsistent)
5939 Importer.
FromDiag(
D->getPropertyIvarDeclLoc(),
5940 diag::note_odr_objc_synthesize_ivar_here)
5941 <<
D->getPropertyIvarDecl()->getDeclName();
5961 return BeginLocOrErr.takeError();
5965 return LocationOrErr.takeError();
5968 if (GetImportedOrCreateDecl(
5971 *BeginLocOrErr, *LocationOrErr,
5972 D->getDepth(),
D->getIndex(), Importer.
Import(
D->getIdentifier()),
5974 D->hasTypeConstraint()))
5980 Error Err = Error::success();
5981 auto ToConceptRef =
importChecked(Err, TC->getConceptReference());
5982 auto ToIDC =
importChecked(Err, TC->getImmediatelyDeclaredConstraint());
5984 return std::move(Err);
5989 if (Error Err = importTemplateParameterDefaultArgument(
D, ToD))
5998 Error Err = Error::success();
6002 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
6003 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
6005 return std::move(Err);
6008 if (GetImportedOrCreateDecl(ToD,
D, Importer.
getToContext(),
6010 ToInnerLocStart, ToLocation,
D->getDepth(),
6012 ToDeclName.getAsIdentifierInfo(), ToType,
6016 Err = importTemplateParameterDefaultArgument(
D, ToD);
6026 auto NameOrErr =
import(
D->getDeclName());
6028 return NameOrErr.takeError();
6033 return LocationOrErr.takeError();
6036 auto TemplateParamsOrErr =
import(
D->getTemplateParameters());
6037 if (!TemplateParamsOrErr)
6038 return TemplateParamsOrErr.takeError();
6041 if (GetImportedOrCreateDecl(
6045 (*NameOrErr).getAsIdentifierInfo(),
D->wasDeclaredWithTypename(),
6046 *TemplateParamsOrErr))
6049 if (Error Err = importTemplateParameterDefaultArgument(
D, ToD))
6058 assert(
D->getTemplatedDecl() &&
"Should be called on templates only");
6059 auto *ToTemplatedDef =
D->getTemplatedDecl()->getDefinition();
6060 if (!ToTemplatedDef)
6063 return cast_or_null<T>(TemplateWithDef);
6074 return std::move(Err);
6088 bool DependentFriend = IsDependentFriend(
D);
6095 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6096 for (
auto *FoundDecl : FoundDecls) {
6101 auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(FoundDecl);
6102 if (FoundTemplate) {
6107 bool IgnoreTemplateParmDepth =
6111 IgnoreTemplateParmDepth)) {
6112 if (DependentFriend || IsDependentFriend(FoundTemplate))
6117 if (
D->isThisDeclarationADefinition() && TemplateWithDef)
6120 FoundByLookup = FoundTemplate;
6138 ConflictingDecls.push_back(FoundDecl);
6142 if (!ConflictingDecls.empty()) {
6145 ConflictingDecls.size());
6147 Name = NameOrErr.get();
6149 return NameOrErr.takeError();
6155 auto TemplateParamsOrErr =
import(
D->getTemplateParameters());
6156 if (!TemplateParamsOrErr)
6157 return TemplateParamsOrErr.takeError();
6161 if (Error Err = importInto(ToTemplated, FromTemplated))
6162 return std::move(Err);
6167 *TemplateParamsOrErr, ToTemplated))
6175 addDeclToContexts(
D, D2);
6176 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
6178 if (FoundByLookup) {
6192 "Found decl must have its templated decl set");
6195 if (ToTemplated != PrevTemplated)
6208 if (Error Err = importInto(ClassTemplate,
D->getSpecializedTemplate()))
6209 return std::move(Err);
6214 return std::move(Err);
6220 return std::move(Err);
6223 void *InsertPos =
nullptr;
6226 dyn_cast<ClassTemplatePartialSpecializationDecl>(
D);
6234 return ToTPListOrErr.takeError();
6235 ToTPList = *ToTPListOrErr;
6245 if (
D->isThisDeclarationADefinition() && PrevDefinition) {
6249 for (
auto *FromField :
D->fields()) {
6250 auto ToOrErr =
import(FromField);
6252 return ToOrErr.takeError();
6258 auto ToOrErr =
import(FromM);
6260 return ToOrErr.takeError();
6268 return PrevDefinition;
6279 return BeginLocOrErr.takeError();
6282 return IdLocOrErr.takeError();
6286 if (
const auto *ASTTemplateArgs =
D->getTemplateArgsAsWritten()) {
6288 return std::move(Err);
6295 if (Error Err = importInto(
6297 return std::move(Err);
6300 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
6301 D2,
D, Importer.
getToContext(),
D->getTagKind(), DC, *BeginLocOrErr,
6302 *IdLocOrErr, ToTPList, ClassTemplate,
6305 cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
6310 auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);
6317 PartSpec2->setInstantiatedFromMember(*ToInstOrErr);
6319 return ToInstOrErr.takeError();
6321 updateLookupTableForTemplateParameters(*ToTPList);
6323 if (GetImportedOrCreateDecl(
6325 *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
6346 if (
auto BraceRangeOrErr =
import(
D->getBraceRange()))
6349 return BraceRangeOrErr.takeError();
6352 return std::move(Err);
6355 if (
auto LocOrErr =
import(
D->getQualifierLoc()))
6358 return LocOrErr.takeError();
6360 if (
D->getTemplateArgsAsWritten())
6363 if (
auto LocOrErr =
import(
D->getTemplateKeywordLoc()))
6366 return LocOrErr.takeError();
6368 if (
auto LocOrErr =
import(
D->getExternKeywordLoc()))
6371 return LocOrErr.takeError();
6373 if (
D->getPointOfInstantiation().isValid()) {
6374 if (
auto POIOrErr =
import(
D->getPointOfInstantiation()))
6377 return POIOrErr.takeError();
6382 if (
auto P =
D->getInstantiatedFrom()) {
6383 if (
auto *CTD = dyn_cast<ClassTemplateDecl *>(
P)) {
6384 if (
auto CTDorErr =
import(CTD))
6387 auto *CTPSD = cast<ClassTemplatePartialSpecializationDecl *>(
P);
6388 auto CTPSDOrErr =
import(CTPSD);
6390 return CTPSDOrErr.takeError();
6393 for (
unsigned I = 0; I < DArgs.
size(); ++I) {
6395 if (
auto ArgOrErr =
import(DArg))
6396 D2ArgsVec[I] = *ArgOrErr;
6398 return ArgOrErr.takeError();
6406 if (
D->isCompleteDefinition())
6408 return std::move(Err);
6420 return std::move(Err);
6426 "Variable templates cannot be declared at function scope");
6429 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6431 for (
auto *FoundDecl : FoundDecls) {
6435 if (
VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
6438 D->getTemplatedDecl()))
6445 assert(FoundTemplate->getDeclContext()->isRecord() &&
6446 "Member variable template imported as non-member, "
6447 "inconsistent imported AST?");
6450 if (!
D->isThisDeclarationADefinition())
6453 if (FoundDef &&
D->isThisDeclarationADefinition())
6456 FoundByLookup = FoundTemplate;
6459 ConflictingDecls.push_back(FoundDecl);
6463 if (!ConflictingDecls.empty()) {
6466 ConflictingDecls.size());
6468 Name = NameOrErr.get();
6470 return NameOrErr.takeError();
6473 VarDecl *DTemplated =
D->getTemplatedDecl();
6479 return TypeOrErr.takeError();
6483 if (Error Err = importInto(ToTemplated, DTemplated))
6484 return std::move(Err);
6487 auto TemplateParamsOrErr =
import(
D->getTemplateParameters());
6488 if (!TemplateParamsOrErr)
6489 return TemplateParamsOrErr.takeError();
6493 Name, *TemplateParamsOrErr, ToTemplated))
6502 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
6504 if (FoundByLookup) {
6508 auto *PrevTemplated =
6510 if (ToTemplated != PrevTemplated)
6525 auto RedeclIt = Redecls.begin();
6528 for (; RedeclIt != Redecls.end() && *RedeclIt !=
D; ++RedeclIt) {
6531 return RedeclOrErr.takeError();
6533 assert(*RedeclIt ==
D);
6536 if (Error Err = importInto(VarTemplate,
D->getSpecializedTemplate()))
6537 return std::move(Err);
6542 return std::move(Err);
6547 return BeginLocOrErr.takeError();
6551 return IdLocOrErr.takeError();
6557 return std::move(Err);
6560 void *InsertPos =
nullptr;
6563 if (FoundSpecialization) {
6571 "Member variable template specialization imported as non-member, "
6572 "inconsistent imported AST?");
6575 if (!
D->isThisDeclarationADefinition())
6580 if (FoundDef &&
D->isThisDeclarationADefinition())
6591 if (
const auto *Args =
D->getTemplateArgsAsWritten()) {
6593 return std::move(Err);
6598 if (
auto *FromPartial = dyn_cast<PartVarSpecDecl>(
D)) {
6599 auto ToTPListOrErr =
import(FromPartial->getTemplateParameters());
6601 return ToTPListOrErr.takeError();
6603 PartVarSpecDecl *ToPartial;
6604 if (GetImportedOrCreateDecl(ToPartial,
D, Importer.
getToContext(), DC,
6605 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
6607 D->getStorageClass(), TemplateArgs))
6611 import(FromPartial->getInstantiatedFromMember()))
6614 return ToInstOrErr.takeError();
6616 if (FromPartial->isMemberSpecialization())
6617 ToPartial->setMemberSpecialization();
6625 if (GetImportedOrCreateDecl(D2,
D, Importer.
getToContext(), DC,
6626 *BeginLocOrErr, *IdLocOrErr, VarTemplate,
6627 QualType(),
nullptr,
D->getStorageClass(),
6638 if (Error Err = importInto(
T,
D->getType()))
6639 return std::move(Err);
6642 auto TInfoOrErr =
import(
D->getTypeSourceInfo());
6644 return TInfoOrErr.takeError();
6647 if (
D->getPointOfInstantiation().isValid()) {
6648 if (
ExpectedSLoc POIOrErr =
import(
D->getPointOfInstantiation()))
6651 return POIOrErr.takeError();
6656 if (
D->getTemplateArgsAsWritten())
6659 if (
auto LocOrErr =
import(
D->getQualifierLoc()))
6662 return LocOrErr.takeError();
6664 if (
D->isConstexpr())
6670 return std::move(Err);
6672 if (FoundSpecialization)
6675 addDeclToContexts(
D, D2);
6678 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
6681 return RedeclOrErr.takeError();
6695 return std::move(Err);
6707 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6708 for (
auto *FoundDecl : FoundDecls) {
6712 if (
auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
6718 if (
D->isThisDeclarationADefinition() && TemplateWithDef)
6721 FoundByLookup = FoundTemplate;
6729 auto ParamsOrErr =
import(
D->getTemplateParameters());
6731 return ParamsOrErr.takeError();
6735 if (Error Err = importInto(TemplatedFD,
D->getTemplatedDecl()))
6736 return std::move(Err);
6753 OldParamDC.reserve(Params->
size());
6754 llvm::transform(*Params, std::back_inserter(OldParamDC),
6758 if (GetImportedOrCreateDecl(ToFunc,
D, Importer.
getToContext(), DC,
Loc, Name,
6759 Params, TemplatedFD))
6765 ToFunc->setLexicalDeclContext(LexicalDC);
6766 addDeclToContexts(
D, ToFunc);
6769 if (
LT && !OldParamDC.empty()) {
6770 for (
unsigned int I = 0; I < OldParamDC.size(); ++I)
6774 if (FoundByLookup) {
6779 "Found decl must have its templated decl set");
6780 auto *PrevTemplated =
6782 if (TemplatedFD != PrevTemplated)
6785 ToFunc->setPreviousDecl(Recent);
6796 Importer.
FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
6797 << S->getStmtClassName();
6806 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; I++) {
6810 Names.push_back(ToII);
6813 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; I++) {
6817 Names.push_back(ToII);
6821 for (
unsigned I = 0,
E = S->getNumClobbers(); I !=
E; I++) {
6822 if (
auto ClobberOrErr =
import(S->getClobberStringLiteral(I)))
6823 Clobbers.push_back(*ClobberOrErr);
6825 return ClobberOrErr.takeError();
6830 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; I++) {
6831 if (
auto OutputOrErr =
import(S->getOutputConstraintLiteral(I)))
6832 Constraints.push_back(*OutputOrErr);
6834 return OutputOrErr.takeError();
6837 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; I++) {
6838 if (
auto InputOrErr =
import(S->getInputConstraintLiteral(I)))
6839 Constraints.push_back(*InputOrErr);
6841 return InputOrErr.takeError();
6847 return std::move(Err);
6851 return std::move(Err);
6854 S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6855 return std::move(Err);
6859 return AsmLocOrErr.takeError();
6860 auto AsmStrOrErr =
import(S->getAsmString());
6862 return AsmStrOrErr.takeError();
6863 ExpectedSLoc RParenLocOrErr =
import(S->getRParenLoc());
6864 if (!RParenLocOrErr)
6865 return RParenLocOrErr.takeError();
6878 S->getNumClobbers(),
6886 Error Err = Error::success();
6891 return std::move(Err);
6897 if (!ToSemiLocOrErr)
6898 return ToSemiLocOrErr.takeError();
6900 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6907 return std::move(Err);
6909 ExpectedSLoc ToLBracLocOrErr =
import(S->getLBracLoc());
6910 if (!ToLBracLocOrErr)
6911 return ToLBracLocOrErr.takeError();
6913 ExpectedSLoc ToRBracLocOrErr =
import(S->getRBracLoc());
6914 if (!ToRBracLocOrErr)
6915 return ToRBracLocOrErr.takeError();
6920 *ToLBracLocOrErr, *ToRBracLocOrErr);
6925 Error Err = Error::success();
6930 auto ToEllipsisLoc =
importChecked(Err, S->getEllipsisLoc());
6933 return std::move(Err);
6936 ToCaseLoc, ToEllipsisLoc, ToColonLoc);
6937 ToStmt->setSubStmt(ToSubStmt);
6944 Error Err = Error::success();
6949 return std::move(Err);
6952 ToDefaultLoc, ToColonLoc, ToSubStmt);
6957 Error Err = Error::success();
6962 return std::move(Err);
6965 ToIdentLoc, ToLabelDecl, ToSubStmt);
6970 if (!ToAttrLocOrErr)
6971 return ToAttrLocOrErr.takeError();
6975 return std::move(Err);
6977 if (!ToSubStmtOrErr)
6978 return ToSubStmtOrErr.takeError();
6981 Importer.
getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6986 Error Err = Error::success();
6989 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
6997 return std::move(Err);
7000 ToInit, ToConditionVariable, ToCond, ToLParenLoc,
7001 ToRParenLoc, ToThen, ToElseLoc, ToElse);
7006 Error Err = Error::success();
7008 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7015 return std::move(Err);
7019 ToCond, ToLParenLoc, ToRParenLoc);
7020 ToStmt->setBody(ToBody);
7021 ToStmt->setSwitchLoc(ToSwitchLoc);
7025 for (
SwitchCase *SC = S->getSwitchCaseList(); SC !=
nullptr;
7026 SC = SC->getNextSwitchCase()) {
7029 return ToSCOrErr.takeError();
7030 if (LastChainedSwitchCase)
7033 ToStmt->setSwitchCaseList(*ToSCOrErr);
7034 LastChainedSwitchCase = *ToSCOrErr;
7042 Error Err = Error::success();
7043 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7050 return std::move(Err);
7053 ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
7058 Error Err = Error::success();
7065 return std::move(Err);
7068 ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
7073 Error Err = Error::success();
7076 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7083 return std::move(Err);
7087 ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
7093 Error Err = Error::success();
7098 return std::move(Err);
7101 ToLabel, ToGotoLoc, ToLabelLoc);
7106 Error Err = Error::success();
7111 return std::move(Err);
7114 ToGotoLoc, ToStarLoc, ToTarget);
7118 ExpectedSLoc ToContinueLocOrErr =
import(S->getContinueLoc());
7119 if (!ToContinueLocOrErr)
7120 return ToContinueLocOrErr.takeError();
7125 auto ToBreakLocOrErr =
import(S->getBreakLoc());
7126 if (!ToBreakLocOrErr)
7127 return ToBreakLocOrErr.takeError();
7133 Error Err = Error::success();
7136 auto ToNRVOCandidate =
importChecked(Err, S->getNRVOCandidate());
7138 return std::move(Err);
7146 Error Err = Error::success();
7148 auto ToExceptionDecl =
importChecked(Err, S->getExceptionDecl());
7149 auto ToHandlerBlock =
importChecked(Err, S->getHandlerBlock());
7151 return std::move(Err);
7154 ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
7160 return ToTryLocOrErr.takeError();
7162 ExpectedStmt ToTryBlockOrErr =
import(S->getTryBlock());
7163 if (!ToTryBlockOrErr)
7164 return ToTryBlockOrErr.takeError();
7167 for (
unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
7169 if (
auto ToHandlerOrErr =
import(FromHandler))
7170 ToHandlers[HI] = *ToHandlerOrErr;
7172 return ToHandlerOrErr.takeError();
7176 cast<CompoundStmt>(*ToTryBlockOrErr), ToHandlers);
7181 Error Err = Error::success();
7188 auto ToLoopVarStmt =
importChecked(Err, S->getLoopVarStmt());
7195 return std::move(Err);
7198 ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
7199 ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
7204 Error Err = Error::success();
7211 return std::move(Err);
7222 Error Err = Error::success();
7225 auto ToCatchParamDecl =
importChecked(Err, S->getCatchParamDecl());
7228 return std::move(Err);
7231 ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
7235 ExpectedSLoc ToAtFinallyLocOrErr =
import(S->getAtFinallyLoc());
7236 if (!ToAtFinallyLocOrErr)
7237 return ToAtFinallyLocOrErr.takeError();
7238 ExpectedStmt ToAtFinallyStmtOrErr =
import(S->getFinallyBody());
7239 if (!ToAtFinallyStmtOrErr)
7240 return ToAtFinallyStmtOrErr.takeError();
7242 *ToAtFinallyStmtOrErr);
7247 Error Err = Error::success();
7250 auto ToFinallyStmt =
importChecked(Err, S->getFinallyStmt());
7252 return std::move(Err);
7255 for (
unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
7257 if (
ExpectedStmt ToCatchStmtOrErr =
import(FromCatchStmt))
7258 ToCatchStmts[CI] = *ToCatchStmtOrErr;
7260 return ToCatchStmtOrErr.takeError();
7264 ToAtTryLoc, ToTryBody,
7265 ToCatchStmts.begin(), ToCatchStmts.size(),
7272 Error Err = Error::success();
7273 auto ToAtSynchronizedLoc =
importChecked(Err, S->getAtSynchronizedLoc());
7277 return std::move(Err);
7280 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
7284 ExpectedSLoc ToThrowLocOrErr =
import(S->getThrowLoc());
7285 if (!ToThrowLocOrErr)
7286 return ToThrowLocOrErr.takeError();
7287 ExpectedExpr ToThrowExprOrErr =
import(S->getThrowExpr());
7288 if (!ToThrowExprOrErr)
7289 return ToThrowExprOrErr.takeError();
7291 *ToThrowLocOrErr, *ToThrowExprOrErr);
7298 return ToAtLocOrErr.takeError();
7300 if (!ToSubStmtOrErr)
7301 return ToSubStmtOrErr.takeError();
7316 Error Err = Error::success();
7321 return std::move(Err);
7322 auto ParentContextOrErr = Importer.
ImportContext(
E->getParentContext());
7323 if (!ParentContextOrErr)
7324 return ParentContextOrErr.takeError();
7328 RParenLoc, *ParentContextOrErr);
7333 Error Err = Error::success();
7336 auto ToWrittenTypeInfo =
importChecked(Err,
E->getWrittenTypeInfo());
7340 return std::move(Err);
7343 ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
7344 E->isMicrosoftABI());
7349 Error Err = Error::success();
7357 return std::move(Err);
7364 bool CondIsTrue = !
E->isConditionDependent() &&
E->isConditionTrue();
7367 ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
7368 ToRParenLoc, CondIsTrue);
7372 Error Err = Error::success();
7379 return std::move(Err);
7387 Error Err = Error::success();
7391 const unsigned NumSubExprs =
E->getNumSubExprs();
7395 ToSubExprs.resize(NumSubExprs);
7398 return std::move(Err);
7401 Importer.
getToContext(), ToSubExprs, ToType, ToBeginLoc, ToRParenLoc);
7407 return TypeOrErr.takeError();
7411 return BeginLocOrErr.takeError();
7418 Error Err = Error::success();
7420 Expr *ToControllingExpr =
nullptr;
7422 if (
E->isExprPredicate())
7426 assert((ToControllingExpr || ToControllingType) &&
7427 "Either the controlling expr or type must be nonnull");
7431 return std::move(Err);
7436 return std::move(Err);
7441 return std::move(Err);
7444 if (
E->isResultDependent()) {
7445 if (ToControllingExpr) {
7447 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7452 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7457 if (ToControllingExpr) {
7459 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7464 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7471 Error Err = Error::success();
7476 return std::move(Err);
7479 E->getIdentKind(),
E->isTransparent(),
7485 Error Err = Error::success();
7487 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
7492 return std::move(Err);
7495 if (
E->getDecl() !=
E->getFoundDecl()) {
7496 auto FoundDOrErr =
import(
E->getFoundDecl());
7498 return FoundDOrErr.takeError();
7499 ToFoundD = *FoundDOrErr;
7504 if (
E->hasExplicitTemplateArgs()) {
7507 E->template_arguments(), ToTAInfo))
7508 return std::move(Err);
7509 ToResInfo = &ToTAInfo;
7513 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
7514 E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
7516 if (
E->hadMultipleCandidates())
7517 ToE->setHadMultipleCandidates(
true);
7518 ToE->setIsImmediateEscalating(
E->isImmediateEscalating());
7525 return TypeOrErr.takeError();
7533 return ToInitOrErr.takeError();
7535 ExpectedSLoc ToEqualOrColonLocOrErr =
import(
E->getEqualOrColonLoc());
7536 if (!ToEqualOrColonLocOrErr)
7537 return ToEqualOrColonLocOrErr.takeError();
7541 for (
unsigned I = 1, N =
E->getNumSubExprs(); I < N; I++) {
7543 ToIndexExprs[I - 1] = *ToArgOrErr;
7545 return ToArgOrErr.takeError();
7550 return std::move(Err);
7554 ToIndexExprs, *ToEqualOrColonLocOrErr,
7555 E->usesGNUSyntax(), *ToInitOrErr);
7562 return ToTypeOrErr.takeError();
7565 if (!ToLocationOrErr)
7566 return ToLocationOrErr.takeError();
7569 *ToTypeOrErr, *ToLocationOrErr);
7575 return ToTypeOrErr.takeError();
7578 if (!ToLocationOrErr)
7579 return ToLocationOrErr.takeError();
7582 Importer.
getToContext(),
E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7589 return ToTypeOrErr.takeError();
7592 if (!ToLocationOrErr)
7593 return ToLocationOrErr.takeError();
7597 *ToTypeOrErr, *ToLocationOrErr);
7601 auto ToTypeOrErr =
import(
E->
getType());
7603 return ToTypeOrErr.takeError();
7606 if (!ToSubExprOrErr)
7607 return ToSubExprOrErr.takeError();
7610 *ToSubExprOrErr, *ToTypeOrErr);
7614 auto ToTypeOrErr =
import(
E->
getType());
7616 return ToTypeOrErr.takeError();
7619 if (!ToLocationOrErr)
7620 return ToLocationOrErr.takeError();
7623 Importer.
getToContext(),
E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
7630 return ToTypeOrErr.takeError();
7633 if (!ToLocationOrErr)
7634 return ToLocationOrErr.takeError();
7637 E->getValue(),
E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
7643 return ToTypeOrErr.takeError();
7647 E->tokloc_begin(),
E->tokloc_end(), ToLocations.begin()))
7648 return std::move(Err);
7652 *ToTypeOrErr, ToLocations.data(), ToLocations.size());
7657 Error Err = Error::success();
7659 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
7663 return std::move(Err);
7667 ToInitializer,
E->isFileScope());
7672 Error Err = Error::success();
7677 return std::move(Err);
7681 E->getSubExprs(),
E->getSubExprs() +
E->getNumSubExprs(),
7683 return std::move(Err);
7687 ToBuiltinLoc, ToExprs, ToType,
E->getOp(), ToRParenLoc);
7691 Error Err = Error::success();
7697 return std::move(Err);
7700 ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
7703 Error Err = Error::success();
7707 return std::move(Err);
7712 Error Err = Error::success();
7717 return std::move(Err);
7720 ParenExpr(ToLParen, ToRParen, ToSubExpr);
7726 return std::move(Err);
7729 if (!ToLParenLocOrErr)
7730 return ToLParenLocOrErr.takeError();
7733 if (!ToRParenLocOrErr)
7734 return ToRParenLocOrErr.takeError();
7737 ToExprs, *ToRParenLocOrErr);
7741 Error Err = Error::success();
7747 return std::move(Err);
7750 StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
7751 E->getTemplateDepth());
7755 Error Err = Error::success();
7760 return std::move(Err);
7763 E->hasStoredFPFeatures());
7764 UO->setType(ToType);
7765 UO->setSubExpr(ToSubExpr);
7766 UO->setOpcode(
E->getOpcode());
7767 UO->setOperatorLoc(ToOperatorLoc);
7768 UO->setCanOverflow(
E->canOverflow());
7769 if (
E->hasStoredFPFeatures())
7770 UO->setStoredFPFeatures(
E->getStoredFPFeatures());
7778 Error Err = Error::success();
7783 return std::move(Err);
7785 if (
E->isArgumentType()) {
7787 import(
E->getArgumentTypeInfo());
7788 if (!ToArgumentTypeInfoOrErr)
7789 return ToArgumentTypeInfoOrErr.takeError();
7792 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
7796 ExpectedExpr ToArgumentExprOrErr =
import(
E->getArgumentExpr());
7797 if (!ToArgumentExprOrErr)
7798 return ToArgumentExprOrErr.takeError();
7801 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
7805 Error Err = Error::success();
7811 return std::move(Err);
7814 Importer.
getToContext(), ToLHS, ToRHS,
E->getOpcode(), ToType,
7816 E->getFPFeatures());
7820 Error Err = Error::success();
7828 return std::move(Err);
7831 ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
7837 Error Err = Error::success();
7847 return std::move(Err);
7850 ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
7857 Error Err = Error::success();
7860 return std::move(Err);
7867 Error Err = Error::success();
7869 auto ToQueriedTypeSourceInfo =
7871 auto ToDimensionExpression =
importChecked(Err,
E->getDimensionExpression());
7875 return std::move(Err);
7878 ToBeginLoc,
E->getTrait(), ToQueriedTypeSourceInfo,
E->getValue(),
7879 ToDimensionExpression, ToEndLoc, ToType);
7883 Error Err = Error::success();
7885 auto ToQueriedExpression =
importChecked(Err,
E->getQueriedExpression());
7889 return std::move(Err);
7892 ToBeginLoc,
E->getTrait(), ToQueriedExpression,
E->getValue(),
7897 Error Err = Error::success();
7902 return std::move(Err);
7909 Error Err = Error::success();
7915 return std::move(Err);
7924 Error Err = Error::success();
7928 auto ToComputationLHSType =
importChecked(Err,
E->getComputationLHSType());
7929 auto ToComputationResultType =
7933 return std::move(Err);
7936 Importer.
getToContext(), ToLHS, ToRHS,
E->getOpcode(), ToType,
7939 ToComputationLHSType, ToComputationResultType);
7946 if (
auto SpecOrErr =
import(*I))
7947 Path.push_back(*SpecOrErr);
7949 return SpecOrErr.takeError();
7957 return ToTypeOrErr.takeError();
7960 if (!ToSubExprOrErr)
7961 return ToSubExprOrErr.takeError();
7964 if (!ToBasePathOrErr)
7965 return ToBasePathOrErr.takeError();
7968 Importer.
getToContext(), *ToTypeOrErr,
E->getCastKind(), *ToSubExprOrErr,
7973 Error Err = Error::success();
7976 auto ToTypeInfoAsWritten =
importChecked(Err,
E->getTypeInfoAsWritten());
7978 return std::move(Err);
7981 if (!ToBasePathOrErr)
7982 return ToBasePathOrErr.takeError();
7986 case Stmt::CStyleCastExprClass: {
7987 auto *CCE = cast<CStyleCastExpr>(
E);
7988 ExpectedSLoc ToLParenLocOrErr =
import(CCE->getLParenLoc());
7989 if (!ToLParenLocOrErr)
7990 return ToLParenLocOrErr.takeError();
7991 ExpectedSLoc ToRParenLocOrErr =
import(CCE->getRParenLoc());
7992 if (!ToRParenLocOrErr)
7993 return ToRParenLocOrErr.takeError();
7996 ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
7997 *ToLParenLocOrErr, *ToRParenLocOrErr);
8000 case Stmt::CXXFunctionalCastExprClass: {
8001 auto *FCE = cast<CXXFunctionalCastExpr>(
E);
8002 ExpectedSLoc ToLParenLocOrErr =
import(FCE->getLParenLoc());
8003 if (!ToLParenLocOrErr)
8004 return ToLParenLocOrErr.takeError();
8005 ExpectedSLoc ToRParenLocOrErr =
import(FCE->getRParenLoc());
8006 if (!ToRParenLocOrErr)
8007 return ToRParenLocOrErr.takeError();
8010 E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
8011 *ToLParenLocOrErr, *ToRParenLocOrErr);
8014 case Stmt::ObjCBridgedCastExprClass: {
8015 auto *OCE = cast<ObjCBridgedCastExpr>(
E);
8016 ExpectedSLoc ToLParenLocOrErr =
import(OCE->getLParenLoc());
8017 if (!ToLParenLocOrErr)
8018 return ToLParenLocOrErr.takeError();
8019 ExpectedSLoc ToBridgeKeywordLocOrErr =
import(OCE->getBridgeKeywordLoc());
8020 if (!ToBridgeKeywordLocOrErr)
8021 return ToBridgeKeywordLocOrErr.takeError();
8023 *ToLParenLocOrErr, OCE->getBridgeKind(),
E->getCastKind(),
8024 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
8026 case Stmt::BuiltinBitCastExprClass: {
8027 auto *BBC = cast<BuiltinBitCastExpr>(
E);
8028 ExpectedSLoc ToKWLocOrErr =
import(BBC->getBeginLoc());
8030 return ToKWLocOrErr.takeError();
8031 ExpectedSLoc ToRParenLocOrErr =
import(BBC->getEndLoc());
8032 if (!ToRParenLocOrErr)
8033 return ToRParenLocOrErr.takeError();
8036 ToTypeInfoAsWritten, *ToKWLocOrErr, *ToRParenLocOrErr);
8039 llvm_unreachable(
"Cast expression of unsupported type!");
8046 for (
int I = 0, N =
E->getNumComponents(); I < N; ++I) {
8052 Error Err = Error::success();
8056 return std::move(Err);
8065 auto ToBSOrErr =
import(FromNode.
getBase());
8067 return ToBSOrErr.takeError();
8072 auto ToFieldOrErr =
import(FromNode.
getField());
8074 return ToFieldOrErr.takeError();
8075 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
8080 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
8087 for (
int I = 0, N =
E->getNumExpressions(); I < N; ++I) {
8089 if (!ToIndexExprOrErr)
8090 return ToIndexExprOrErr.takeError();
8091 ToExprs[I] = *ToIndexExprOrErr;
8094 Error Err = Error::success();
8096 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8100 return std::move(Err);
8103 Importer.
getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
8104 ToExprs, ToRParenLoc);
8108 Error Err = Error::success();
8114 return std::move(Err);
8123 ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
8127 Error Err = Error::success();
8132 return std::move(Err);
8135 ToSubExpr, ToType, ToThrowLoc,
E->isThrownVariableInScope());
8140 if (!ToUsedLocOrErr)
8141 return ToUsedLocOrErr.takeError();
8143 auto ToParamOrErr =
import(
E->getParam());
8145 return ToParamOrErr.takeError();
8147 auto UsedContextOrErr = Importer.
ImportContext(
E->getUsedContext());
8148 if (!UsedContextOrErr)
8149 return UsedContextOrErr.takeError();
8159 std::optional<ParmVarDecl *> FromParam =
8161 assert(FromParam &&
"ParmVarDecl was not imported?");
8164 return std::move(Err);
8166 Expr *RewrittenInit =
nullptr;
8167 if (
E->hasRewrittenInit()) {
8170 return ExprOrErr.takeError();
8171 RewrittenInit = ExprOrErr.get();
8174 *ToParamOrErr, RewrittenInit,
8180 Error Err = Error::success();
8182 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8185 return std::move(Err);
8188 ToType, ToTypeSourceInfo, ToRParenLoc);
8194 if (!ToSubExprOrErr)
8195 return ToSubExprOrErr.takeError();
8197 auto ToDtorOrErr =
import(
E->getTemporary()->getDestructor());
8199 return ToDtorOrErr.takeError();
8209 Error Err = Error::success();
8212 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8213 auto ToParenOrBraceRange =
importChecked(Err,
E->getParenOrBraceRange());
8215 return std::move(Err);
8219 return std::move(Err);
8222 Importer.
getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
8223 ToParenOrBraceRange,
E->hadMultipleCandidates(),
8224 E->isListInitialization(),
E->isStdInitListInitialization(),
8225 E->requiresZeroInitialization());
8232 return std::move(Err);
8234 Error Err = Error::success();
8238 return std::move(Err);
8242 if (GetImportedOrCreateDecl(To,
D, Temporary, ExtendingDecl,
8243 D->getManglingNumber()))
8253 Error Err = Error::success();
8256 Err,
E->getLifetimeExtendedTemporaryDecl() ?
nullptr :
E->getSubExpr());
8257 auto ToMaterializedDecl =
8260 return std::move(Err);
8262 if (!ToTemporaryExpr)
8263 ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
8266 ToType, ToTemporaryExpr,
E->isBoundToLvalueReference(),
8267 ToMaterializedDecl);
8273 Error Err = Error::success();
8278 return std::move(Err);
8281 ToType, ToPattern, ToEllipsisLoc,
E->getNumExpansions());
8285 Error Err = Error::success();
8291 return std::move(Err);
8293 std::optional<unsigned> Length;
8295 Length =
E->getPackLength();
8298 if (
E->isPartiallySubstituted()) {
8300 ToPartialArguments))
8301 return std::move(Err);
8305 Importer.
getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
8306 Length, ToPartialArguments);
8311 Error Err = Error::success();
8313 auto ToOperatorDelete =
importChecked(Err,
E->getOperatorDelete());
8318 auto ToAllocatedTypeSourceInfo =
8321 auto ToDirectInitRange =
importChecked(Err,
E->getDirectInitRange());
8323 return std::move(Err);
8328 return std::move(Err);
8332 ToOperatorDelete,
E->passAlignment(),
E->doesUsualArrayDeleteWantSize(),
8333 ToPlacementArgs, ToTypeIdParens, ToArraySize,
E->getInitializationStyle(),
8334 ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
8339 Error Err = Error::success();
8341 auto ToOperatorDelete =
importChecked(Err,
E->getOperatorDelete());
8345 return std::move(Err);
8348 ToType,
E->isGlobalDelete(),
E->isArrayForm(),
E->isArrayFormAsWritten(),
8349 E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
8354 Error Err = Error::success();
8358 auto ToParenOrBraceRange =
importChecked(Err,
E->getParenOrBraceRange());
8360 return std::move(Err);
8364 return std::move(Err);
8367 Importer.
getToContext(), ToType, ToLocation, ToConstructor,
8368 E->isElidable(), ToArgs,
E->hadMultipleCandidates(),
8369 E->isListInitialization(),
E->isStdInitListInitialization(),
8370 E->requiresZeroInitialization(),
E->getConstructionKind(),
8371 ToParenOrBraceRange);
8378 if (!ToSubExprOrErr)
8379 return ToSubExprOrErr.takeError();
8383 return std::move(Err);
8386 Importer.
getToContext(), *ToSubExprOrErr,
E->cleanupsHaveSideEffects(),
8391 Error Err = Error::success();
8396 return std::move(Err);
8400 return std::move(Err);
8404 E->getFPFeatures());
8410 return ToTypeOrErr.takeError();
8413 if (!ToLocationOrErr)
8414 return ToLocationOrErr.takeError();
8417 *ToTypeOrErr,
E->isImplicit());
8423 return ToTypeOrErr.takeError();
8426 if (!ToLocationOrErr)
8427 return ToLocationOrErr.takeError();
8430 *ToTypeOrErr, *ToLocationOrErr);
8434 Error Err = Error::success();
8438 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8442 auto ToName =
importChecked(Err,
E->getMemberNameInfo().getName());
8443 auto ToLoc =
importChecked(Err,
E->getMemberNameInfo().getLoc());
8445 return std::move(Err);
8453 if (
E->hasExplicitTemplateArgs()) {
8456 E->template_arguments(), ToTAInfo))
8457 return std::move(Err);
8458 ResInfo = &ToTAInfo;
8462 ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8463 ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
8470 Error Err = Error::success();
8474 auto ToScopeTypeInfo =
importChecked(Err,
E->getScopeTypeInfo());
8475 auto ToColonColonLoc =
importChecked(Err,
E->getColonColonLoc());
8478 return std::move(Err);
8483 ExpectedSLoc ToDestroyedTypeLocOrErr =
import(
E->getDestroyedTypeLoc());
8484 if (!ToDestroyedTypeLocOrErr)
8485 return ToDestroyedTypeLocOrErr.takeError();
8488 if (
auto ToTIOrErr =
import(
E->getDestroyedTypeInfo()))
8491 return ToTIOrErr.takeError();
8495 Importer.
getToContext(), ToBase,
E->isArrow(), ToOperatorLoc,
8496 ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
8501 Error Err = Error::success();
8505 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8506 auto ToFirstQualifierFoundInScope =
8509 return std::move(Err);
8511 Expr *ToBase =
nullptr;
8512 if (!
E->isImplicitAccess()) {
8514 ToBase = *ToBaseOrErr;
8516 return ToBaseOrErr.takeError();
8521 if (
E->hasExplicitTemplateArgs()) {
8524 E->template_arguments(), ToTAInfo))
8525 return std::move(Err);
8526 ResInfo = &ToTAInfo;
8531 return std::move(Err);
8537 return std::move(Err);
8540 Importer.
getToContext(), ToBase, ToType,
E->isArrow(), ToOperatorLoc,
8541 ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
8542 ToMemberNameInfo, ResInfo);
8547 Error Err = Error::success();
8549 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8555 return std::move(Err);
8559 return std::move(Err);
8563 if (
E->hasExplicitTemplateArgs()) {
8566 return std::move(Err);
8567 ResInfo = &ToTAInfo;
8571 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
8572 ToNameInfo, ResInfo);
8577 Error Err = Error::success();
8581 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8583 return std::move(Err);
8588 return std::move(Err);
8591 Importer.
getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
8598 if (!ToNamingClassOrErr)
8599 return ToNamingClassOrErr.takeError();
8601 auto ToQualifierLocOrErr =
import(
E->getQualifierLoc());
8602 if (!ToQualifierLocOrErr)
8603 return ToQualifierLocOrErr.takeError();
8605 Error Err = Error::success();
8609 return std::move(Err);
8614 return std::move(Err);
8617 for (
auto *
D :
E->decls())
8618 if (
auto ToDOrErr =
import(
D))
8619 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8621 return ToDOrErr.takeError();
8623 if (
E->hasExplicitTemplateArgs()) {
8626 E->getLAngleLoc(),
E->getRAngleLoc(),
E->template_arguments(),
8628 return std::move(Err);
8630 ExpectedSLoc ToTemplateKeywordLocOrErr =
import(
E->getTemplateKeywordLoc());
8631 if (!ToTemplateKeywordLocOrErr)
8632 return ToTemplateKeywordLocOrErr.takeError();
8634 const bool KnownDependent =
8636 ExprDependence::TypeValue;
8638 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8639 *ToTemplateKeywordLocOrErr, ToNameInfo,
E->requiresADL(), &ToTAInfo,
8640 ToDecls.
begin(), ToDecls.
end(), KnownDependent,
8645 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8646 ToNameInfo,
E->requiresADL(), ToDecls.
begin(), ToDecls.
end(),
8653 Error Err = Error::success();
8657 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8661 return std::move(Err);
8666 return std::move(Err);
8669 for (
Decl *
D :
E->decls())
8670 if (
auto ToDOrErr =
import(
D))
8671 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8673 return ToDOrErr.takeError();
8677 if (
E->hasExplicitTemplateArgs()) {
8679 E->copyTemplateArgumentsInto(FromTAInfo);
8681 return std::move(Err);
8682 ResInfo = &ToTAInfo;
8685 Expr *ToBase =
nullptr;
8686 if (!
E->isImplicitAccess()) {
8688 ToBase = *ToBaseOrErr;
8690 return ToBaseOrErr.takeError();
8694 Importer.
getToContext(),
E->hasUnresolvedUsing(), ToBase, ToType,
8695 E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8696 ToNameInfo, ResInfo, ToDecls.
begin(), ToDecls.
end());
8700 Error Err = Error::success();
8705 return std::move(Err);
8707 unsigned NumArgs =
E->getNumArgs();
8710 return std::move(Err);
8712 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
E)) {
8714 Importer.
getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
8715 OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
8716 OCE->getADLCallKind());
8721 0,
E->getADLCallKind());
8726 auto ToClassOrErr =
import(FromClass);
8728 return ToClassOrErr.takeError();
8731 auto ToCallOpOrErr =
import(
E->getCallOperator());
8733 return ToCallOpOrErr.takeError();
8737 return std::move(Err);
8739 Error Err = Error::success();
8740 auto ToIntroducerRange =
importChecked(Err,
E->getIntroducerRange());
8741 auto ToCaptureDefaultLoc =
importChecked(Err,
E->getCaptureDefaultLoc());
8744 return std::move(Err);
8747 E->getCaptureDefault(), ToCaptureDefaultLoc,
8748 E->hasExplicitParameters(),
8749 E->hasExplicitResultType(), ToCaptureInits,
8755 Error Err = Error::success();
8760 return std::move(Err);
8764 return std::move(Err);
8768 ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
8771 if (
E->hasArrayFiller()) {
8772 if (
ExpectedExpr ToFillerOrErr =
import(
E->getArrayFiller()))
8775 return ToFillerOrErr.takeError();
8778 if (
FieldDecl *FromFD =
E->getInitializedFieldInUnion()) {
8779 if (
auto ToFDOrErr =
import(FromFD))
8782 return ToFDOrErr.takeError();
8786 if (
auto ToSyntFormOrErr =
import(SyntForm))
8789 return ToSyntFormOrErr.takeError();
8803 return ToTypeOrErr.takeError();
8806 if (!ToSubExprOrErr)
8807 return ToSubExprOrErr.takeError();
8810 *ToTypeOrErr, *ToSubExprOrErr);
8815 Error Err = Error::success();
8820 return std::move(Err);
8823 ToLocation, ToType, ToConstructor,
E->constructsVBase(),
8824 E->inheritedFromVBase());
8828 Error Err = Error::success();
8833 return std::move(Err);
8836 ToType, ToCommonExpr, ToSubExpr);
8842 return ToTypeOrErr.takeError();
8848 if (!ToBeginLocOrErr)
8849 return ToBeginLocOrErr.takeError();
8851 auto ToFieldOrErr =
import(
E->getField());
8853 return ToFieldOrErr.takeError();
8855 auto UsedContextOrErr = Importer.
ImportContext(
E->getUsedContext());
8856 if (!UsedContextOrErr)
8857 return UsedContextOrErr.takeError();
8861 "Field should have in-class initializer if there is a default init "
8862 "expression that uses it.");
8867 auto ToInClassInitializerOrErr =
8868 import(
E->getField()->getInClassInitializer());
8869 if (!ToInClassInitializerOrErr)
8870 return ToInClassInitializerOrErr.takeError();
8874 Expr *RewrittenInit =
nullptr;
8875 if (
E->hasRewrittenInit()) {
8878 return ExprOrErr.takeError();
8879 RewrittenInit = ExprOrErr.get();
8883 ToField, *UsedContextOrErr, RewrittenInit);
8887 Error Err = Error::success();
8890 auto ToTypeInfoAsWritten =
importChecked(Err,
E->getTypeInfoAsWritten());
8893 auto ToAngleBrackets =
importChecked(Err,
E->getAngleBrackets());
8895 return std::move(Err);
8900 if (!ToBasePathOrErr)
8901 return ToBasePathOrErr.takeError();
8903 if (
auto CCE = dyn_cast<CXXStaticCastExpr>(
E)) {
8905 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8906 ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
8908 }
else if (isa<CXXDynamicCastExpr>(
E)) {
8910 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8911 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8912 }
else if (isa<CXXReinterpretCastExpr>(
E)) {
8914 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8915 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8916 }
else if (isa<CXXConstCastExpr>(
E)) {
8918 Importer.
getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
8919 ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8921 llvm_unreachable(
"Unknown cast type");
8922 return make_error<ASTImportError>();
8928 Error Err = Error::success();
8931 auto ToAssociatedDecl =
importChecked(Err,
E->getAssociatedDecl());
8934 return std::move(Err);
8937 ToType,
E->
getValueKind(), ToExprLoc, ToReplacement, ToAssociatedDecl,
8938 E->getIndex(),
E->getPackIndex(),
E->isReferenceParameter());
8942 Error Err = Error::success();
8947 return std::move(Err);
8951 return std::move(Err);
8958 Importer.
getToContext(), ToType, ToBeginLoc,
E->getTrait(), ToArgs,
8965 return ToTypeOrErr.takeError();
8968 if (!ToSourceRangeOrErr)
8969 return ToSourceRangeOrErr.takeError();
8971 if (
E->isTypeOperand()) {
8972 if (
auto ToTSIOrErr =
import(
E->getTypeOperandSourceInfo()))
8974 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
8976 return ToTSIOrErr.takeError();
8979 ExpectedExpr ToExprOperandOrErr =
import(
E->getExprOperand());
8980 if (!ToExprOperandOrErr)
8981 return ToExprOperandOrErr.takeError();
8984 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8988 Error Err = Error::success();
8999 return std::move(Err);
9002 CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS,
E->getOperator(),
9003 ToEllipsisLoc, ToRHS, ToRParenLoc,
E->getNumExpansions());
9008 Error ImportErrors = Error::success();
9010 if (
auto ImportedOrErr =
import(FromOverriddenMethod))
9012 (*ImportedOrErr)->getCanonicalDecl()));
9015 joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
9017 return ImportErrors;
9023 std::shared_ptr<ASTImporterSharedState> SharedState)
9024 : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
9025 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
9030 this->SharedState = std::make_shared<ASTImporterSharedState>();
9040 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
9041 "Try to get field index for non-field.");
9045 return std::nullopt;
9048 for (
const auto *
D : Owner->decls()) {
9052 if (isa<FieldDecl>(*
D) || isa<IndirectFieldDecl>(*
D))
9056 llvm_unreachable(
"Field was not found in its parent context.");
9058 return std::nullopt;
9071 if (SharedState->getLookupTable()) {
9078 getCanonicalForwardRedeclChain<NamespaceDecl>(
9079 dyn_cast<NamespaceDecl>(ReDC));
9080 for (
auto *
D : NSChain) {
9082 SharedState->getLookupTable()->lookup(dyn_cast<NamespaceDecl>(
D),
9089 SharedState->getLookupTable()->lookup(ReDC, Name);
9094 FoundDeclsTy
Result(NoloadLookupResult.
begin(), NoloadLookupResult.
end());
9111void ASTImporter::AddToLookupTable(
Decl *ToD) {
9112 SharedState->addDeclToLookup(ToD);
9118 return Importer.
Visit(FromD);
9142 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9143 ImportedTypes.find(FromT);
9144 if (Pos != ImportedTypes.end())
9151 return ToTOrErr.takeError();
9154 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
9156 return ToTOrErr->getTypePtr();
9165 return ToTyOrErr.takeError();
9178 return TOrErr.takeError();
9181 return BeginLocOrErr.takeError();
9190template <
typename T>
struct AttrArgImporter {
9191 AttrArgImporter(
const AttrArgImporter<T> &) =
delete;
9192 AttrArgImporter(AttrArgImporter<T> &&) =
default;
9193 AttrArgImporter<T> &operator=(
const AttrArgImporter<T> &) =
delete;
9194 AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) =
default;
9197 : To(I.importChecked(Err, From)) {}
9199 const T &value() {
return To; }
9210template <
typename T>
struct AttrArgArrayImporter {
9211 AttrArgArrayImporter(
const AttrArgArrayImporter<T> &) =
delete;
9212 AttrArgArrayImporter(AttrArgArrayImporter<T> &&) =
default;
9213 AttrArgArrayImporter<T> &operator=(
const AttrArgArrayImporter<T> &) =
delete;
9214 AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) =
default;
9217 const llvm::iterator_range<T *> &From,
9218 unsigned ArraySize) {
9221 To.reserve(ArraySize);
9225 T *value() {
return To.data(); }
9232 Error Err{Error::success()};
9233 Attr *ToAttr =
nullptr;
9238 AttrImporter(
ASTImporter &I) : Importer(I), NImporter(I) {}
9241 template <
typename T>
T *castAttrAs() {
return cast<T>(ToAttr); }
9242 template <
typename T>
const T *castAttrAs()
const {
return cast<T>(ToAttr); }
9247 template <
class T> AttrArgImporter<T> importArg(
const T &From) {
9248 return AttrArgImporter<T>(NImporter, Err, From);
9254 template <
typename T>
9255 AttrArgArrayImporter<T> importArrayArg(
const llvm::iterator_range<T *> &From,
9256 unsigned ArraySize) {
9257 return AttrArgArrayImporter<T>(NImporter, Err, From, ArraySize);
9268 template <
typename T,
typename... Arg>
9269 void importAttr(
const T *FromAttr, Arg &&...ImportedArg) {
9270 static_assert(std::is_base_of<Attr, T>::value,
9271 "T should be subclass of Attr.");
9272 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9276 Importer.
Import(FromAttr->getScopeName());
9286 FromAttr->getParsedKind(), FromAttr->getForm());
9290 std::forward<Arg>(ImportedArg)..., ToI);
9294 if (
auto *ToInheritableAttr = dyn_cast<InheritableAttr>(ToAttr))
9295 ToInheritableAttr->setInherited(FromAttr->isInherited());
9301 void cloneAttr(
const Attr *FromAttr) {
9302 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9316 return std::move(Err);
9317 assert(ToAttr &&
"Attribute should be created.");
9324 AttrImporter AI(*
this);
9327 switch (FromAttr->
getKind()) {
9328 case attr::Aligned: {
9329 auto *From = cast<AlignedAttr>(FromAttr);
9330 if (From->isAlignmentExpr())
9331 AI.importAttr(From,
true, AI.importArg(From->getAlignmentExpr()).value());
9333 AI.importAttr(From,
false,
9334 AI.importArg(From->getAlignmentType()).value());
9338 case attr::AlignValue: {
9339 auto *From = cast<AlignValueAttr>(FromAttr);
9340 AI.importAttr(From, AI.importArg(From->getAlignment()).value());
9344 case attr::Format: {
9345 const auto *From = cast<FormatAttr>(FromAttr);
9346 AI.importAttr(From,
Import(From->getType()), From->getFormatIdx(),
9347 From->getFirstArg());
9351 case attr::EnableIf: {
9352 const auto *From = cast<EnableIfAttr>(FromAttr);
9353 AI.importAttr(From, AI.importArg(From->getCond()).value(),
9354 From->getMessage());
9358 case attr::AssertCapability: {
9359 const auto *From = cast<AssertCapabilityAttr>(FromAttr);
9361 AI.importArrayArg(From->args(), From->args_size()).value(),
9365 case attr::AcquireCapability: {
9366 const auto *From = cast<AcquireCapabilityAttr>(FromAttr);
9368 AI.importArrayArg(From->args(), From->args_size()).value(),
9372 case attr::TryAcquireCapability: {
9373 const auto *From = cast<TryAcquireCapabilityAttr>(FromAttr);
9374 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9375 AI.importArrayArg(From->args(), From->args_size()).value(),
9379 case attr::ReleaseCapability: {
9380 const auto *From = cast<ReleaseCapabilityAttr>(FromAttr);
9382 AI.importArrayArg(From->args(), From->args_size()).value(),
9386 case attr::RequiresCapability: {
9387 const auto *From = cast<RequiresCapabilityAttr>(FromAttr);
9389 AI.importArrayArg(From->args(), From->args_size()).value(),
9393 case attr::GuardedBy: {
9394 const auto *From = cast<GuardedByAttr>(FromAttr);
9395 AI.importAttr(From, AI.importArg(From->getArg()).value());
9398 case attr::PtGuardedBy: {
9399 const auto *From = cast<PtGuardedByAttr>(FromAttr);
9400 AI.importAttr(From, AI.importArg(From->getArg()).value());
9403 case attr::AcquiredAfter: {
9404 const auto *From = cast<AcquiredAfterAttr>(FromAttr);
9406 AI.importArrayArg(From->args(), From->args_size()).value(),
9410 case attr::AcquiredBefore: {
9411 const auto *From = cast<AcquiredBeforeAttr>(FromAttr);
9413 AI.importArrayArg(From->args(), From->args_size()).value(),
9417 case attr::AssertExclusiveLock: {
9418 const auto *From = cast<AssertExclusiveLockAttr>(FromAttr);
9420 AI.importArrayArg(From->args(), From->args_size()).value(),
9424 case attr::AssertSharedLock: {
9425 const auto *From = cast<AssertSharedLockAttr>(FromAttr);
9427 AI.importArrayArg(From->args(), From->args_size()).value(),
9431 case attr::ExclusiveTrylockFunction: {
9432 const auto *From = cast<ExclusiveTrylockFunctionAttr>(FromAttr);
9433 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9434 AI.importArrayArg(From->args(), From->args_size()).value(),
9438 case attr::SharedTrylockFunction: {
9439 const auto *From = cast<SharedTrylockFunctionAttr>(FromAttr);
9440 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9441 AI.importArrayArg(From->args(), From->args_size()).value(),
9445 case attr::LockReturned: {
9446 const auto *From = cast<LockReturnedAttr>(FromAttr);
9447 AI.importAttr(From, AI.importArg(From->getArg()).value());
9450 case attr::LocksExcluded: {
9451 const auto *From = cast<LocksExcludedAttr>(FromAttr);
9453 AI.importArrayArg(From->args(), From->args_size()).value(),
9461 AI.cloneAttr(FromAttr);
9466 return std::move(AI).getResult();
9470 return ImportedDecls.lookup(FromD);
9474 auto FromDPos = ImportedFromDecls.find(ToD);
9475 if (FromDPos == ImportedFromDecls.end())
9477 return FromDPos->second->getTranslationUnitDecl();
9485 ImportPath.
push(FromD);
9486 auto ImportPathBuilder =
9487 llvm::make_scope_exit([
this]() { ImportPath.
pop(); });
9492 return make_error<ASTImportError>(*Error);
9498 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9500 return make_error<ASTImportError>(*Error);
9517 auto Pos = ImportedDecls.find(FromD);
9518 if (Pos != ImportedDecls.end()) {
9521 auto *ToD = Pos->second;
9522 ImportedDecls.erase(Pos);
9534 auto PosF = ImportedFromDecls.find(ToD);
9535 if (PosF != ImportedFromDecls.end()) {
9540 SharedState->removeDeclFromLookup(ToD);
9541 ImportedFromDecls.erase(PosF);
9553 handleAllErrors(ToDOrErr.takeError(),
9557 if (Pos != ImportedDecls.end())
9558 SharedState->setImportDeclError(Pos->second, ErrOut);
9562 for (
const auto &
Path : SavedImportPaths[FromD]) {
9565 Decl *PrevFromDi = FromD;
9568 if (FromDi == FromD)
9575 PrevFromDi = FromDi;
9579 auto Ii = ImportedDecls.find(FromDi);
9580 if (Ii != ImportedDecls.end())
9581 SharedState->setImportDeclError(Ii->second, ErrOut);
9586 SavedImportPaths.erase(FromD);
9589 return make_error<ASTImportError>(ErrOut);
9601 return make_error<ASTImportError>(*Err);
9607 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9609 return make_error<ASTImportError>(*Error);
9612 assert(ImportedDecls.count(FromD) != 0 &&
"Missing call to MapImported?");
9616 auto ToAttrOrErr =
Import(FromAttr);
9620 return ToAttrOrErr.takeError();
9627 SavedImportPaths.erase(FromD);
9642 return ToDCOrErr.takeError();
9643 auto *ToDC = cast<DeclContext>(*ToDCOrErr);
9647 if (
auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
9648 auto *FromRecord = cast<RecordDecl>(FromDC);
9649 if (ToRecord->isCompleteDefinition())
9657 if (FromRecord->getASTContext().getExternalSource() &&
9658 !FromRecord->isCompleteDefinition())
9659 FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
9661 if (FromRecord->isCompleteDefinition())
9664 return std::move(Err);
9665 }
else if (
auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
9666 auto *FromEnum = cast<EnumDecl>(FromDC);
9667 if (ToEnum->isCompleteDefinition()) {
9669 }
else if (FromEnum->isCompleteDefinition()) {
9672 return std::move(Err);
9676 }
else if (
auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
9677 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
9678 if (ToClass->getDefinition()) {
9683 return std::move(Err);
9687 }
else if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
9688 auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
9689 if (ToProto->getDefinition()) {
9694 return std::move(Err);
9705 return cast_or_null<Expr>(*ToSOrErr);
9707 return ToSOrErr.takeError();
9715 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
9716 if (Pos != ImportedStmts.end())
9725 if (
auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
9726 auto *FromE = cast<Expr>(FromS);
9729 ToE->setValueKind(FromE->getValueKind());
9730 ToE->setObjectKind(FromE->getObjectKind());
9731 ToE->setDependence(FromE->getDependence());
9735 ImportedStmts[FromS] = *ToSOrErr;
9746 return std::move(Err);
9750 assert(FromNNS->
getAsIdentifier() &&
"NNS should contain identifier.");
9757 cast<NamespaceDecl>(*NSOrErr));
9759 return NSOrErr.takeError();
9764 cast<NamespaceAliasDecl>(*NSADOrErr));
9766 return NSADOrErr.takeError();
9774 cast<CXXRecordDecl>(*RDOrErr));
9776 return RDOrErr.takeError();
9786 return TyOrErr.takeError();
9790 llvm_unreachable(
"Invalid nested name specifier kind");
9802 NestedNames.push_back(NNS);
9808 while (!NestedNames.empty()) {
9809 NNS = NestedNames.pop_back_val();
9812 return std::move(Err);
9819 return std::move(Err);
9823 return std::move(Err);
9839 ToLocalBeginLoc, ToLocalEndLoc);
9846 return std::move(Err);
9866 if (!ToSourceRangeOrErr)
9867 return ToSourceRangeOrErr.takeError();
9870 ToSourceRangeOrErr->getBegin(),
9871 ToSourceRangeOrErr->getEnd());
9883 return TemplateName(cast<TemplateDecl>((*ToTemplateOrErr)->getCanonicalDecl()));
9885 return ToTemplateOrErr.takeError();
9890 for (
auto *I : *FromStorage) {
9891 if (
auto ToOrErr =
Import(I))
9892 ToTemplates.
addDecl(cast<NamedDecl>(*ToOrErr));
9894 return ToOrErr.takeError();
9904 return DeclNameOrErr.takeError();
9911 if (!QualifierOrErr)
9912 return QualifierOrErr.takeError();
9915 return TNOrErr.takeError();
9923 if (!QualifierOrErr)
9924 return QualifierOrErr.takeError();
9939 if (!ReplacementOrErr)
9940 return ReplacementOrErr.takeError();
9943 if (!AssociatedDeclOrErr)
9944 return AssociatedDeclOrErr.takeError();
9947 *ReplacementOrErr, *AssociatedDeclOrErr, Subst->
getIndex(),
9958 return ArgPackOrErr.takeError();
9961 if (!AssociatedDeclOrErr)
9962 return AssociatedDeclOrErr.takeError();
9965 *ArgPackOrErr, *AssociatedDeclOrErr, SubstPack->
getIndex(),
9971 return UsingOrError.takeError();
9972 return TemplateName(cast<UsingShadowDecl>(*UsingOrError));
9975 llvm_unreachable(
"Unexpected DeducedTemplate");
9978 llvm_unreachable(
"Invalid template name kind");
9991 return ToFileIDOrErr.takeError();
9999 return std::move(Err);
10001 return std::move(Err);
10007 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
10008 if (Pos != ImportedFileIDs.end())
10009 return Pos->second;
10021 return ToSpLoc.takeError();
10024 return ToExLocS.takeError();
10034 return ToExLocE.takeError();
10040 if (!IsBuiltin && !
Cache->BufferOverridden) {
10044 return ToIncludeLoc.takeError();
10055 if (
Cache->OrigEntry &&
Cache->OrigEntry->getDir()) {
10066 ToID = ToSM.
createFileID(*Entry, ToIncludeLocOrFakeLoc,
10073 std::optional<llvm::MemoryBufferRef> FromBuf =
10079 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
10080 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
10081 FromBuf->getBufferIdentifier());
10087 assert(ToID.
isValid() &&
"Unexpected invalid fileID was created.");
10089 ImportedFileIDs[FromID] = ToID;
10096 return ToExprOrErr.takeError();
10099 if (!LParenLocOrErr)
10100 return LParenLocOrErr.takeError();
10103 if (!RParenLocOrErr)
10104 return RParenLocOrErr.takeError();
10109 return ToTInfoOrErr.takeError();
10114 return std::move(Err);
10117 ToContext, *ToTInfoOrErr, From->
isBaseVirtual(), *LParenLocOrErr,
10118 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
10122 return ToFieldOrErr.takeError();
10125 if (!MemberLocOrErr)
10126 return MemberLocOrErr.takeError();
10129 ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
10130 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10133 if (!ToIFieldOrErr)
10134 return ToIFieldOrErr.takeError();
10137 if (!MemberLocOrErr)
10138 return MemberLocOrErr.takeError();
10141 ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
10142 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10146 return ToTInfoOrErr.takeError();
10148 return new (ToContext)
10150 *ToExprOrErr, *RParenLocOrErr);
10153 return make_error<ASTImportError>();
10159 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
10160 if (Pos != ImportedCXXBaseSpecifiers.end())
10161 return Pos->second;
10164 if (!ToSourceRange)
10165 return ToSourceRange.takeError();
10168 return ToTSI.takeError();
10170 if (!ToEllipsisLoc)
10171 return ToEllipsisLoc.takeError();
10175 ImportedCXXBaseSpecifiers[BaseSpec] =
Imported;
10187 return ToOrErr.takeError();
10188 Decl *To = *ToOrErr;
10190 auto *FromDC = cast<DeclContext>(From);
10193 if (
auto *ToRecord = dyn_cast<RecordDecl>(To)) {
10194 if (!ToRecord->getDefinition()) {
10196 cast<RecordDecl>(FromDC), ToRecord,
10201 if (
auto *ToEnum = dyn_cast<EnumDecl>(To)) {
10202 if (!ToEnum->getDefinition()) {
10208 if (
auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
10209 if (!ToIFace->getDefinition()) {
10211 cast<ObjCInterfaceDecl>(FromDC), ToIFace,
10216 if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
10217 if (!ToProto->getDefinition()) {
10219 cast<ObjCProtocolDecl>(FromDC), ToProto,
10241 return ToSelOrErr.takeError();
10248 return ToTyOrErr.takeError();
10256 return ToTyOrErr.takeError();
10262 cast<TemplateDecl>(*ToTemplateOrErr));
10264 return ToTemplateOrErr.takeError();
10272 return ToTyOrErr.takeError();
10288 llvm_unreachable(
"Invalid DeclarationName Kind!");
10309 for (
unsigned I = 1, N = FromSel.
getNumArgs(); I < N; ++I)
10317 llvm::Error Err = llvm::Error::success();
10318 auto ImportLoop = [&](
const APValue *From,
APValue *To,
unsigned Size) {
10319 for (
unsigned Idx = 0; Idx < Size; Idx++) {
10324 switch (FromValue.
getKind()) {
10338 ImportLoop(((
const APValue::Vec *)(
const char *)&FromValue.Data)->Elts,
10345 ImportLoop(((
const APValue::Arr *)(
const char *)&FromValue.Data)->Elts,
10346 ((
const APValue::Arr *)(
const char *)&
Result.Data)->Elts,
10353 ((
const APValue::StructData *)(
const char *)&FromValue.Data)->Elts,
10354 ((
const APValue::StructData *)(
const char *)&
Result.Data)->Elts,
10362 return std::move(Err);
10363 Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
10367 Result.MakeAddrLabelDiff();
10371 return std::move(Err);
10372 Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
10373 cast<AddrLabelExpr>(ImpRHS));
10377 const Decl *ImpMemPtrDecl =
10380 return std::move(Err);
10382 Result.setMemberPointerUninit(
10383 cast<const ValueDecl>(ImpMemPtrDecl),
10387 Result.getMemberPointerPath();
10392 return std::move(Err);
10402 "in C++20 dynamic allocation are transient so they shouldn't "
10403 "appear in the AST");
10405 if (
const auto *
E =
10410 return std::move(Err);
10420 return std::move(Err);
10432 return std::move(Err);
10446 for (
unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
10449 FromPath[LoopIdx].getAsBaseOrMember().getPointer();
10452 return std::move(Err);
10453 if (
auto *RD = dyn_cast<CXXRecordDecl>(
FromDecl))
10456 FromElemTy = cast<ValueDecl>(
FromDecl)->getType();
10458 ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
10463 FromPath[LoopIdx].getAsArrayIndex());
10471 return std::move(Err);
10479 unsigned NumDecls) {
10489 if (LastDiagFromFrom)
10492 LastDiagFromFrom =
false;
10497 if (!LastDiagFromFrom)
10500 LastDiagFromFrom =
true;
10505 if (
auto *ID = dyn_cast<ObjCInterfaceDecl>(
D)) {
10506 if (!ID->getDefinition())
10507 ID->startDefinition();
10509 else if (
auto *PD = dyn_cast<ObjCProtocolDecl>(
D)) {
10510 if (!PD->getDefinition())
10511 PD->startDefinition();
10513 else if (
auto *TD = dyn_cast<TagDecl>(
D)) {
10514 if (!TD->getDefinition() && !TD->isBeingDefined()) {
10515 TD->startDefinition();
10516 TD->setCompleteDefinition(
true);
10520 assert(0 &&
"CompleteDecl called on a Decl that can't be completed");
10525 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
10526 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
10527 "Try to import an already imported Decl");
10528 if (Pos != ImportedDecls.end())
10529 return Pos->second;
10530 ImportedDecls[From] = To;
10533 ImportedFromDecls[To] = From;
10538 AddToLookupTable(To);
10542std::optional<ASTImportError>
10544 auto Pos = ImportDeclErrors.find(FromD);
10545 if (Pos != ImportDeclErrors.end())
10546 return Pos->second;
10548 return std::nullopt;
10552 auto InsertRes = ImportDeclErrors.insert({From, Error});
10556 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
10561 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
10563 if (Pos != ImportedTypes.end()) {
10568 llvm::consumeError(ToFromOrErr.takeError());
10575 return Ctx.IsEquivalent(From, To);
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
static FriendCountAndPosition getFriendCountAndPosition(ASTImporter &Importer, FriendDecl *FD)
static bool IsEquivalentFriend(ASTImporter &Importer, FriendDecl *FD1, FriendDecl *FD2)
static auto getTemplateDefinition(T *D) -> T *
static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D)
static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To, ASTImporter &Importer)
static StructuralEquivalenceKind getStructuralEquivalenceKind(const ASTImporter &Importer)
Defines enum values for all the target-independent builtin functions.
enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::FileManager interface and associated types.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
llvm::SmallVector< std::pair< const MemRegion *, SVal >, 4 > Bindings
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the Objective-C statement AST node classes.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
const NamedDecl * FromDecl
unsigned getVersion() const
QualType getTypeInfoType() const
static LValueBase getTypeInfo(TypeInfoLValue LV, QualType TypeInfo)
unsigned getCallIndex() const
A non-discriminated union of a base, field, or array index.
static LValuePathEntry ArrayIndex(uint64_t Index)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
const LValueBase getLValueBase() const
ArrayRef< LValuePathEntry > getLValuePath() const
const FieldDecl * getUnionField() const
unsigned getStructNumFields() const
llvm::PointerIntPair< const Decl *, 1, bool > BaseOrMemberType
A FieldDecl or CXXRecordDecl, along with a flag indicating whether we mean a virtual or non-virtual b...
ValueKind getKind() const
bool isLValueOnePastTheEnd() const
bool isMemberPointerToDerivedMember() const
unsigned getArrayInitializedElts() const
unsigned getStructNumBases() const
bool hasLValuePath() const
const ValueDecl * getMemberPointerDecl() const
APValue & getUnionValue()
const AddrLabelExpr * getAddrLabelDiffRHS() const
CharUnits & getLValueOffset()
unsigned getVectorLength() const
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
unsigned getArraySize() const
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
@ None
There is no such object (it's outside its lifetime).
bool isNullPointer() const
const AddrLabelExpr * getAddrLabelDiffLHS() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
QualType getParenType(QualType NamedType) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
BuiltinTemplateDecl * getBuiltinCommonTypeDecl() 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 getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
QualType getRecordType(const RecordDecl *Decl) const
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
QualType getCountAttributedType(QualType T, Expr *CountExpr, bool CountInBytes, bool OrNull, ArrayRef< TypeCoupledDeclRefInfo > DependentDecls) const
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 getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex, SubstTemplateTypeParmTypeFlag Flag=SubstTemplateTypeParmTypeFlag::None) const
Retrieve a substitution-result 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 getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true) const
Form a pack expansion type with the given pattern.
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.
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.
llvm::DenseSet< std::tuple< Decl *, Decl *, int > > NonEquivalentDeclSet
TranslationUnitDecl * GetFromTU(Decl *ToD)
Return the translation unit from where the declaration was imported.
llvm::Expected< DeclContext * > ImportContext(DeclContext *FromDC)
Import the given declaration context from the "from" AST context into the "to" AST context.
llvm::Error ImportDefinition(Decl *From)
Import the definition of the given declaration, including all of the declarations it contains.
virtual Expected< DeclarationName > HandleNameConflict(DeclarationName Name, DeclContext *DC, unsigned IDNS, NamedDecl **Decls, unsigned NumDecls)
Cope with a name conflict when importing a declaration into the given context.
virtual bool returnWithErrorInTest()
Used only in unittests to verify the behaviour of the error handling.
std::optional< DeclT * > getImportedFromDecl(const DeclT *ToD) const
Return the declaration in the "from" context from which the declaration in the "to" context was impor...
void RegisterImportedDecl(Decl *FromD, Decl *ToD)
std::optional< ASTImportError > getImportDeclErrorIfAny(Decl *FromD) const
Return if import of the given declaration has failed and if yes the kind of the problem.
friend class ASTNodeImporter
static std::optional< unsigned > getFieldIndex(Decl *F)
Determine the index of a field in its parent record.
llvm::Error importInto(ImportT &To, const ImportT &From)
Import the given object, returns the result.
virtual Decl * GetOriginalDecl(Decl *To)
Called by StructuralEquivalenceContext.
virtual void Imported(Decl *From, Decl *To)
Subclasses can override this function to observe all of the From -> To declaration mappings as they a...
DiagnosticBuilder FromDiag(SourceLocation Loc, unsigned DiagID)
Report a diagnostic in the "from" context.
bool IsStructurallyEquivalent(QualType From, QualType To, bool Complain=true)
Determine whether the given types are structurally equivalent.
virtual Expected< Decl * > ImportImpl(Decl *From)
Can be overwritten by subclasses to implement their own import logic.
bool isMinimalImport() const
Whether the importer will perform a minimal import, creating to-be-completed forward declarations whe...
ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, ASTContext &FromContext, FileManager &FromFileManager, bool MinimalImport, std::shared_ptr< ASTImporterSharedState > SharedState=nullptr)
llvm::Expected< ExprWithCleanups::CleanupObject > Import(ExprWithCleanups::CleanupObject From)
Import cleanup objects owned by ExprWithCleanup.
virtual void CompleteDecl(Decl *D)
Called for ObjCInterfaceDecl, ObjCProtocolDecl, and TagDecl.
Decl * GetAlreadyImportedOrNull(const Decl *FromD) const
Return the copy of the given declaration in the "to" context if it has already been imported from the...
void setImportDeclError(Decl *From, ASTImportError Error)
Mark (newly) imported declaration with error.
ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D)
ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E)
ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E)
ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D)
ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E)
ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D)
ExpectedDecl VisitFunctionDecl(FunctionDecl *D)
ExpectedDecl VisitParmVarDecl(ParmVarDecl *D)
ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E)
ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E)
ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D)
ExpectedDecl VisitUsingDecl(UsingDecl *D)
ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D)
ExpectedStmt VisitStmt(Stmt *S)
ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D)
ExpectedDecl VisitFieldDecl(FieldDecl *D)
Error ImportFieldDeclDefinition(const FieldDecl *From, const FieldDecl *To)
Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD=nullptr)
ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E)
ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E)
ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S)
ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D)
ExpectedStmt VisitShuffleVectorExpr(ShuffleVectorExpr *E)
ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D)
ExpectedDecl VisitRecordDecl(RecordDecl *D)
ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E)
ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D)
Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin)
ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S)
T importChecked(Error &Err, const T &From)
ExpectedStmt VisitVAArgExpr(VAArgExpr *E)
ExpectedStmt VisitDefaultStmt(DefaultStmt *S)
ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D)
ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E)
ExpectedDecl VisitLabelDecl(LabelDecl *D)
ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E)
ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S)
ExpectedStmt VisitUnaryOperator(UnaryOperator *E)
Error ImportTemplateParameterLists(const DeclTy *FromD, DeclTy *ToD)
Error ImportDeclContext(DeclContext *FromDC, bool ForceImport=false)
ExpectedStmt VisitContinueStmt(ContinueStmt *S)
ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E)
ExpectedDecl VisitVarDecl(VarDecl *D)
ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E)
ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D)
Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To)
ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E)
ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E)
ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D)
ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D)
ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E)
ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE)
ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E)
ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D)
ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E)
ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D)
Expected< InheritedConstructor > ImportInheritedConstructor(const InheritedConstructor &From)
ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E)
Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc)
Error ImportDefinition(RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind=IDK_Default)
ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S)
ExpectedStmt VisitConstantExpr(ConstantExpr *E)
ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E)
ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E)
ExpectedDecl VisitDecl(Decl *D)
bool hasSameVisibilityContextAndLinkage(T *Found, T *From)
ExpectedStmt VisitParenExpr(ParenExpr *E)
ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S)
ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E)
ExpectedStmt VisitInitListExpr(InitListExpr *E)
Expected< FunctionTemplateAndArgsTy > ImportFunctionTemplateWithTemplateArgsFromSpecialization(FunctionDecl *FromFD)
ExpectedStmt VisitReturnStmt(ReturnStmt *S)
ExpectedStmt VisitAtomicExpr(AtomicExpr *E)
ExpectedStmt VisitConditionalOperator(ConditionalOperator *E)
ExpectedStmt VisitChooseExpr(ChooseExpr *E)
ExpectedStmt VisitCompoundStmt(CompoundStmt *S)
Expected< TemplateArgument > ImportTemplateArgument(const TemplateArgument &From)
ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E)
ExpectedStmt VisitCaseStmt(CaseStmt *S)
ExpectedStmt VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E)
ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E)
ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D)
ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E)
ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E)
ExpectedStmt VisitLambdaExpr(LambdaExpr *LE)
ExpectedStmt VisitBinaryOperator(BinaryOperator *E)
ExpectedStmt VisitCallExpr(CallExpr *E)
ExpectedStmt VisitDeclStmt(DeclStmt *S)
ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E)
ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E)
Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin)
ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D)
ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D)
Expected< CXXCastPath > ImportCastPath(CastExpr *E)
Expected< APValue > ImportAPValue(const APValue &FromValue)
ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D)
ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E)
ExpectedDecl VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D)
ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E)
ExpectedDecl VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D)
ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias)
ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D)
ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D)
ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D)
Expected< ObjCTypeParamList * > ImportObjCTypeParamList(ObjCTypeParamList *list)
ExpectedDecl VisitUsingPackDecl(UsingPackDecl *D)
ExpectedStmt VisitWhileStmt(WhileStmt *S)
ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D)
ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E)
ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S)
ExpectedDecl VisitFriendDecl(FriendDecl *D)
Error ImportContainerChecked(const InContainerTy &InContainer, OutContainerTy &OutContainer)
ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E)
ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E)
bool IsStructuralMatch(Decl *From, Decl *To, bool Complain=true, bool IgnoreTemplateParmDepth=false)
ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E)
ExpectedStmt VisitForStmt(ForStmt *S)
ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E)
ExpectedDecl VisitEnumDecl(EnumDecl *D)
ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D)
ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E)
ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E)
ExpectedStmt VisitSwitchStmt(SwitchStmt *S)
ExpectedType VisitType(const Type *T)
ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D)
ExpectedDecl ImportUsingShadowDecls(BaseUsingDecl *D, BaseUsingDecl *ToSI)
ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E)
ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E)
ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D)
ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E)
ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D)
ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E)
ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E)
ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D)
Error ImportTemplateArguments(ArrayRef< TemplateArgument > FromArgs, SmallVectorImpl< TemplateArgument > &ToArgs)
ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D)
ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E)
ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D)
ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D)
ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E)
ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E)
Error ImportTemplateArgumentListInfo(const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo)
ExpectedStmt VisitDoStmt(DoStmt *S)
ExpectedStmt VisitNullStmt(NullStmt *S)
ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E)
ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D)
Error ImportOverriddenMethods(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod)
ExpectedStmt VisitStringLiteral(StringLiteral *E)
Error ImportDeclarationNameLoc(const DeclarationNameInfo &From, DeclarationNameInfo &To)
ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E)
bool hasReturnTypeDeclaredInside(FunctionDecl *D)
This function checks if the given function has a return type that contains a reference (in any way) t...
ASTNodeImporter(ASTImporter &Importer)
std::tuple< FunctionTemplateDecl *, TemplateArgsTy > FunctionTemplateAndArgsTy
ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D)
ExpectedStmt VisitMemberExpr(MemberExpr *E)
ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E)
Error ImportInitializer(VarDecl *From, VarDecl *To)
ImportDefinitionKind
What we should import from the definition.
@ IDK_Everything
Import everything.
@ IDK_Default
Import the default subset of the definition, which might be nothing (if minimal import is set) or mig...
@ IDK_Basic
Import only the bare bones needed to establish a valid DeclContext.
ExpectedDecl VisitTypedefDecl(TypedefDecl *D)
ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D)
ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E)
ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D)
ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E)
ExpectedStmt VisitIfStmt(IfStmt *S)
ExpectedStmt VisitLabelStmt(LabelStmt *S)
ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E)
ExpectedStmt VisitConvertVectorExpr(ConvertVectorExpr *E)
ExpectedDecl VisitUsingEnumDecl(UsingEnumDecl *D)
ExpectedStmt VisitGotoStmt(GotoStmt *S)
ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E)
ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S)
ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S)
ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D)
ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S)
ExpectedDecl VisitImportDecl(ImportDecl *D)
Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD)
ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E)
ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E)
ExpectedDecl VisitEmptyDecl(EmptyDecl *D)
ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E)
ExpectedStmt VisitExpr(Expr *E)
Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam, ParmVarDecl *ToParam)
ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E)
ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S)
ExpectedStmt VisitAttributedStmt(AttributedStmt *S)
ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S)
ExpectedStmt VisitParenListExpr(ParenListExpr *E)
Expected< FunctionDecl * > FindFunctionTemplateSpecialization(FunctionDecl *FromFD)
ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D)
ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S)
Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD)
ExpectedStmt VisitStmtExpr(StmtExpr *E)
ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E)
bool shouldForceImportDeclContext(ImportDefinitionKind IDK)
ExpectedDecl VisitBindingDecl(BindingDecl *D)
ExpectedStmt VisitBreakStmt(BreakStmt *S)
Represents an access specifier followed by colon ':'.
AddrLabelExpr - The GNU address of label extension, representing &&label.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Represents a loop initializing the elements of an array.
Represents a constant array type that does not decay to a pointer when used as a function parameter.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
A structure for storing the information associated with a name that has been assumed to be a template...
DeclarationName getDeclName() const
Get the name of the template.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Attr - This represents one attribute.
attr::Kind getKind() const
void setPackExpansion(bool PE)
Attr * clone(ASTContext &C) const
SourceRange getRange() const
void setRange(SourceRange R)
void setAttrName(const IdentifierInfo *AttrNameII)
const IdentifierInfo * getAttrName() const
Represents an attribute applied to a statement.
static AttributedStmt * Create(const ASTContext &C, SourceLocation Loc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
An attributed type is a type to which a type attribute has been applied.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Represents a C++ declaration that introduces decls from somewhere else.
void addShadowDecl(UsingShadowDecl *S)
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
A binding in a decomposition declaration.
void setBinding(QualType DeclaredType, Expr *Binding)
Set the binding for this BindingDecl, along with its declared type (which should be a possibly-cv-qua...
void setDecomposedDecl(ValueDecl *Decomposed)
Set the decomposed variable for this BindingDecl.
A fixed int type of a specified bitwidth.
BreakStmt - This represents a break.
Represents a C++2a __builtin_bit_cast(T, v) expression.
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
This class is used for builtin types like 'int'.
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
Represents a base class of a C++ class.
AccessSpecifier getAccessSpecifierAsWritten() const
Retrieves the access specifier as written in the source code (which may mean that no access specifier...
SourceLocation getEllipsisLoc() const
For a pack expansion, determine the location of the ellipsis.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
TypeSourceInfo * getTypeSourceInfo() const
Retrieves the type and source location of the base class.
bool isBaseOfClass() const
Determine whether this base class is a base of a class declared with the 'class' keyword (vs.
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Represents binding an expression to a temporary.
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
A boolean literal, per ([C++ lex.bool] Boolean literals).
static CXXBoolLiteralExpr * Create(const ASTContext &C, bool Val, QualType Ty, SourceLocation Loc)
CXXCatchStmt - This represents a C++ catch block.
static CXXConstCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Represents a call to a C++ constructor.
void setIsImmediateEscalating(bool Set)
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
Represents a C++ base or member initializer.
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
bool isDelegatingInitializer() const
Determine whether this initializer is creating a delegating constructor.
Expr * getInit() const
Get the initializer.
SourceLocation getRParenLoc() const
SourceLocation getEllipsisLoc() const
SourceLocation getLParenLoc() const
bool isPackExpansion() const
Determine whether this initializer is a pack expansion.
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
bool isMemberInitializer() const
Determine whether this initializer is initializing a non-static data member.
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
bool isIndirectMemberInitializer() const
SourceLocation getMemberLocation() const
IndirectFieldDecl * getIndirectMember() const
bool isBaseVirtual() const
Returns whether the base is virtual or not.
Represents a C++ deduction guide declaration.
A default argument (C++ [dcl.fct.default]).
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
A use of a default initializer in a constructor or in aggregate initialization.
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext, Expr *RewrittenInitExpr)
Field is the non-static data member whose default initializer is used by this expression.
Represents a delete expression for memory deallocation and destructor calls, e.g.
Represents a C++ member access expression where the actual member referenced could not be resolved be...
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a C++ destructor within a class.
void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg)
static CXXDynamicCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Represents a folding of a pack over an operator.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, SourceLocation RPLoc)
Represents a call to an inherited base class constructor from an inheriting constructor.
Represents a call to a member function that may be written either with member call syntax (e....
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
Represents a static or instance method of a struct/union/class.
void addOverriddenMethod(const CXXMethodDecl *MD)
overridden_method_range overridden_methods() const
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Abstract class common to all of the C++ "named"/"keyword" casts.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, ArrayRef< Expr * > PlacementArgs, SourceRange TypeIdParens, std::optional< Expr * > ArraySize, CXXNewInitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
The null pointer literal (C++11 [lex.nullptr])
static CXXOperatorCallExpr * Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, ADLCallKind UsesADL=NotADL)
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Represents a C++ struct/union/class.
CXXRecordDecl * getMostRecentDecl()
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
method_range methods() const
CXXRecordDecl * getDefinition() const
static CXXRecordDecl * CreateLambda(const ASTContext &C, DeclContext *DC, TypeSourceInfo *Info, SourceLocation Loc, unsigned DependencyKind, bool IsGeneric, LambdaCaptureDefault CaptureDefault)
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
void setDescribedClassTemplate(ClassTemplateDecl *Template)
void setLambdaNumbering(LambdaNumbering Numbering)
Set the mangling numbers and context declaration for a lambda class.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
CXXRecordDecl * getPreviousDecl()
static CXXReinterpretCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
A rewritten comparison expression that was originally written using operator syntax.
An expression "T()" which creates an rvalue of a non-class type T.
static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Represents a C++ functional cast expression that builds a temporary object.
static CXXTemporaryObjectExpr * Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, ArrayRef< Expr * > Args, SourceRange ParenOrBraceRange, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization)
Represents a C++ temporary.
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Represents the this expression in C++.
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
A C++ throw-expression (C++ [except.throw]).
CXXTryStmt - A C++ try block, including all handlers.
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, CompoundStmt *tryBlock, ArrayRef< Stmt * > handlers)
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
CaseStmt - Represent a case statement.
static CaseStmt * Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs, SourceLocation caseLoc, SourceLocation ellipsisLoc, SourceLocation colonLoc)
Build a case statement.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CharUnits - This is an opaque type for sizes expressed in character units.
How to handle import errors that occur when import of a child declaration of a DeclContext fails.
bool ignoreChildErrorOnParent(Decl *FromChildD) const
Determine if import failure of a child does not cause import failure of its parent.
ChildErrorHandlingStrategy(const Decl *FromD)
void handleChildImportResult(Error &ResultErr, Error &&ChildErr)
Process the import result of a child (of the current declaration).
ChildErrorHandlingStrategy(const DeclContext *FromDC)
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Declaration of a class template.
void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
ClassTemplateDecl * getMostRecentDecl()
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
QualType getInjectedSpecializationType() const
Retrieves the injected specialization type for this partial specialization.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a class template specialization, which refers to a class template with a given set of temp...
void setPointOfInstantiation(SourceLocation Loc)
void setExternKeywordLoc(SourceLocation Loc)
Sets the location of the extern keyword.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
Complex values, per C99 6.2.5p11.
CompoundAssignOperator - For compound assignments (e.g.
static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
A reference to a concept and its template args, as it appears in the code.
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
NamedDecl * getFoundDecl() const
const DeclarationNameInfo & getConceptNameInfo() const
ConceptDecl * getNamedConcept() const
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
SourceLocation getTemplateKWLoc() const
ConditionalOperator - The ?: ternary operator.
Represents the canonical version of C arrays with a specified constant size.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Represents a concrete matrix type with constant number of rows and columns.
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
ContinueStmt - This represents a continue.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
Represents a pointer type decayed from an array or function type.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDeclInternal(Decl *D)
Add the declaration D into this context, but suppress searches for external declarations with the sam...
bool containsDeclAndLoad(Decl *D) const
Checks whether a declaration is in this context.
void removeDecl(Decl *D)
Removes a declaration from this context.
lookup_result noload_lookup(DeclarationName Name)
Find the declarations with the given name that are visible within this context; don't attempt to retr...
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
void localUncachedLookup(DeclarationName Name, SmallVectorImpl< NamedDecl * > &Results)
A simplistic name lookup mechanism that performs name lookup into this declaration context without co...
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
A reference to a declared variable, function, enum, etc.
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
A simple visitor class that helps create declaration visitors.
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration.
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isParameterPack() const
Whether this declaration is a parameter pack.
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_None
Not a friend object.
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
const char * getDeclKindName() const
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
@ IDNS_NonMemberOperator
This declaration is a C++ operator declared in a non-class context.
@ IDNS_TagFriend
This declaration is a friend class.
@ IDNS_Ordinary
Ordinary names.
@ IDNS_ObjCProtocol
Objective C @protocol.
@ IDNS_Namespace
Namespaces, declared with 'namespace foo {}'.
@ IDNS_OrdinaryFriend
This declaration is a friend function.
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
void setImplicit(bool I=true)
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
bool isInAnonymousNamespace() const
SourceLocation getBeginLoc() const LLVM_READONLY
TranslationUnitDecl * getTranslationUnitDecl()
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setLexicalDeclContext(DeclContext *DC)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name.
const IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it.
static DeclarationName getUsingDirectiveName()
Returns the name for all C++ using-directives.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
@ CXXConversionFunctionName
QualType getCXXNameType() const
If this name is one of the C++ names (of a constructor, destructor, or conversion function),...
Selector getObjCSelector() const
Get the Objective-C selector stored in this declaration name.
NameKind getNameKind() const
Determine what kind of name this is.
bool isEmpty() const
Evaluates true when this declaration name is empty.
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Represents the type decltype(expr) (C++11).
A decomposition declaration.
Represents a C++17 deduced template specialization type.
Represents an extended address space qualifier where the input address space value is dependent.
Represents a qualified type name for which the type name is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents an array type in C++ whose size is a value-dependent expression.
Represents an extended vector type where either the type or size is dependent.
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Represents a dependent template name that cannot be resolved prior to template instantiation.
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Represents a template specialization type whose template cannot be resolved, e.g.
Represents a vector type where either the type or size is dependent.
Represents a single C99 designator.
static Designator CreateArrayRangeDesignator(unsigned Index, SourceLocation LBracketLoc, SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
Creates a GNU array-range designator.
static Designator CreateFieldDesignator(const IdentifierInfo *FieldName, SourceLocation DotLoc, SourceLocation FieldLoc)
Creates a field designator.
static Designator CreateArrayDesignator(unsigned Index, SourceLocation LBracketLoc, SourceLocation RBracketLoc)
Creates an array designator.
Represents a C99 designated initializer expression.
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
A little helper class used to produce diagnostics.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
void notePriorDiagnosticFrom(const DiagnosticsEngine &Other)
Note that the prior diagnostic was emitted by some other DiagnosticsEngine, and we may be attaching a...
DoStmt - This represents a 'do/while' stmt.
Symbolic representation of a dynamic allocation.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
Represents an empty-declaration.
An instance of this object exists for each enum constant that is defined.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
void setIntegerType(QualType T)
Set the underlying integer type.
EnumDecl * getMostRecentDecl()
void completeDefinition(QualType NewType, QualType PromotionType, unsigned NumPositiveBits, unsigned NumNegativeBits)
When created, the EnumDecl corresponds to a forward-declared enum.
EnumDecl * getDefinition() const
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
QualType getPromotionType() const
Return the integer type that enumerators should promote to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
ExplicitCastExpr - An explicit cast written in the source code.
Store information needed for an explicit specifier.
ExplicitSpecKind getKind() const
const Expr * getExpr() const
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
llvm::PointerUnion< BlockDecl *, CompoundLiteralExpr * > CleanupObject
The type of objects that are kept in the cleanup.
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
ExprDependence getDependence() const
An expression trait intrinsic.
ExtVectorType - Extended vector type.
virtual void CompleteType(TagDecl *Tag)
Gives the external AST source an opportunity to complete an incomplete type.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
void setCapturedVLAType(const VariableArrayType *VLAType)
Set the captured variable length array type for this field.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Implements support for file system lookup, file system caching, and directory search management.
OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Get a FileEntryRef if it exists, without doing anything on error.
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
ForStmt - This represents a 'for (init;cond;inc)' stmt.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Represents a function declaration or definition.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
ArrayRef< ParmVarDecl * > parameters() const
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
void setDefaultLoc(SourceLocation NewLoc)
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
@ TK_MemberSpecialization
@ TK_DependentNonTemplate
@ TK_FunctionTemplateSpecialization
@ TK_DependentFunctionTemplateSpecialization
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
void setInstantiatedFromDecl(FunctionDecl *FD)
Specify that this function declaration was instantiated from a FunctionDecl FD.
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
void setRangeEnd(SourceLocation E)
FunctionDecl * getInstantiatedFromDecl() const
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
void setDefaulted(bool D=true)
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
void setExplicitlyDefaulted(bool ED=true)
State that this function is explicitly defaulted.
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > exceptions() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getMostRecentDecl()
ExtInfo getExtInfo() const
QualType getReturnType() const
This represents a GCC inline-assembly statement extension.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Represents a C11 generic selection.
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression accepting an expression predicate.
GotoStmt - This represents a direct goto.
One of these records is kept for each identifier that is lexed.
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
void setBuiltinID(unsigned ID)
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
IfStmt - This represents an if/then/else.
static IfStmt * Create(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL, SourceLocation RPL, Stmt *Then, SourceLocation EL=SourceLocation(), Stmt *Else=nullptr)
Create an IfStmt.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Represents an implicitly-generated value initialization of an object of a given type.
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
IndirectGotoStmt - This represents an indirect goto.
Description of a constructor that was inherited from a base class.
CXXConstructorDecl * getConstructor() const
ConstructorUsingShadowDecl * getShadowDecl() const
Describes an C or C++ initializer list.
void setSyntacticForm(InitListExpr *Init)
void setArrayFiller(Expr *filler)
void setInitializedFieldInUnion(FieldDecl *FD)
void sawArrayRangeDesignator(bool ARD=true)
The injected class name of a C++ class template or class template partial specialization.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
An lvalue reference type, per C++11 [dcl.ref].
Represents the declaration of a label.
void setStmt(LabelStmt *T)
LabelStmt - Represents a label, which has a substatement.
Describes the capture of a variable or of this, or of a C++1y init-capture.
bool capturesVariable() const
Determine whether this capture handles a variable.
bool isPackExpansion() const
Determine whether this capture is a pack expansion, which captures a function parameter pack.
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis for a capture that is a pack expansion.
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
ValueDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
bool isImplicit() const
Determine whether this was an implicit capture (not written between the square brackets introducing t...
SourceLocation getLocation() const
Retrieve the source location of the capture.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
static LambdaExpr * Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange, LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc, bool ExplicitParams, bool ExplicitResultType, ArrayRef< Expr * > CaptureInits, SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack)
Construct a new lambda expression.
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
Represents a linkage specification.
void setRBraceLoc(SourceLocation L)
Represents the results of name lookup.
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
A pointer to member type per C++ 8.3.3 - Pointers to members.
Provides information a specialization of a member of a class template, which may be a member function...
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
This represents a decl that may have a name.
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a C++ namespace alias.
Represent a C++ namespace.
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace that inhabits this namespace, if any.
void setRBraceLoc(SourceLocation L)
Class that aids in the construction of nested-name-specifiers along with source-location information ...
A C++ nested-name-specifier augmented with source location information.
SourceLocation getLocalEndLoc() const
Retrieve the location of the end of this component of the nested-name-specifier.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
SpecifierKind
The kind of specifier that completes this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
static NestedNameSpecifier * SuperSpecifier(const ASTContext &Context, CXXRecordDecl *RD)
Returns the nested name specifier representing the __super scope for the given CXXRecordDecl.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
NullStmt - This is the null statement ";": C99 6.8.3p3.
Represents Objective-C's @catch statement.
Represents Objective-C's @finally statement.
Represents Objective-C's @synchronized statement.
Represents Objective-C's @throw statement.
Represents Objective-C's @try ... @catch ... @finally statement.
static ObjCAtTryStmt * Create(const ASTContext &Context, SourceLocation atTryLoc, Stmt *atTryStmt, Stmt **CatchStmts, unsigned NumCatchStmts, Stmt *atFinallyStmt)
Represents Objective-C's @autoreleasepool Statement.
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...
ObjCCategoryDecl - Represents a category declaration.
void setTypeParamList(ObjCTypeParamList *TPL)
Set the type parameters of this category.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
void setImplementation(ObjCCategoryImplDecl *ImplD)
ObjCProtocolList::iterator protocol_iterator
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
Represents Objective-C's collection statement.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
const ObjCInterfaceDecl * getSuperClass() const
Represents an ObjC class declaration.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
ObjCCategoryDecl * FindCategoryDeclaration(const IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
protocol_loc_iterator protocol_loc_begin() const
void setImplementation(ObjCImplementationDecl *ImplD)
known_categories_range known_categories() const
void setSuperClass(TypeSourceInfo *superClass)
protocol_iterator protocol_end() const
SourceLocation getSuperClassLoc() const
Retrieve the starting location of the superclass.
void setTypeParamList(ObjCTypeParamList *TPL)
Set the type parameters of this class.
ObjCProtocolList::iterator protocol_iterator
ObjCImplementationDecl * getImplementation() const
protocol_iterator protocol_begin() const
void startDefinition()
Starts the definition of this Objective-C class, taking it from a forward declaration (@class) to a d...
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCInterfaceDecl * getSuperClass() const
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
TypeSourceInfo * getSuperClassTInfo() const
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCMethodDecl - Represents an instance or class method declaration.
void setMethodParams(ASTContext &C, ArrayRef< ParmVarDecl * > Params, ArrayRef< SourceLocation > SelLocs={})
Sets the method's parameters and selector source locations.
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implicit parameters.
ParmVarDecl *const * param_iterator
ObjCInterfaceDecl * getClassInterface()
Represents a pointer to an Objective C object.
Represents a class type in Objective C.
Represents one property declaration in an Objective-C interface.
void setSetterName(Selector Sel, SourceLocation Loc=SourceLocation())
void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal)
void setPropertyAttributesAsWritten(ObjCPropertyAttribute::Kind PRVal)
void setPropertyIvarDecl(ObjCIvarDecl *Ivar)
void setSetterMethodDecl(ObjCMethodDecl *gDecl)
void setGetterName(Selector Sel, SourceLocation Loc=SourceLocation())
void setGetterMethodDecl(ObjCMethodDecl *gDecl)
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
ObjCIvarDecl * getPropertyIvarDecl() const
SourceLocation getPropertyIvarDeclLoc() const
Kind getPropertyImplementation() const
Represents an Objective-C protocol declaration.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
void startDefinition()
Starts the definition of this Objective-C protocol.
ObjCProtocolList::iterator protocol_iterator
protocol_iterator protocol_begin() const
protocol_iterator protocol_end() const
protocol_loc_iterator protocol_loc_begin() const
Represents the declaration of an Objective-C type parameter.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
SourceLocation getRAngleLoc() const
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
SourceLocation getLAngleLoc() const
Represents a type parameter type in Objective C.
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
Helper class for OffsetOfExpr.
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
FieldDecl * getField() const
For a field offsetof node, returns the field.
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
@ Array
An index into an array.
@ Identifier
A field in a dependent type, known only by its name.
@ Base
An implicit indirection through a C++ base class, when the field found is in a base class.
SourceLocation getBeginLoc() const LLVM_READONLY
Kind getKind() const
Determine what kind of offsetof node this is.
SourceLocation getEndLoc() const LLVM_READONLY
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
A structure for storing the information associated with an overloaded template name.
Represents a C++11 pack expansion that produces a sequence of expressions.
Represents a pack expansion of types.
ParenExpr - This represents a parenthesized expression, e.g.
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
bool isKNRPromoted() const
True if the value passed to this parameter must undergo K&R-style default argument promotion:
void setObjCDeclQualifier(ObjCDeclQualifier QTVal)
void setDefaultArg(Expr *defarg)
SourceLocation getExplicitObjectParamThisLoc() const
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
void setUninstantiatedDefaultArg(Expr *arg)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
void setObjCMethodScopeInfo(unsigned parameterIndex)
bool hasInheritedDefaultArg() const
void setKNRPromoted(bool promoted)
void setExplicitObjectParameterLoc(SourceLocation Loc)
Expr * getUninstantiatedDefaultArg()
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
void setHasInheritedDefaultArg(bool I=true)
PointerType - C99 6.7.5.1 - Pointer Declarators.
[C99 6.4.2.2] - A predefined identifier such as func.
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
Stores the type being destroyed by a pseudo-destructor expression.
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
QualType getCanonicalType() const
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Represents a template name as written in source code.
TemplateName getUnderlyingTemplate() const
Return the underlying template name.
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
bool hasTemplateKeyword() const
Whether the template name was prefixed by the "template" keyword.
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool isLambda() const
Determine whether this record is a class describing a lambda function object.
void setAnonymousStructOrUnion(bool Anon)
RecordDecl * getMostRecentDecl()
virtual void completeDefinition()
Note that the definition of this type is now complete.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Provides common interface for the Decls that can be redeclared.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Base for LValueReferenceType and RValueReferenceType.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
static ReturnStmt * Create(const ASTContext &Ctx, SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
Create a return statement.
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Smart pointer class that efficiently represents Objective-C method names.
const IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
bool isNull() const
Determine whether this is the empty selector.
unsigned getNumArgs() const
static std::enable_if_t< std::is_base_of_v< Attr, AttrInfo >, SourceLocation > getAttrLoc(const AttrInfo &AL)
A helper function to provide Attribute Location for the Attr types AND the ParsedAttr.
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Represents an expression that computes the length of a parameter pack.
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, std::optional< unsigned > Length=std::nullopt, ArrayRef< TemplateArgument > PartialArgs={})
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
Encodes a location in the source.
This class handles loading and caching of source files into memory.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
bool isWrittenInBuiltinFile(SourceLocation Loc) const
Returns whether Loc is located in a <built-in> file.
FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
SourceLocation getComposedLoc(FileID FID, unsigned Offset) const
Form a SourceLocation from a FileID and Offset pair.
FileManager & getFileManager() const
FileID getMainFileID() const
Returns the FileID of the main source file.
unsigned getFileIDSize(FileID FID) const
The size of the SLocEntry that FID represents.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file.
SourceLocation createExpansionLoc(SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned Length, bool ExpansionIsTokenRange=true, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)
Creates an expansion SLocEntry for a macro use.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
SourceLocation createMacroArgExpansionLoc(SourceLocation SpellingLoc, SourceLocation ExpansionLoc, unsigned Length)
Creates an expansion SLocEntry for the substitution of an argument into a function-like macro's body.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
One instance of this struct is kept for every file loaded or used.
Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded,...
SourceLocation getExpansionLocStart() const
bool isExpansionTokenRange() const
SourceLocation getSpellingLoc() const
bool isMacroArgExpansion() const
SourceLocation getExpansionLocEnd() const
const ContentCache & getContentCache() const
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
SourceLocation getIncludeLoc() const
This is a discriminated union of FileInfo and ExpansionInfo.
const FileInfo & getFile() const
const ExpansionInfo & getExpansion() const
Represents a C++11 static_assert declaration.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
child_iterator child_begin()
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
child_iterator child_end()
const char * getStmtClassName() const
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
Represents a reference to a non-type template parameter that has been substituted with a template arg...
A structure for storing an already-substituted template template parameter pack.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
TemplateArgument getArgumentPack() const
Retrieve the template template argument pack with which this parameter was substituted.
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
A structure for storing the information associated with a substituted template template parameter.
TemplateName getReplacement() const
std::optional< unsigned > getPackIndex() const
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
Represents the result of substituting a set of types for a template type parameter pack.
Represents the result of substituting a type for a template type parameter.
void setNextSwitchCase(SwitchCase *SC)
SwitchStmt - This represents a 'switch' stmt.
static SwitchStmt * Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a switch statement.
Represents the declaration of a struct/union/class/enum.
bool isBeingDefined() const
Return true if this decl is currently being defined.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
void setBraceRange(SourceRange R)
void setCompleteDefinition(bool V=true)
True if this decl has its body fully specified.
A convenient class for passing around template argument information.
SourceLocation getRAngleLoc() const
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
SourceLocation getLAngleLoc() const
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Location wrapper for a TemplateArgument.
TemplateArgumentLocInfo getLocInfo() const
const TemplateArgument & getArgument() const
Represents a template argument.
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
QualType getParamTypeForDecl() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
std::optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce,...
QualType getAsType() const
Retrieve the type for a type template argument.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
QualType getIntegralType() const
Retrieve the type of the integral value.
bool getIsDefaulted() const
If returns 'true', this TemplateArgument corresponds to a default template parameter.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) 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,...
@ DeducedTemplate
A template name that refers to another TemplateName with deduced default arguments.
@ QualifiedTemplate
A qualified template name, where the qualification is kept to describe the source code as written.
@ AssumedTemplate
An unqualified-id that has been assumed to name a function template that will be found by ADL.
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
SourceLocation getTemplateLoc() const
Represents a type template specialization; the template must be a class template, a type alias templa...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Declaration of a template type parameter.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
TypeAliasTemplateDecl * getDescribedAliasTemplate() const
Declaration of an alias template.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
Symbolic representation of typeid(T) for some type T.
const Type * getType() const
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
ExpectedType Visit(const Type *T)
Performs the operation associated with this visitor object.
The base class of the type hierarchy.
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
bool isPointerType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
QualType getCanonicalTypeInternal() const
const char * getTypeClassName() const
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Base class for declarations which introduce a typedef-name.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
static UnaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
static UnresolvedMemberExpr * Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
void addDecl(NamedDecl *D)
A set of unresolved declarations.
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represents a dependent using declaration which was marked with typename.
Represents a dependent using declaration which was not marked with typename.
Represents a C++ using-declaration.
Represents C++ using-directive.
Represents a C++ using-enum-declaration.
Represents a pack of using declarations that a single using-declarator pack-expanded into.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represents a call to the builtin function __builtin_va_arg.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
EvaluatedStmt * getEvaluatedStmt() const
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form,...
void setInlineSpecified()
void setTSCSpec(ThreadStorageClassSpecifier TSC)
const Expr * getInit() const
void setConstexpr(bool IC)
void setDescribedVarTemplate(VarTemplateDecl *Template)
void setImplicitlyInline()
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
VarTemplateDecl * getMostRecentDecl()
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
Represents a variable template specialization, which refers to a variable template with a given set o...
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setPointOfInstantiation(SourceLocation Loc)
VarTemplateSpecializationDecl * getMostRecentDecl()
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
WhileStmt - This represents a 'while' stmt.
static WhileStmt * Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body, SourceLocation WL, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a while statement.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
StructuralEquivalenceKind
Whether to perform a normal or minimal equivalence check.
CanThrowResult
Possible results from evaluation of a noexcept expression.
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__builtin_common_type
This names the __builtin_common_type BuiltinTemplateDecl.
@ BTK__make_integer_seq
This names the __make_integer_seq BuiltinTemplateDecl.
CastKind
CastKind - The kind of operation required for a conversion.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
const FunctionProtoType * T
llvm::SmallVector< Decl *, 2 > getCanonicalForwardRedeclChain(Decl *D)
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
static void updateFlags(const Decl *From, Decl *To)
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
Location information for a TemplateArgument.
SourceLocation getTemplateEllipsisLoc() const
NestedNameSpecifierLoc getTemplateQualifierLoc() const
TypeSourceInfo * getAsTypeSourceInfo() const
SourceLocation getTemplateNameLoc() const