Lines Matching defs:import
137 /// How to handle import errors that occur when import of a child declaration
143 /// Ignore import errors of the children.
145 /// of it failed to import. Otherwise the import errors of the child nodes
146 /// are accumulated (joined) into the import error object of the parent.
157 /// Process the import result of a child (of the current declaration).
158 /// \param ResultErr The import error that can be used as result of
168 /// Determine if import failure of a child does not cause import failure of
188 // Use this to import pointers of specific type.
197 // Call the import function of ASTImporter for a baseclass of type `T` and
200 auto import(T *From)
210 auto import(const T *From) {
211 return import(const_cast<T *>(From));
214 // Call the import function of ASTImporter for type `T`.
216 Expected<T> import(const T &From) {
222 Expected<std::optional<T>> import(std::optional<T> From) {
225 return import(*From);
238 // Always use these functions to create a Decl during import. There are
309 // In minimal import case the decl must be added even if it is not
367 import(D->getDefaultArgStorage().getInheritedFrom());
375 import(D->getDefaultArgStorage()
387 import(D->getDefaultArgument());
433 /// What we should import from the definition.
436 /// nothing (if minimal import is set) or might be everything (if minimal
437 /// import is not set).
689 // Don't attempt to import nodes if we hit an error earlier.
692 Expected<T> MaybeVal = import(From);
704 Expected<ItemT> ToOrErr = import(*Ibegin);
744 auto ToLAngleLocOrErr = import(FromLAngleLoc);
747 auto ToRAngleLocOrErr = import(FromRAngleLoc);
796 ASTNodeImporter::import(TemplateParameterList *From) {
801 ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
805 auto ToTemplateLocOrErr = import(From->getTemplateLoc());
808 auto ToLAngleLocOrErr = import(From->getLAngleLoc());
811 auto ToRAngleLocOrErr = import(From->getRAngleLoc());
826 ASTNodeImporter::import(const TemplateArgument &From) {
832 ExpectedType ToTypeOrErr = import(From.getAsType());
840 ExpectedType ToTypeOrErr = import(From.getIntegralType());
847 Expected<ValueDecl *> ToOrErr = import(From.getAsDecl());
850 ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl());
858 ExpectedType ToTypeOrErr = import(From.getNullPtrType());
866 ExpectedType ToTypeOrErr = import(From.getStructuralValueType());
869 Expected<APValue> ToValueOrErr = import(From.getAsStructuralValue());
877 Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate());
886 import(From.getAsTemplateOrTemplatePattern());
895 if (ExpectedExpr ToExpr = import(From.getAsExpr()))
916 ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
917 Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
926 ExpectedExpr E = import(FromInfo.getAsExpr());
931 if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo()))
937 import(FromInfo.getTemplateQualifierLoc());
940 auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
944 import(FromInfo.getTemplateEllipsisLoc());
956 Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
963 if (auto ToDOrErr = import(FromD))
975 ASTNodeImporter::import(const Designator &D) {
979 ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc());
983 ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc());
991 ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc());
995 ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc());
1004 ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
1015 Expected<ConceptReference *> ASTNodeImporter::import(ConceptReference *From) {
1042 Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
1045 if (auto VarOrErr = import(From.getCapturedVar()))
1051 auto LocationOrErr = import(From.getLocation());
1107 ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
1188 ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType());
1196 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1204 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1213 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1223 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1233 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1243 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1247 ExpectedTypePtr ClassTypeOrErr = import(T->getClass());
1279 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1330 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1340 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1352 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1362 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1369 ExpectedType TyOrErr = import(A);
1378 ExpectedType TyOrErr = import(E);
1421 ExpectedType ToInnerTypeOrErr = import(T->getInnerType());
1431 ExpectedType Pattern = import(T->getPattern());
1434 ExpectedExpr Index = import(T->getIndexExpr());
1441 Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
1449 ExpectedType ToUnderlyingTypeOrErr = import(T->desugar());
1457 ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1464 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnmodifiedType());
1472 Expected<UsingShadowDecl *> FoundOrErr = import(T->getFoundDecl());
1475 Expected<QualType> UnderlyingOrErr = import(T->getUnderlyingType());
1484 ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1488 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1498 ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1502 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1512 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1516 ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
1534 Expected<TemplateName> ToTemplateNameOrErr = import(T->getTemplateName());
1537 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1547 Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
1559 Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
1567 Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
1575 ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType());
1578 ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType());
1589 ExpectedType ToWrappedTypeOrErr = import(T->desugar());
1598 Expected<ValueDecl *> ToDeclOrErr = import(TI.getDecl());
1611 Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
1621 Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
1625 ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
1636 Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
1640 Expected<TemplateArgument> ToArgumentPack = import(T->getArgumentPack());
1650 auto ToTemplateOrErr = import(T->getTemplateName());
1663 if (ExpectedType TyOrErr = import(FromCanonType))
1675 auto ToQualifierOrErr = import(T->getQualifier());
1679 ExpectedType ToNamedTypeOrErr = import(T->getNamedType());
1683 Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl());
1695 ExpectedType ToPatternOrErr = import(T->getPattern());
1706 auto ToQualifierOrErr = import(T->getQualifier());
1723 auto ToQualifierOrErr = import(T->getQualifier());
1731 if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
1744 Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
1752 ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1758 if (ExpectedType TyOrErr = import(TypeArg))
1766 if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P))
1780 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1789 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1841 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1864 ExpectedExpr ToNumBitsExprOrErr = import(T->getNumBitsExpr());
1900 Expected<ObjCTypeParamDecl *> ToDeclOrErr = import(T->getDecl());
1906 Expected<ObjCProtocolDecl *> ToProtocolOrErr = import(FromProtocol);
1917 ExpectedType ToElementTypeOrErr = import(T->getElementType());
2037 // We only have to import To.LocInfo.
2048 if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange()))
2055 if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc()))
2064 if (auto ToTInfoOrErr = import(From.getNamedTypeInfo()))
2102 ExpectedDecl ImportedOrErr = import(From);
2124 // e.g when we import a class like this:
2130 // During the import of `a` we import first the dependencies in sequence,
2143 // calling an import at this point would result in an uncontrolled import, we
2179 ExpectedDecl ImportedOrErr = import(From);
2193 // element is a RecordDecl and if so we need to import the definition.
2247 Expected<CXXMethodDecl *> ToMOrErr = import(FromM);
2269 // There are cases in LLDB when we first import a class without its
2283 // set in CXXRecordDecl::CreateLambda. We must import the contained
2291 if (auto ToCaptureOrErr = import(FromCapture))
2312 // import. Some AST constructs (expressions) require the record layout
2314 // constructed. Import of such AST node is possible during import of the
2316 // fields imported) at that time without multiple AST import passes.
2345 ExpectedType TyOrErr = import(Base1.getType());
2351 if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc()))
2362 auto RangeOrErr = import(Base1.getSourceRange());
2366 auto TSIOrErr = import(Base1.getTypeSourceInfo());
2399 ExpectedExpr ToInitOrErr = import(FromInit);
2408 // FIXME: Also import the initializer value.
2429 import(Importer.getFromContext().getTypeDeclType(From));
2433 ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType());
2453 if (auto ToOrErr = import(Arg))
2462 // FIXME: Do not forget to remove this and use only 'import'.
2465 return import(From);
2472 if (auto ToLocOrErr = import(FromLoc))
2488 // Eliminate a potential failure point where we attempt to re-import
2489 // something we're trying to import while completing ToRecord.
2522 ExpectedSLoc LocOrErr = import(D->getLocation());
2574 ExpectedSLoc LocOrErr = import(D->getLocation());
2577 auto ColonLocOrErr = import(D->getColonLoc());
2673 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2676 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
2751 // Do not import the DeclContext, we will import it once the TypedefNameDecl
2792 // a rename strategy at import.
2944 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2958 Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
3020 // was found, perform the import always.
3061 if (Expected<EnumDecl *> ToInstOrErr = import(FromInst))
3065 if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
3189 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
3198 auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
3207 ExpectedDecl CDeclOrErr = import(Numbering.ContextDecl);
3293 if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
3299 import(MemberInfo->getPointOfInstantiation()))
3315 if (auto BraceRangeOrErr = import(D->getBraceRange()))
3319 if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
3372 ExpectedType TypeOrErr = import(D->getType());
3376 ExpectedExpr InitOrErr = import(D->getInitExpr());
3401 import(FromD->getTemplateParameterList(I)))
3418 import(FromFD->getInstantiatedFromDecl()))
3425 import(FromFD->getInstantiatedFromMemberFunction()))
3430 if (ExpectedSLoc POIOrErr = import(
3456 ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
3474 if (Expected<FunctionTemplateDecl *> ToFTDOrErr = import(FTD))
3515 if (ExpectedStmt ToBodyOrErr = import(FromBody))
3758 // Import the first part of the decl chain. I.e. import all previous
3761 ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3855 // template. This avoids need for a similar check at import of the
3878 // Set to true if we do not import the type of the function as is. There are
3880 // the import. To avoid an infinite recursion when importing, we create the
3930 if (Expected<ParmVarDecl *> ToPOrErr = import(P))
3946 import(FromConstructor->getInheritedConstructor());
4033 auto Imported = import(Msg);
4079 auto ToFTOrErr = import(FromFT);
4101 // If it is a template, import all related things.
4119 if (ExpectedType TyOrErr = import(D->getType()))
4123 if (Expected<TypeSourceInfo *> TSIOrErr = import(D->getTypeSourceInfo()))
4133 // Import the rest of the chain. I.e. import all subsequent declarations.
4135 ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
4195 if (ExpectedExpr ToInitializerOrErr = import(FromInitializer)) {
4254 "Duplicate import of in-class initializer.");
4305 auto TypeOrErr = import(D->getType());
4314 if (Expected<NamedDecl *> ToD = import(PI))
4415 if (auto TSIOrErr = import(D->getFriendType()))
4424 if (auto ListOrErr = import(FromTPLists[I]))
4430 auto LocationOrErr = import(D->getLocation());
4433 auto FriendLocOrErr = import(D->getFriendLoc());
4436 auto EllipsisLocOrErr = import(D->getEllipsisLoc());
4507 // Import the first part of the decl chain. I.e. import all previous
4510 ExpectedDecl RedeclOrErr = import(*RedeclIt);
4570 if (auto TyOrErr = import(D->getType()))
4647 auto ToVTOrErr = import(D->getDescribedVarTemplate());
4653 if (Expected<VarDecl *> ToInstOrErr = import(FromInst))
4657 if (ExpectedSLoc POIOrErr = import(MSI->getPointOfInstantiation()))
4671 // Import the rest of the chain. I.e. import all subsequent declarations.
4673 ExpectedDecl RedeclOrErr = import(*RedeclIt);
4705 if (auto LocOrErr = import(FromParam->getExplicitObjectParamThisLoc()))
4714 if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg()))
4721 if (auto ToDefArgOrErr = import(FromParam->getDefaultArg()))
4764 // Do not import the default expression before GetImportedOrCreateDecl call
4765 // to avoid possible infinite import loop because circular dependency.
4879 if (Expected<ParmVarDecl *> ToPOrErr = import(FromP))
4939 // Only import 'ObjCTypeParamType' after the decl is created.
5004 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
5009 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
5027 // If we have an implementation, import it as well.
5030 import(D->getImplementation()))
5060 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
5065 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
5086 // from, but this particular declaration is not that definition, import the
5090 if (ExpectedDecl ImportedDefOrErr = import(Definition))
5118 auto ToAtBeginLocOrErr = import(D->getAtStartLoc());
5145 ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
5149 ExpectedSLoc LangLocOrErr = import(D->getLocation());
5162 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
5177 if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow))
5219 if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern))
5257 if (Expected<UsingEnumDecl *> ToPatternOrErr = import(FromPattern))
5277 Expected<BaseUsingDecl *> ToIntroducerOrErr = import(D->getIntroducer());
5281 Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
5315 if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
5489 if (auto FromSuperOrErr = import(FromSuper))
5525 // If this class has a superclass, import it.
5527 if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo()))
5543 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
5548 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
5562 auto ToCatOrErr = import(Cat);
5567 // If we have an @implementation, import it as well.
5570 import(From->getImplementation()))
5590 if (auto toTypeParamOrErr = import(fromTypeParam))
5596 auto LAngleLocOrErr = import(list->getLAngleLoc());
5600 auto RAngleLocOrErr = import(list->getRAngleLoc());
5612 // but this particular declaration is not that definition, import the
5616 if (ExpectedDecl ImportedDefOrErr = import(Definition))
5646 ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc());
5959 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5963 ExpectedSLoc LocationOrErr = import(D->getLocation());
6026 auto NameOrErr = import(D->getDeclName());
6031 ExpectedSLoc LocationOrErr = import(D->getLocation());
6036 auto TemplateParamsOrErr = import(D->getTemplateParameters());
6081 // imported ones only if strictly necessary, otherwise import these as new
6155 auto TemplateParamsOrErr = import(D->getTemplateParameters());
6182 // It is possible that during the import of the class template definition
6183 // we start the import of a fwd friend decl of the very same class template
6187 // import of the fwd friend decl) we start to import the definition again
6232 auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
6250 auto ToOrErr = import(FromField);
6258 auto ToOrErr = import(FromM);
6277 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
6280 ExpectedSLoc IdLocOrErr = import(D->getLocation());
6308 // Update InsertPos, because preceding import calls may have invalidated
6316 import(PartialSpec->getInstantiatedFromMember()))
6329 // Update InsertPos, because preceding import calls may have invalidated
6346 if (auto BraceRangeOrErr = import(D->getBraceRange()))
6355 if (auto LocOrErr = import(D->getQualifierLoc()))
6363 if (auto LocOrErr = import(D->getTemplateKeywordLoc()))
6368 if (auto LocOrErr = import(D->getExternKeywordLoc()))
6374 if (auto POIOrErr = import(D->getPointOfInstantiation()))
6384 if (auto CTDorErr = import(CTD))
6388 auto CTPSDOrErr = import(CTPSD);
6395 if (auto ArgOrErr = import(DArg))
6477 ExpectedType TypeOrErr = import(DTemplated->getType());
6487 auto TemplateParamsOrErr = import(D->getTemplateParameters());
6521 // A VarTemplateSpecializationDecl inherits from VarDecl, the import is done
6526 // Import the first part of the decl chain. I.e. import all previous
6529 ExpectedDecl RedeclOrErr = import(*RedeclIt);
6545 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
6549 auto IdLocOrErr = import(D->getLocation());
6599 auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
6611 import(FromPartial->getInstantiatedFromMember()))
6632 // Update InsertPos, because preceding import calls may have invalidated
6642 auto TInfoOrErr = import(D->getTypeSourceInfo());
6648 if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation()))
6659 if (auto LocOrErr = import(D->getQualifierLoc()))
6677 // Import the rest of the chain. I.e. import all subsequent declarations.
6679 ExpectedDecl RedeclOrErr = import(*RedeclIt);
6729 auto ParamsOrErr = import(D->getTemplateParameters());
6748 // for TemplateTemplateParmDecl. The same happens at import when the
6765 // If not, there is AST incompatibility that can be caused by previous import
6830 if (auto ClobberOrErr = import(S->getClobberStringLiteral(I)))
6839 if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I)))
6846 if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
6865 ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
6868 auto AsmStrOrErr = import(S->getAsmString());
6871 ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
6904 ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
6917 ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
6921 ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
6977 ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
6984 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
7035 Expected<SwitchCase *> ToSCOrErr = import(SC);
7126 ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
7133 auto ToBreakLocOrErr = import(S->getBreakLoc());
7166 ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc());
7170 ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock());
7177 if (auto ToHandlerOrErr = import(FromHandler))
7243 ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc());
7246 ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
7265 if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt))
7292 ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc());
7295 ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
7304 ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
7307 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
7413 ExpectedType TypeOrErr = import(E->getType());
7417 ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
7504 auto FoundDOrErr = import(E->getFoundDecl());
7531 ExpectedType TypeOrErr = import(E->getType());
7539 ExpectedExpr ToInitOrErr = import(E->getInit());
7543 ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc());
7550 if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
7568 ExpectedType ToTypeOrErr = import(E->getType());
7572 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7581 ExpectedType ToTypeOrErr = import(E->getType());
7585 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7595 ExpectedType ToTypeOrErr = import(E->getType());
7599 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7609 auto ToTypeOrErr = import(E->getType());
7613 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7622 auto ToTypeOrErr = import(E->getType());
7626 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7636 ExpectedType ToTypeOrErr = import(E->getType());
7640 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7649 ExpectedType ToTypeOrErr = import(E->getType());
7736 ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
7740 ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
7795 import(E->getArgumentTypeInfo());
7804 ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
7954 if (auto SpecOrErr = import(*I))
7963 ExpectedType ToTypeOrErr = import(E->getType());
7967 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7996 ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc());
7999 ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc());
8010 ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc());
8013 ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc());
8024 ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc());
8027 ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc());
8036 ExpectedSLoc ToKWLocOrErr = import(BBC->getBeginLoc());
8039 ExpectedSLoc ToRParenLocOrErr = import(BBC->getEndLoc());
8073 auto ToBSOrErr = import(FromNode.getBase());
8080 auto ToFieldOrErr = import(FromNode.getField());
8096 ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I));
8147 ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation());
8151 auto ToParamOrErr = import(E->getParam());
8160 // This is needed because it can happen that during the import of the
8176 ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
8201 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8205 auto ToDtorOrErr = import(E->getTemporary()->getDestructor());
8385 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8416 ExpectedType ToTypeOrErr = import(E->getType());
8420 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
8429 ExpectedType ToTypeOrErr = import(E->getType());
8433 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
8491 ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc());
8496 if (auto ToTIOrErr = import(E->getDestroyedTypeInfo()))
8521 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
8605 Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
8609 auto ToQualifierLocOrErr = import(E->getQualifierLoc());
8626 if (auto ToDOrErr = import(D))
8638 ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
8678 if (auto ToDOrErr = import(D))
8695 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
8734 auto ToClassOrErr = import(FromClass);
8739 auto ToCallOpOrErr = import(E->getCallOperator());
8780 if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
8787 if (auto ToFDOrErr = import(FromFD))
8794 if (auto ToSyntFormOrErr = import(SyntForm))
8809 ExpectedType ToTypeOrErr = import(E->getType());
8813 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8848 ExpectedType ToTypeOrErr = import(E->getType());
8855 ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc());
8859 auto ToFieldOrErr = import(E->getField());
8876 import(E->getField()->getInClassInitializer());
8884 ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
8971 ExpectedType ToTypeOrErr = import(E->getType());
8975 auto ToSourceRangeOrErr = import(E->getSourceRange());
8980 if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
8987 ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand());
9018 if (auto ImportedOrErr = import(FromOverriddenMethod))
9112 // loading external decls during the import.
9197 // import of the data.
9215 // import of the data. The array data is accessible in a pointer form, this form
9274 // If an import error happens, the internal error is set to it, and any
9275 // further import attempt is ignored.
9280 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9306 // Create a clone of the 'FromAttr' and import its source range only.
9310 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9321 // Get the result of the previous import attempt (can be used only once).
9466 // The default branch works for attributes that have no arguments to import.
9467 // FIXME: Handle every attribute type that has arguments of type to import
9497 // Check whether there was a previous failed import.
9511 // If FromD has some updated flags after last import, apply it.
9513 // If we encounter a cycle during an import then we save the relevant part
9514 // of the import path associated to the Decl.
9523 // Failed to import.
9545 // then we import and set its DeclContext. So, the DC might not be set
9571 // The import path contains import-dependency nodes first.
9578 // We should not set import error on a node and all following nodes in
9579 // the path if child import errors are ignored.
9612 // We could import from the current TU without error. But previously we
10535 "Try to import an already imported Decl");
10543 // import and set its DeclContext. So, the DC is still not set when we reach