57#include "llvm/ADT/ArrayRef.h"
58#include "llvm/ADT/DenseMap.h"
59#include "llvm/ADT/STLExtras.h"
60#include "llvm/ADT/ScopeExit.h"
61#include "llvm/ADT/SmallVector.h"
62#include "llvm/Support/ErrorHandling.h"
63#include "llvm/Support/MemoryBuffer.h"
74 using llvm::make_error;
89 return "NameConflict";
91 return "UnsupportedConstruct";
93 return "Unknown error";
95 llvm_unreachable(
"Invalid error code.");
96 return "Invalid error code.";
102 llvm_unreachable(
"Function not implemented.");
111 for (
auto *R :
D->getFirstDecl()->
redecls()) {
112 if (R !=
D->getFirstDecl())
113 Redecls.push_back(R);
115 Redecls.push_back(
D->getFirstDecl());
116 std::reverse(Redecls.begin(), Redecls.end());
121 if (
auto *FD = dyn_cast<FunctionDecl>(
D))
122 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
123 if (
auto *VD = dyn_cast<VarDecl>(
D))
124 return getCanonicalForwardRedeclChain<VarDecl>(VD);
125 if (
auto *TD = dyn_cast<TagDecl>(
D))
126 return getCanonicalForwardRedeclChain<TagDecl>(TD);
127 llvm_unreachable(
"Bad declaration kind");
148 bool const IgnoreChildErrors;
152 : FromDC(FromDC), IgnoreChildErrors(!
isa<
TagDecl>(FromDC)) {}
162 if (ChildErr && !IgnoreChildErrors)
163 ResultErr = joinErrors(std::move(ResultErr), std::move(ChildErr));
165 consumeError(std::move(ChildErr));
171 if (!IgnoreChildErrors || !FromDC)
179 public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
183 template <
typename ImportT>
184 [[nodiscard]] Error importInto(ImportT &To,
const ImportT &From) {
189 template <
typename ImportT>
190 [[nodiscard]] Error importInto(ImportT *&To, ImportT *From) {
191 auto ToOrErr = Importer.
Import(From);
193 To = cast_or_null<ImportT>(*ToOrErr);
194 return ToOrErr.takeError();
199 template <
typename T>
203 auto ToOrErr = Importer.
Import(From);
205 return ToOrErr.takeError();
206 return cast_or_null<T>(*ToOrErr);
209 template <
typename T>
210 auto import(
const T *From) {
211 return import(
const_cast<T *
>(From));
215 template <
typename T>
217 return Importer.
Import(From);
221 template <
typename T>
225 return import(*From);
232 template <
typename ToDeclT>
struct CallOverloadedCreateFun {
233 template <
typename... Args>
decltype(
auto)
operator()(Args &&... args) {
234 return ToDeclT::Create(std::forward<Args>(args)...);
244 template <
typename ToDeclT,
typename FromDeclT,
typename... Args>
245 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
250 CallOverloadedCreateFun<ToDeclT> OC;
251 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
252 std::forward<Args>(args)...);
259 template <
typename NewDeclT,
typename ToDeclT,
typename FromDeclT,
261 [[nodiscard]]
bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
263 CallOverloadedCreateFun<NewDeclT> OC;
264 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
265 std::forward<Args>(args)...);
269 template <
typename ToDeclT,
typename CreateFunT,
typename FromDeclT,
272 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
273 FromDeclT *FromD, Args &&...args) {
281 ToD = CreateFun(std::forward<Args>(args)...);
284 Importer.SharedState->markAsNewDecl(ToD);
285 InitializeImportedDecl(FromD, ToD);
289 void InitializeImportedDecl(
Decl *FromD,
Decl *ToD) {
293 if (FromD->isImplicit())
301 if (
D->doesThisDeclarationHaveABody() &&
307 void addDeclToContexts(
Decl *FromD,
Decl *ToD) {
312 if (!FromD->getDescribedTemplate() &&
319 DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
323 bool Visible =
false;
336 if (
auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
337 auto *ToNamed = cast<NamedDecl>(ToD);
339 FromDC->
lookup(FromNamed->getDeclName());
340 if (llvm::is_contained(FromLookup, FromNamed))
357 updateLookupTableForTemplateParameters(
361 template <
typename TemplateParmDeclT>
362 Error importTemplateParameterDefaultArgument(
const TemplateParmDeclT *
D,
363 TemplateParmDeclT *ToD) {
364 if (
D->hasDefaultArgument()) {
365 if (
D->defaultArgumentWasInherited()) {
367 import(
D->getDefaultArgStorage().getInheritedFrom());
368 if (!ToInheritedFromOrErr)
369 return ToInheritedFromOrErr.takeError();
370 TemplateParmDeclT *ToInheritedFrom = *ToInheritedFromOrErr;
371 if (!ToInheritedFrom->hasDefaultArgument()) {
375 import(
D->getDefaultArgStorage()
377 ->getDefaultArgument());
378 if (!ToInheritedDefaultArgOrErr)
379 return ToInheritedDefaultArgOrErr.takeError();
380 ToInheritedFrom->setDefaultArgument(Importer.
getToContext(),
381 *ToInheritedDefaultArgOrErr);
383 ToD->setInheritedDefaultArgument(ToD->getASTContext(),
387 import(
D->getDefaultArgument());
388 if (!ToDefaultArgOrErr)
389 return ToDefaultArgOrErr.takeError();
392 if (!ToD->hasDefaultArgument())
397 return Error::success();
409#define TYPE(Class, Base) \
410 ExpectedType Visit##Class##Type(const Class##Type *T);
411#include "clang/AST/TypeNodes.inc"
469 template <
typename InContainerTy>
473 template<
typename InContainerTy>
480 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
485 template <
typename DeclTy>
498 template <
typename T>
502 bool IgnoreTemplateParmDepth =
false);
694 Err = MaybeVal.takeError();
700 template<
typename IIter,
typename OIter>
702 using ItemT = std::remove_reference_t<
decltype(*Obegin)>;
703 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
706 return ToOrErr.takeError();
709 return Error::success();
716 template<
typename InContainerTy,
typename OutContainerTy>
718 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
720 InContainer.begin(), InContainer.end(), OutContainer.begin());
723 template<
typename InContainerTy,
typename OIter>
740template <
typename InContainerTy>
744 auto ToLAngleLocOrErr =
import(FromLAngleLoc);
745 if (!ToLAngleLocOrErr)
746 return ToLAngleLocOrErr.takeError();
747 auto ToRAngleLocOrErr =
import(FromRAngleLoc);
748 if (!ToRAngleLocOrErr)
749 return ToRAngleLocOrErr.takeError();
755 return Error::success();
759Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
770 return ImportTemplateArgumentListInfo(
771 From.LAngleLoc, From.RAngleLoc, From.arguments(),
Result);
783 if (Error Err = importInto(std::get<0>(
Result), FTSInfo->getTemplate()))
784 return std::move(Err);
789 return std::move(Err);
799 return std::move(Err);
802 if (!ToRequiresClause)
803 return ToRequiresClause.takeError();
806 if (!ToTemplateLocOrErr)
807 return ToTemplateLocOrErr.takeError();
809 if (!ToLAngleLocOrErr)
810 return ToLAngleLocOrErr.takeError();
812 if (!ToRAngleLocOrErr)
813 return ToRAngleLocOrErr.takeError();
834 return ToTypeOrErr.takeError();
842 return ToTypeOrErr.takeError();
849 return ToOrErr.takeError();
852 return ToTypeOrErr.takeError();
853 return TemplateArgument(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()),
860 return ToTypeOrErr.takeError();
868 return ToTypeOrErr.takeError();
871 return ToValueOrErr.takeError();
878 if (!ToTemplateOrErr)
879 return ToTemplateOrErr.takeError();
887 if (!ToTemplateOrErr)
888 return ToTemplateOrErr.takeError();
898 return ToExpr.takeError();
904 return std::move(Err);
911 llvm_unreachable(
"Invalid template argument kind");
919 return ArgOrErr.takeError();
928 return E.takeError();
934 return TSIOrErr.takeError();
936 auto ToTemplateQualifierLocOrErr =
938 if (!ToTemplateQualifierLocOrErr)
939 return ToTemplateQualifierLocOrErr.takeError();
941 if (!ToTemplateNameLocOrErr)
942 return ToTemplateNameLocOrErr.takeError();
943 auto ToTemplateEllipsisLocOrErr =
945 if (!ToTemplateEllipsisLocOrErr)
946 return ToTemplateEllipsisLocOrErr.takeError();
949 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
959 size_t NumDecls = DG.
end() - DG.
begin();
961 ToDecls.reserve(NumDecls);
962 for (
Decl *FromD : DG) {
963 if (
auto ToDOrErr =
import(FromD))
964 ToDecls.push_back(*ToDOrErr);
966 return ToDOrErr.takeError();
976 if (
D.isFieldDesignator()) {
981 return ToDotLocOrErr.takeError();
984 if (!ToFieldLocOrErr)
985 return ToFieldLocOrErr.takeError();
988 ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
991 ExpectedSLoc ToLBracketLocOrErr =
import(
D.getLBracketLoc());
992 if (!ToLBracketLocOrErr)
993 return ToLBracketLocOrErr.takeError();
995 ExpectedSLoc ToRBracketLocOrErr =
import(
D.getRBracketLoc());
996 if (!ToRBracketLocOrErr)
997 return ToRBracketLocOrErr.takeError();
999 if (
D.isArrayDesignator())
1001 *ToLBracketLocOrErr,
1002 *ToRBracketLocOrErr);
1004 ExpectedSLoc ToEllipsisLocOrErr =
import(
D.getEllipsisLoc());
1005 if (!ToEllipsisLocOrErr)
1006 return ToEllipsisLocOrErr.takeError();
1008 assert(
D.isArrayRangeDesignator());
1010 D.getArrayIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
1011 *ToRBracketLocOrErr);
1016 Error Err = Error::success();
1019 auto ToConceptNameLoc =
1025 return std::move(Err);
1028 if (ASTTemplateArgs)
1030 return std::move(Err);
1048 return VarOrErr.takeError();
1053 return LocationOrErr.takeError();
1058 return std::move(Err);
1065template <
typename T>
1067 if (
Found->getLinkageInternal() != From->getLinkageInternal())
1070 if (From->hasExternalFormalLinkage())
1071 return Found->hasExternalFormalLinkage();
1074 if (From->isInAnonymousNamespace())
1075 return Found->isInAnonymousNamespace();
1077 return !
Found->isInAnonymousNamespace() &&
1078 !
Found->hasExternalFormalLinkage();
1098using namespace clang;
1107 ExpectedType UnderlyingTypeOrErr =
import(
T->getValueType());
1108 if (!UnderlyingTypeOrErr)
1109 return UnderlyingTypeOrErr.takeError();
1115 switch (
T->getKind()) {
1116#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1117 case BuiltinType::Id: \
1118 return Importer.getToContext().SingletonId;
1119#include "clang/Basic/OpenCLImageTypes.def"
1120#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1121 case BuiltinType::Id: \
1122 return Importer.getToContext().Id##Ty;
1123#include "clang/Basic/OpenCLExtensionTypes.def"
1124#define SVE_TYPE(Name, Id, SingletonId) \
1125 case BuiltinType::Id: \
1126 return Importer.getToContext().SingletonId;
1127#include "clang/Basic/AArch64SVEACLETypes.def"
1128#define PPC_VECTOR_TYPE(Name, Id, Size) \
1129 case BuiltinType::Id: \
1130 return Importer.getToContext().Id##Ty;
1131#include "clang/Basic/PPCTypes.def"
1132#define RVV_TYPE(Name, Id, SingletonId) \
1133 case BuiltinType::Id: \
1134 return Importer.getToContext().SingletonId;
1135#include "clang/Basic/RISCVVTypes.def"
1136#define WASM_TYPE(Name, Id, SingletonId) \
1137 case BuiltinType::Id: \
1138 return Importer.getToContext().SingletonId;
1139#include "clang/Basic/WebAssemblyReferenceTypes.def"
1140#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
1141 case BuiltinType::Id: \
1142 return Importer.getToContext().SingletonId;
1143#include "clang/Basic/AMDGPUTypes.def"
1144#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1145 case BuiltinType::Id: \
1146 return Importer.getToContext().SingletonId;
1147#include "clang/Basic/HLSLIntangibleTypes.def"
1148#define SHARED_SINGLETON_TYPE(Expansion)
1149#define BUILTIN_TYPE(Id, SingletonId) \
1150 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1151#include "clang/AST/BuiltinTypes.def"
1159 case BuiltinType::Char_U:
1168 case BuiltinType::Char_S:
1177 case BuiltinType::WChar_S:
1178 case BuiltinType::WChar_U:
1184 llvm_unreachable(
"Invalid BuiltinType Kind!");
1188 ExpectedType ToOriginalTypeOrErr =
import(
T->getOriginalType());
1189 if (!ToOriginalTypeOrErr)
1190 return ToOriginalTypeOrErr.takeError();
1196 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1197 if (!ToElementTypeOrErr)
1198 return ToElementTypeOrErr.takeError();
1205 if (!ToPointeeTypeOrErr)
1206 return ToPointeeTypeOrErr.takeError();
1214 if (!ToPointeeTypeOrErr)
1215 return ToPointeeTypeOrErr.takeError();
1223 ExpectedType ToPointeeTypeOrErr =
import(
T->getPointeeTypeAsWritten());
1224 if (!ToPointeeTypeOrErr)
1225 return ToPointeeTypeOrErr.takeError();
1233 ExpectedType ToPointeeTypeOrErr =
import(
T->getPointeeTypeAsWritten());
1234 if (!ToPointeeTypeOrErr)
1235 return ToPointeeTypeOrErr.takeError();
1244 if (!ToPointeeTypeOrErr)
1245 return ToPointeeTypeOrErr.takeError();
1248 if (!ClassTypeOrErr)
1249 return ClassTypeOrErr.takeError();
1257 Error Err = Error::success();
1261 return std::move(Err);
1264 ToElementType,
T->getSize(), ToSizeExpr,
T->getSizeModifier(),
1265 T->getIndexTypeCVRQualifiers());
1271 if (!ToArrayTypeOrErr)
1272 return ToArrayTypeOrErr.takeError();
1279 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1280 if (!ToElementTypeOrErr)
1281 return ToElementTypeOrErr.takeError();
1284 T->getSizeModifier(),
1285 T->getIndexTypeCVRQualifiers());
1290 Error Err = Error::success();
1295 return std::move(Err);
1297 ToElementType, ToSizeExpr,
T->getSizeModifier(),
1298 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1301ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1303 Error Err = Error::success();
1308 return std::move(Err);
1313 ToElementType, ToSizeExpr,
T->getSizeModifier(),
1314 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1317ExpectedType ASTNodeImporter::VisitDependentSizedExtVectorType(
1319 Error Err = Error::success();
1324 return std::move(Err);
1326 ToElementType, ToSizeExpr, ToAttrLoc);
1330 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1331 if (!ToElementTypeOrErr)
1332 return ToElementTypeOrErr.takeError();
1335 T->getNumElements(),
1336 T->getVectorKind());
1340 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1341 if (!ToElementTypeOrErr)
1342 return ToElementTypeOrErr.takeError();
1345 T->getNumElements());
1353 if (!ToReturnTypeOrErr)
1354 return ToReturnTypeOrErr.takeError();
1363 if (!ToReturnTypeOrErr)
1364 return ToReturnTypeOrErr.takeError();
1371 return TyOrErr.takeError();
1372 ArgTypes.push_back(*TyOrErr);
1380 return TyOrErr.takeError();
1381 ExceptionTypes.push_back(*TyOrErr);
1385 Error Err = Error::success();
1402 return std::move(Err);
1405 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1410 Error Err = Error::success();
1412 auto ToPrevD =
importChecked(Err,
T->getDecl()->getPreviousDecl());
1414 return std::move(Err);
1417 ToD, cast_or_null<TypeDecl>(ToPrevD));
1422 if (!ToInnerTypeOrErr)
1423 return ToInnerTypeOrErr.takeError();
1433 return Pattern.takeError();
1436 return Index.takeError();
1443 return ToDeclOrErr.takeError();
1450 if (!ToUnderlyingTypeOrErr)
1451 return ToUnderlyingTypeOrErr.takeError();
1459 return ToExprOrErr.takeError();
1464 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnmodifiedType());
1465 if (!ToUnderlyingTypeOrErr)
1466 return ToUnderlyingTypeOrErr.takeError();
1474 return FoundOrErr.takeError();
1476 if (!UnderlyingOrErr)
1477 return UnderlyingOrErr.takeError();
1486 return ToExprOrErr.takeError();
1488 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1489 if (!ToUnderlyingTypeOrErr)
1490 return ToUnderlyingTypeOrErr.takeError();
1493 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1499 if (!ToBaseTypeOrErr)
1500 return ToBaseTypeOrErr.takeError();
1502 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1503 if (!ToUnderlyingTypeOrErr)
1504 return ToUnderlyingTypeOrErr.takeError();
1507 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr,
T->getUTTKind());
1512 ExpectedType ToDeducedTypeOrErr =
import(
T->getDeducedType());
1513 if (!ToDeducedTypeOrErr)
1514 return ToDeducedTypeOrErr.takeError();
1516 ExpectedDecl ToTypeConstraintConcept =
import(
T->getTypeConstraintConcept());
1517 if (!ToTypeConstraintConcept)
1518 return ToTypeConstraintConcept.takeError();
1523 return std::move(Err);
1526 *ToDeducedTypeOrErr,
T->getKeyword(),
false,
1527 false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1531ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1535 if (!ToTemplateNameOrErr)
1536 return ToTemplateNameOrErr.takeError();
1537 ExpectedType ToDeducedTypeOrErr =
import(
T->getDeducedType());
1538 if (!ToDeducedTypeOrErr)
1539 return ToDeducedTypeOrErr.takeError();
1545ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1549 return ToDeclOrErr.takeError();
1553 const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
1554 assert(isa_and_nonnull<InjectedClassNameType>(Ty));
1561 return ToDeclOrErr.takeError();
1569 return ToDeclOrErr.takeError();
1575 ExpectedType ToModifiedTypeOrErr =
import(
T->getModifiedType());
1576 if (!ToModifiedTypeOrErr)
1577 return ToModifiedTypeOrErr.takeError();
1578 ExpectedType ToEquivalentTypeOrErr =
import(
T->getEquivalentType());
1579 if (!ToEquivalentTypeOrErr)
1580 return ToEquivalentTypeOrErr.takeError();
1583 T->getAttrKind(), *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr,
1590 if (!ToWrappedTypeOrErr)
1591 return ToWrappedTypeOrErr.takeError();
1593 Error Err = Error::success();
1600 return ToDeclOrErr.takeError();
1601 CoupledDecls.emplace_back(*ToDeclOrErr, TI.isDeref());
1605 *ToWrappedTypeOrErr, CountExpr,
T->isCountInBytes(),
T->isOrNull(),
1606 ArrayRef(CoupledDecls.data(), CoupledDecls.size()));
1609ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1613 return ToDeclOrErr.takeError();
1616 T->getDepth(),
T->getIndex(),
T->isParameterPack(), *ToDeclOrErr);
1619ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1623 return ReplacedOrErr.takeError();
1625 ExpectedType ToReplacementTypeOrErr =
import(
T->getReplacementType());
1626 if (!ToReplacementTypeOrErr)
1627 return ToReplacementTypeOrErr.takeError();
1630 *ToReplacementTypeOrErr, *ReplacedOrErr,
T->getIndex(),
T->getPackIndex(),
1631 T->getSubstitutionFlag());
1634ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1638 return ReplacedOrErr.takeError();
1641 if (!ToArgumentPack)
1642 return ToArgumentPack.takeError();
1645 *ReplacedOrErr,
T->getIndex(),
T->getFinal(), *ToArgumentPack);
1648ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1650 auto ToTemplateOrErr =
import(
T->getTemplateName());
1651 if (!ToTemplateOrErr)
1652 return ToTemplateOrErr.takeError();
1657 return std::move(Err);
1664 ToCanonType = *TyOrErr;
1666 return TyOrErr.takeError();
1675 auto ToQualifierOrErr =
import(
T->getQualifier());
1676 if (!ToQualifierOrErr)
1677 return ToQualifierOrErr.takeError();
1680 if (!ToNamedTypeOrErr)
1681 return ToNamedTypeOrErr.takeError();
1684 if (!ToOwnedTagDeclOrErr)
1685 return ToOwnedTagDeclOrErr.takeError();
1690 *ToOwnedTagDeclOrErr);
1696 if (!ToPatternOrErr)
1697 return ToPatternOrErr.takeError();
1700 T->getNumExpansions(),
1704ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1706 auto ToQualifierOrErr =
import(
T->getQualifier());
1707 if (!ToQualifierOrErr)
1708 return ToQualifierOrErr.takeError();
1713 ToPack.reserve(
T->template_arguments().size());
1715 return std::move(Err);
1718 T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1723 auto ToQualifierOrErr =
import(
T->getQualifier());
1724 if (!ToQualifierOrErr)
1725 return ToQualifierOrErr.takeError();
1734 return TyOrErr.takeError();
1746 return ToDeclOrErr.takeError();
1753 if (!ToBaseTypeOrErr)
1754 return ToBaseTypeOrErr.takeError();
1757 for (
auto TypeArg :
T->getTypeArgsAsWritten()) {
1759 TypeArgs.push_back(*TyOrErr);
1761 return TyOrErr.takeError();
1765 for (
auto *
P :
T->quals()) {
1767 Protocols.push_back(*ProtocolOrErr);
1769 return ProtocolOrErr.takeError();
1775 T->isKindOfTypeAsWritten());
1781 if (!ToPointeeTypeOrErr)
1782 return ToPointeeTypeOrErr.takeError();
1789 ExpectedType ToUnderlyingTypeOrErr =
import(
T->getUnderlyingType());
1790 if (!ToUnderlyingTypeOrErr)
1791 return ToUnderlyingTypeOrErr.takeError();
1799 Error Err = Error::success();
1800 QualType ToOriginalType = importChecked(Err,
T->getOriginalType());
1801 QualType ToAdjustedType = importChecked(Err,
T->getAdjustedType());
1803 return std::move(Err);
1805 return Importer.getToContext().getAdjustedType(ToOriginalType,
1810 return Importer.getToContext().getBitIntType(
T->isUnsigned(),
1814ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType(
1816 Error Err = Error::success();
1817 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err,
T->getAttr());
1818 QualType ToWrappedType = importChecked(Err,
T->getWrappedType());
1820 return std::move(Err);
1822 return Importer.getToContext().getBTFTagAttributedType(ToBTFAttr,
1826ExpectedType clang::ASTNodeImporter::VisitHLSLAttributedResourceType(
1828 Error Err = Error::success();
1830 QualType ToWrappedType = importChecked(Err,
T->getWrappedType());
1831 QualType ToContainedType = importChecked(Err,
T->getContainedType());
1833 return std::move(Err);
1835 return Importer.getToContext().getHLSLAttributedResourceType(
1836 ToWrappedType, ToContainedType, ToAttrs);
1839ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType(
1841 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1842 if (!ToElementTypeOrErr)
1843 return ToElementTypeOrErr.takeError();
1845 return Importer.getToContext().getConstantMatrixType(
1846 *ToElementTypeOrErr,
T->getNumRows(),
T->getNumColumns());
1849ExpectedType clang::ASTNodeImporter::VisitDependentAddressSpaceType(
1851 Error Err = Error::success();
1853 Expr *ToAddrSpaceExpr = importChecked(Err,
T->getAddrSpaceExpr());
1856 return std::move(Err);
1858 return Importer.getToContext().getDependentAddressSpaceType(
1859 ToPointeeType, ToAddrSpaceExpr, ToAttrLoc);
1862ExpectedType clang::ASTNodeImporter::VisitDependentBitIntType(
1864 ExpectedExpr ToNumBitsExprOrErr =
import(
T->getNumBitsExpr());
1865 if (!ToNumBitsExprOrErr)
1866 return ToNumBitsExprOrErr.takeError();
1867 return Importer.getToContext().getDependentBitIntType(
T->isUnsigned(),
1868 *ToNumBitsExprOrErr);
1871ExpectedType clang::ASTNodeImporter::VisitDependentSizedMatrixType(
1873 Error Err = Error::success();
1874 QualType ToElementType = importChecked(Err,
T->getElementType());
1875 Expr *ToRowExpr = importChecked(Err,
T->getRowExpr());
1876 Expr *ToColumnExpr = importChecked(Err,
T->getColumnExpr());
1879 return std::move(Err);
1881 return Importer.getToContext().getDependentSizedMatrixType(
1882 ToElementType, ToRowExpr, ToColumnExpr, ToAttrLoc);
1885ExpectedType clang::ASTNodeImporter::VisitDependentVectorType(
1887 Error Err = Error::success();
1888 QualType ToElementType = importChecked(Err,
T->getElementType());
1889 Expr *ToSizeExpr = importChecked(Err,
T->getSizeExpr());
1892 return std::move(Err);
1894 return Importer.getToContext().getDependentVectorType(
1895 ToElementType, ToSizeExpr, ToAttrLoc,
T->getVectorKind());
1898ExpectedType clang::ASTNodeImporter::VisitObjCTypeParamType(
1902 return ToDeclOrErr.takeError();
1907 if (!ToProtocolOrErr)
1908 return ToProtocolOrErr.takeError();
1909 ToProtocols.push_back(*ToProtocolOrErr);
1912 return Importer.getToContext().getObjCTypeParamType(*ToDeclOrErr,
1917 ExpectedType ToElementTypeOrErr =
import(
T->getElementType());
1918 if (!ToElementTypeOrErr)
1919 return ToElementTypeOrErr.takeError();
1922 if (
T->isReadOnly())
1942 if (isa<RecordDecl>(
D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1944 auto getLeafPointeeType = [](
const Type *
T) {
1952 getLeafPointeeType(
P->getType().getCanonicalType().getTypePtr());
1953 auto *RT = dyn_cast<RecordType>(LeafT);
1954 if (RT && RT->getDecl() ==
D) {
1967 if (Error Err = importInto(Name,
D->getDeclName()))
1979 return Error::success();
1986 if (Error Err = importInto(Name,
D->getDeclName()))
1998 return Error::success();
2003 return Error::success();
2006 if (Error Err = importInto(ToD, FromD))
2009 if (
RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
2010 if (
RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
2011 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
2012 !ToRecord->getDefinition()) {
2017 return Error::success();
2020 if (
EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
2021 if (
EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
2022 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2027 return Error::success();
2030 return Error::success();
2045 return Error::success();
2051 return ToRangeOrErr.takeError();
2052 return Error::success();
2058 return LocOrErr.takeError();
2059 return Error::success();
2067 return ToTInfoOrErr.takeError();
2068 return Error::success();
2071 llvm_unreachable(
"Unknown name kind.");
2078 return ToDCOrErr.takeError();
2092 auto MightNeedReordering = [](
const Decl *
D) {
2093 return isa<FieldDecl>(
D) || isa<IndirectFieldDecl>(
D) || isa<FriendDecl>(
D);
2097 Error ChildErrors = Error::success();
2098 for (
auto *From : FromDC->
decls()) {
2099 if (!MightNeedReordering(From))
2108 if (!ImportedOrErr) {
2110 ImportedOrErr.takeError());
2113 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
2114 Decl *ImportedDecl = *ImportedOrErr;
2115 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
2116 if (FieldFrom && FieldTo) {
2148 consumeError(std::move(ChildErrors));
2149 return ToDCOrErr.takeError();
2152 if (
const auto *FromRD = dyn_cast<RecordDecl>(FromDC)) {
2156 for (
auto *
D : FromRD->decls()) {
2157 if (!MightNeedReordering(
D))
2160 assert(
D &&
"DC contains a null decl");
2163 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->
containsDecl(ToD));
2175 for (
auto *From : FromDC->
decls()) {
2176 if (MightNeedReordering(From))
2182 ImportedOrErr.takeError());
2202 if (!FromRecordDecl || !ToRecordDecl) {
2206 if (RecordFrom && RecordTo) {
2207 FromRecordDecl = RecordFrom->
getDecl();
2208 ToRecordDecl = RecordTo->getDecl();
2212 if (FromRecordDecl && ToRecordDecl) {
2218 return Error::success();
2225 return ToDCOrErr.takeError();
2231 if (!ToLexicalDCOrErr)
2232 return ToLexicalDCOrErr.takeError();
2233 ToLexicalDC = *ToLexicalDCOrErr;
2237 return Error::success();
2243 "Import implicit methods to or from non-definition");
2246 if (FromM->isImplicit()) {
2249 return ToMOrErr.takeError();
2252 return Error::success();
2261 return ToTypedefOrErr.takeError();
2263 return Error::success();
2268 auto DefinitionCompleter = [To]() {
2287 auto *FromCXXRD = cast<CXXRecordDecl>(From);
2289 ToCaptures.reserve(FromCXXRD->capture_size());
2290 for (
const auto &FromCapture : FromCXXRD->captures()) {
2291 if (
auto ToCaptureOrErr =
import(FromCapture))
2292 ToCaptures.push_back(*ToCaptureOrErr);
2294 return ToCaptureOrErr.takeError();
2296 cast<CXXRecordDecl>(To)->setCaptures(Importer.
getToContext(),
2303 DefinitionCompleter();
2307 return Error::success();
2322 auto DefinitionCompleterScopeExit =
2323 llvm::make_scope_exit(DefinitionCompleter);
2329 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2330 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2331 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2333 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2334 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2336 #define FIELD(Name, Width, Merge) \
2337 ToData.Name = FromData.Name;
2338 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2341 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2344 for (
const auto &Base1 : FromCXX->bases()) {
2347 return TyOrErr.takeError();
2350 if (Base1.isPackExpansion()) {
2351 if (
ExpectedSLoc LocOrErr =
import(Base1.getEllipsisLoc()))
2352 EllipsisLoc = *LocOrErr;
2354 return LocOrErr.takeError();
2362 auto RangeOrErr =
import(Base1.getSourceRange());
2364 return RangeOrErr.takeError();
2366 auto TSIOrErr =
import(Base1.getTypeSourceInfo());
2368 return TSIOrErr.takeError();
2374 Base1.isBaseOfClass(),
2375 Base1.getAccessSpecifierAsWritten(),
2380 ToCXX->setBases(Bases.data(), Bases.size());
2388 return Error::success();
2393 return Error::success();
2397 return Error::success();
2401 return ToInitOrErr.takeError();
2412 return Error::success();
2420 return Error::success();
2431 return ToTypeOrErr.takeError();
2434 if (!ToPromotionTypeOrErr)
2435 return ToPromotionTypeOrErr.takeError();
2446 return Error::success();
2452 for (
const auto &Arg : FromArgs) {
2453 if (
auto ToOrErr =
import(Arg))
2454 ToArgs.push_back(*ToOrErr);
2456 return ToOrErr.takeError();
2459 return Error::success();
2465 return import(From);
2468template <
typename InContainerTy>
2471 for (
const auto &FromLoc : Container) {
2472 if (
auto ToLocOrErr =
import(FromLoc))
2475 return ToLocOrErr.takeError();
2477 return Error::success();
2487 bool IgnoreTemplateParmDepth) {
2498 false, Complain,
false,
2499 IgnoreTemplateParmDepth);
2500 return Ctx.IsEquivalent(From, To);
2519 return std::move(Err);
2524 return LocOrErr.takeError();
2527 if (GetImportedOrCreateDecl(ToD,
D, Importer.
getToContext(), DC, *LocOrErr))
2550 return std::move(Err);
2556 Name.getAsIdentifierInfo()))
2559 Error Err = Error::success();
2564 return std::move(Err);
2568 addDeclToContexts(
D, ToD);
2576 return LocOrErr.takeError();
2577 auto ColonLocOrErr =
import(
D->getColonLoc());
2579 return ColonLocOrErr.takeError();
2584 return DCOrErr.takeError();
2589 DC, *LocOrErr, *ColonLocOrErr))
2603 return DCOrErr.takeError();
2607 Error Err = Error::success();
2613 return std::move(Err);
2616 if (GetImportedOrCreateDecl(
2617 ToD,
D, Importer.
getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2618 ToRParenLoc,
D->isFailed()))
2633 return std::move(Err);
2642 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2648 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2649 for (
auto *FoundDecl : FoundDecls) {
2653 if (
auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2654 MergeWithNamespace = FoundNS;
2655 ConflictingDecls.clear();
2659 ConflictingDecls.push_back(FoundDecl);
2662 if (!ConflictingDecls.empty()) {
2665 ConflictingDecls.size());
2667 Name = NameOrErr.get();
2669 return NameOrErr.takeError();
2675 return BeginLocOrErr.takeError();
2677 if (!RBraceLocOrErr)
2678 return RBraceLocOrErr.takeError();
2683 if (GetImportedOrCreateDecl(ToNamespace,
D, Importer.
getToContext(), DC,
2684 D->isInline(), *BeginLocOrErr,
Loc,
2685 Name.getAsIdentifierInfo(),
2686 nullptr,
D->isNested()))
2695 if (
auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2696 TU->setAnonymousNamespace(ToNamespace);
2698 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2704 return std::move(Err);
2716 return std::move(Err);
2722 Error Err = Error::success();
2726 auto ToTargetNameLoc =
importChecked(Err,
D->getTargetNameLoc());
2729 return std::move(Err);
2734 if (GetImportedOrCreateDecl(
2735 ToD,
D, Importer.
getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2736 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2754 return std::move(Err);
2773 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2774 for (
auto *FoundDecl : FoundDecls) {
2777 if (
auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2781 QualType FromUT =
D->getUnderlyingType();
2782 QualType FoundUT = FoundTypedef->getUnderlyingType();
2796 if (FromR && FoundR &&
2807 ConflictingDecls.push_back(FoundDecl);
2812 if (!ConflictingDecls.empty()) {
2814 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2816 Name = NameOrErr.get();
2818 return NameOrErr.takeError();
2822 Error Err = Error::success();
2824 auto ToTypeSourceInfo =
importChecked(Err,
D->getTypeSourceInfo());
2827 return std::move(Err);
2834 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2836 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2838 }
else if (GetImportedOrCreateDecl<TypedefDecl>(
2840 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2845 return std::move(Err);
2849 Importer.AddToLookupTable(ToTypedef);
2854 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(
D) :
nullptr;
2877 return std::move(Err);
2887 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2888 for (
auto *FoundDecl : FoundDecls) {
2891 if (
auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) {
2894 ConflictingDecls.push_back(FoundDecl);
2898 if (!ConflictingDecls.empty()) {
2900 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2902 Name = NameOrErr.get();
2904 return NameOrErr.takeError();
2908 Error Err = Error::success();
2909 auto ToTemplateParameters =
importChecked(Err,
D->getTemplateParameters());
2910 auto ToTemplatedDecl =
importChecked(Err,
D->getTemplatedDecl());
2912 return std::move(Err);
2916 Name, ToTemplateParameters, ToTemplatedDecl))
2919 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2925 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2936 return std::move(Err);
2943 if (
D->isGnuLocal()) {
2946 return BeginLocOrErr.takeError();
2948 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2953 Name.getAsIdentifierInfo()))
2960 return ToStmtOrErr.takeError();
2962 ToLabel->
setStmt(*ToStmtOrErr);
2975 return std::move(Err);
2982 if (!SearchName &&
D->getTypedefNameForAnonDecl()) {
2983 if (Error Err = importInto(
2984 SearchName,
D->getTypedefNameForAnonDecl()->getDeclName()))
2985 return std::move(Err);
2995 Importer.findDeclsInToCtx(DC, SearchName);
2996 for (
auto *FoundDecl : FoundDecls) {
3000 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
3001 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
3002 FoundDecl = Tag->getDecl();
3005 if (
auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
3010 if (
D->isThisDeclarationADefinition() && FoundDef)
3015 ConflictingDecls.push_back(FoundDecl);
3024 if (SearchName && !ConflictingDecls.empty()) {
3026 SearchName, DC, IDNS, ConflictingDecls.data(),
3027 ConflictingDecls.size());
3029 Name = NameOrErr.get();
3031 return NameOrErr.takeError();
3035 Error Err = Error::success();
3041 return std::move(Err);
3045 if (GetImportedOrCreateDecl(
3047 Loc, Name.getAsIdentifierInfo(), PrevDecl,
D->isScoped(),
3048 D->isScopedUsingClassTag(),
D->isFixed()))
3056 addDeclToContexts(
D, D2);
3060 EnumDecl *FromInst =
D->getInstantiatedFromMemberEnum();
3062 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
3064 return ToInstOrErr.takeError();
3065 if (
ExpectedSLoc POIOrErr =
import(MemberInfo->getPointOfInstantiation()))
3068 return POIOrErr.takeError();
3072 if (
D->isCompleteDefinition())
3074 return std::move(Err);
3080 bool IsFriendTemplate =
false;
3081 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3083 DCXX->getDescribedClassTemplate() &&
3084 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
3094 return std::move(Err);
3101 if (!SearchName &&
D->getTypedefNameForAnonDecl()) {
3102 if (Error Err = importInto(
3103 SearchName,
D->getTypedefNameForAnonDecl()->getDeclName()))
3104 return std::move(Err);
3111 bool DependentFriend = IsFriendTemplate && IsDependentContext;
3118 Importer.findDeclsInToCtx(DC, SearchName);
3119 if (!FoundDecls.empty()) {
3122 if (
D->hasExternalLexicalStorage() && !
D->isCompleteDefinition())
3126 for (
auto *FoundDecl : FoundDecls) {
3131 if (
auto *Typedef = dyn_cast<TypedefNameDecl>(
Found)) {
3132 if (
const auto *Tag = Typedef->getUnderlyingType()->getAs<
TagType>())
3133 Found = Tag->getDecl();
3136 if (
auto *FoundRecord = dyn_cast<RecordDecl>(
Found)) {
3155 if (
D->isThisDeclarationADefinition() && FoundDef) {
3159 if (
const auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3160 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
3161 assert(FoundCXX &&
"Record type mismatch");
3167 return std::move(Err);
3174 ConflictingDecls.push_back(FoundDecl);
3178 if (!ConflictingDecls.empty() && SearchName) {
3180 SearchName, DC, IDNS, ConflictingDecls.data(),
3181 ConflictingDecls.size());
3183 Name = NameOrErr.get();
3185 return NameOrErr.takeError();
3191 return BeginLocOrErr.takeError();
3196 if (
auto *DCXX = dyn_cast<CXXRecordDecl>(
D)) {
3197 if (DCXX->isLambda()) {
3198 auto TInfoOrErr =
import(DCXX->getLambdaTypeInfo());
3200 return TInfoOrErr.takeError();
3201 if (GetImportedOrCreateSpecialDecl(
3203 DC, *TInfoOrErr,
Loc, DCXX->getLambdaDependencyKind(),
3204 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
3209 return CDeclOrErr.takeError();
3212 }
else if (DCXX->isInjectedClassName()) {
3215 const bool DelayTypeCreation =
true;
3216 if (GetImportedOrCreateDecl(
3218 *BeginLocOrErr,
Loc, Name.getAsIdentifierInfo(),
3219 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
3222 D2CXX, dyn_cast<CXXRecordDecl>(DC));
3224 if (GetImportedOrCreateDecl(D2CXX,
D, Importer.
getToContext(),
3225 D->getTagKind(), DC, *BeginLocOrErr,
Loc,
3226 Name.getAsIdentifierInfo(),
3227 cast_or_null<CXXRecordDecl>(PrevDecl)))
3234 addDeclToContexts(
D, D2);
3237 DCXX->getDescribedClassTemplate()) {
3239 if (Error Err = importInto(ToDescribed, FromDescribed))
3240 return std::move(Err);
3242 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
3262 const Type *FrontTy =
3263 cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
3266 InjSpec = InjTy->getInjectedSpecializationType();
3269 for (
auto *R : Redecls) {
3270 auto *RI = cast<CXXRecordDecl>(R);
3271 if (R != Redecls.front() ||
3272 !isa<InjectedClassNameType>(RI->getTypeForDecl()))
3273 RI->setTypeForDecl(
nullptr);
3288 DCXX->getMemberSpecializationInfo()) {
3290 MemberInfo->getTemplateSpecializationKind();
3296 return ToInstOrErr.takeError();
3299 import(MemberInfo->getPointOfInstantiation()))
3303 return POIOrErr.takeError();
3308 D->getTagKind(), DC, *BeginLocOrErr,
Loc,
3309 Name.getAsIdentifierInfo(), PrevDecl))
3312 addDeclToContexts(
D, D2);
3315 if (
auto BraceRangeOrErr =
import(
D->getBraceRange()))
3318 return BraceRangeOrErr.takeError();
3319 if (
auto QualifierLocOrErr =
import(
D->getQualifierLoc()))
3322 return QualifierLocOrErr.takeError();
3324 if (
D->isAnonymousStructOrUnion())
3327 if (
D->isCompleteDefinition())
3329 return std::move(Err);
3341 return std::move(Err);
3350 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3351 for (
auto *FoundDecl : FoundDecls) {
3355 if (
auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3358 ConflictingDecls.push_back(FoundDecl);
3362 if (!ConflictingDecls.empty()) {
3364 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3366 Name = NameOrErr.get();
3368 return NameOrErr.takeError();
3374 return TypeOrErr.takeError();
3378 return InitOrErr.takeError();
3381 if (GetImportedOrCreateDecl(
3383 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr,
D->getInitVal()))
3384 return ToEnumerator;
3389 return ToEnumerator;
3392template <
typename DeclTy>
3395 unsigned int Num = FromD->getNumTemplateParameterLists();
3397 return Error::success();
3399 for (
unsigned int I = 0; I <
Num; ++I)
3401 import(FromD->getTemplateParameterList(I)))
3402 ToTPLists[I] = *ToTPListOrErr;
3404 return ToTPListOrErr.takeError();
3405 ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3406 return Error::success();
3414 return Error::success();
3420 return Error::success();
3426 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3428 return InstFDOrErr.takeError();
3434 return POIOrErr.takeError();
3436 return Error::success();
3440 auto FunctionAndArgsOrErr =
3442 if (!FunctionAndArgsOrErr)
3443 return FunctionAndArgsOrErr.takeError();
3446 Importer.
getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3450 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3451 if (FromTAArgsAsWritten)
3453 *FromTAArgsAsWritten, ToTAInfo))
3456 ExpectedSLoc POIOrErr =
import(FTSInfo->getPointOfInstantiation());
3458 return POIOrErr.takeError();
3464 ToFD->setFunctionTemplateSpecialization(
3465 std::get<0>(*FunctionAndArgsOrErr), ToTAList,
nullptr,
3466 TSK, FromTAArgsAsWritten ? &ToTAInfo :
nullptr, *POIOrErr);
3467 return Error::success();
3475 Candidates.
addDecl(*ToFTDOrErr);
3477 return ToFTDOrErr.takeError();
3482 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3483 if (FromTAArgsAsWritten)
3490 FromTAArgsAsWritten ? &ToTAInfo :
nullptr);
3491 return Error::success();
3494 llvm_unreachable(
"All cases should be covered!");
3499 auto FunctionAndArgsOrErr =
3501 if (!FunctionAndArgsOrErr)
3502 return FunctionAndArgsOrErr.takeError();
3506 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3507 void *InsertPos =
nullptr;
3518 return ToBodyOrErr.takeError();
3520 return Error::success();
3529 assert(DCi &&
"Declaration should have a context");
3543 ToProcess.push_back(S);
3544 while (!ToProcess.empty()) {
3545 const Stmt *CurrentS = ToProcess.pop_back_val();
3547 if (
const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS)) {
3548 if (
const Decl *
D = DeclRef->getDecl())
3551 }
else if (
const auto *
E =
3552 dyn_cast_or_null<SubstNonTypeTemplateParmExpr>(CurrentS)) {
3553 if (
const Decl *
D =
E->getAssociatedDecl())
3586class IsTypeDeclaredInsideVisitor
3587 :
public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3589 IsTypeDeclaredInsideVisitor(
const FunctionDecl *ParentDC)
3590 : ParentDC(ParentDC) {}
3596 if (std::optional<bool> Res = Visit(
T.getTypePtr()))
3599 T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3601 if (std::optional<bool> Res = Visit(DsT.
getTypePtr()))
3604 DsT =
T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3609 std::optional<bool> VisitTagType(
const TagType *
T) {
3610 if (
auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(
T->getDecl()))
3611 for (
const auto &Arg : Spec->getTemplateArgs().asArray())
3612 if (checkTemplateArgument(Arg))
3617 std::optional<bool> VisitPointerType(
const PointerType *
T) {
3622 return CheckType(
T->getPointeeTypeAsWritten());
3625 std::optional<bool> VisitTypedefType(
const TypedefType *
T) {
3631 std::optional<bool> VisitUsingType(
const UsingType *
T) {
3632 if (
T->getFoundDecl() &&
3641 for (
const auto &Arg :
T->template_arguments())
3642 if (checkTemplateArgument(Arg))
3649 return CheckType(
T->getBaseType());
3664 return CheckType(
T->getElementType());
3669 "Variable array should not occur in deduced return type of a function");
3673 llvm_unreachable(
"Incomplete array should not occur in deduced return type "
3678 llvm_unreachable(
"Dependent array should not occur in deduced return type "
3705 if (checkTemplateArgument(PackArg))
3717 llvm_unreachable(
"Unknown TemplateArgument::ArgKind enum");
3727 assert(FromFPT &&
"Must be called on FunctionProtoType");
3729 auto IsCXX11Lambda = [&]() {
3730 if (Importer.FromContext.
getLangOpts().CPlusPlus14)
3736 QualType RetT = FromFPT->getReturnType();
3737 if (isa<AutoType>(RetT.
getTypePtr()) || IsCXX11Lambda()) {
3739 IsTypeDeclaredInsideVisitor Visitor(Def ? Def :
D);
3740 return Visitor.CheckType(RetT);
3757 auto RedeclIt = Redecls.begin();
3760 for (; RedeclIt != Redecls.end() && *RedeclIt !=
D; ++RedeclIt) {
3763 return ToRedeclOrErr.takeError();
3765 assert(*RedeclIt ==
D);
3773 return std::move(Err);
3785 if (
D->getTemplatedKind() ==
3788 if (!FoundFunctionOrErr)
3789 return FoundFunctionOrErr.takeError();
3790 if (
FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3791 if (
Decl *Def = FindAndMapDefinition(
D, FoundFunction))
3793 FoundByLookup = FoundFunction;
3801 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3802 for (
auto *FoundDecl : FoundDecls) {
3806 if (
auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3811 if (
Decl *Def = FindAndMapDefinition(
D, FoundFunction))
3813 FoundByLookup = FoundFunction;
3824 Importer.
ToDiag(
Loc, diag::warn_odr_function_type_inconsistent)
3825 << Name <<
D->getType() << FoundFunction->getType();
3826 Importer.
ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3827 << FoundFunction->getType();
3828 ConflictingDecls.push_back(FoundDecl);
3832 if (!ConflictingDecls.empty()) {
3834 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3836 Name = NameOrErr.get();
3838 return NameOrErr.takeError();
3848 if (FoundByLookup) {
3849 if (isa<CXXMethodDecl>(FoundByLookup)) {
3851 if (!
D->doesThisDeclarationHaveABody()) {
3853 D->getDescribedFunctionTemplate()) {
3858 "Templated function mapped to non-templated?");
3874 return std::move(Err);
3885 bool UsedDifferentProtoType =
false;
3887 QualType FromReturnTy = FromFPT->getReturnType();
3895 UsedDifferentProtoType =
true;
3906 FromEPI = DefaultEPI;
3907 UsedDifferentProtoType =
true;
3910 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3915 Error Err = Error::success();
3918 auto ToInnerLocStart =
importChecked(Err,
D->getInnerLocStart());
3922 auto TrailingRequiresClause =
3925 return std::move(Err);
3929 for (
auto *
P :
D->parameters()) {
3931 Parameters.push_back(*ToPOrErr);
3933 return ToPOrErr.takeError();
3938 if (
auto *FromConstructor = dyn_cast<CXXConstructorDecl>(
D)) {
3940 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3942 return std::move(Err);
3944 if (FromConstructor->isInheritingConstructor()) {
3946 import(FromConstructor->getInheritedConstructor());
3947 if (!ImportedInheritedCtor)
3948 return ImportedInheritedCtor.takeError();
3949 ToInheritedConstructor = *ImportedInheritedCtor;
3951 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3952 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3953 ToInnerLocStart, NameInfo,
T, TInfo, ESpec,
D->UsesFPIntrin(),
3954 D->isInlineSpecified(),
D->
isImplicit(),
D->getConstexprKind(),
3955 ToInheritedConstructor, TrailingRequiresClause))
3959 Error Err = Error::success();
3961 Err,
const_cast<FunctionDecl *
>(FromDtor->getOperatorDelete()));
3962 auto ToThisArg =
importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3964 return std::move(Err);
3966 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3967 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3968 ToInnerLocStart, NameInfo,
T, TInfo,
D->UsesFPIntrin(),
3969 D->isInlineSpecified(),
D->
isImplicit(),
D->getConstexprKind(),
3970 TrailingRequiresClause))
3977 dyn_cast<CXXConversionDecl>(
D)) {
3979 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3981 return std::move(Err);
3982 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3983 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3984 ToInnerLocStart, NameInfo,
T, TInfo,
D->UsesFPIntrin(),
3985 D->isInlineSpecified(), ESpec,
D->getConstexprKind(),
3988 }
else if (
auto *Method = dyn_cast<CXXMethodDecl>(
D)) {
3989 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3990 ToFunction,
D, Importer.
getToContext(), cast<CXXRecordDecl>(DC),
3991 ToInnerLocStart, NameInfo,
T, TInfo, Method->getStorageClass(),
3992 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3995 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(
D)) {
3997 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,
4007 Guide->getDeductionCandidateKind(), TrailingRequiresClause,
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))
6773 ToFunc->setLexicalDeclContext(LexicalDC);
6774 addDeclToContexts(
D, ToFunc);
6777 if (
LT && !OldParamDC.empty()) {
6778 for (
unsigned int I = 0; I < OldParamDC.size(); ++I)
6782 if (FoundByLookup) {
6787 "Found decl must have its templated decl set");
6788 auto *PrevTemplated =
6790 if (TemplatedFD != PrevTemplated)
6793 ToFunc->setPreviousDecl(Recent);
6804 Importer.
FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
6805 << S->getStmtClassName();
6814 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; I++) {
6818 Names.push_back(ToII);
6821 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; I++) {
6825 Names.push_back(ToII);
6829 for (
unsigned I = 0,
E = S->getNumClobbers(); I !=
E; I++) {
6830 if (
auto ClobberOrErr =
import(S->getClobberStringLiteral(I)))
6831 Clobbers.push_back(*ClobberOrErr);
6833 return ClobberOrErr.takeError();
6838 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; I++) {
6839 if (
auto OutputOrErr =
import(S->getOutputConstraintLiteral(I)))
6840 Constraints.push_back(*OutputOrErr);
6842 return OutputOrErr.takeError();
6845 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; I++) {
6846 if (
auto InputOrErr =
import(S->getInputConstraintLiteral(I)))
6847 Constraints.push_back(*InputOrErr);
6849 return InputOrErr.takeError();
6855 return std::move(Err);
6859 return std::move(Err);
6862 S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6863 return std::move(Err);
6867 return AsmLocOrErr.takeError();
6868 auto AsmStrOrErr =
import(S->getAsmString());
6870 return AsmStrOrErr.takeError();
6871 ExpectedSLoc RParenLocOrErr =
import(S->getRParenLoc());
6872 if (!RParenLocOrErr)
6873 return RParenLocOrErr.takeError();
6886 S->getNumClobbers(),
6894 Error Err = Error::success();
6899 return std::move(Err);
6905 if (!ToSemiLocOrErr)
6906 return ToSemiLocOrErr.takeError();
6908 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6915 return std::move(Err);
6917 ExpectedSLoc ToLBracLocOrErr =
import(S->getLBracLoc());
6918 if (!ToLBracLocOrErr)
6919 return ToLBracLocOrErr.takeError();
6921 ExpectedSLoc ToRBracLocOrErr =
import(S->getRBracLoc());
6922 if (!ToRBracLocOrErr)
6923 return ToRBracLocOrErr.takeError();
6928 *ToLBracLocOrErr, *ToRBracLocOrErr);
6933 Error Err = Error::success();
6938 auto ToEllipsisLoc =
importChecked(Err, S->getEllipsisLoc());
6941 return std::move(Err);
6944 ToCaseLoc, ToEllipsisLoc, ToColonLoc);
6945 ToStmt->setSubStmt(ToSubStmt);
6952 Error Err = Error::success();
6957 return std::move(Err);
6960 ToDefaultLoc, ToColonLoc, ToSubStmt);
6965 Error Err = Error::success();
6970 return std::move(Err);
6973 ToIdentLoc, ToLabelDecl, ToSubStmt);
6978 if (!ToAttrLocOrErr)
6979 return ToAttrLocOrErr.takeError();
6983 return std::move(Err);
6985 if (!ToSubStmtOrErr)
6986 return ToSubStmtOrErr.takeError();
6989 Importer.
getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6994 Error Err = Error::success();
6997 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7005 return std::move(Err);
7008 ToInit, ToConditionVariable, ToCond, ToLParenLoc,
7009 ToRParenLoc, ToThen, ToElseLoc, ToElse);
7014 Error Err = Error::success();
7016 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7023 return std::move(Err);
7027 ToCond, ToLParenLoc, ToRParenLoc);
7028 ToStmt->setBody(ToBody);
7029 ToStmt->setSwitchLoc(ToSwitchLoc);
7033 for (
SwitchCase *SC = S->getSwitchCaseList(); SC !=
nullptr;
7034 SC = SC->getNextSwitchCase()) {
7037 return ToSCOrErr.takeError();
7038 if (LastChainedSwitchCase)
7041 ToStmt->setSwitchCaseList(*ToSCOrErr);
7042 LastChainedSwitchCase = *ToSCOrErr;
7050 Error Err = Error::success();
7051 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7058 return std::move(Err);
7061 ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
7066 Error Err = Error::success();
7073 return std::move(Err);
7076 ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
7081 Error Err = Error::success();
7084 auto ToConditionVariable =
importChecked(Err, S->getConditionVariable());
7091 return std::move(Err);
7095 ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
7101 Error Err = Error::success();
7106 return std::move(Err);
7109 ToLabel, ToGotoLoc, ToLabelLoc);
7114 Error Err = Error::success();
7119 return std::move(Err);
7122 ToGotoLoc, ToStarLoc, ToTarget);
7126 ExpectedSLoc ToContinueLocOrErr =
import(S->getContinueLoc());
7127 if (!ToContinueLocOrErr)
7128 return ToContinueLocOrErr.takeError();
7133 auto ToBreakLocOrErr =
import(S->getBreakLoc());
7134 if (!ToBreakLocOrErr)
7135 return ToBreakLocOrErr.takeError();
7141 Error Err = Error::success();
7144 auto ToNRVOCandidate =
importChecked(Err, S->getNRVOCandidate());
7146 return std::move(Err);
7154 Error Err = Error::success();
7156 auto ToExceptionDecl =
importChecked(Err, S->getExceptionDecl());
7157 auto ToHandlerBlock =
importChecked(Err, S->getHandlerBlock());
7159 return std::move(Err);
7162 ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
7168 return ToTryLocOrErr.takeError();
7170 ExpectedStmt ToTryBlockOrErr =
import(S->getTryBlock());
7171 if (!ToTryBlockOrErr)
7172 return ToTryBlockOrErr.takeError();
7175 for (
unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
7177 if (
auto ToHandlerOrErr =
import(FromHandler))
7178 ToHandlers[HI] = *ToHandlerOrErr;
7180 return ToHandlerOrErr.takeError();
7184 cast<CompoundStmt>(*ToTryBlockOrErr), ToHandlers);
7189 Error Err = Error::success();
7196 auto ToLoopVarStmt =
importChecked(Err, S->getLoopVarStmt());
7203 return std::move(Err);
7206 ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
7207 ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
7212 Error Err = Error::success();
7219 return std::move(Err);
7230 Error Err = Error::success();
7233 auto ToCatchParamDecl =
importChecked(Err, S->getCatchParamDecl());
7236 return std::move(Err);
7239 ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
7243 ExpectedSLoc ToAtFinallyLocOrErr =
import(S->getAtFinallyLoc());
7244 if (!ToAtFinallyLocOrErr)
7245 return ToAtFinallyLocOrErr.takeError();
7246 ExpectedStmt ToAtFinallyStmtOrErr =
import(S->getFinallyBody());
7247 if (!ToAtFinallyStmtOrErr)
7248 return ToAtFinallyStmtOrErr.takeError();
7250 *ToAtFinallyStmtOrErr);
7255 Error Err = Error::success();
7258 auto ToFinallyStmt =
importChecked(Err, S->getFinallyStmt());
7260 return std::move(Err);
7263 for (
unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
7265 if (
ExpectedStmt ToCatchStmtOrErr =
import(FromCatchStmt))
7266 ToCatchStmts[CI] = *ToCatchStmtOrErr;
7268 return ToCatchStmtOrErr.takeError();
7272 ToAtTryLoc, ToTryBody,
7273 ToCatchStmts.begin(), ToCatchStmts.size(),
7280 Error Err = Error::success();
7281 auto ToAtSynchronizedLoc =
importChecked(Err, S->getAtSynchronizedLoc());
7285 return std::move(Err);
7288 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
7292 ExpectedSLoc ToThrowLocOrErr =
import(S->getThrowLoc());
7293 if (!ToThrowLocOrErr)
7294 return ToThrowLocOrErr.takeError();
7295 ExpectedExpr ToThrowExprOrErr =
import(S->getThrowExpr());
7296 if (!ToThrowExprOrErr)
7297 return ToThrowExprOrErr.takeError();
7299 *ToThrowLocOrErr, *ToThrowExprOrErr);
7306 return ToAtLocOrErr.takeError();
7308 if (!ToSubStmtOrErr)
7309 return ToSubStmtOrErr.takeError();
7324 Error Err = Error::success();
7329 return std::move(Err);
7330 auto ParentContextOrErr = Importer.
ImportContext(
E->getParentContext());
7331 if (!ParentContextOrErr)
7332 return ParentContextOrErr.takeError();
7336 RParenLoc, *ParentContextOrErr);
7341 Error Err = Error::success();
7344 auto ToWrittenTypeInfo =
importChecked(Err,
E->getWrittenTypeInfo());
7348 return std::move(Err);
7351 ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
7352 E->isMicrosoftABI());
7357 Error Err = Error::success();
7365 return std::move(Err);
7372 bool CondIsTrue = !
E->isConditionDependent() &&
E->isConditionTrue();
7375 ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
7376 ToRParenLoc, CondIsTrue);
7380 Error Err = Error::success();
7387 return std::move(Err);
7395 Error Err = Error::success();
7399 const unsigned NumSubExprs =
E->getNumSubExprs();
7403 ToSubExprs.resize(NumSubExprs);
7406 return std::move(Err);
7409 Importer.
getToContext(), ToSubExprs, ToType, ToBeginLoc, ToRParenLoc);
7415 return TypeOrErr.takeError();
7419 return BeginLocOrErr.takeError();
7426 Error Err = Error::success();
7428 Expr *ToControllingExpr =
nullptr;
7430 if (
E->isExprPredicate())
7434 assert((ToControllingExpr || ToControllingType) &&
7435 "Either the controlling expr or type must be nonnull");
7439 return std::move(Err);
7444 return std::move(Err);
7449 return std::move(Err);
7452 if (
E->isResultDependent()) {
7453 if (ToControllingExpr) {
7455 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7460 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7465 if (ToControllingExpr) {
7467 ToCtx, ToGenericLoc, ToControllingExpr,
llvm::ArrayRef(ToAssocTypes),
7472 ToCtx, ToGenericLoc, ToControllingType,
llvm::ArrayRef(ToAssocTypes),
7479 Error Err = Error::success();
7484 return std::move(Err);
7487 E->getIdentKind(),
E->isTransparent(),
7493 Error Err = Error::success();
7495 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
7500 return std::move(Err);
7503 if (
E->getDecl() !=
E->getFoundDecl()) {
7504 auto FoundDOrErr =
import(
E->getFoundDecl());
7506 return FoundDOrErr.takeError();
7507 ToFoundD = *FoundDOrErr;
7512 if (
E->hasExplicitTemplateArgs()) {
7515 E->template_arguments(), ToTAInfo))
7516 return std::move(Err);
7517 ToResInfo = &ToTAInfo;
7521 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
7522 E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
7524 if (
E->hadMultipleCandidates())
7525 ToE->setHadMultipleCandidates(
true);
7526 ToE->setIsImmediateEscalating(
E->isImmediateEscalating());
7533 return TypeOrErr.takeError();
7541 return ToInitOrErr.takeError();
7543 ExpectedSLoc ToEqualOrColonLocOrErr =
import(
E->getEqualOrColonLoc());
7544 if (!ToEqualOrColonLocOrErr)
7545 return ToEqualOrColonLocOrErr.takeError();
7549 for (
unsigned I = 1, N =
E->getNumSubExprs(); I < N; I++) {
7551 ToIndexExprs[I - 1] = *ToArgOrErr;
7553 return ToArgOrErr.takeError();
7558 return std::move(Err);
7562 ToIndexExprs, *ToEqualOrColonLocOrErr,
7563 E->usesGNUSyntax(), *ToInitOrErr);
7570 return ToTypeOrErr.takeError();
7573 if (!ToLocationOrErr)
7574 return ToLocationOrErr.takeError();
7577 *ToTypeOrErr, *ToLocationOrErr);
7583 return ToTypeOrErr.takeError();
7586 if (!ToLocationOrErr)
7587 return ToLocationOrErr.takeError();
7590 Importer.
getToContext(),
E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7597 return ToTypeOrErr.takeError();
7600 if (!ToLocationOrErr)
7601 return ToLocationOrErr.takeError();
7605 *ToTypeOrErr, *ToLocationOrErr);
7609 auto ToTypeOrErr =
import(
E->
getType());
7611 return ToTypeOrErr.takeError();
7614 if (!ToSubExprOrErr)
7615 return ToSubExprOrErr.takeError();
7618 *ToSubExprOrErr, *ToTypeOrErr);
7622 auto ToTypeOrErr =
import(
E->
getType());
7624 return ToTypeOrErr.takeError();
7627 if (!ToLocationOrErr)
7628 return ToLocationOrErr.takeError();
7631 Importer.
getToContext(),
E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
7638 return ToTypeOrErr.takeError();
7641 if (!ToLocationOrErr)
7642 return ToLocationOrErr.takeError();
7645 E->getValue(),
E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
7651 return ToTypeOrErr.takeError();
7655 E->tokloc_begin(),
E->tokloc_end(), ToLocations.begin()))
7656 return std::move(Err);
7660 *ToTypeOrErr, ToLocations.data(), ToLocations.size());
7665 Error Err = Error::success();
7667 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
7671 return std::move(Err);
7675 ToInitializer,
E->isFileScope());
7680 Error Err = Error::success();
7685 return std::move(Err);
7689 E->getSubExprs(),
E->getSubExprs() +
E->getNumSubExprs(),
7691 return std::move(Err);
7695 ToBuiltinLoc, ToExprs, ToType,
E->getOp(), ToRParenLoc);
7699 Error Err = Error::success();
7705 return std::move(Err);
7708 ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
7711 Error Err = Error::success();
7715 return std::move(Err);
7720 Error Err = Error::success();
7725 return std::move(Err);
7728 ParenExpr(ToLParen, ToRParen, ToSubExpr);
7734 return std::move(Err);
7737 if (!ToLParenLocOrErr)
7738 return ToLParenLocOrErr.takeError();
7741 if (!ToRParenLocOrErr)
7742 return ToRParenLocOrErr.takeError();
7745 ToExprs, *ToRParenLocOrErr);
7749 Error Err = Error::success();
7755 return std::move(Err);
7758 StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
7759 E->getTemplateDepth());
7763 Error Err = Error::success();
7768 return std::move(Err);
7771 E->hasStoredFPFeatures());
7772 UO->setType(ToType);
7773 UO->setSubExpr(ToSubExpr);
7774 UO->setOpcode(
E->getOpcode());
7775 UO->setOperatorLoc(ToOperatorLoc);
7776 UO->setCanOverflow(
E->canOverflow());
7777 if (
E->hasStoredFPFeatures())
7778 UO->setStoredFPFeatures(
E->getStoredFPFeatures());
7786 Error Err = Error::success();
7791 return std::move(Err);
7793 if (
E->isArgumentType()) {
7795 import(
E->getArgumentTypeInfo());
7796 if (!ToArgumentTypeInfoOrErr)
7797 return ToArgumentTypeInfoOrErr.takeError();
7800 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
7804 ExpectedExpr ToArgumentExprOrErr =
import(
E->getArgumentExpr());
7805 if (!ToArgumentExprOrErr)
7806 return ToArgumentExprOrErr.takeError();
7809 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
7813 Error Err = Error::success();
7819 return std::move(Err);
7822 Importer.
getToContext(), ToLHS, ToRHS,
E->getOpcode(), ToType,
7824 E->getFPFeatures());
7828 Error Err = Error::success();
7836 return std::move(Err);
7839 ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
7845 Error Err = Error::success();
7855 return std::move(Err);
7858 ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
7865 Error Err = Error::success();
7868 return std::move(Err);
7875 Error Err = Error::success();
7877 auto ToQueriedTypeSourceInfo =
7879 auto ToDimensionExpression =
importChecked(Err,
E->getDimensionExpression());
7883 return std::move(Err);
7886 ToBeginLoc,
E->getTrait(), ToQueriedTypeSourceInfo,
E->getValue(),
7887 ToDimensionExpression, ToEndLoc, ToType);
7891 Error Err = Error::success();
7893 auto ToQueriedExpression =
importChecked(Err,
E->getQueriedExpression());
7897 return std::move(Err);
7900 ToBeginLoc,
E->getTrait(), ToQueriedExpression,
E->getValue(),
7905 Error Err = Error::success();
7910 return std::move(Err);
7917 Error Err = Error::success();
7923 return std::move(Err);
7932 Error Err = Error::success();
7936 auto ToComputationLHSType =
importChecked(Err,
E->getComputationLHSType());
7937 auto ToComputationResultType =
7941 return std::move(Err);
7944 Importer.
getToContext(), ToLHS, ToRHS,
E->getOpcode(), ToType,
7947 ToComputationLHSType, ToComputationResultType);
7954 if (
auto SpecOrErr =
import(*I))
7955 Path.push_back(*SpecOrErr);
7957 return SpecOrErr.takeError();
7965 return ToTypeOrErr.takeError();
7968 if (!ToSubExprOrErr)
7969 return ToSubExprOrErr.takeError();
7972 if (!ToBasePathOrErr)
7973 return ToBasePathOrErr.takeError();
7976 Importer.
getToContext(), *ToTypeOrErr,
E->getCastKind(), *ToSubExprOrErr,
7981 Error Err = Error::success();
7984 auto ToTypeInfoAsWritten =
importChecked(Err,
E->getTypeInfoAsWritten());
7986 return std::move(Err);
7989 if (!ToBasePathOrErr)
7990 return ToBasePathOrErr.takeError();
7994 case Stmt::CStyleCastExprClass: {
7995 auto *CCE = cast<CStyleCastExpr>(
E);
7996 ExpectedSLoc ToLParenLocOrErr =
import(CCE->getLParenLoc());
7997 if (!ToLParenLocOrErr)
7998 return ToLParenLocOrErr.takeError();
7999 ExpectedSLoc ToRParenLocOrErr =
import(CCE->getRParenLoc());
8000 if (!ToRParenLocOrErr)
8001 return ToRParenLocOrErr.takeError();
8004 ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
8005 *ToLParenLocOrErr, *ToRParenLocOrErr);
8008 case Stmt::CXXFunctionalCastExprClass: {
8009 auto *FCE = cast<CXXFunctionalCastExpr>(
E);
8010 ExpectedSLoc ToLParenLocOrErr =
import(FCE->getLParenLoc());
8011 if (!ToLParenLocOrErr)
8012 return ToLParenLocOrErr.takeError();
8013 ExpectedSLoc ToRParenLocOrErr =
import(FCE->getRParenLoc());
8014 if (!ToRParenLocOrErr)
8015 return ToRParenLocOrErr.takeError();
8018 E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
8019 *ToLParenLocOrErr, *ToRParenLocOrErr);
8022 case Stmt::ObjCBridgedCastExprClass: {
8023 auto *OCE = cast<ObjCBridgedCastExpr>(
E);
8024 ExpectedSLoc ToLParenLocOrErr =
import(OCE->getLParenLoc());
8025 if (!ToLParenLocOrErr)
8026 return ToLParenLocOrErr.takeError();
8027 ExpectedSLoc ToBridgeKeywordLocOrErr =
import(OCE->getBridgeKeywordLoc());
8028 if (!ToBridgeKeywordLocOrErr)
8029 return ToBridgeKeywordLocOrErr.takeError();
8031 *ToLParenLocOrErr, OCE->getBridgeKind(),
E->getCastKind(),
8032 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
8034 case Stmt::BuiltinBitCastExprClass: {
8035 auto *BBC = cast<BuiltinBitCastExpr>(
E);
8036 ExpectedSLoc ToKWLocOrErr =
import(BBC->getBeginLoc());
8038 return ToKWLocOrErr.takeError();
8039 ExpectedSLoc ToRParenLocOrErr =
import(BBC->getEndLoc());
8040 if (!ToRParenLocOrErr)
8041 return ToRParenLocOrErr.takeError();
8044 ToTypeInfoAsWritten, *ToKWLocOrErr, *ToRParenLocOrErr);
8047 llvm_unreachable(
"Cast expression of unsupported type!");
8054 for (
int I = 0, N =
E->getNumComponents(); I < N; ++I) {
8060 Error Err = Error::success();
8064 return std::move(Err);
8073 auto ToBSOrErr =
import(FromNode.
getBase());
8075 return ToBSOrErr.takeError();
8080 auto ToFieldOrErr =
import(FromNode.
getField());
8082 return ToFieldOrErr.takeError();
8083 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
8088 ToNodes.push_back(
OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
8095 for (
int I = 0, N =
E->getNumExpressions(); I < N; ++I) {
8097 if (!ToIndexExprOrErr)
8098 return ToIndexExprOrErr.takeError();
8099 ToExprs[I] = *ToIndexExprOrErr;
8102 Error Err = Error::success();
8104 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8108 return std::move(Err);
8111 Importer.
getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
8112 ToExprs, ToRParenLoc);
8116 Error Err = Error::success();
8122 return std::move(Err);
8131 ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
8135 Error Err = Error::success();
8140 return std::move(Err);
8143 ToSubExpr, ToType, ToThrowLoc,
E->isThrownVariableInScope());
8148 if (!ToUsedLocOrErr)
8149 return ToUsedLocOrErr.takeError();
8151 auto ToParamOrErr =
import(
E->getParam());
8153 return ToParamOrErr.takeError();
8155 auto UsedContextOrErr = Importer.
ImportContext(
E->getUsedContext());
8156 if (!UsedContextOrErr)
8157 return UsedContextOrErr.takeError();
8167 std::optional<ParmVarDecl *> FromParam =
8169 assert(FromParam &&
"ParmVarDecl was not imported?");
8172 return std::move(Err);
8174 Expr *RewrittenInit =
nullptr;
8175 if (
E->hasRewrittenInit()) {
8178 return ExprOrErr.takeError();
8179 RewrittenInit = ExprOrErr.get();
8182 *ToParamOrErr, RewrittenInit,
8188 Error Err = Error::success();
8190 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8193 return std::move(Err);
8196 ToType, ToTypeSourceInfo, ToRParenLoc);
8202 if (!ToSubExprOrErr)
8203 return ToSubExprOrErr.takeError();
8205 auto ToDtorOrErr =
import(
E->getTemporary()->getDestructor());
8207 return ToDtorOrErr.takeError();
8217 Error Err = Error::success();
8220 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8221 auto ToParenOrBraceRange =
importChecked(Err,
E->getParenOrBraceRange());
8223 return std::move(Err);
8227 return std::move(Err);
8230 Importer.
getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
8231 ToParenOrBraceRange,
E->hadMultipleCandidates(),
8232 E->isListInitialization(),
E->isStdInitListInitialization(),
8233 E->requiresZeroInitialization());
8240 return std::move(Err);
8242 Error Err = Error::success();
8246 return std::move(Err);
8250 if (GetImportedOrCreateDecl(To,
D, Temporary, ExtendingDecl,
8251 D->getManglingNumber()))
8261 Error Err = Error::success();
8264 Err,
E->getLifetimeExtendedTemporaryDecl() ?
nullptr :
E->getSubExpr());
8265 auto ToMaterializedDecl =
8268 return std::move(Err);
8270 if (!ToTemporaryExpr)
8271 ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
8274 ToType, ToTemporaryExpr,
E->isBoundToLvalueReference(),
8275 ToMaterializedDecl);
8281 Error Err = Error::success();
8286 return std::move(Err);
8289 ToType, ToPattern, ToEllipsisLoc,
E->getNumExpansions());
8293 Error Err = Error::success();
8299 return std::move(Err);
8301 std::optional<unsigned> Length;
8303 Length =
E->getPackLength();
8306 if (
E->isPartiallySubstituted()) {
8308 ToPartialArguments))
8309 return std::move(Err);
8313 Importer.
getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
8314 Length, ToPartialArguments);
8319 Error Err = Error::success();
8321 auto ToOperatorDelete =
importChecked(Err,
E->getOperatorDelete());
8326 auto ToAllocatedTypeSourceInfo =
8329 auto ToDirectInitRange =
importChecked(Err,
E->getDirectInitRange());
8331 return std::move(Err);
8336 return std::move(Err);
8340 ToOperatorDelete,
E->passAlignment(),
E->doesUsualArrayDeleteWantSize(),
8341 ToPlacementArgs, ToTypeIdParens, ToArraySize,
E->getInitializationStyle(),
8342 ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
8347 Error Err = Error::success();
8349 auto ToOperatorDelete =
importChecked(Err,
E->getOperatorDelete());
8353 return std::move(Err);
8356 ToType,
E->isGlobalDelete(),
E->isArrayForm(),
E->isArrayFormAsWritten(),
8357 E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
8362 Error Err = Error::success();
8366 auto ToParenOrBraceRange =
importChecked(Err,
E->getParenOrBraceRange());
8368 return std::move(Err);
8372 return std::move(Err);
8375 Importer.
getToContext(), ToType, ToLocation, ToConstructor,
8376 E->isElidable(), ToArgs,
E->hadMultipleCandidates(),
8377 E->isListInitialization(),
E->isStdInitListInitialization(),
8378 E->requiresZeroInitialization(),
E->getConstructionKind(),
8379 ToParenOrBraceRange);
8386 if (!ToSubExprOrErr)
8387 return ToSubExprOrErr.takeError();
8391 return std::move(Err);
8394 Importer.
getToContext(), *ToSubExprOrErr,
E->cleanupsHaveSideEffects(),
8399 Error Err = Error::success();
8404 return std::move(Err);
8408 return std::move(Err);
8412 E->getFPFeatures());
8418 return ToTypeOrErr.takeError();
8421 if (!ToLocationOrErr)
8422 return ToLocationOrErr.takeError();
8425 *ToTypeOrErr,
E->isImplicit());
8431 return ToTypeOrErr.takeError();
8434 if (!ToLocationOrErr)
8435 return ToLocationOrErr.takeError();
8438 *ToTypeOrErr, *ToLocationOrErr);
8442 Error Err = Error::success();
8446 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8450 auto ToName =
importChecked(Err,
E->getMemberNameInfo().getName());
8451 auto ToLoc =
importChecked(Err,
E->getMemberNameInfo().getLoc());
8453 return std::move(Err);
8461 if (
E->hasExplicitTemplateArgs()) {
8464 E->template_arguments(), ToTAInfo))
8465 return std::move(Err);
8466 ResInfo = &ToTAInfo;
8470 ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8471 ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
8478 Error Err = Error::success();
8482 auto ToScopeTypeInfo =
importChecked(Err,
E->getScopeTypeInfo());
8483 auto ToColonColonLoc =
importChecked(Err,
E->getColonColonLoc());
8486 return std::move(Err);
8491 ExpectedSLoc ToDestroyedTypeLocOrErr =
import(
E->getDestroyedTypeLoc());
8492 if (!ToDestroyedTypeLocOrErr)
8493 return ToDestroyedTypeLocOrErr.takeError();
8496 if (
auto ToTIOrErr =
import(
E->getDestroyedTypeInfo()))
8499 return ToTIOrErr.takeError();
8503 Importer.
getToContext(), ToBase,
E->isArrow(), ToOperatorLoc,
8504 ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
8509 Error Err = Error::success();
8513 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8514 auto ToFirstQualifierFoundInScope =
8517 return std::move(Err);
8519 Expr *ToBase =
nullptr;
8520 if (!
E->isImplicitAccess()) {
8522 ToBase = *ToBaseOrErr;
8524 return ToBaseOrErr.takeError();
8529 if (
E->hasExplicitTemplateArgs()) {
8532 E->template_arguments(), ToTAInfo))
8533 return std::move(Err);
8534 ResInfo = &ToTAInfo;
8539 return std::move(Err);
8545 return std::move(Err);
8548 Importer.
getToContext(), ToBase, ToType,
E->isArrow(), ToOperatorLoc,
8549 ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
8550 ToMemberNameInfo, ResInfo);
8555 Error Err = Error::success();
8557 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8563 return std::move(Err);
8567 return std::move(Err);
8571 if (
E->hasExplicitTemplateArgs()) {
8574 return std::move(Err);
8575 ResInfo = &ToTAInfo;
8579 Importer.
getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
8580 ToNameInfo, ResInfo);
8585 Error Err = Error::success();
8589 auto ToTypeSourceInfo =
importChecked(Err,
E->getTypeSourceInfo());
8591 return std::move(Err);
8596 return std::move(Err);
8599 Importer.
getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
8606 if (!ToNamingClassOrErr)
8607 return ToNamingClassOrErr.takeError();
8609 auto ToQualifierLocOrErr =
import(
E->getQualifierLoc());
8610 if (!ToQualifierLocOrErr)
8611 return ToQualifierLocOrErr.takeError();
8613 Error Err = Error::success();
8617 return std::move(Err);
8622 return std::move(Err);
8625 for (
auto *
D :
E->decls())
8626 if (
auto ToDOrErr =
import(
D))
8627 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8629 return ToDOrErr.takeError();
8631 if (
E->hasExplicitTemplateArgs()) {
8634 E->getLAngleLoc(),
E->getRAngleLoc(),
E->template_arguments(),
8636 return std::move(Err);
8638 ExpectedSLoc ToTemplateKeywordLocOrErr =
import(
E->getTemplateKeywordLoc());
8639 if (!ToTemplateKeywordLocOrErr)
8640 return ToTemplateKeywordLocOrErr.takeError();
8642 const bool KnownDependent =
8644 ExprDependence::TypeValue;
8646 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8647 *ToTemplateKeywordLocOrErr, ToNameInfo,
E->requiresADL(), &ToTAInfo,
8648 ToDecls.
begin(), ToDecls.
end(), KnownDependent,
8653 Importer.
getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
8654 ToNameInfo,
E->requiresADL(), ToDecls.
begin(), ToDecls.
end(),
8661 Error Err = Error::success();
8665 auto ToTemplateKeywordLoc =
importChecked(Err,
E->getTemplateKeywordLoc());
8669 return std::move(Err);
8674 return std::move(Err);
8677 for (
Decl *
D :
E->decls())
8678 if (
auto ToDOrErr =
import(
D))
8679 ToDecls.
addDecl(cast<NamedDecl>(*ToDOrErr));
8681 return ToDOrErr.takeError();
8685 if (
E->hasExplicitTemplateArgs()) {
8687 E->copyTemplateArgumentsInto(FromTAInfo);
8689 return std::move(Err);
8690 ResInfo = &ToTAInfo;
8693 Expr *ToBase =
nullptr;
8694 if (!
E->isImplicitAccess()) {
8696 ToBase = *ToBaseOrErr;
8698 return ToBaseOrErr.takeError();
8702 Importer.
getToContext(),
E->hasUnresolvedUsing(), ToBase, ToType,
8703 E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8704 ToNameInfo, ResInfo, ToDecls.
begin(), ToDecls.
end());
8708 Error Err = Error::success();
8713 return std::move(Err);
8715 unsigned NumArgs =
E->getNumArgs();
8718 return std::move(Err);
8720 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
E)) {
8722 Importer.
getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
8723 OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
8724 OCE->getADLCallKind());
8729 0,
E->getADLCallKind());
8734 auto ToClassOrErr =
import(FromClass);
8736 return ToClassOrErr.takeError();
8739 auto ToCallOpOrErr =
import(
E->getCallOperator());
8741 return ToCallOpOrErr.takeError();
8745 return std::move(Err);
8747 Error Err = Error::success();
8748 auto ToIntroducerRange =
importChecked(Err,
E->getIntroducerRange());
8749 auto ToCaptureDefaultLoc =
importChecked(Err,
E->getCaptureDefaultLoc());
8752 return std::move(Err);
8755 E->getCaptureDefault(), ToCaptureDefaultLoc,
8756 E->hasExplicitParameters(),
8757 E->hasExplicitResultType(), ToCaptureInits,
8763 Error Err = Error::success();
8768 return std::move(Err);
8772 return std::move(Err);
8776 ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
8779 if (
E->hasArrayFiller()) {
8780 if (
ExpectedExpr ToFillerOrErr =
import(
E->getArrayFiller()))
8783 return ToFillerOrErr.takeError();
8786 if (
FieldDecl *FromFD =
E->getInitializedFieldInUnion()) {
8787 if (
auto ToFDOrErr =
import(FromFD))
8790 return ToFDOrErr.takeError();
8794 if (
auto ToSyntFormOrErr =
import(SyntForm))
8797 return ToSyntFormOrErr.takeError();
8811 return ToTypeOrErr.takeError();
8814 if (!ToSubExprOrErr)
8815 return ToSubExprOrErr.takeError();
8818 *ToTypeOrErr, *ToSubExprOrErr);
8823 Error Err = Error::success();
8828 return std::move(Err);
8831 ToLocation, ToType, ToConstructor,
E->constructsVBase(),
8832 E->inheritedFromVBase());
8836 Error Err = Error::success();
8841 return std::move(Err);
8844 ToType, ToCommonExpr, ToSubExpr);
8850 return ToTypeOrErr.takeError();
8856 if (!ToBeginLocOrErr)
8857 return ToBeginLocOrErr.takeError();
8859 auto ToFieldOrErr =
import(
E->getField());
8861 return ToFieldOrErr.takeError();
8863 auto UsedContextOrErr = Importer.
ImportContext(
E->getUsedContext());
8864 if (!UsedContextOrErr)
8865 return UsedContextOrErr.takeError();
8869 "Field should have in-class initializer if there is a default init "
8870 "expression that uses it.");
8875 auto ToInClassInitializerOrErr =
8876 import(
E->getField()->getInClassInitializer());
8877 if (!ToInClassInitializerOrErr)
8878 return ToInClassInitializerOrErr.takeError();
8882 Expr *RewrittenInit =
nullptr;
8883 if (
E->hasRewrittenInit()) {
8886 return ExprOrErr.takeError();
8887 RewrittenInit = ExprOrErr.get();
8891 ToField, *UsedContextOrErr, RewrittenInit);
8895 Error Err = Error::success();
8898 auto ToTypeInfoAsWritten =
importChecked(Err,
E->getTypeInfoAsWritten());
8901 auto ToAngleBrackets =
importChecked(Err,
E->getAngleBrackets());
8903 return std::move(Err);
8908 if (!ToBasePathOrErr)
8909 return ToBasePathOrErr.takeError();
8911 if (
auto CCE = dyn_cast<CXXStaticCastExpr>(
E)) {
8913 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8914 ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
8916 }
else if (isa<CXXDynamicCastExpr>(
E)) {
8918 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8919 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8920 }
else if (isa<CXXReinterpretCastExpr>(
E)) {
8922 Importer.
getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8923 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8924 }
else if (isa<CXXConstCastExpr>(
E)) {
8926 Importer.
getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
8927 ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8929 llvm_unreachable(
"Unknown cast type");
8930 return make_error<ASTImportError>();
8936 Error Err = Error::success();
8939 auto ToAssociatedDecl =
importChecked(Err,
E->getAssociatedDecl());
8942 return std::move(Err);
8945 ToType,
E->
getValueKind(), ToExprLoc, ToReplacement, ToAssociatedDecl,
8946 E->getIndex(),
E->getPackIndex(),
E->isReferenceParameter());
8950 Error Err = Error::success();
8955 return std::move(Err);
8959 return std::move(Err);
8966 Importer.
getToContext(), ToType, ToBeginLoc,
E->getTrait(), ToArgs,
8973 return ToTypeOrErr.takeError();
8976 if (!ToSourceRangeOrErr)
8977 return ToSourceRangeOrErr.takeError();
8979 if (
E->isTypeOperand()) {
8980 if (
auto ToTSIOrErr =
import(
E->getTypeOperandSourceInfo()))
8982 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
8984 return ToTSIOrErr.takeError();
8987 ExpectedExpr ToExprOperandOrErr =
import(
E->getExprOperand());
8988 if (!ToExprOperandOrErr)
8989 return ToExprOperandOrErr.takeError();
8992 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8996 Error Err = Error::success();
9007 return std::move(Err);
9010 CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS,
E->getOperator(),
9011 ToEllipsisLoc, ToRHS, ToRParenLoc,
E->getNumExpansions());
9016 Error ImportErrors = Error::success();
9018 if (
auto ImportedOrErr =
import(FromOverriddenMethod))
9020 (*ImportedOrErr)->getCanonicalDecl()));
9023 joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
9025 return ImportErrors;
9031 std::shared_ptr<ASTImporterSharedState> SharedState)
9032 : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
9033 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
9038 this->SharedState = std::make_shared<ASTImporterSharedState>();
9048 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
9049 "Try to get field index for non-field.");
9053 return std::nullopt;
9056 for (
const auto *
D : Owner->decls()) {
9060 if (isa<FieldDecl>(*
D) || isa<IndirectFieldDecl>(*
D))
9064 llvm_unreachable(
"Field was not found in its parent context.");
9066 return std::nullopt;
9079 if (SharedState->getLookupTable()) {
9086 getCanonicalForwardRedeclChain<NamespaceDecl>(
9087 dyn_cast<NamespaceDecl>(ReDC));
9088 for (
auto *
D : NSChain) {
9090 SharedState->getLookupTable()->lookup(dyn_cast<NamespaceDecl>(
D),
9097 SharedState->getLookupTable()->lookup(ReDC, Name);
9102 FoundDeclsTy
Result(NoloadLookupResult.
begin(), NoloadLookupResult.
end());
9119void ASTImporter::AddToLookupTable(
Decl *ToD) {
9120 SharedState->addDeclToLookup(ToD);
9126 return Importer.
Visit(FromD);
9150 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9151 ImportedTypes.find(FromT);
9152 if (Pos != ImportedTypes.end())
9159 return ToTOrErr.takeError();
9162 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
9164 return ToTOrErr->getTypePtr();
9173 return ToTyOrErr.takeError();
9186 return TOrErr.takeError();
9189 return BeginLocOrErr.takeError();
9198template <
typename T>
struct AttrArgImporter {
9199 AttrArgImporter(
const AttrArgImporter<T> &) =
delete;
9200 AttrArgImporter(AttrArgImporter<T> &&) =
default;
9201 AttrArgImporter<T> &operator=(
const AttrArgImporter<T> &) =
delete;
9202 AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) =
default;
9205 : To(I.importChecked(Err, From)) {}
9207 const T &value() {
return To; }
9218template <
typename T>
struct AttrArgArrayImporter {
9219 AttrArgArrayImporter(
const AttrArgArrayImporter<T> &) =
delete;
9220 AttrArgArrayImporter(AttrArgArrayImporter<T> &&) =
default;
9221 AttrArgArrayImporter<T> &operator=(
const AttrArgArrayImporter<T> &) =
delete;
9222 AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) =
default;
9225 const llvm::iterator_range<T *> &From,
9226 unsigned ArraySize) {
9229 To.reserve(ArraySize);
9233 T *value() {
return To.data(); }
9240 Error Err{Error::success()};
9241 Attr *ToAttr =
nullptr;
9246 AttrImporter(
ASTImporter &I) : Importer(I), NImporter(I) {}
9249 template <
typename T>
T *castAttrAs() {
return cast<T>(ToAttr); }
9250 template <
typename T>
const T *castAttrAs()
const {
return cast<T>(ToAttr); }
9255 template <
class T> AttrArgImporter<T> importArg(
const T &From) {
9256 return AttrArgImporter<T>(NImporter, Err, From);
9262 template <
typename T>
9263 AttrArgArrayImporter<T> importArrayArg(
const llvm::iterator_range<T *> &From,
9264 unsigned ArraySize) {
9265 return AttrArgArrayImporter<T>(NImporter, Err, From, ArraySize);
9276 template <
typename T,
typename... Arg>
9277 void importAttr(
const T *FromAttr, Arg &&...ImportedArg) {
9278 static_assert(std::is_base_of<Attr, T>::value,
9279 "T should be subclass of Attr.");
9280 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9284 Importer.
Import(FromAttr->getScopeName());
9294 FromAttr->getParsedKind(), FromAttr->getForm());
9298 std::forward<Arg>(ImportedArg)..., ToI);
9302 if (
auto *ToInheritableAttr = dyn_cast<InheritableAttr>(ToAttr))
9303 ToInheritableAttr->setInherited(FromAttr->isInherited());
9309 void cloneAttr(
const Attr *FromAttr) {
9310 assert(!ToAttr &&
"Use one AttrImporter to import one Attribute object.");
9324 return std::move(Err);
9325 assert(ToAttr &&
"Attribute should be created.");
9332 AttrImporter AI(*
this);
9335 switch (FromAttr->
getKind()) {
9336 case attr::Aligned: {
9337 auto *From = cast<AlignedAttr>(FromAttr);
9338 if (From->isAlignmentExpr())
9339 AI.importAttr(From,
true, AI.importArg(From->getAlignmentExpr()).value());
9341 AI.importAttr(From,
false,
9342 AI.importArg(From->getAlignmentType()).value());
9346 case attr::AlignValue: {
9347 auto *From = cast<AlignValueAttr>(FromAttr);
9348 AI.importAttr(From, AI.importArg(From->getAlignment()).value());
9352 case attr::Format: {
9353 const auto *From = cast<FormatAttr>(FromAttr);
9354 AI.importAttr(From,
Import(From->getType()), From->getFormatIdx(),
9355 From->getFirstArg());
9359 case attr::EnableIf: {
9360 const auto *From = cast<EnableIfAttr>(FromAttr);
9361 AI.importAttr(From, AI.importArg(From->getCond()).value(),
9362 From->getMessage());
9366 case attr::AssertCapability: {
9367 const auto *From = cast<AssertCapabilityAttr>(FromAttr);
9369 AI.importArrayArg(From->args(), From->args_size()).value(),
9373 case attr::AcquireCapability: {
9374 const auto *From = cast<AcquireCapabilityAttr>(FromAttr);
9376 AI.importArrayArg(From->args(), From->args_size()).value(),
9380 case attr::TryAcquireCapability: {
9381 const auto *From = cast<TryAcquireCapabilityAttr>(FromAttr);
9382 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9383 AI.importArrayArg(From->args(), From->args_size()).value(),
9387 case attr::ReleaseCapability: {
9388 const auto *From = cast<ReleaseCapabilityAttr>(FromAttr);
9390 AI.importArrayArg(From->args(), From->args_size()).value(),
9394 case attr::RequiresCapability: {
9395 const auto *From = cast<RequiresCapabilityAttr>(FromAttr);
9397 AI.importArrayArg(From->args(), From->args_size()).value(),
9401 case attr::GuardedBy: {
9402 const auto *From = cast<GuardedByAttr>(FromAttr);
9403 AI.importAttr(From, AI.importArg(From->getArg()).value());
9406 case attr::PtGuardedBy: {
9407 const auto *From = cast<PtGuardedByAttr>(FromAttr);
9408 AI.importAttr(From, AI.importArg(From->getArg()).value());
9411 case attr::AcquiredAfter: {
9412 const auto *From = cast<AcquiredAfterAttr>(FromAttr);
9414 AI.importArrayArg(From->args(), From->args_size()).value(),
9418 case attr::AcquiredBefore: {
9419 const auto *From = cast<AcquiredBeforeAttr>(FromAttr);
9421 AI.importArrayArg(From->args(), From->args_size()).value(),
9425 case attr::AssertExclusiveLock: {
9426 const auto *From = cast<AssertExclusiveLockAttr>(FromAttr);
9428 AI.importArrayArg(From->args(), From->args_size()).value(),
9432 case attr::AssertSharedLock: {
9433 const auto *From = cast<AssertSharedLockAttr>(FromAttr);
9435 AI.importArrayArg(From->args(), From->args_size()).value(),
9439 case attr::ExclusiveTrylockFunction: {
9440 const auto *From = cast<ExclusiveTrylockFunctionAttr>(FromAttr);
9441 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9442 AI.importArrayArg(From->args(), From->args_size()).value(),
9446 case attr::SharedTrylockFunction: {
9447 const auto *From = cast<SharedTrylockFunctionAttr>(FromAttr);
9448 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9449 AI.importArrayArg(From->args(), From->args_size()).value(),
9453 case attr::LockReturned: {
9454 const auto *From = cast<LockReturnedAttr>(FromAttr);
9455 AI.importAttr(From, AI.importArg(From->getArg()).value());
9458 case attr::LocksExcluded: {
9459 const auto *From = cast<LocksExcludedAttr>(FromAttr);
9461 AI.importArrayArg(From->args(), From->args_size()).value(),
9469 AI.cloneAttr(FromAttr);
9474 return std::move(AI).getResult();
9478 return ImportedDecls.lookup(FromD);
9482 auto FromDPos = ImportedFromDecls.find(ToD);
9483 if (FromDPos == ImportedFromDecls.end())
9485 return FromDPos->second->getTranslationUnitDecl();
9493 ImportPath.
push(FromD);
9494 auto ImportPathBuilder =
9495 llvm::make_scope_exit([
this]() { ImportPath.
pop(); });
9500 return make_error<ASTImportError>(*Error);
9506 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9508 return make_error<ASTImportError>(*Error);
9525 auto Pos = ImportedDecls.find(FromD);
9526 if (Pos != ImportedDecls.end()) {
9529 auto *ToD = Pos->second;
9530 ImportedDecls.erase(Pos);
9542 auto PosF = ImportedFromDecls.find(ToD);
9543 if (PosF != ImportedFromDecls.end()) {
9548 SharedState->removeDeclFromLookup(ToD);
9549 ImportedFromDecls.erase(PosF);
9561 handleAllErrors(ToDOrErr.takeError(),
9565 if (Pos != ImportedDecls.end())
9566 SharedState->setImportDeclError(Pos->second, ErrOut);
9570 for (
const auto &
Path : SavedImportPaths[FromD]) {
9573 Decl *PrevFromDi = FromD;
9576 if (FromDi == FromD)
9583 PrevFromDi = FromDi;
9587 auto Ii = ImportedDecls.find(FromDi);
9588 if (Ii != ImportedDecls.end())
9589 SharedState->setImportDeclError(Ii->second, ErrOut);
9594 SavedImportPaths.erase(FromD);
9597 return make_error<ASTImportError>(ErrOut);
9609 return make_error<ASTImportError>(*Err);
9615 if (
auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9617 return make_error<ASTImportError>(*Error);
9620 assert(ImportedDecls.count(FromD) != 0 &&
"Missing call to MapImported?");
9624 auto ToAttrOrErr =
Import(FromAttr);
9628 return ToAttrOrErr.takeError();
9635 SavedImportPaths.erase(FromD);
9650 return ToDCOrErr.takeError();
9651 auto *ToDC = cast<DeclContext>(*ToDCOrErr);
9655 if (
auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
9656 auto *FromRecord = cast<RecordDecl>(FromDC);
9657 if (ToRecord->isCompleteDefinition())
9665 if (FromRecord->getASTContext().getExternalSource() &&
9666 !FromRecord->isCompleteDefinition())
9667 FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
9669 if (FromRecord->isCompleteDefinition())
9672 return std::move(Err);
9673 }
else if (
auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
9674 auto *FromEnum = cast<EnumDecl>(FromDC);
9675 if (ToEnum->isCompleteDefinition()) {
9677 }
else if (FromEnum->isCompleteDefinition()) {
9680 return std::move(Err);
9684 }
else if (
auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
9685 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
9686 if (ToClass->getDefinition()) {
9691 return std::move(Err);
9695 }
else if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
9696 auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
9697 if (ToProto->getDefinition()) {
9702 return std::move(Err);
9713 return cast_or_null<Expr>(*ToSOrErr);
9715 return ToSOrErr.takeError();
9723 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
9724 if (Pos != ImportedStmts.end())
9733 if (
auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
9734 auto *FromE = cast<Expr>(FromS);
9737 ToE->setValueKind(FromE->getValueKind());
9738 ToE->setObjectKind(FromE->getObjectKind());
9739 ToE->setDependence(FromE->getDependence());
9743 ImportedStmts[FromS] = *ToSOrErr;
9754 return std::move(Err);
9758 assert(FromNNS->
getAsIdentifier() &&
"NNS should contain identifier.");
9765 cast<NamespaceDecl>(*NSOrErr));
9767 return NSOrErr.takeError();
9772 cast<NamespaceAliasDecl>(*NSADOrErr));
9774 return NSADOrErr.takeError();
9782 cast<CXXRecordDecl>(*RDOrErr));
9784 return RDOrErr.takeError();
9794 return TyOrErr.takeError();
9798 llvm_unreachable(
"Invalid nested name specifier kind");
9810 NestedNames.push_back(NNS);
9816 while (!NestedNames.empty()) {
9817 NNS = NestedNames.pop_back_val();
9820 return std::move(Err);
9827 return std::move(Err);
9831 return std::move(Err);
9847 ToLocalBeginLoc, ToLocalEndLoc);
9854 return std::move(Err);
9874 if (!ToSourceRangeOrErr)
9875 return ToSourceRangeOrErr.takeError();
9878 ToSourceRangeOrErr->getBegin(),
9879 ToSourceRangeOrErr->getEnd());
9891 return TemplateName(cast<TemplateDecl>((*ToTemplateOrErr)->getCanonicalDecl()));
9893 return ToTemplateOrErr.takeError();
9898 for (
auto *I : *FromStorage) {
9899 if (
auto ToOrErr =
Import(I))
9900 ToTemplates.
addDecl(cast<NamedDecl>(*ToOrErr));
9902 return ToOrErr.takeError();
9912 return DeclNameOrErr.takeError();
9919 if (!QualifierOrErr)
9920 return QualifierOrErr.takeError();
9923 return TNOrErr.takeError();
9931 if (!QualifierOrErr)
9932 return QualifierOrErr.takeError();
9947 if (!ReplacementOrErr)
9948 return ReplacementOrErr.takeError();
9951 if (!AssociatedDeclOrErr)
9952 return AssociatedDeclOrErr.takeError();
9955 *ReplacementOrErr, *AssociatedDeclOrErr, Subst->
getIndex(),
9966 return ArgPackOrErr.takeError();
9969 if (!AssociatedDeclOrErr)
9970 return AssociatedDeclOrErr.takeError();
9973 *ArgPackOrErr, *AssociatedDeclOrErr, SubstPack->
getIndex(),
9979 return UsingOrError.takeError();
9980 return TemplateName(cast<UsingShadowDecl>(*UsingOrError));
9983 llvm_unreachable(
"Unexpected DeducedTemplate");
9986 llvm_unreachable(
"Invalid template name kind");
9999 return ToFileIDOrErr.takeError();
10007 return std::move(Err);
10009 return std::move(Err);
10015 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
10016 if (Pos != ImportedFileIDs.end())
10017 return Pos->second;
10029 return ToSpLoc.takeError();
10032 return ToExLocS.takeError();
10042 return ToExLocE.takeError();
10048 if (!IsBuiltin && !
Cache->BufferOverridden) {
10052 return ToIncludeLoc.takeError();
10063 if (
Cache->OrigEntry &&
Cache->OrigEntry->getDir()) {
10074 ToID = ToSM.
createFileID(*Entry, ToIncludeLocOrFakeLoc,
10081 std::optional<llvm::MemoryBufferRef> FromBuf =
10087 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
10088 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
10089 FromBuf->getBufferIdentifier());
10095 assert(ToID.
isValid() &&
"Unexpected invalid fileID was created.");
10097 ImportedFileIDs[FromID] = ToID;
10104 return ToExprOrErr.takeError();
10107 if (!LParenLocOrErr)
10108 return LParenLocOrErr.takeError();
10111 if (!RParenLocOrErr)
10112 return RParenLocOrErr.takeError();
10117 return ToTInfoOrErr.takeError();
10122 return std::move(Err);
10125 ToContext, *ToTInfoOrErr, From->
isBaseVirtual(), *LParenLocOrErr,
10126 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
10130 return ToFieldOrErr.takeError();
10133 if (!MemberLocOrErr)
10134 return MemberLocOrErr.takeError();
10137 ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
10138 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10141 if (!ToIFieldOrErr)
10142 return ToIFieldOrErr.takeError();
10145 if (!MemberLocOrErr)
10146 return MemberLocOrErr.takeError();
10149 ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
10150 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10154 return ToTInfoOrErr.takeError();
10156 return new (ToContext)
10158 *ToExprOrErr, *RParenLocOrErr);
10161 return make_error<ASTImportError>();
10167 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
10168 if (Pos != ImportedCXXBaseSpecifiers.end())
10169 return Pos->second;
10172 if (!ToSourceRange)
10173 return ToSourceRange.takeError();
10176 return ToTSI.takeError();
10178 if (!ToEllipsisLoc)
10179 return ToEllipsisLoc.takeError();
10183 ImportedCXXBaseSpecifiers[BaseSpec] =
Imported;
10195 return ToOrErr.takeError();
10196 Decl *To = *ToOrErr;
10198 auto *FromDC = cast<DeclContext>(From);
10201 if (
auto *ToRecord = dyn_cast<RecordDecl>(To)) {
10202 if (!ToRecord->getDefinition()) {
10204 cast<RecordDecl>(FromDC), ToRecord,
10209 if (
auto *ToEnum = dyn_cast<EnumDecl>(To)) {
10210 if (!ToEnum->getDefinition()) {
10216 if (
auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
10217 if (!ToIFace->getDefinition()) {
10219 cast<ObjCInterfaceDecl>(FromDC), ToIFace,
10224 if (
auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
10225 if (!ToProto->getDefinition()) {
10227 cast<ObjCProtocolDecl>(FromDC), ToProto,
10249 return ToSelOrErr.takeError();
10256 return ToTyOrErr.takeError();
10264 return ToTyOrErr.takeError();
10270 cast<TemplateDecl>(*ToTemplateOrErr));
10272 return ToTemplateOrErr.takeError();
10280 return ToTyOrErr.takeError();
10296 llvm_unreachable(
"Invalid DeclarationName Kind!");
10317 for (
unsigned I = 1, N = FromSel.
getNumArgs(); I < N; ++I)
10325 llvm::Error Err = llvm::Error::success();
10326 auto ImportLoop = [&](
const APValue *From,
APValue *To,
unsigned Size) {
10327 for (
unsigned Idx = 0; Idx < Size; Idx++) {
10332 switch (FromValue.
getKind()) {
10346 ImportLoop(((
const APValue::Vec *)(
const char *)&FromValue.Data)->Elts,
10353 ImportLoop(((
const APValue::Arr *)(
const char *)&FromValue.Data)->Elts,
10354 ((
const APValue::Arr *)(
const char *)&
Result.Data)->Elts,
10361 ((
const APValue::StructData *)(
const char *)&FromValue.Data)->Elts,
10362 ((
const APValue::StructData *)(
const char *)&
Result.Data)->Elts,
10370 return std::move(Err);
10371 Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
10375 Result.MakeAddrLabelDiff();
10379 return std::move(Err);
10380 Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
10381 cast<AddrLabelExpr>(ImpRHS));
10385 const Decl *ImpMemPtrDecl =
10388 return std::move(Err);
10390 Result.setMemberPointerUninit(
10391 cast<const ValueDecl>(ImpMemPtrDecl),
10395 Result.getMemberPointerPath();
10400 return std::move(Err);
10410 "in C++20 dynamic allocation are transient so they shouldn't "
10411 "appear in the AST");
10413 if (
const auto *
E =
10418 return std::move(Err);
10428 return std::move(Err);
10440 return std::move(Err);
10454 for (
unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
10457 FromPath[LoopIdx].getAsBaseOrMember().getPointer();
10460 return std::move(Err);
10461 if (
auto *RD = dyn_cast<CXXRecordDecl>(
FromDecl))
10464 FromElemTy = cast<ValueDecl>(
FromDecl)->getType();
10466 ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
10471 FromPath[LoopIdx].getAsArrayIndex());
10479 return std::move(Err);
10487 unsigned NumDecls) {
10497 if (LastDiagFromFrom)
10500 LastDiagFromFrom =
false;
10505 if (!LastDiagFromFrom)
10508 LastDiagFromFrom =
true;
10513 if (
auto *ID = dyn_cast<ObjCInterfaceDecl>(
D)) {
10514 if (!ID->getDefinition())
10515 ID->startDefinition();
10517 else if (
auto *PD = dyn_cast<ObjCProtocolDecl>(
D)) {
10518 if (!PD->getDefinition())
10519 PD->startDefinition();
10521 else if (
auto *TD = dyn_cast<TagDecl>(
D)) {
10522 if (!TD->getDefinition() && !TD->isBeingDefined()) {
10523 TD->startDefinition();
10524 TD->setCompleteDefinition(
true);
10528 assert(0 &&
"CompleteDecl called on a Decl that can't be completed");
10533 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
10534 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
10535 "Try to import an already imported Decl");
10536 if (Pos != ImportedDecls.end())
10537 return Pos->second;
10538 ImportedDecls[From] = To;
10541 ImportedFromDecls[To] = From;
10546 AddToLookupTable(To);
10550std::optional<ASTImportError>
10552 auto Pos = ImportDeclErrors.find(FromD);
10553 if (Pos != ImportDeclErrors.end())
10554 return Pos->second;
10556 return std::nullopt;
10560 auto InsertRes = ImportDeclErrors.insert({From, Error});
10564 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
10569 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
10571 if (Pos != ImportedTypes.end()) {
10576 llvm::consumeError(ToFromOrErr.takeError());
10583 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)
This file provides some common utility functions for processing Lambda related AST Constructs.
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.
SourceDeductionGuideKind getSourceDeductionGuideKind() const
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...
bool isLambdaMethod(const DeclContext *DC)
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