Lines Matching +full:msi +full:- +full:base +full:- +full:vec
1 //===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
12 //===----------------------------------------------------------------------===//
112 for (auto *R : D->getFirstDecl()->redecls()) {
113 if (R != D->getFirstDecl())
116 Redecls.push_back(D->getFirstDecl());
134 if (From->isUsed(false) && !To->isUsed(false))
135 To->setIsUsed();
142 /// It is nullptr if a non-DeclContext is imported.
174 return FromDC->containsDecl(FromChildD);
202 -> std::conditional_t<std::is_base_of_v<Type, T>, Expected<const T *>,
285 Importer.SharedState->markAsNewDecl(ToD);
291 ToD->IdentifierNamespace = FromD->IdentifierNamespace;
292 if (FromD->isUsed())
293 ToD->setIsUsed();
294 if (FromD->isImplicit())
295 ToD->setImplicit();
302 if (D->doesThisDeclarationHaveABody() &&
303 FoundFunction->hasBody(Definition))
313 if (!FromD->getDescribedTemplate() &&
314 FromD->getFriendObjectKind() == Decl::FOK_None)
315 ToD->getLexicalDeclContext()->addDeclInternal(ToD);
319 DeclContext *FromDC = FromD->getDeclContext();
320 DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
321 DeclContext *ToDC = ToD->getDeclContext();
322 DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();
325 if (FromDC->containsDeclAndLoad(FromD)) {
326 ToDC->addDeclInternal(ToD);
329 if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) {
330 ToLexicalDC->addDeclInternal(ToD);
340 FromDC->lookup(FromNamed->getDeclName());
342 ToDC->makeDeclVisibleInContext(ToNamed);
349 ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
354 LT->update(TP, OldDC);
371 #define TYPE(Class, Base) \
739 assert(FromFD->getTemplatedKind() ==
744 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
745 if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
749 if (Error Err = ImportTemplateArguments(FTSInfo->TemplateArguments->asArray(),
759 SmallVector<NamedDecl *, 4> To(From->size());
763 ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
767 auto ToTemplateLocOrErr = import(From->getTemplateLoc());
770 auto ToLAngleLocOrErr = import(From->getLAngleLoc());
773 auto ToRAngleLocOrErr = import(From->getRAngleLoc());
815 return TemplateArgument(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()),
921 size_t NumDecls = DG.end() - DG.begin();
979 auto ToNNS = importChecked(Err, From->getNestedNameSpecifierLoc());
980 auto ToTemplateKWLoc = importChecked(Err, From->getTemplateKWLoc());
982 importChecked(Err, From->getConceptNameInfo().getLoc());
983 auto ToConceptName = importChecked(Err, From->getConceptNameInfo().getName());
984 auto ToFoundDecl = importChecked(Err, From->getFoundDecl());
985 auto ToNamedConcept = importChecked(Err, From->getNamedConcept());
989 const auto *ASTTemplateArgs = From->getTemplateArgsAsWritten();
1029 if (Found->getLinkageInternal() != From->getLinkageInternal())
1032 if (From->hasExternalFormalLinkage())
1033 return Found->hasExternalFormalLinkage();
1034 if (Importer.GetFromTU(Found) != From->getTranslationUnitDecl())
1036 if (From->isInAnonymousNamespace())
1037 return Found->isInAnonymousNamespace();
1039 return !Found->isInAnonymousNamespace() &&
1040 !Found->hasExternalFormalLinkage();
1046 if (Found->getLinkageInternal() != From->getLinkageInternal())
1049 if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace())
1050 return Importer.GetFromTU(Found) == From->getTranslationUnitDecl();
1051 return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace();
1056 //----------------------------------------------------------------------------
1058 //----------------------------------------------------------------------------
1064 << T->getTypeClassName();
1069 ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
1077 switch (T->getKind()) {
1146 ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType());
1154 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1162 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1171 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1181 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1191 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1201 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1205 ExpectedTypePtr ClassTypeOrErr = import(T->getClass());
1216 auto ToElementType = importChecked(Err, T->getElementType());
1217 auto ToSizeExpr = importChecked(Err, T->getSizeExpr());
1222 ToElementType, T->getSize(), ToSizeExpr, T->getSizeModifier(),
1223 T->getIndexTypeCVRQualifiers());
1237 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1242 T->getSizeModifier(),
1243 T->getIndexTypeCVRQualifiers());
1249 QualType ToElementType = importChecked(Err, T->getElementType());
1250 Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1251 SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1255 ToElementType, ToSizeExpr, T->getSizeModifier(),
1256 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1262 QualType ToElementType = importChecked(Err, T->getElementType());
1263 Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1264 SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1271 ToElementType, ToSizeExpr, T->getSizeModifier(),
1272 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1278 QualType ToElementType = importChecked(Err, T->getElementType());
1279 Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1280 SourceLocation ToAttrLoc = importChecked(Err, T->getAttributeLoc());
1288 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1293 T->getNumElements(),
1294 T->getVectorKind());
1298 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1303 T->getNumElements());
1310 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1315 T->getExtInfo());
1320 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1326 for (const auto &A : T->param_types()) {
1335 for (const auto &E : T->exceptions()) {
1342 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1369 auto ToD = importChecked(Err, T->getDecl());
1370 auto ToPrevD = importChecked(Err, T->getDecl()->getPreviousDecl());
1379 ExpectedType ToInnerTypeOrErr = import(T->getInnerType());
1389 ExpectedType Pattern = import(T->getPattern());
1392 ExpectedExpr Index = import(T->getIndexExpr());
1399 Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
1404 if (ToDecl->getTypeForDecl())
1405 return QualType(ToDecl->getTypeForDecl(), 0);
1407 ExpectedType ToUnderlyingTypeOrErr = import(T->desugar());
1415 ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1418 return Importer.getToContext().getTypeOfExprType(*ToExprOrErr, T->getKind());
1422 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnmodifiedType());
1426 T->getKind());
1430 Expected<UsingShadowDecl *> FoundOrErr = import(T->getFoundDecl());
1433 Expected<QualType> UnderlyingOrErr = import(T->getUnderlyingType());
1442 ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1446 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1456 ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1460 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1465 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
1470 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1474 ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
1479 if (Error Err = ImportTemplateArguments(T->getTypeConstraintArguments(),
1484 *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
1492 Expected<TemplateName> ToTemplateNameOrErr = import(T->getTemplateName());
1495 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1500 *ToTemplateNameOrErr, *ToDeducedTypeOrErr, T->isDependentType());
1505 Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
1510 // T->getDecl() is imported. Here we can return the existing type.
1511 const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
1517 Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
1525 Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
1533 ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType());
1536 ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType());
1540 return Importer.getToContext().getAttributedType(T->getAttrKind(),
1546 ExpectedType ToWrappedTypeOrErr = import(T->desugar());
1551 Expr *CountExpr = importChecked(Err, T->getCountExpr());
1554 for (const TypeCoupledDeclRefInfo &TI : T->dependent_decls()) {
1562 *ToWrappedTypeOrErr, CountExpr, T->isCountInBytes(), T->isOrNull(),
1568 Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
1573 T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr);
1578 Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
1582 ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
1587 *ToReplacementTypeOrErr, *ReplacedOrErr, T->getIndex(),
1588 T->getPackIndex());
1593 Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
1597 Expected<TemplateArgument> ToArgumentPack = import(T->getArgumentPack());
1602 *ReplacedOrErr, T->getIndex(), T->getFinal(), *ToArgumentPack);
1607 auto ToTemplateOrErr = import(T->getTemplateName());
1613 ImportTemplateArguments(T->template_arguments(), ToTemplateArgs))
1617 if (!T->isCanonicalUnqualified()) {
1632 auto ToQualifierOrErr = import(T->getQualifier());
1636 ExpectedType ToNamedTypeOrErr = import(T->getNamedType());
1640 Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl());
1644 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1652 ExpectedType ToPatternOrErr = import(T->getPattern());
1657 T->getNumExpansions(),
1663 auto ToQualifierOrErr = import(T->getQualifier());
1667 IdentifierInfo *ToName = Importer.Import(T->getIdentifier());
1670 ToPack.reserve(T->template_arguments().size());
1671 if (Error Err = ImportTemplateArguments(T->template_arguments(), ToPack))
1675 T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1680 auto ToQualifierOrErr = import(T->getQualifier());
1684 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1687 if (T != T->getCanonicalTypeInternal().getTypePtr()) {
1688 if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
1694 return Importer.getToContext().getDependentNameType(T->getKeyword(),
1701 Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
1709 ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1714 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1722 for (auto *P : T->quals()) {
1732 T->isKindOfTypeAsWritten());
1737 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1746 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1750 IdentifierInfo *ToIdentifier = Importer.Import(T->getMacroIdentifier());
1757 QualType ToOriginalType = importChecked(Err, T->getOriginalType());
1758 QualType ToAdjustedType = importChecked(Err, T->getAdjustedType());
1767 return Importer.getToContext().getBitIntType(T->isUnsigned(),
1768 T->getNumBits());
1774 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err, T->getAttr());
1775 QualType ToWrappedType = importChecked(Err, T->getWrappedType());
1785 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1790 *ToElementTypeOrErr, T->getNumRows(), T->getNumColumns());
1796 QualType ToPointeeType = importChecked(Err, T->getPointeeType());
1797 Expr *ToAddrSpaceExpr = importChecked(Err, T->getAddrSpaceExpr());
1798 SourceLocation ToAttrLoc = importChecked(Err, T->getAttributeLoc());
1808 ExpectedExpr ToNumBitsExprOrErr = import(T->getNumBitsExpr());
1811 return Importer.getToContext().getDependentBitIntType(T->isUnsigned(),
1818 QualType ToElementType = importChecked(Err, T->getElementType());
1819 Expr *ToRowExpr = importChecked(Err, T->getRowExpr());
1820 Expr *ToColumnExpr = importChecked(Err, T->getColumnExpr());
1821 SourceLocation ToAttrLoc = importChecked(Err, T->getAttributeLoc());
1832 QualType ToElementType = importChecked(Err, T->getElementType());
1833 Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1834 SourceLocation ToAttrLoc = importChecked(Err, T->getAttributeLoc());
1839 ToElementType, ToSizeExpr, ToAttrLoc, T->getVectorKind());
1844 Expected<ObjCTypeParamDecl *> ToDeclOrErr = import(T->getDecl());
1849 for (ObjCProtocolDecl *FromProtocol : T->getProtocols()) {
1861 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1866 if (T->isReadOnly())
1872 //----------------------------------------------------------------------------
1874 //----------------------------------------------------------------------------
1884 DeclContext *OrigDC = D->getDeclContext();
1887 FunDecl->hasBody()) {
1889 while (T->isPointerType() || T->isArrayType()) {
1890 T = T->getPointeeOrArrayElementType();
1894 for (const ParmVarDecl *P : FunDecl->parameters()) {
1896 getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
1898 if (RT && RT->getDecl() == D) {
1899 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1900 << D->getDeclKindName();
1911 if (Error Err = importInto(Name, D->getDeclName()))
1915 if (Error Err = importInto(Loc, D->getLocation()))
1930 if (Error Err = importInto(Name, D->getDeclName()))
1934 if (Error Err = importInto(Loc, D->getLocation()))
1955 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1956 !ToRecord->getDefinition()) {
1966 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2042 for (auto *From : FromDC->decls()) {
2100 for (auto *D : FromRD->decls()) {
2107 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD));
2109 ToDC->removeDecl(ToD);
2113 ToDC->addDeclInternal(ToD);
2119 for (auto *From : FromDC->decls()) {
2138 QualType FromType = From->getType();
2139 QualType ToType = To->getType();
2140 if (FromType->isArrayType()) {
2141 // getBaseElementTypeUnsafe(...) handles multi-dimensonal arrays for us.
2142 FromRecordDecl = FromType->getBaseElementTypeUnsafe()->getAsRecordDecl();
2143 ToRecordDecl = ToType->getBaseElementTypeUnsafe()->getAsRecordDecl();
2147 const RecordType *RecordFrom = FromType->getAs<RecordType>();
2148 const RecordType *RecordTo = ToType->getAs<RecordType>();
2151 FromRecordDecl = RecordFrom->getDecl();
2152 ToRecordDecl = RecordTo->getDecl();
2157 if (FromRecordDecl->isCompleteDefinition() &&
2158 !ToRecordDecl->isCompleteDefinition())
2167 auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext());
2172 if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
2174 FromD->getLexicalDeclContext());
2186 assert(From->isCompleteDefinition() && To->getDefinition() == To &&
2187 "Import implicit methods to or from non-definition");
2189 for (CXXMethodDecl *FromM : From->methods())
2190 if (FromM->isImplicit()) {
2201 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
2203 To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr));
2219 To->setCompleteDefinition(false);
2220 To->completeDefinition();
2223 if (To->getDefinition() || To->isBeingDefined()) {
2229 (To->isLambda() && shouldForceImportDeclContext(Kind))) {
2230 if (To->isLambda()) {
2233 ToCaptures.reserve(FromCXXRD->capture_size());
2234 for (const auto &FromCapture : FromCXXRD->captures()) {
2240 cast<CXXRecordDecl>(To)->setCaptures(Importer.getToContext(),
2246 if (To->isLambda())
2254 To->startDefinition();
2262 To->setCompleteDefinition(true);
2272 // Add base classes.
2275 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2277 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2278 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2285 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2288 for (const auto &Base1 : FromCXX->bases()) {
2301 // Ensure that we have a definition for the base.
2303 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()))
2324 ToCXX->setBases(Bases.data(), Bases.size());
2336 if (To->getAnyInitializer())
2339 Expr *FromInit = From->getInit();
2347 To->setInit(*ToInitOrErr);
2348 if (EvaluatedStmt *FromEval = From->getEvaluatedStmt()) {
2349 EvaluatedStmt *ToEval = To->ensureEvaluatedStmt();
2350 ToEval->HasConstantInitialization = FromEval->HasConstantInitialization;
2351 ToEval->HasConstantDestruction = FromEval->HasConstantDestruction;
2361 if (To->getDefinition() || To->isBeingDefined()) {
2367 To->startDefinition();
2377 ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType());
2387 To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
2388 From->getNumPositiveBits(),
2389 From->getNumNegativeBits());
2432 // Eliminate a potential failure point where we attempt to re-import
2448 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2449 << D->getDeclKindName();
2454 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2455 << D->getDeclKindName();
2466 ExpectedSLoc LocOrErr = import(D->getLocation());
2474 ToD->setLexicalDeclContext(LexicalDC);
2475 LexicalDC->addDeclInternal(ToD);
2504 QualType ToType = importChecked(Err, D->getType());
2505 Expr *ToBinding = importChecked(Err, D->getBinding());
2506 ValueDecl *ToDecomposedDecl = importChecked(Err, D->getDecomposedDecl());
2510 ToD->setBinding(ToType, ToBinding);
2511 ToD->setDecomposedDecl(ToDecomposedDecl);
2518 ExpectedSLoc LocOrErr = import(D->getLocation());
2521 auto ColonLocOrErr = import(D->getColonLoc());
2526 auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2532 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
2538 ToD->setLexicalDeclContext(DC);
2539 DC->addDeclInternal(ToD);
2545 auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2552 auto ToLocation = importChecked(Err, D->getLocation());
2553 auto ToRParenLoc = importChecked(Err, D->getRParenLoc());
2554 auto ToAssertExpr = importChecked(Err, D->getAssertExpr());
2555 auto ToMessage = importChecked(Err, D->getMessage());
2562 ToRParenLoc, D->isFailed()))
2565 ToD->setLexicalDeclContext(LexicalDC);
2566 LexicalDC->addDeclInternal(ToD);
2587 MergeWithNamespace = TU->getAnonymousNamespace();
2589 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2594 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
2617 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2620 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
2628 D->isInline(), *BeginLocOrErr, Loc,
2630 /*PrevDecl=*/nullptr, D->isNested()))
2632 ToNamespace->setRBraceLoc(*RBraceLocOrErr);
2633 ToNamespace->setLexicalDeclContext(LexicalDC);
2634 LexicalDC->addDeclInternal(ToNamespace);
2640 TU->setAnonymousNamespace(ToNamespace);
2642 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2667 auto ToNamespaceLoc = importChecked(Err, D->getNamespaceLoc());
2668 auto ToAliasLoc = importChecked(Err, D->getAliasLoc());
2669 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2670 auto ToTargetNameLoc = importChecked(Err, D->getTargetNameLoc());
2671 auto ToNamespace = importChecked(Err, D->getNamespace());
2675 IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier());
2683 ToD->setLexicalDeclContext(LexicalDC);
2684 LexicalDC->addDeclInternal(ToD);
2703 Importer.GetAlreadyImportedOrNull(cast<Decl>(D->getDeclContext())));
2706 cast<Decl>(D->getLexicalDeclContext())));
2714 if (DC && !DC->isFunctionOrMethod()) {
2719 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2725 QualType FromUT = D->getUnderlyingType();
2726 QualType FoundUT = FoundTypedef->getUnderlyingType();
2738 RecordDecl *FromR = FromUT->getAsRecordDecl();
2739 RecordDecl *FoundR = FoundUT->getAsRecordDecl();
2746 if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
2767 auto ToUnderlyingType = importChecked(Err, D->getUnderlyingType());
2768 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
2769 auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2790 ToTypedef->setDeclContext(DC);
2791 ToTypedef->setLexicalDeclContext(LexicalDC);
2795 ToTypedef->setAccess(D->getAccess());
2799 if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
2800 LexicalDC->addDeclInternal(ToTypedef);
2828 if (!DC->isFunctionOrMethod()) {
2833 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2853 auto ToTemplateParameters = importChecked(Err, D->getTemplateParameters());
2854 auto ToTemplatedDecl = importChecked(Err, D->getTemplatedDecl());
2863 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2865 ToAlias->setAccess(D->getAccess());
2866 ToAlias->setLexicalDeclContext(LexicalDC);
2867 LexicalDC->addDeclInternal(ToAlias);
2884 assert(LexicalDC->isFunctionOrMethod());
2887 if (D->isGnuLocal()) {
2888 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2902 Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
2906 ToLabel->setStmt(*ToStmtOrErr);
2907 ToLabel->setLexicalDeclContext(LexicalDC);
2908 LexicalDC->addDeclInternal(ToLabel);
2926 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2928 SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
2936 if (!DC->isFunctionOrMethod()) {
2941 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2945 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2946 FoundDecl = Tag->getDecl();
2953 EnumDecl *FoundDef = FoundEnum->getDefinition();
2954 if (D->isThisDeclarationADefinition() && FoundDef)
2956 PrevDecl = FoundEnum->getMostRecentDecl();
2965 // Structural in-equivalence is not detected in this way here, but it may
2980 auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2981 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2982 auto ToIntegerType = importChecked(Err, D->getIntegerType());
2983 auto ToBraceRange = importChecked(Err, D->getBraceRange());
2991 Loc, Name.getAsIdentifierInfo(), PrevDecl, D->isScoped(),
2992 D->isScopedUsingClassTag(), D->isFixed()))
2995 D2->setQualifierInfo(ToQualifierLoc);
2996 D2->setIntegerType(ToIntegerType);
2997 D2->setBraceRange(ToBraceRange);
2998 D2->setAccess(D->getAccess());
2999 D2->setLexicalDeclContext(LexicalDC);
3002 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
3003 TemplateSpecializationKind SK = MemberInfo->getTemplateSpecializationKind();
3004 EnumDecl *FromInst = D->getInstantiatedFromMemberEnum();
3006 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
3009 if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
3010 D2->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3016 if (D->isCompleteDefinition())
3027 DCXX->getDescribedClassTemplate() &&
3028 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
3045 if (!SearchName && D->getTypedefNameForAnonDecl()) {
3047 SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
3053 bool IsDependentContext = DC != LexicalDC ? LexicalDC->isDependentContext()
3054 : DC->isDependentContext();
3059 if (!DependentFriend && !DC->isFunctionOrMethod() && !D->isLambda()) {
3066 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
3067 D->getASTContext().getExternalSource()->CompleteType(D);
3071 if (!FoundDecl->isInIdentifierNamespace(IDNS))
3076 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3077 Found = Tag->getDecl();
3098 RecordDecl *FoundDef = FoundRecord->getDefinition();
3099 if (D->isThisDeclarationADefinition() && FoundDef) {
3101 // user-defined methods.
3114 PrevDecl = FoundRecord->getMostRecentDecl();
3132 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
3140 if (DCXX->isLambda()) {
3141 auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
3146 DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
3147 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
3149 CXXRecordDecl::LambdaNumbering Numbering = DCXX->getLambdaNumbering();
3154 D2CXX->setLambdaNumbering(Numbering);
3155 } else if (DCXX->isInjectedClassName()) {
3160 D2CXX, D, Importer.getToContext(), D->getTagKind(), DC,
3168 D->getTagKind(), DC, *BeginLocOrErr, Loc,
3175 D2->setAccess(D->getAccess());
3176 D2->setLexicalDeclContext(LexicalDC);
3180 DCXX->getDescribedClassTemplate()) {
3184 D2CXX->setDescribedClassTemplate(ToDescribed);
3185 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
3191 for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
3193 if (Record && Record->isInjectedClassName()) {
3206 cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
3208 if (auto *InjTy = FrontTy->getAs<InjectedClassNameType>())
3209 InjSpec = InjTy->getInjectedSpecializationType();
3211 InjSpec = ToDescribed->getInjectedClassNameSpecialization();
3215 !isa<InjectedClassNameType>(RI->getTypeForDecl()))
3216 RI->setTypeForDecl(nullptr);
3224 Injected->setTypeForDecl(nullptr);
3231 DCXX->getMemberSpecializationInfo()) {
3233 MemberInfo->getTemplateSpecializationKind();
3234 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
3237 D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
3242 import(MemberInfo->getPointOfInstantiation()))
3243 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
3251 D->getTagKind(), DC, *BeginLocOrErr, Loc,
3254 D2->setLexicalDeclContext(LexicalDC);
3258 if (auto BraceRangeOrErr = import(D->getBraceRange()))
3259 D2->setBraceRange(*BraceRangeOrErr);
3262 if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
3263 D2->setQualifierInfo(*QualifierLocOrErr);
3267 if (D->isAnonymousStructOrUnion())
3268 D2->setAnonymousStructOrUnion(true);
3270 if (D->isCompleteDefinition())
3290 if (!LexicalDC->isFunctionOrMethod()) {
3295 if (!FoundDecl->isInIdentifierNamespace(IDNS))
3315 ExpectedType TypeOrErr = import(D->getType());
3319 ExpectedExpr InitOrErr = import(D->getInitExpr());
3326 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal()))
3329 ToEnumerator->setAccess(D->getAccess());
3330 ToEnumerator->setLexicalDeclContext(LexicalDC);
3331 LexicalDC->addDeclInternal(ToEnumerator);
3338 unsigned int Num = FromD->getNumTemplateParameterLists();
3344 import(FromD->getTemplateParameterList(I)))
3348 ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3354 switch (FromFD->getTemplatedKind()) {
3361 import(FromFD->getInstantiatedFromDecl()))
3362 ToFD->setInstantiatedFromDecl(*InstFDOrErr);
3365 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
3368 import(FromFD->getInstantiatedFromMemberFunction()))
3369 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3374 FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
3375 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3391 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
3393 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3399 ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
3406 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
3407 ToFD->setFunctionTemplateSpecialization(
3414 auto *FromInfo = FromFD->getDependentSpecializationInfo();
3416 for (FunctionTemplateDecl *FTD : FromInfo->getCandidates()) {
3425 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3431 ToFD->setDependentTemplateSpecialization(
3451 auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos);
3457 if (Stmt *FromBody = FromFD->getBody()) {
3459 ToFD->setBody(*ToBodyOrErr);
3471 DCi = D->getDeclContext();
3473 while (DCi != D->getTranslationUnitDecl()) {
3476 DCi = DCi->getParent();
3489 ToProcess.append(CurrentS->child_begin(), CurrentS->child_end());
3491 if (const Decl *D = DeclRef->getDecl())
3496 if (const Decl *D = E->getAssociatedDecl())
3517 /// check the same visitor is re-used (it has no state-dependent data).
3520 /// - True, found a declaration inside \c ParentDC.
3521 /// - False, found declarations only outside \c ParentDC and it is not possible
3523 /// - Empty optional value, found no declarations or only outside \c ParentDC,
3542 T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3547 DsT = T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
3553 if (auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl()))
3554 for (const auto &Arg : Spec->getTemplateArgs().asArray())
3557 return isAncestorDeclContextOf(ParentDC, T->getDecl());
3561 return CheckType(T->getPointeeType());
3565 return CheckType(T->getPointeeTypeAsWritten());
3569 const TypedefNameDecl *TD = T->getDecl();
3575 if (T->getFoundDecl() &&
3576 isAncestorDeclContextOf(ParentDC, T->getFoundDecl()))
3584 for (const auto &Arg : T->template_arguments())
3594 if (isAncestorDeclContextOf(ParentDC, T->getAssociatedDecl()))
3600 if (T->getSizeExpr() && isAncestorDeclContextOf(ParentDC, T->getSizeExpr()))
3603 return CheckType(T->getElementType());
3664 QualType FromTy = D->getType();
3665 const auto *FromFPT = FromTy->getAs<FunctionProtoType>();
3672 if (FromFPT->hasTrailingReturn())
3676 return cast<CXXRecordDecl>(MD->getDeclContext())->isLambda();
3681 QualType RetT = FromFPT->getReturnType();
3683 FunctionDecl *Def = D->getDefinition();
3723 FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
3730 if (D->getTemplatedKind() ==
3743 else if (!LexicalDC->isFunctionOrMethod()) {
3748 if (!FoundDecl->isInIdentifierNamespace(IDNS))
3770 << Name << D->getType() << FoundFunction->getType();
3771 Importer.ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3772 << FoundFunction->getType();
3787 // We do not allow more than one in-class declaration of a function. This is
3789 // assumes there is only one in-class declaration. Building a redecl
3790 // chain would result in more than one in-class declaration for
3795 if (D->getLexicalDeclContext() == D->getDeclContext()) {
3796 if (!D->doesThisDeclarationHaveABody()) {
3798 D->getDescribedFunctionTemplate()) {
3802 assert(FoundByLookup->getDescribedFunctionTemplate() &&
3803 "Templated function mapped to non-templated?");
3805 FoundByLookup->getDescribedFunctionTemplate());
3818 if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
3821 QualType FromTy = D->getType();
3822 TypeSourceInfo *FromTSI = D->getTypeSourceInfo();
3831 if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
3832 QualType FromReturnTy = FromFPT->getReturnType();
3842 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3855 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3857 FromTy, D->getBeginLoc());
3863 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3864 auto ToEndLoc = importChecked(Err, D->getEndLoc());
3865 auto ToDefaultLoc = importChecked(Err, D->getDefaultLoc());
3866 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
3868 importChecked(Err, D->getTrailingRequiresClause());
3874 for (auto *P : D->parameters()) {
3885 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3889 if (FromConstructor->isInheritingConstructor()) {
3891 import(FromConstructor->getInheritedConstructor());
3898 ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->UsesFPIntrin(),
3899 D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(),
3906 Err, const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()));
3907 auto ToThisArg = importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3913 ToInnerLocStart, NameInfo, T, TInfo, D->UsesFPIntrin(),
3914 D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(),
3920 ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg);
3924 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3929 ToInnerLocStart, NameInfo, T, TInfo, D->UsesFPIntrin(),
3930 D->isInlineSpecified(), ESpec, D->getConstexprKind(),
3936 ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3937 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3938 D->getConstexprKind(), SourceLocation(), TrailingRequiresClause))
3942 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3944 importChecked(Err, Guide->getCorrespondingConstructor());
3952 ->setDeductionCandidateKind(Guide->getDeductionCandidateKind());
3956 NameInfo, T, TInfo, D->getStorageClass(), D->UsesFPIntrin(),
3957 D->isInlineSpecified(), D->hasWrittenPrototype(),
3958 D->getConstexprKind(), TrailingRequiresClause))
3965 FoundByLookup->getMostRecentDecl());
3966 ToFunction->setPreviousDecl(Recent);
3969 // noexcept-unevaluated, while the newly imported function may have an
3974 StringLiteral *Msg = D->getDeletedMessage();
3982 ToFunction->setQualifierInfo(ToQualifierLoc);
3983 ToFunction->setAccess(D->getAccess());
3984 ToFunction->setLexicalDeclContext(LexicalDC);
3985 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3986 ToFunction->setTrivial(D->isTrivial());
3987 ToFunction->setIsPureVirtual(D->isPureVirtual());
3988 ToFunction->setDefaulted(D->isDefaulted());
3989 ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
3990 ToFunction->setDeletedAsWritten(D->isDeletedAsWritten());
3991 ToFunction->setFriendConstraintRefersToEnclosingTemplate(
3992 D->FriendConstraintRefersToEnclosingTemplate());
3993 ToFunction->setRangeEnd(ToEndLoc);
3994 ToFunction->setDefaultLoc(ToDefaultLoc);
3997 ToFunction->setDefaultedOrDeletedInfo(
4003 Param->setOwningFunction(ToFunction);
4004 ToFunction->addDeclInternal(Param);
4005 if (ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable())
4006 LT->update(Param, Importer.getToContext().getTranslationUnitDecl());
4008 ToFunction->setParams(Parameters);
4014 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
4029 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
4033 FromConstructor->inits(), CtorInitializers))
4039 ToCtor->setCtorInitializers(Memory);
4040 ToCtor->setNumCtorInitializers(NumInitializers);
4053 if (D->doesThisDeclarationHaveABody()) {
4062 if (ExpectedType TyOrErr = import(D->getType()))
4063 ToFunction->setType(*TyOrErr);
4066 if (Expected<TypeSourceInfo *> TSIOrErr = import(D->getTypeSourceInfo()))
4067 ToFunction->setTypeSourceInfo(*TSIOrErr);
4128 if (Importer.IsStructurallyEquivalent(D->getType(),
4129 FoundField->getType())) {
4135 // Note: `hasInClassInitializer()` is not the same as non-null
4137 if (Expr *FromInitializer = D->getInClassInitializer()) {
4141 assert(FoundField->hasInClassInitializer() &&
4142 "Field should have an in-class initializer if it has an "
4144 if (!FoundField->getInClassInitializer())
4145 FoundField->setInClassInitializer(*ToInitializerOrErr);
4155 << Name << D->getType() << FoundField->getType();
4156 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4157 << FoundField->getType();
4164 auto ToType = importChecked(Err, D->getType());
4165 auto ToTInfo = importChecked(Err, D->getTypeSourceInfo());
4166 auto ToBitWidth = importChecked(Err, D->getBitWidth());
4167 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4172 ToCapturedVLAType, cast_or_null<Type>(D->getCapturedVLAType())))
4178 ToType, ToTInfo, ToBitWidth, D->isMutable(),
4179 D->getInClassInitStyle()))
4184 // marked as having non-zero size.
4188 ToField->setAccess(D->getAccess());
4189 ToField->setLexicalDeclContext(LexicalDC);
4190 ToField->setImplicit(D->isImplicit());
4192 ToField->setCapturedVLAType(cast<VariableArrayType>(ToCapturedVLAType));
4193 LexicalDC->addDeclInternal(ToField);
4196 auto ToInitializer = importChecked(Err, D->getInClassInitializer());
4200 auto *AlreadyImported = ToField->getInClassInitializer();
4203 "Duplicate import of in-class initializer.");
4205 ToField->setInClassInitializer(ToInitializer);
4232 if (Importer.IsStructurallyEquivalent(D->getType(),
4233 FoundField->getType(),
4240 if (!Name && I < N-1)
4245 << Name << D->getType() << FoundField->getType();
4246 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
4247 << FoundField->getType();
4254 auto TypeOrErr = import(D->getType());
4259 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
4262 for (auto *PI : D->chain())
4268 llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
4275 ToIndirectField->setAccess(D->getAccess());
4276 ToIndirectField->setLexicalDeclContext(LexicalDC);
4277 LexicalDC->addDeclInternal(ToIndirectField);
4291 if ((!FD1->getFriendType()) != (!FD2->getFriendType()))
4294 if (const TypeSourceInfo *TSI = FD1->getFriendType())
4296 TSI->getType(), FD2->getFriendType()->getType(), /*Complain=*/false);
4300 FD1->getASTContext(), FD2->getASTContext(), NonEquivalentDecls,
4310 const auto *RD = cast<CXXRecordDecl>(FD->getLexicalDeclContext());
4312 for (FriendDecl *FoundFriend : RD->friends()) {
4337 for (FriendDecl *ImportedFriend : RD->friends())
4345 "Class with non-matching friends is imported, ODR check wrong?");
4353 if (NamedDecl *FriendD = D->getFriendDecl()) {
4358 if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
4359 !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
4360 ToFriendD->setObjectOfFriendDecl(false);
4364 if (auto TSIOrErr = import(D->getFriendType()))
4370 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
4371 auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
4372 for (unsigned I = 0; I < D->NumTPLists; I++) {
4379 auto LocationOrErr = import(D->getLocation());
4382 auto FriendLocOrErr = import(D->getFriendLoc());
4392 FrD->setAccess(D->getAccess());
4393 FrD->setLexicalDeclContext(LexicalDC);
4394 LexicalDC->addDeclInternal(FrD);
4413 if (Importer.IsStructurallyEquivalent(D->getType(),
4414 FoundIvar->getType())) {
4420 << Name << D->getType() << FoundIvar->getType();
4421 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
4422 << FoundIvar->getType();
4429 auto ToType = importChecked(Err, D->getType());
4430 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4431 auto ToBitWidth = importChecked(Err, D->getBitWidth());
4432 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4441 D->getAccessControl(),ToBitWidth, D->getSynthesize()))
4444 ToIvar->setLexicalDeclContext(LexicalDC);
4445 LexicalDC->addDeclInternal(ToIvar);
4475 if (D->isFileVarDecl()) {
4480 if (!FoundDecl->isInIdentifierNamespace(IDNS))
4486 if (Importer.IsStructurallyEquivalent(D->getType(),
4487 FoundVar->getType())) {
4491 VarDecl *FoundDef = FoundVar->getDefinition();
4492 if (D->isThisDeclarationADefinition() && FoundDef)
4500 if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
4509 = Importer.getToContext().getAsArrayType(FoundVar->getType());
4511 = Importer.getToContext().getAsArrayType(D->getType());
4516 if (auto TyOrErr = import(D->getType()))
4517 FoundVar->setType(*TyOrErr);
4531 << Name << D->getType() << FoundVar->getType();
4532 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4533 << FoundVar->getType();
4549 auto ToType = importChecked(Err, D->getType());
4550 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4551 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4552 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4558 SmallVector<BindingDecl *> Bindings(FromDecomp->bindings().size());
4560 ImportArrayChecked(FromDecomp->bindings(), Bindings.begin()))
4565 Loc, ToType, ToTypeSourceInfo, D->getStorageClass(), Bindings))
4573 ToTypeSourceInfo, D->getStorageClass()))
4577 ToVar->setTSCSpec(D->getTSCSpec());
4578 ToVar->setQualifierInfo(ToQualifierLoc);
4579 ToVar->setAccess(D->getAccess());
4580 ToVar->setLexicalDeclContext(LexicalDC);
4581 if (D->isInlineSpecified())
4582 ToVar->setInlineSpecified();
4583 if (D->isInline())
4584 ToVar->setImplicitlyInline();
4587 auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl());
4588 ToVar->setPreviousDecl(Recent);
4592 if (D->getDescribedVarTemplate()) {
4593 auto ToVTOrErr = import(D->getDescribedVarTemplate());
4596 } else if (MemberSpecializationInfo *MSI = D->getMemberSpecializationInfo()) {
4597 TemplateSpecializationKind SK = MSI->getTemplateSpecializationKind();
4598 VarDecl *FromInst = D->getInstantiatedFromStaticDataMember();
4600 ToVar->setInstantiationOfStaticDataMember(*ToInstOrErr, SK);
4603 if (ExpectedSLoc POIOrErr = import(MSI->getPointOfInstantiation()))
4604 ToVar->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
4612 if (D->isConstexpr())
4613 ToVar->setConstexpr(true);
4633 auto ToDeclName = importChecked(Err, D->getDeclName());
4634 auto ToLocation = importChecked(Err, D->getLocation());
4635 auto ToType = importChecked(Err, D->getType());
4643 ToType, D->getParameterKind()))
4650 ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
4651 ToParam->setExplicitObjectParameterLoc(
4652 FromParam->getExplicitObjectParamThisLoc());
4653 ToParam->setKNRPromoted(FromParam->isKNRPromoted());
4655 if (FromParam->hasUninstantiatedDefaultArg()) {
4656 if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg()))
4657 ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
4660 } else if (FromParam->hasUnparsedDefaultArg()) {
4661 ToParam->setUnparsedDefaultArg();
4662 } else if (FromParam->hasDefaultArg()) {
4663 if (auto ToDefArgOrErr = import(FromParam->getDefaultArg()))
4664 ToParam->setDefaultArg(*ToDefArgOrErr);
4689 auto ToDeclName = importChecked(Err, D->getDeclName());
4690 auto ToLocation = importChecked(Err, D->getLocation());
4691 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4692 auto ToType = importChecked(Err, D->getType());
4693 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4701 ToTypeSourceInfo, D->getStorageClass(),
4711 if (D->isObjCMethodParameter()) {
4712 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
4713 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
4715 ToParm->setScopeInfo(D->getFunctionScopeDepth(),
4716 D->getFunctionScopeIndex());
4736 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
4740 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
4741 FoundMethod->getReturnType())) {
4743 << D->isInstanceMethod() << Name << D->getReturnType()
4744 << FoundMethod->getReturnType();
4745 Importer.ToDiag(FoundMethod->getLocation(),
4747 << D->isInstanceMethod() << Name;
4753 if (D->param_size() != FoundMethod->param_size()) {
4755 << D->isInstanceMethod() << Name
4756 << D->param_size() << FoundMethod->param_size();
4757 Importer.ToDiag(FoundMethod->getLocation(),
4759 << D->isInstanceMethod() << Name;
4765 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
4766 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
4768 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
4769 (*FoundP)->getType())) {
4770 Importer.FromDiag((*P)->getLocation(),
4772 << D->isInstanceMethod() << Name
4773 << (*P)->getType() << (*FoundP)->getType();
4774 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4775 << (*FoundP)->getType();
4781 // Check variadic/non-variadic.
4783 if (D->isVariadic() != FoundMethod->isVariadic()) {
4785 << D->isInstanceMethod() << Name;
4786 Importer.ToDiag(FoundMethod->getLocation(),
4788 << D->isInstanceMethod() << Name;
4799 auto ToEndLoc = importChecked(Err, D->getEndLoc());
4800 auto ToReturnType = importChecked(Err, D->getReturnType());
4802 importChecked(Err, D->getReturnTypeSourceInfo());
4810 D->isInstanceMethod(), D->isVariadic(), D->isPropertyAccessor(),
4811 D->isSynthesizedAccessorStub(), D->isImplicit(), D->isDefined(),
4812 D->getImplementationControl(), D->hasRelatedResultType()))
4820 for (auto *FromP : D->parameters()) {
4829 ToParam->setOwningFunction(ToMethod);
4830 ToMethod->addDeclInternal(ToParam);
4834 D->getSelectorLocs(FromSelLocs);
4839 ToMethod->setMethodParams(Importer.getToContext(), ToParams, ToSelLocs);
4841 ToMethod->setLexicalDeclContext(LexicalDC);
4842 LexicalDC->addDeclInternal(ToMethod);
4847 if (D->getSelfDecl())
4848 ToMethod->createImplicitParams(Importer.getToContext(),
4849 ToMethod->getClassInterface());
4866 auto ToVarianceLoc = importChecked(Err, D->getVarianceLoc());
4867 auto ToLocation = importChecked(Err, D->getLocation());
4868 auto ToColonLoc = importChecked(Err, D->getColonLoc());
4869 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4875 Result, D, Importer.getToContext(), DC, D->getVariance(),
4876 ToVarianceLoc, D->getIndex(),
4882 auto ToTypeForDecl = importChecked(Err, D->getTypeForDecl());
4885 Result->setTypeForDecl(ToTypeForDecl);
4886 Result->setLexicalDeclContext(LexicalDC);
4902 if (Error Err = importInto(ToInterface, D->getClassInterface()))
4907 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4912 auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
4913 auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
4914 auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
4915 auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
4928 ToCategory->setLexicalDeclContext(LexicalDC);
4929 LexicalDC->addDeclInternal(ToCategory);
4932 if (auto PListOrErr = ImportObjCTypeParamList(D->getTypeParamList()))
4933 ToCategory->setTypeParamList(*PListOrErr);
4941 = D->protocol_loc_begin();
4942 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4943 FromProtoEnd = D->protocol_end();
4958 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4970 if (D->getImplementation()) {
4972 import(D->getImplementation()))
4973 ToCategory->setImplementation(*ToImplOrErr);
4983 if (To->getDefinition()) {
4991 To->startDefinition();
4997 From->protocol_loc_begin();
4998 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4999 FromProtoEnd = From->protocol_end();
5015 To->setProtocolList(Protocols.data(), Protocols.size(),
5030 ObjCProtocolDecl *Definition = D->getDefinition();
5051 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
5060 auto ToAtBeginLocOrErr = import(D->getAtStartLoc());
5069 ToProto->setLexicalDeclContext(LexicalDC);
5070 LexicalDC->addDeclInternal(ToProto);
5075 if (D->isThisDeclarationADefinition())
5087 ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
5091 ExpectedSLoc LangLocOrErr = import(D->getLocation());
5095 bool HasBraces = D->hasBraces();
5100 D->getLanguage(), HasBraces))
5104 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
5107 ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
5110 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
5111 LexicalDC->addDeclInternal(ToLinkageSpec);
5118 for (UsingShadowDecl *FromShadow : D->shadows()) {
5120 ToSI->addShadowDecl(*ToShadowOrErr);
5140 auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
5141 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
5142 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
5147 if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
5153 D->hasTypename()))
5156 ToUsing->setLexicalDeclContext(LexicalDC);
5157 LexicalDC->addDeclInternal(ToUsing);
5182 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
5183 auto ToEnumLoc = importChecked(Err, D->getEnumLoc());
5184 auto ToNameLoc = importChecked(Err, D->getLocation());
5185 auto *ToEnumType = importChecked(Err, D->getEnumType());
5194 ToUsingEnum->setLexicalDeclContext(LexicalDC);
5195 LexicalDC->addDeclInternal(ToUsingEnum);
5219 Expected<BaseUsingDecl *> ToIntroducerOrErr = import(D->getIntroducer());
5223 Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
5232 Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
5238 // We should pass the NominatedBaseClassShadowDecl to it (if non-null) to
5244 FromConstructorUsingShadow->constructsVirtualBase()))
5252 ToShadow->setLexicalDeclContext(LexicalDC);
5253 ToShadow->setAccess(D->getAccess());
5266 LexicalDC->addDeclInternal(ToShadow);
5281 auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor());
5286 auto ToNominatedNamespace = importChecked(Err, D->getNominatedNamespace());
5287 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
5289 importChecked(Err, D->getNamespaceKeyLocation());
5290 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
5291 auto ToIdentLocation = importChecked(Err, D->getIdentLocation());
5304 ToUsingDir->setLexicalDeclContext(LexicalDC);
5305 LexicalDC->addDeclInternal(ToUsingDir);
5321 Importer.Import(D->getInstantiatedFromUsingDecl());
5324 SmallVector<NamedDecl *, 4> Expansions(D->expansions().size());
5325 if (Error Err = ImportArrayChecked(D->expansions(), Expansions.begin()))
5351 auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
5352 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
5353 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
5354 auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
5359 if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
5368 ToUsingValue->setAccess(D->getAccess());
5369 ToUsingValue->setLexicalDeclContext(LexicalDC);
5370 LexicalDC->addDeclInternal(ToUsingValue);
5387 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
5388 auto ToTypenameLoc = importChecked(Err, D->getTypenameLoc());
5389 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
5390 auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
5400 ToUsing->setAccess(D->getAccess());
5401 ToUsing->setLexicalDeclContext(LexicalDC);
5402 LexicalDC->addDeclInternal(ToUsing);
5409 switch (D->getBuiltinTemplateKind()) {
5424 if (To->getDefinition()) {
5426 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
5434 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
5437 Importer.ToDiag(To->getLocation(),
5439 << To->getDeclName();
5441 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
5442 << To->getSuperClass()->getDeclName();
5444 Importer.ToDiag(To->getLocation(),
5446 if (From->getSuperClass())
5447 Importer.FromDiag(From->getSuperClassLoc(),
5449 << From->getSuperClass()->getDeclName();
5451 Importer.FromDiag(From->getLocation(),
5462 To->startDefinition();
5465 if (From->getSuperClass()) {
5466 if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo()))
5467 To->setSuperClass(*SuperTInfoOrErr);
5476 From->protocol_loc_begin();
5478 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
5479 FromProtoEnd = From->protocol_end();
5495 To->setProtocolList(Protocols.data(), Protocols.size(),
5500 for (auto *Cat : From->known_categories()) {
5507 if (From->getImplementation()) {
5509 import(From->getImplementation()))
5510 To->setImplementation(*ToImplOrErr);
5535 auto LAngleLocOrErr = import(list->getLAngleLoc());
5539 auto RAngleLocOrErr = import(list->getRAngleLoc());
5553 ObjCInterfaceDecl *Definition = D->getDefinition();
5575 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5585 ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc());
5593 /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
5595 ToIface->setLexicalDeclContext(LexicalDC);
5596 LexicalDC->addDeclInternal(ToIface);
5602 ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
5603 ToIface->setTypeParamList(*ToPListOrErr);
5607 if (D->isThisDeclarationADefinition())
5617 if (Error Err = importInto(Category, D->getCategoryDecl()))
5620 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
5627 auto ToLocation = importChecked(Err, D->getLocation());
5628 auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
5629 auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
5635 Importer.Import(D->getIdentifier()), Category->getClassInterface(),
5639 ToImpl->setLexicalDeclContext(LexicalDC);
5640 LexicalDC->addDeclInternal(ToImpl);
5641 Category->setImplementation(ToImpl);
5655 if (Error Err = importInto(Iface, D->getClassInterface()))
5660 if (Error Err = importInto(Super, D->getSuperClass()))
5663 ObjCImplementationDecl *Impl = Iface->getImplementation();
5672 auto ToLocation = importChecked(Err, D->getLocation());
5673 auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
5674 auto ToSuperClassLoc = importChecked(Err, D->getSuperClassLoc());
5675 auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
5676 auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
5689 Impl->setLexicalDeclContext(LexicalDC);
5692 Iface->setImplementation(Impl);
5693 Importer.MapImported(D, Iface->getImplementation());
5695 Importer.MapImported(D, Iface->getImplementation());
5698 if ((Super && !Impl->getSuperClass()) ||
5699 (!Super && Impl->getSuperClass()) ||
5700 (Super && Impl->getSuperClass() &&
5701 !declaresSameEntity(Super->getCanonicalDecl(),
5702 Impl->getSuperClass()))) {
5703 Importer.ToDiag(Impl->getLocation(),
5705 << Iface->getDeclName();
5708 if (Impl->getSuperClass())
5709 Importer.ToDiag(Impl->getLocation(),
5711 << Impl->getSuperClass()->getDeclName();
5713 Importer.ToDiag(Impl->getLocation(),
5715 if (D->getSuperClass())
5716 Importer.FromDiag(D->getLocation(),
5718 << D->getSuperClass()->getDeclName();
5720 Importer.FromDiag(D->getLocation(),
5751 if (FoundProp->isInstanceProperty() != D->isInstanceProperty())
5755 if (!Importer.IsStructurallyEquivalent(D->getType(),
5756 FoundProp->getType())) {
5758 << Name << D->getType() << FoundProp->getType();
5759 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
5760 << FoundProp->getType();
5774 auto ToType = importChecked(Err, D->getType());
5775 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5776 auto ToAtLoc = importChecked(Err, D->getAtLoc());
5777 auto ToLParenLoc = importChecked(Err, D->getLParenLoc());
5787 ToTypeSourceInfo, D->getPropertyImplementation()))
5790 auto ToGetterName = importChecked(Err, D->getGetterName());
5791 auto ToSetterName = importChecked(Err, D->getSetterName());
5792 auto ToGetterNameLoc = importChecked(Err, D->getGetterNameLoc());
5793 auto ToSetterNameLoc = importChecked(Err, D->getSetterNameLoc());
5794 auto ToGetterMethodDecl = importChecked(Err, D->getGetterMethodDecl());
5795 auto ToSetterMethodDecl = importChecked(Err, D->getSetterMethodDecl());
5796 auto ToPropertyIvarDecl = importChecked(Err, D->getPropertyIvarDecl());
5800 ToProperty->setLexicalDeclContext(LexicalDC);
5801 LexicalDC->addDeclInternal(ToProperty);
5803 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
5804 ToProperty->setPropertyAttributesAsWritten(
5805 D->getPropertyAttributesAsWritten());
5806 ToProperty->setGetterName(ToGetterName, ToGetterNameLoc);
5807 ToProperty->setSetterName(ToSetterName, ToSetterNameLoc);
5808 ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
5809 ToProperty->setSetterMethodDecl(ToSetterMethodDecl);
5810 ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
5817 if (Error Err = importInto(Property, D->getPropertyDecl()))
5828 if (Error Err = importInto(Ivar, D->getPropertyIvarDecl()))
5832 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
5833 Property->getQueryKind());
5837 auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
5838 auto ToLocation = importChecked(Err, D->getLocation());
5840 importChecked(Err, D->getPropertyIvarDeclLoc());
5847 D->getPropertyImplementation(), Ivar,
5851 ToImpl->setLexicalDeclContext(LexicalDC);
5852 LexicalDC->addDeclInternal(ToImpl);
5856 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
5857 Importer.ToDiag(ToImpl->getLocation(),
5859 << Property->getDeclName()
5860 << (ToImpl->getPropertyImplementation()
5862 Importer.FromDiag(D->getLocation(),
5864 << D->getPropertyDecl()->getDeclName()
5865 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
5871 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
5872 Ivar != ToImpl->getPropertyIvarDecl()) {
5873 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
5875 << Property->getDeclName()
5876 << ToImpl->getPropertyIvarDecl()->getDeclName()
5877 << Ivar->getDeclName();
5878 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
5880 << D->getPropertyIvarDecl()->getDeclName();
5898 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5902 ExpectedSLoc LocationOrErr = import(D->getLocation());
5911 D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
5912 D->wasDeclaredWithTypename(), D->isParameterPack(),
5913 D->hasTypeConstraint()))
5916 // Import the type-constraint
5917 if (const TypeConstraint *TC = D->getTypeConstraint()) {
5920 auto ToConceptRef = importChecked(Err, TC->getConceptReference());
5921 auto ToIDC = importChecked(Err, TC->getImmediatelyDeclaredConstraint());
5925 ToD->setTypeConstraint(ToConceptRef, ToIDC);
5928 if (D->hasDefaultArgument()) {
5930 import(D->getDefaultArgument());
5933 ToD->setDefaultArgument(ToD->getASTContext(), *ToDefaultArgOrErr);
5943 auto ToDeclName = importChecked(Err, D->getDeclName());
5944 auto ToLocation = importChecked(Err, D->getLocation());
5945 auto ToType = importChecked(Err, D->getType());
5946 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5947 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
5954 ToInnerLocStart, ToLocation, D->getDepth(),
5955 D->getPosition(),
5957 D->isParameterPack(), ToTypeSourceInfo))
5960 if (D->hasDefaultArgument()) {
5962 import(D->getDefaultArgument());
5965 ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
5974 auto NameOrErr = import(D->getDeclName());
5979 ExpectedSLoc LocationOrErr = import(D->getLocation());
5984 auto TemplateParamsOrErr = import(D->getTemplateParameters());
5992 D->getDepth(), D->getPosition(), D->isParameterPack(),
5993 (*NameOrErr).getAsIdentifierInfo(), D->wasDeclaredWithTypename(),
5997 if (D->hasDefaultArgument()) {
5999 import(D->getDefaultArgument());
6002 ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
6010 template <typename T> static auto getTemplateDefinition(T *D) -> T * {
6011 assert(D->getTemplatedDecl() && "Should be called on templates only");
6012 auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
6015 auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
6038 return TD->getFriendObjectKind() != Decl::FOK_None &&
6039 TD->getLexicalDeclContext()->isDependentContext();
6046 if (!DC->isFunctionOrMethod()) {
6050 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary |
6062 (FoundTemplate->getFriendObjectKind() != Decl::FOK_None) !=
6063 (D->getFriendObjectKind() != Decl::FOK_None);
6071 if (D->isThisDeclarationADefinition() && TemplateWithDef)
6094 CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
6096 auto TemplateParamsOrErr = import(D->getTemplateParameters());
6111 ToTemplated->setDescribedClassTemplate(D2);
6113 D2->setAccess(D->getAccess());
6114 D2->setLexicalDeclContext(LexicalDC);
6121 const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6131 if (!ToTemplated->getPreviousDecl()) {
6132 assert(FoundByLookup->getTemplatedDecl() &&
6135 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6137 ToTemplated->setPreviousDecl(PrevTemplated);
6140 D2->setPreviousDecl(Recent);
6149 if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate()))
6160 ImportTemplateArguments(D->getTemplateArgs().asArray(), TemplateArgs))
6173 auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
6177 PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs,
6181 PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
6185 CXXRecordDecl *PrevDefinition = PrevDecl->getDefinition();
6186 if (D->isThisDeclarationADefinition() && PrevDefinition) {
6190 for (auto *FromField : D->fields()) {
6198 for (CXXMethodDecl *FromM : D->methods()) {
6218 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
6221 ExpectedSLoc IdLocOrErr = import(D->getLocation());
6227 if (const auto *ASTTemplateArgs = D->getTemplateArgsAsWritten()) {
6237 CanonInjType, PartialSpec->getInjectedSpecializationType()))
6242 D2, D, Importer.getToContext(), D->getTagKind(), DC, *BeginLocOrErr,
6252 if (!ClassTemplate->findPartialSpecialization(TemplateArgs, ToTPList,
6255 ClassTemplate->AddPartialSpecialization(PartSpec2, InsertPos);
6257 import(PartialSpec->getInstantiatedFromMember()))
6258 PartSpec2->setInstantiatedFromMember(*ToInstOrErr);
6265 D2, D, Importer.getToContext(), D->getTagKind(), DC,
6272 if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos))
6274 ClassTemplate->AddSpecialization(D2, InsertPos);
6277 D2->setSpecializationKind(D->getSpecializationKind());
6280 D2->setLexicalDeclContext(LexicalDC);
6283 if (D2->isExplicitInstantiationOrSpecialization()) {
6284 LexicalDC->addDeclInternal(D2);
6287 if (auto BraceRangeOrErr = import(D->getBraceRange()))
6288 D2->setBraceRange(*BraceRangeOrErr);
6296 if (auto LocOrErr = import(D->getQualifierLoc()))
6297 D2->setQualifierInfo(*LocOrErr);
6301 if (D->getTemplateArgsAsWritten())
6302 D2->setTemplateArgsAsWritten(ToTAInfo);
6304 if (auto LocOrErr = import(D->getTemplateKeywordLoc()))
6305 D2->setTemplateKeywordLoc(*LocOrErr);
6309 if (auto LocOrErr = import(D->getExternKeywordLoc()))
6310 D2->setExternKeywordLoc(*LocOrErr);
6314 if (D->getPointOfInstantiation().isValid()) {
6315 if (auto POIOrErr = import(D->getPointOfInstantiation()))
6316 D2->setPointOfInstantiation(*POIOrErr);
6321 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
6323 if (auto P = D->getInstantiatedFrom()) {
6326 D2->setInstantiationOf(*CTDorErr);
6332 const TemplateArgumentList &DArgs = D->getTemplateInstantiationArgs();
6341 D2->setInstantiationOf(
6347 if (D->isCompleteDefinition())
6366 assert(!DC->isFunctionOrMethod() &&
6373 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
6378 if (!hasSameVisibilityContextAndLinkage(FoundTemplate->getTemplatedDecl(),
6379 D->getTemplatedDecl()))
6385 if (D->getDeclContext()->isRecord()) {
6386 assert(FoundTemplate->getDeclContext()->isRecord() &&
6387 "Member variable template imported as non-member, "
6391 if (!D->isThisDeclarationADefinition())
6394 if (FoundDef && D->isThisDeclarationADefinition())
6414 VarDecl *DTemplated = D->getTemplatedDecl();
6418 ExpectedType TypeOrErr = import(DTemplated->getType());
6428 auto TemplateParamsOrErr = import(D->getTemplateParameters());
6437 ToTemplated->setDescribedVarTemplate(ToVarTD);
6439 ToVarTD->setAccess(D->getAccess());
6440 ToVarTD->setLexicalDeclContext(LexicalDC);
6441 LexicalDC->addDeclInternal(ToVarTD);
6447 const_cast<VarTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6448 if (!ToTemplated->getPreviousDecl()) {
6450 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6452 ToTemplated->setPreviousDecl(PrevTemplated);
6454 ToVarTD->setPreviousDecl(Recent);
6477 if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate()))
6486 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
6490 auto IdLocOrErr = import(D->getLocation());
6497 ImportTemplateArguments(D->getTemplateArgs().asArray(), TemplateArgs))
6503 VarTemplate->findSpecialization(TemplateArgs, InsertPos);
6506 VarDecl *FoundDef = FoundSpecialization->getDefinition();
6507 if (D->getDeclContext()->isRecord()) {
6511 FoundSpecialization->getDeclContext()->isRecord() &&
6512 "Member variable template specialization imported as non-member, "
6516 if (!D->isThisDeclarationADefinition())
6521 if (FoundDef && D->isThisDeclarationADefinition())
6532 if (const auto *Args = D->getTemplateArgsAsWritten()) {
6540 auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
6548 D->getStorageClass(), TemplateArgs))
6552 import(FromPartial->getInstantiatedFromMember()))
6553 ToPartial->setInstantiatedFromMember(*ToInstOrErr);
6557 if (FromPartial->isMemberSpecialization())
6558 ToPartial->setMemberSpecialization();
6568 QualType(), nullptr, D->getStorageClass(),
6575 if (!VarTemplate->findSpecialization(TemplateArgs, InsertPos))
6576 VarTemplate->AddSpecialization(D2, InsertPos);
6579 if (Error Err = importInto(T, D->getType()))
6581 D2->setType(T);
6583 auto TInfoOrErr = import(D->getTypeSourceInfo());
6586 D2->setTypeSourceInfo(*TInfoOrErr);
6588 if (D->getPointOfInstantiation().isValid()) {
6589 if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation()))
6590 D2->setPointOfInstantiation(*POIOrErr);
6595 D2->setSpecializationKind(D->getSpecializationKind());
6597 if (D->getTemplateArgsAsWritten())
6598 D2->setTemplateArgsAsWritten(ToTAInfo);
6600 if (auto LocOrErr = import(D->getQualifierLoc()))
6601 D2->setQualifierInfo(*LocOrErr);
6605 if (D->isConstexpr())
6606 D2->setConstexpr(true);
6608 D2->setAccess(D->getAccess());
6614 D2->setPreviousDecl(FoundSpecialization->getMostRecentDecl());
6646 if (!LexicalDC->isFunctionOrMethod()) {
6650 if (!FoundDecl->isInIdentifierNamespace(IDNS))
6659 if (D->isThisDeclarationADefinition() && TemplateWithDef)
6670 auto ParamsOrErr = import(D->getTemplateParameters());
6676 if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl()))
6687 // objects (for deduction guides) the same parameters are re-used. The
6694 OldParamDC.reserve(Params->size());
6696 [](NamedDecl *ND) { return ND->getDeclContext(); });
6703 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
6705 ToFunc->setAccess(D->getAccess());
6706 ToFunc->setLexicalDeclContext(LexicalDC);
6709 ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
6712 LT->updateForced(Params->getParam(I), OldParamDC[I]);
6717 const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6718 if (!TemplatedFD->getPreviousDecl()) {
6719 assert(FoundByLookup->getTemplatedDecl() &&
6722 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6724 TemplatedFD->setPreviousDecl(PrevTemplated);
6726 ToFunc->setPreviousDecl(Recent);
6732 //----------------------------------------------------------------------------
6734 //----------------------------------------------------------------------------
6737 Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
6738 << S->getStmtClassName();
6747 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6748 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
6754 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6755 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
6762 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
6763 if (auto ClobberOrErr = import(S->getClobberStringLiteral(I)))
6771 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6772 if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I)))
6778 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6779 if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
6785 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
6786 S->getNumLabels());
6787 if (Error Err = ImportContainerChecked(S->outputs(), Exprs))
6791 ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
6795 S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6798 ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
6801 auto AsmStrOrErr = import(S->getAsmString());
6804 ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
6811 S->isSimple(),
6812 S->isVolatile(),
6813 S->getNumOutputs(),
6814 S->getNumInputs(),
6819 S->getNumClobbers(),
6821 S->getNumLabels(),
6828 auto ToDG = importChecked(Err, S->getDeclGroup());
6829 auto ToBeginLoc = importChecked(Err, S->getBeginLoc());
6830 auto ToEndLoc = importChecked(Err, S->getEndLoc());
6837 ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
6841 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6845 SmallVector<Stmt *, 8> ToStmts(S->size());
6847 if (Error Err = ImportContainerChecked(S->body(), ToStmts))
6850 ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
6854 ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
6859 S->hasStoredFPFeatures() ? S->getStoredFPFeatures() : FPOptionsOverride();
6867 auto ToLHS = importChecked(Err, S->getLHS());
6868 auto ToRHS = importChecked(Err, S->getRHS());
6869 auto ToSubStmt = importChecked(Err, S->getSubStmt());
6870 auto ToCaseLoc = importChecked(Err, S->getCaseLoc());
6871 auto ToEllipsisLoc = importChecked(Err, S->getEllipsisLoc());
6872 auto ToColonLoc = importChecked(Err, S->getColonLoc());
6878 ToStmt->setSubStmt(ToSubStmt);
6886 auto ToDefaultLoc = importChecked(Err, S->getDefaultLoc());
6887 auto ToColonLoc = importChecked(Err, S->getColonLoc());
6888 auto ToSubStmt = importChecked(Err, S->getSubStmt());
6899 auto ToIdentLoc = importChecked(Err, S->getIdentLoc());
6900 auto ToLabelDecl = importChecked(Err, S->getDecl());
6901 auto ToSubStmt = importChecked(Err, S->getSubStmt());
6910 ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
6913 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
6917 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6928 auto ToIfLoc = importChecked(Err, S->getIfLoc());
6929 auto ToInit = importChecked(Err, S->getInit());
6930 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6931 auto ToCond = importChecked(Err, S->getCond());
6932 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6933 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6934 auto ToThen = importChecked(Err, S->getThen());
6935 auto ToElseLoc = importChecked(Err, S->getElseLoc());
6936 auto ToElse = importChecked(Err, S->getElse());
6940 return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->getStatementKind(),
6948 auto ToInit = importChecked(Err, S->getInit());
6949 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6950 auto ToCond = importChecked(Err, S->getCond());
6951 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6952 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6953 auto ToBody = importChecked(Err, S->getBody());
6954 auto ToSwitchLoc = importChecked(Err, S->getSwitchLoc());
6961 ToStmt->setBody(ToBody);
6962 ToStmt->setSwitchLoc(ToSwitchLoc);
6964 // Now we have to re-chain the cases.
6966 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
6967 SC = SC->getNextSwitchCase()) {
6972 LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
6974 ToStmt->setSwitchCaseList(*ToSCOrErr);
6984 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6985 auto ToCond = importChecked(Err, S->getCond());
6986 auto ToBody = importChecked(Err, S->getBody());
6987 auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
6988 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6989 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
7000 auto ToBody = importChecked(Err, S->getBody());
7001 auto ToCond = importChecked(Err, S->getCond());
7002 auto ToDoLoc = importChecked(Err, S->getDoLoc());
7003 auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
7004 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
7015 auto ToInit = importChecked(Err, S->getInit());
7016 auto ToCond = importChecked(Err, S->getCond());
7017 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
7018 auto ToInc = importChecked(Err, S->getInc());
7019 auto ToBody = importChecked(Err, S->getBody());
7020 auto ToForLoc = importChecked(Err, S->getForLoc());
7021 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
7022 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
7035 auto ToLabel = importChecked(Err, S->getLabel());
7036 auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
7037 auto ToLabelLoc = importChecked(Err, S->getLabelLoc());
7048 auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
7049 auto ToStarLoc = importChecked(Err, S->getStarLoc());
7050 auto ToTarget = importChecked(Err, S->getTarget());
7059 ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
7066 auto ToBreakLocOrErr = import(S->getBreakLoc());
7075 auto ToReturnLoc = importChecked(Err, S->getReturnLoc());
7076 auto ToRetValue = importChecked(Err, S->getRetValue());
7077 auto ToNRVOCandidate = importChecked(Err, S->getNRVOCandidate());
7088 auto ToCatchLoc = importChecked(Err, S->getCatchLoc());
7089 auto ToExceptionDecl = importChecked(Err, S->getExceptionDecl());
7090 auto ToHandlerBlock = importChecked(Err, S->getHandlerBlock());
7099 ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc());
7103 ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock());
7107 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
7108 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
7109 CXXCatchStmt *FromHandler = S->getHandler(HI);
7123 auto ToInit = importChecked(Err, S->getInit());
7124 auto ToRangeStmt = importChecked(Err, S->getRangeStmt());
7125 auto ToBeginStmt = importChecked(Err, S->getBeginStmt());
7126 auto ToEndStmt = importChecked(Err, S->getEndStmt());
7127 auto ToCond = importChecked(Err, S->getCond());
7128 auto ToInc = importChecked(Err, S->getInc());
7129 auto ToLoopVarStmt = importChecked(Err, S->getLoopVarStmt());
7130 auto ToBody = importChecked(Err, S->getBody());
7131 auto ToForLoc = importChecked(Err, S->getForLoc());
7132 auto ToCoawaitLoc = importChecked(Err, S->getCoawaitLoc());
7133 auto ToColonLoc = importChecked(Err, S->getColonLoc());
7134 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
7146 auto ToElement = importChecked(Err, S->getElement());
7147 auto ToCollection = importChecked(Err, S->getCollection());
7148 auto ToBody = importChecked(Err, S->getBody());
7149 auto ToForLoc = importChecked(Err, S->getForLoc());
7150 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
7164 auto ToAtCatchLoc = importChecked(Err, S->getAtCatchLoc());
7165 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
7166 auto ToCatchParamDecl = importChecked(Err, S->getCatchParamDecl());
7167 auto ToCatchBody = importChecked(Err, S->getCatchBody());
7176 ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc());
7179 ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
7189 auto ToAtTryLoc = importChecked(Err, S->getAtTryLoc());
7190 auto ToTryBody = importChecked(Err, S->getTryBody());
7191 auto ToFinallyStmt = importChecked(Err, S->getFinallyStmt());
7195 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
7196 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
7197 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
7214 auto ToAtSynchronizedLoc = importChecked(Err, S->getAtSynchronizedLoc());
7215 auto ToSynchExpr = importChecked(Err, S->getSynchExpr());
7216 auto ToSynchBody = importChecked(Err, S->getSynchBody());
7225 ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc());
7228 ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
7237 ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
7240 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
7247 //----------------------------------------------------------------------------
7249 //----------------------------------------------------------------------------
7251 Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node)
7252 << E->getStmtClassName();
7258 auto ToType = importChecked(Err, E->getType());
7259 auto BLoc = importChecked(Err, E->getBeginLoc());
7260 auto RParenLoc = importChecked(Err, E->getEndLoc());
7263 auto ParentContextOrErr = Importer.ImportContext(E->getParentContext());
7268 SourceLocExpr(Importer.getToContext(), E->getIdentKind(), ToType, BLoc,
7275 auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
7276 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7277 auto ToWrittenTypeInfo = importChecked(Err, E->getWrittenTypeInfo());
7278 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7279 auto ToType = importChecked(Err, E->getType());
7285 E->isMicrosoftABI());
7291 auto ToCond = importChecked(Err, E->getCond());
7292 auto ToLHS = importChecked(Err, E->getLHS());
7293 auto ToRHS = importChecked(Err, E->getRHS());
7294 auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
7295 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7296 auto ToType = importChecked(Err, E->getType());
7300 ExprValueKind VK = E->getValueKind();
7301 ExprObjectKind OK = E->getObjectKind();
7304 // condition-dependent.
7305 bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue();
7314 auto *ToSrcExpr = importChecked(Err, E->getSrcExpr());
7315 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7316 auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
7317 auto ToType = importChecked(Err, E->getType());
7318 auto *ToTSI = importChecked(Err, E->getTypeSourceInfo());
7323 ConvertVectorExpr(ToSrcExpr, ToTSI, ToType, E->getValueKind(),
7324 E->getObjectKind(), ToBuiltinLoc, ToRParenLoc);
7329 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7330 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7331 auto ToType = importChecked(Err, E->getType());
7332 const unsigned NumSubExprs = E->getNumSubExprs();
7335 llvm::ArrayRef<Expr *> FromSubExprs(E->getSubExprs(), NumSubExprs);
7346 ExpectedType TypeOrErr = import(E->getType());
7350 ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
7360 auto ToGenericLoc = importChecked(Err, E->getGenericLoc());
7363 if (E->isExprPredicate())
7364 ToControllingExpr = importChecked(Err, E->getControllingExpr());
7366 ToControllingType = importChecked(Err, E->getControllingType());
7369 auto ToDefaultLoc = importChecked(Err, E->getDefaultLoc());
7370 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7374 ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
7379 ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
7385 if (E->isResultDependent()) {
7390 E->containsUnexpandedParameterPack());
7395 E->containsUnexpandedParameterPack());
7402 E->containsUnexpandedParameterPack(), E->getResultIndex());
7407 E->containsUnexpandedParameterPack(), E->getResultIndex());
7413 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7414 auto ToType = importChecked(Err, E->getType());
7415 auto ToFunctionName = importChecked(Err, E->getFunctionName());
7420 E->getIdentKind(), E->isTransparent(),
7427 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7428 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7429 auto ToDecl = importChecked(Err, E->getDecl());
7430 auto ToLocation = importChecked(Err, E->getLocation());
7431 auto ToType = importChecked(Err, E->getType());
7436 if (E->getDecl() != E->getFoundDecl()) {
7437 auto FoundDOrErr = import(E->getFoundDecl());
7445 if (E->hasExplicitTemplateArgs()) {
7447 ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
7448 E->template_arguments(), ToTAInfo))
7455 E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
7456 E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse());
7457 if (E->hadMultipleCandidates())
7458 ToE->setHadMultipleCandidates(true);
7459 ToE->setIsImmediateEscalating(E->isImmediateEscalating());
7464 ExpectedType TypeOrErr = import(E->getType());
7472 ExpectedExpr ToInitOrErr = import(E->getInit());
7476 ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc());
7480 SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
7482 for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
7483 if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
7484 ToIndexExprs[I - 1] = *ToArgOrErr;
7489 SmallVector<Designator, 4> ToDesignators(E->size());
7490 if (Error Err = ImportContainerChecked(E->designators(), ToDesignators))
7496 E->usesGNUSyntax(), *ToInitOrErr);
7501 ExpectedType ToTypeOrErr = import(E->getType());
7505 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7514 ExpectedType ToTypeOrErr = import(E->getType());
7518 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7523 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7528 ExpectedType ToTypeOrErr = import(E->getType());
7532 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7537 Importer.getToContext(), E->getValue(), E->isExact(),
7542 auto ToTypeOrErr = import(E->getType());
7546 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7555 auto ToTypeOrErr = import(E->getType());
7559 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7564 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
7569 ExpectedType ToTypeOrErr = import(E->getType());
7573 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7578 E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
7582 ExpectedType ToTypeOrErr = import(E->getType());
7586 SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
7588 E->tokloc_begin(), E->tokloc_end(), ToLocations.begin()))
7592 Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(),
7599 auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
7600 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7601 auto ToType = importChecked(Err, E->getType());
7602 auto ToInitializer = importChecked(Err, E->getInitializer());
7607 ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
7608 ToInitializer, E->isFileScope());
7614 auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
7615 auto ToType = importChecked(Err, E->getType());
7616 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7620 SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
7622 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
7628 ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
7633 auto ToAmpAmpLoc = importChecked(Err, E->getAmpAmpLoc());
7634 auto ToLabelLoc = importChecked(Err, E->getLabelLoc());
7635 auto ToLabel = importChecked(Err, E->getLabel());
7636 auto ToType = importChecked(Err, E->getType());
7645 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7646 auto ToResult = importChecked(Err, E->getAPValueResult());
7654 auto ToLParen = importChecked(Err, E->getLParen());
7655 auto ToRParen = importChecked(Err, E->getRParen());
7656 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7665 SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
7666 if (Error Err = ImportContainerChecked(E->exprs(), ToExprs))
7669 ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
7673 ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
7683 auto ToSubStmt = importChecked(Err, E->getSubStmt());
7684 auto ToType = importChecked(Err, E->getType());
7685 auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
7686 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7692 E->getTemplateDepth());
7697 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7698 auto ToType = importChecked(Err, E->getType());
7699 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7704 E->hasStoredFPFeatures());
7705 UO->setType(ToType);
7706 UO->setSubExpr(ToSubExpr);
7707 UO->setOpcode(E->getOpcode());
7708 UO->setOperatorLoc(ToOperatorLoc);
7709 UO->setCanOverflow(E->canOverflow());
7710 if (E->hasStoredFPFeatures())
7711 UO->setStoredFPFeatures(E->getStoredFPFeatures());
7720 auto ToType = importChecked(Err, E->getType());
7721 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7722 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7726 if (E->isArgumentType()) {
7728 import(E->getArgumentTypeInfo());
7733 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
7737 ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
7742 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
7747 auto ToLHS = importChecked(Err, E->getLHS());
7748 auto ToRHS = importChecked(Err, E->getRHS());
7749 auto ToType = importChecked(Err, E->getType());
7750 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7755 Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
7756 E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
7757 E->getFPFeatures());
7762 auto ToCond = importChecked(Err, E->getCond());
7763 auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
7764 auto ToLHS = importChecked(Err, E->getLHS());
7765 auto ToColonLoc = importChecked(Err, E->getColonLoc());
7766 auto ToRHS = importChecked(Err, E->getRHS());
7767 auto ToType = importChecked(Err, E->getType());
7773 E->getValueKind(), E->getObjectKind());
7779 auto ToCommon = importChecked(Err, E->getCommon());
7780 auto ToOpaqueValue = importChecked(Err, E->getOpaqueValue());
7781 auto ToCond = importChecked(Err, E->getCond());
7782 auto ToTrueExpr = importChecked(Err, E->getTrueExpr());
7783 auto ToFalseExpr = importChecked(Err, E->getFalseExpr());
7784 auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
7785 auto ToColonLoc = importChecked(Err, E->getColonLoc());
7786 auto ToType = importChecked(Err, E->getType());
7792 ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
7793 E->getObjectKind());
7799 auto ToSemanticForm = importChecked(Err, E->getSemanticForm());
7804 CXXRewrittenBinaryOperator(ToSemanticForm, E->isReversed());
7809 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7811 importChecked(Err, E->getQueriedTypeSourceInfo());
7812 auto ToDimensionExpression = importChecked(Err, E->getDimensionExpression());
7813 auto ToEndLoc = importChecked(Err, E->getEndLoc());
7814 auto ToType = importChecked(Err, E->getType());
7819 ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(),
7825 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7826 auto ToQueriedExpression = importChecked(Err, E->getQueriedExpression());
7827 auto ToEndLoc = importChecked(Err, E->getEndLoc());
7828 auto ToType = importChecked(Err, E->getType());
7833 ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
7839 auto ToLocation = importChecked(Err, E->getLocation());
7840 auto ToType = importChecked(Err, E->getType());
7841 auto ToSourceExpr = importChecked(Err, E->getSourceExpr());
7846 ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr);
7851 auto ToLHS = importChecked(Err, E->getLHS());
7852 auto ToRHS = importChecked(Err, E->getRHS());
7853 auto ToType = importChecked(Err, E->getType());
7854 auto ToRBracketLoc = importChecked(Err, E->getRBracketLoc());
7859 ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
7866 auto ToLHS = importChecked(Err, E->getLHS());
7867 auto ToRHS = importChecked(Err, E->getRHS());
7868 auto ToType = importChecked(Err, E->getType());
7869 auto ToComputationLHSType = importChecked(Err, E->getComputationLHSType());
7871 importChecked(Err, E->getComputationResultType());
7872 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7877 Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
7878 E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
7879 E->getFPFeatures(),
7886 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
7896 ExpectedType ToTypeOrErr = import(E->getType());
7900 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7909 Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr,
7910 &(*ToBasePathOrErr), E->getValueKind(), E->getFPFeatures());
7915 auto ToType = importChecked(Err, E->getType());
7916 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7917 auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
7926 switch (E->getStmtClass()) {
7929 ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc());
7932 ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc());
7936 Importer.getToContext(), ToType, E->getValueKind(), E->getCastKind(),
7937 ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
7943 ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc());
7946 ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc());
7950 Importer.getToContext(), ToType, E->getValueKind(), ToTypeInfoAsWritten,
7951 E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
7957 ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc());
7960 ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc());
7964 *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
7969 ExpectedSLoc ToKWLocOrErr = import(BBC->getBeginLoc());
7972 ExpectedSLoc ToRParenLocOrErr = import(BBC->getEndLoc());
7976 ToType, E->getValueKind(), E->getCastKind(), ToSubExpr,
7987 for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
7988 const OffsetOfNode &FromNode = E->getComponent(I);
7992 if (FromNode.getKind() != OffsetOfNode::Base) {
8005 case OffsetOfNode::Base: {
8027 SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
8028 for (int I = 0, N = E->getNumExpressions(); I < N; ++I) {
8029 ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I));
8036 auto ToType = importChecked(Err, E->getType());
8037 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
8038 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8039 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8050 auto ToType = importChecked(Err, E->getType());
8051 auto ToOperand = importChecked(Err, E->getOperand());
8052 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
8053 auto ToEndLoc = importChecked(Err, E->getEndLoc());
8058 if (E->isValueDependent())
8061 ToCanThrow = E->getValue() ? CT_Can : CT_Cannot;
8069 auto ToSubExpr = importChecked(Err, E->getSubExpr());
8070 auto ToType = importChecked(Err, E->getType());
8071 auto ToThrowLoc = importChecked(Err, E->getThrowLoc());
8076 ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
8080 ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation());
8084 auto ToParamOrErr = import(E->getParam());
8088 auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
8099 if (!ToParam->getDefaultArg()) {
8108 if (E->hasRewrittenInit()) {
8109 ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
8122 auto ToType = importChecked(Err, E->getType());
8123 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
8124 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8134 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8138 auto ToDtorOrErr = import(E->getTemporary()->getDestructor());
8151 auto ToConstructor = importChecked(Err, E->getConstructor());
8152 auto ToType = importChecked(Err, E->getType());
8153 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
8154 auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
8158 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
8159 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
8164 ToParenOrBraceRange, E->hadMultipleCandidates(),
8165 E->isListInitialization(), E->isStdInitListInitialization(),
8166 E->requiresZeroInitialization());
8176 auto Temporary = importChecked(Err, D->getTemporaryExpr());
8177 auto ExtendingDecl = importChecked(Err, D->getExtendingDecl());
8184 D->getManglingNumber()))
8187 To->setLexicalDeclContext(LexicalDC);
8188 LexicalDC->addDeclInternal(To);
8195 auto ToType = importChecked(Err, E->getType());
8197 Err, E->getLifetimeExtendedTemporaryDecl() ? nullptr : E->getSubExpr());
8199 importChecked(Err, E->getLifetimeExtendedTemporaryDecl());
8204 ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
8207 ToType, ToTemporaryExpr, E->isBoundToLvalueReference(),
8215 auto ToType = importChecked(Err, E->getType());
8216 auto ToPattern = importChecked(Err, E->getPattern());
8217 auto ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
8222 ToType, ToPattern, ToEllipsisLoc, E->getNumExpansions());
8227 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8228 auto ToPack = importChecked(Err, E->getPack());
8229 auto ToPackLoc = importChecked(Err, E->getPackLoc());
8230 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8235 if (!E->isValueDependent())
8236 Length = E->getPackLength();
8239 if (E->isPartiallySubstituted()) {
8240 if (Error Err = ImportTemplateArguments(E->getPartialArguments(),
8253 auto ToOperatorNew = importChecked(Err, E->getOperatorNew());
8254 auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
8255 auto ToTypeIdParens = importChecked(Err, E->getTypeIdParens());
8256 auto ToArraySize = importChecked(Err, E->getArraySize());
8257 auto ToInitializer = importChecked(Err, E->getInitializer());
8258 auto ToType = importChecked(Err, E->getType());
8260 importChecked(Err, E->getAllocatedTypeSourceInfo());
8261 auto ToSourceRange = importChecked(Err, E->getSourceRange());
8262 auto ToDirectInitRange = importChecked(Err, E->getDirectInitRange());
8266 SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
8268 ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
8272 Importer.getToContext(), E->isGlobalNew(), ToOperatorNew,
8273 ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(),
8274 ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(),
8281 auto ToType = importChecked(Err, E->getType());
8282 auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
8283 auto ToArgument = importChecked(Err, E->getArgument());
8284 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
8289 ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
8290 E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
8296 auto ToType = importChecked(Err, E->getType());
8297 auto ToLocation = importChecked(Err, E->getLocation());
8298 auto ToConstructor = importChecked(Err, E->getConstructor());
8299 auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
8303 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
8304 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
8309 E->isElidable(), ToArgs, E->hadMultipleCandidates(),
8310 E->isListInitialization(), E->isStdInitListInitialization(),
8311 E->requiresZeroInitialization(), E->getConstructionKind(),
8313 ToE->setIsImmediateEscalating(E->isImmediateEscalating());
8318 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8322 SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
8323 if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects))
8327 Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
8333 auto ToCallee = importChecked(Err, E->getCallee());
8334 auto ToType = importChecked(Err, E->getType());
8335 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8339 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
8340 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
8344 ToType, E->getValueKind(), ToRParenLoc,
8345 E->getFPFeatures());
8349 ExpectedType ToTypeOrErr = import(E->getType());
8353 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
8358 *ToTypeOrErr, E->isImplicit());
8362 ExpectedType ToTypeOrErr = import(E->getType());
8366 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
8370 return CXXBoolLiteralExpr::Create(Importer.getToContext(), E->getValue(),
8376 auto ToBase = importChecked(Err, E->getBase());
8377 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8378 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
8379 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
8380 auto ToMemberDecl = importChecked(Err, E->getMemberDecl());
8381 auto ToType = importChecked(Err, E->getType());
8382 auto ToDecl = importChecked(Err, E->getFoundDecl().getDecl());
8383 auto ToName = importChecked(Err, E->getMemberNameInfo().getName());
8384 auto ToLoc = importChecked(Err, E->getMemberNameInfo().getLoc());
8389 DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());
8394 if (E->hasExplicitTemplateArgs()) {
8396 ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
8397 E->template_arguments(), ToTAInfo))
8402 return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(),
8405 ResInfo, ToType, E->getValueKind(),
8406 E->getObjectKind(), E->isNonOdrUse());
8412 auto ToBase = importChecked(Err, E->getBase());
8413 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8414 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
8415 auto ToScopeTypeInfo = importChecked(Err, E->getScopeTypeInfo());
8416 auto ToColonColonLoc = importChecked(Err, E->getColonColonLoc());
8417 auto ToTildeLoc = importChecked(Err, E->getTildeLoc());
8422 if (const IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
8424 ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc());
8429 if (auto ToTIOrErr = import(E->getDestroyedTypeInfo()))
8436 Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc,
8443 auto ToType = importChecked(Err, E->getType());
8444 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8445 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
8446 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
8448 importChecked(Err, E->getFirstQualifierFoundInScope());
8453 if (!E->isImplicitAccess()) {
8454 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
8462 if (E->hasExplicitTemplateArgs()) {
8464 ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
8465 E->template_arguments(), ToTAInfo))
8469 auto ToMember = importChecked(Err, E->getMember());
8470 auto ToMemberLoc = importChecked(Err, E->getMemberLoc());
8477 ImportDeclarationNameLoc(E->getMemberNameInfo(), ToMemberNameInfo))
8481 Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc,
8489 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
8490 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
8491 auto ToDeclName = importChecked(Err, E->getDeclName());
8492 auto ToNameLoc = importChecked(Err, E->getNameInfo().getLoc());
8493 auto ToLAngleLoc = importChecked(Err, E->getLAngleLoc());
8494 auto ToRAngleLoc = importChecked(Err, E->getRAngleLoc());
8499 if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
8504 if (E->hasExplicitTemplateArgs()) {
8506 ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
8519 auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
8520 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8521 auto ToType = importChecked(Err, E->getType());
8522 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
8526 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
8528 ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
8533 llvm::ArrayRef(ToArgs), ToRParenLoc, E->isListInitialization());
8538 Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
8542 auto ToQualifierLocOrErr = import(E->getQualifierLoc());
8547 auto ToName = importChecked(Err, E->getName());
8548 auto ToNameLoc = importChecked(Err, E->getNameLoc());
8554 if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
8558 for (auto *D : E->decls())
8564 if (E->hasExplicitTemplateArgs()) {
8567 E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
8571 ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
8576 (E->getDependence() & ExprDependence::TypeValue) ==
8580 *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo,
8582 /*KnownInstantiationDependent=*/E->isInstantiationDependent());
8587 ToNameInfo, E->requiresADL(), ToDecls.begin(), ToDecls.end(),
8588 /*KnownDependent=*/E->isTypeDependent(),
8589 /*KnownInstantiationDependent=*/E->isInstantiationDependent());
8595 auto ToType = importChecked(Err, E->getType());
8596 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8597 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
8598 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
8599 auto ToName = importChecked(Err, E->getName());
8600 auto ToNameLoc = importChecked(Err, E->getNameLoc());
8606 if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
8610 for (Decl *D : E->decls())
8618 if (E->hasExplicitTemplateArgs()) {
8620 E->copyTemplateArgumentsInto(FromTAInfo);
8627 if (!E->isImplicitAccess()) {
8628 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
8635 Importer.getToContext(), E->hasUnresolvedUsing(), ToBase, ToType,
8636 E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8642 auto ToCallee = importChecked(Err, E->getCallee());
8643 auto ToType = importChecked(Err, E->getType());
8644 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8648 unsigned NumArgs = E->getNumArgs();
8650 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
8655 Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
8656 OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
8657 OCE->getADLCallKind());
8661 E->getValueKind(), ToRParenLoc, E->getFPFeatures(),
8662 /*MinNumArgs=*/0, E->getADLCallKind());
8666 CXXRecordDecl *FromClass = E->getLambdaClass();
8672 auto ToCallOpOrErr = import(E->getCallOperator());
8676 SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
8677 if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits))
8681 auto ToIntroducerRange = importChecked(Err, E->getIntroducerRange());
8682 auto ToCaptureDefaultLoc = importChecked(Err, E->getCaptureDefaultLoc());
8683 auto ToEndLoc = importChecked(Err, E->getEndLoc());
8688 E->getCaptureDefault(), ToCaptureDefaultLoc,
8689 E->hasExplicitParameters(),
8690 E->hasExplicitResultType(), ToCaptureInits,
8691 ToEndLoc, E->containsUnexpandedParameterPack());
8697 auto ToLBraceLoc = importChecked(Err, E->getLBraceLoc());
8698 auto ToRBraceLoc = importChecked(Err, E->getRBraceLoc());
8699 auto ToType = importChecked(Err, E->getType());
8703 SmallVector<Expr *, 4> ToExprs(E->getNumInits());
8704 if (Error Err = ImportContainerChecked(E->inits(), ToExprs))
8710 To->setType(ToType);
8712 if (E->hasArrayFiller()) {
8713 if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
8714 To->setArrayFiller(*ToFillerOrErr);
8719 if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) {
8721 To->setInitializedFieldInUnion(*ToFDOrErr);
8726 if (InitListExpr *SyntForm = E->getSyntacticForm()) {
8728 To->setSyntacticForm(*ToSyntFormOrErr);
8735 To->sawArrayRangeDesignator(E->hadArrayRangeDesignator());
8742 ExpectedType ToTypeOrErr = import(E->getType());
8746 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8757 auto ToLocation = importChecked(Err, E->getLocation());
8758 auto ToType = importChecked(Err, E->getType());
8759 auto ToConstructor = importChecked(Err, E->getConstructor());
8764 ToLocation, ToType, ToConstructor, E->constructsVBase(),
8765 E->inheritedFromVBase());
8770 auto ToType = importChecked(Err, E->getType());
8771 auto ToCommonExpr = importChecked(Err, E->getCommonExpr());
8772 auto ToSubExpr = importChecked(Err, E->getSubExpr());
8781 ExpectedType ToTypeOrErr = import(E->getType());
8788 ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc());
8792 auto ToFieldOrErr = import(E->getField());
8796 auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
8801 assert(ToField->hasInClassInitializer() &&
8802 "Field should have in-class initializer if there is a default init "
8804 if (!ToField->getInClassInitializer()) {
8805 // The in-class initializer may be not yet set in "To" AST even if the
8809 import(E->getField()->getInClassInitializer());
8812 ToField->setInClassInitializer(*ToInClassInitializerOrErr);
8816 if (E->hasRewrittenInit()) {
8817 ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
8829 auto ToType = importChecked(Err, E->getType());
8830 auto ToSubExpr = importChecked(Err, E->getSubExpr());
8831 auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
8832 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8833 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8834 auto ToAngleBrackets = importChecked(Err, E->getAngleBrackets());
8838 ExprValueKind VK = E->getValueKind();
8839 CastKind CK = E->getCastKind();
8847 ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
8870 auto ToType = importChecked(Err, E->getType());
8871 auto ToExprLoc = importChecked(Err, E->getExprLoc());
8872 auto ToAssociatedDecl = importChecked(Err, E->getAssociatedDecl());
8873 auto ToReplacement = importChecked(Err, E->getReplacement());
8878 ToType, E->getValueKind(), ToExprLoc, ToReplacement, ToAssociatedDecl,
8879 E->getIndex(), E->getPackIndex(), E->isReferenceParameter());
8884 auto ToType = importChecked(Err, E->getType());
8885 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
8886 auto ToEndLoc = importChecked(Err, E->getEndLoc());
8890 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
8891 if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs))
8894 // According to Sema::BuildTypeTrait(), if E is value-dependent,
8896 bool ToValue = (E->isValueDependent() ? false : E->getValue());
8899 Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs,
8904 ExpectedType ToTypeOrErr = import(E->getType());
8908 auto ToSourceRangeOrErr = import(E->getSourceRange());
8912 if (E->isTypeOperand()) {
8913 if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
8920 ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand());
8931 QualType ToType = importChecked(Err, E->getType());
8932 UnresolvedLookupExpr *ToCallee = importChecked(Err, E->getCallee());
8933 SourceLocation ToLParenLoc = importChecked(Err, E->getLParenLoc());
8934 Expr *ToLHS = importChecked(Err, E->getLHS());
8935 SourceLocation ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
8936 Expr *ToRHS = importChecked(Err, E->getRHS());
8937 SourceLocation ToRParenLoc = importChecked(Err, E->getRParenLoc());
8943 CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS, E->getOperator(),
8944 ToEllipsisLoc, ToRHS, ToRParenLoc, E->getNumExpansions());
8950 for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
8952 ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>(
8953 (*ImportedOrErr)->getCanonicalDecl()));
8971 this->SharedState = std::make_shared<ASTImporterSharedState>();
8982 "Try to get field index for non-field.");
8984 auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
8989 for (const auto *D : Owner->decls()) {
9011 DeclContext *ReDC = DC->getRedeclContext();
9012 if (SharedState->getLookupTable()) {
9014 SharedState->getLookupTable()->lookup(ReDC, Name);
9017 DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name);
9030 ReDC->localUncachedLookup(Name, Result);
9036 SharedState->addDeclToLookup(ToD);
9069 return Pos->second;
9078 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
9080 return ToTOrErr->getTypePtr();
9100 ExpectedType TOrErr = Import(FromTSI->getType());
9103 ExpectedSLoc BeginLocOrErr = Import(FromTSI->getTypeLoc().getBeginLoc());
9198 const IdentifierInfo *ToAttrName = Importer.Import(FromAttr->getAttrName());
9200 Importer.Import(FromAttr->getScopeName());
9202 NImporter.importChecked(Err, FromAttr->getRange());
9204 NImporter.importChecked(Err, FromAttr->getScopeLoc());
9210 FromAttr->getParsedKind(), FromAttr->getForm());
9216 ToAttr->setImplicit(FromAttr->isImplicit());
9217 ToAttr->setPackExpansion(FromAttr->isPackExpansion());
9219 ToInheritableAttr->setInherited(FromAttr->isInherited());
9228 SourceRange ToRange = NImporter.importChecked(Err, FromAttr->getRange());
9232 ToAttr = FromAttr->clone(Importer.getToContext());
9233 ToAttr->setRange(ToRange);
9234 ToAttr->setAttrName(Importer.Import(FromAttr->getAttrName()));
9251 switch (FromAttr->getKind()) {
9254 if (From->isAlignmentExpr())
9255 AI.importAttr(From, true, AI.importArg(From->getAlignmentExpr()).value());
9258 AI.importArg(From->getAlignmentType()).value());
9264 AI.importAttr(From, AI.importArg(From->getAlignment()).value());
9270 AI.importAttr(From, Import(From->getType()), From->getFormatIdx(),
9271 From->getFirstArg());
9277 AI.importAttr(From, AI.importArg(From->getCond()).value(),
9278 From->getMessage());
9285 AI.importArrayArg(From->args(), From->args_size()).value(),
9286 From->args_size());
9292 AI.importArrayArg(From->args(), From->args_size()).value(),
9293 From->args_size());
9298 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9299 AI.importArrayArg(From->args(), From->args_size()).value(),
9300 From->args_size());
9306 AI.importArrayArg(From->args(), From->args_size()).value(),
9307 From->args_size());
9313 AI.importArrayArg(From->args(), From->args_size()).value(),
9314 From->args_size());
9319 AI.importAttr(From, AI.importArg(From->getArg()).value());
9324 AI.importAttr(From, AI.importArg(From->getArg()).value());
9330 AI.importArrayArg(From->args(), From->args_size()).value(),
9331 From->args_size());
9337 AI.importArrayArg(From->args(), From->args_size()).value(),
9338 From->args_size());
9344 AI.importArrayArg(From->args(), From->args_size()).value(),
9345 From->args_size());
9351 AI.importArrayArg(From->args(), From->args_size()).value(),
9352 From->args_size());
9357 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9358 AI.importArrayArg(From->args(), From->args_size()).value(),
9359 From->args_size());
9364 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
9365 AI.importArrayArg(From->args(), From->args_size()).value(),
9366 From->args_size());
9371 AI.importAttr(From, AI.importArg(From->getArg()).value());
9377 AI.importArrayArg(From->args(), From->args_size()).value(),
9378 From->args_size());
9401 return FromDPos->second->getTranslationUnitDecl();
9405 if (!FromD->hasAttrs() || ToD->hasAttrs())
9407 for (const Attr *FromAttr : FromD->getAttrs()) {
9410 ToD->addAttr(*ToAttrOrErr);
9435 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9458 auto *ToD = Pos->second;
9476 if (ToD->getDeclContext())
9477 SharedState->removeDeclFromLookup(ToD);
9495 SharedState->setImportDeclError(Pos->second, ErrOut);
9500 // The import path contains import-dependency nodes first.
9518 SharedState->setImportDeclError(Ii->second, ErrOut);
9544 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9575 // When we're using a record/enum/Objective-C class/protocol as a context, we
9579 if (ToRecord->isCompleteDefinition())
9585 // If there are base classes they won't be imported and we will
9587 if (FromRecord->getASTContext().getExternalSource() &&
9588 !FromRecord->isCompleteDefinition())
9589 FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
9591 if (FromRecord->isCompleteDefinition())
9597 if (ToEnum->isCompleteDefinition()) {
9599 } else if (FromEnum->isCompleteDefinition()) {
9608 if (ToClass->getDefinition()) {
9610 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
9619 if (ToProto->getDefinition()) {
9621 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
9647 return Pos->second;
9659 ToE->setValueKind(FromE->getValueKind());
9660 ToE->setObjectKind(FromE->getObjectKind());
9661 ToE->setDependence(FromE->getDependence());
9675 if (Error Err = importInto(Prefix, FromNNS->getPrefix()))
9678 switch (FromNNS->getKind()) {
9680 assert(FromNNS->getAsIdentifier() && "NNS should contain identifier.");
9682 Import(FromNNS->getAsIdentifier()));
9685 if (ExpectedDecl NSOrErr = Import(FromNNS->getAsNamespace())) {
9692 if (ExpectedDecl NSADOrErr = Import(FromNNS->getAsNamespaceAlias()))
9702 if (ExpectedDecl RDOrErr = Import(FromNNS->getAsRecordDecl()))
9710 if (ExpectedTypePtr TyOrErr = Import(FromNNS->getAsType())) {
9712 FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate;
9729 // Push each of the nested-name-specifiers's onto a stack for
9744 NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
9758 Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc,
9763 Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc,
9768 Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(),
9778 QualType(Spec->getAsType(), 0), ToTLoc);
9781 Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
9785 Builder.Extend(getToContext(), SourceLocation{}, TSI->getTypeLoc(),
9799 Builder.MakeSuper(getToContext(), Spec->getAsRecordDecl(),
9800 ToSourceRangeOrErr->getBegin(),
9801 ToSourceRangeOrErr->getEnd());
9813 return TemplateName(cast<TemplateDecl>((*ToTemplateOrErr)->getCanonicalDecl()));
9832 auto DeclNameOrErr = Import(FromStorage->getDeclName());
9840 auto QualifierOrErr = Import(QTN->getQualifier());
9843 auto TNOrErr = Import(QTN->getUnderlyingTemplate());
9847 *QualifierOrErr, QTN->hasTemplateKeyword(), *TNOrErr);
9852 auto QualifierOrErr = Import(DTN->getQualifier());
9856 if (DTN->isIdentifier()) {
9858 Import(DTN->getIdentifier()));
9862 DTN->getOperator());
9868 auto ReplacementOrErr = Import(Subst->getReplacement());
9872 auto AssociatedDeclOrErr = Import(Subst->getAssociatedDecl());
9877 *ReplacementOrErr, *AssociatedDeclOrErr, Subst->getIndex(),
9878 Subst->getPackIndex());
9886 Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
9890 auto AssociatedDeclOrErr = Import(SubstPack->getAssociatedDecl());
9895 *ArgPackOrErr, *AssociatedDeclOrErr, SubstPack->getIndex(),
9896 SubstPack->getFinal());
9937 return Pos->second;
9968 if (!IsBuiltin && !Cache->BufferOverridden) {
9983 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
9986 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
9989 ToFileManager.getOptionalFileRef(Cache->OrigEntry->getName());
10000 // FIXME: We want to re-use the existing MemoryBuffer!
10002 Cache->getBufferOrNone(FromContext.getDiagnostics(),
10008 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
10009 FromBuf->getBufferIdentifier());
10022 ExpectedExpr ToExprOrErr = Import(From->getInit());
10026 auto LParenLocOrErr = Import(From->getLParenLoc());
10030 auto RParenLocOrErr = Import(From->getRParenLoc());
10034 if (From->isBaseInitializer()) {
10035 auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
10040 if (From->isPackExpansion())
10041 if (Error Err = importInto(EllipsisLoc, From->getEllipsisLoc()))
10045 ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
10047 } else if (From->isMemberInitializer()) {
10048 ExpectedDecl ToFieldOrErr = Import(From->getMember());
10052 auto MemberLocOrErr = Import(From->getMemberLocation());
10059 } else if (From->isIndirectMemberInitializer()) {
10060 ExpectedDecl ToIFieldOrErr = Import(From->getIndirectMember());
10064 auto MemberLocOrErr = Import(From->getMemberLocation());
10071 } else if (From->isDelegatingInitializer()) {
10072 auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
10089 return Pos->second;
10091 Expected<SourceRange> ToSourceRange = Import(BaseSpec->getSourceRange());
10094 Expected<TypeSourceInfo *> ToTSI = Import(BaseSpec->getTypeSourceInfo());
10097 ExpectedSLoc ToEllipsisLoc = Import(BaseSpec->getEllipsisLoc());
10101 *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
10102 BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
10122 if (!ToRecord->getDefinition()) {
10130 if (!ToEnum->getDefinition()) {
10137 if (!ToIFace->getDefinition()) {
10145 if (!ToProto->getDefinition()) {
10223 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
10225 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
10226 ToId->setBuiltinID(FromId->getBuiltinID());
10266 ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
10273 ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
10274 ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
10281 ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
10282 ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
10321 ToPath[Idx] = cast<const CXXRecordDecl>(ImpDecl->getCanonicalDecl());
10326 APValue::LValueBase Base;
10335 FromElemTy = E->getType();
10339 Base = APValue::LValueBase(ImpExpr,
10344 FromValue.getLValueBase().get<const ValueDecl *>()->getType();
10349 Base = APValue::LValueBase(cast<ValueDecl>(ImpDecl),
10361 Base = APValue::LValueBase::getTypeInfo(TypeInfoLValue(ImpTypeInfo),
10370 Base, Offset, PathLength, FromValue.isLValueOnePastTheEnd(),
10375 if (FromElemTy->isRecordType()) {
10384 FromElemTy = cast<ValueDecl>(FromDecl)->getType();
10389 Importer.FromContext.getAsArrayType(FromElemTy)->getElementType();
10395 Result.setLValue(Base, Offset, APValue::NoLValuePath{},
10434 if (!ID->getDefinition())
10435 ID->startDefinition();
10438 if (!PD->getDefinition())
10439 PD->startDefinition();
10442 if (!TD->getDefinition() && !TD->isBeingDefined()) {
10443 TD->startDefinition();
10444 TD->setCompleteDefinition(true);
10454 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
10457 return Pos->second;
10465 if (To->getDeclContext())
10474 return Pos->second;
10484 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);