Lines Matching defs:import
138 /// How to handle import errors that occur when import of a child declaration
144 /// Ignore import errors of the children.
146 /// of it failed to import. Otherwise the import errors of the child nodes
147 /// are accumulated (joined) into the import error object of the parent.
158 /// Process the import result of a child (of the current declaration).
159 /// \param ResultErr The import error that can be used as result of
169 /// Determine if import failure of a child does not cause import failure of
189 // Use this to import pointers of specific type.
198 // Call the import function of ASTImporter for a baseclass of type `T` and
201 auto import(T *From)
211 auto import(const T *From) {
212 return import(const_cast<T *>(From));
215 // Call the import function of ASTImporter for type `T`.
217 Expected<T> import(const T &From) {
223 Expected<std::optional<T>> import(std::optional<T> From) {
226 return import(*From);
239 // Always use these functions to create a Decl during import. There are
310 // In minimal import case the decl must be added even if it is not
395 /// What we should import from the definition.
398 /// nothing (if minimal import is set) or might be everything (if minimal
399 /// import is not set).
651 // Don't attempt to import nodes if we hit an error earlier.
654 Expected<T> MaybeVal = import(From);
666 Expected<ItemT> ToOrErr = import(*Ibegin);
706 auto ToLAngleLocOrErr = import(FromLAngleLoc);
709 auto ToRAngleLocOrErr = import(FromRAngleLoc);
758 ASTNodeImporter::import(TemplateParameterList *From) {
763 ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
767 auto ToTemplateLocOrErr = import(From->getTemplateLoc());
770 auto ToLAngleLocOrErr = import(From->getLAngleLoc());
773 auto ToRAngleLocOrErr = import(From->getRAngleLoc());
788 ASTNodeImporter::import(const TemplateArgument &From) {
794 ExpectedType ToTypeOrErr = import(From.getAsType());
802 ExpectedType ToTypeOrErr = import(From.getIntegralType());
809 Expected<ValueDecl *> ToOrErr = import(From.getAsDecl());
812 ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl());
820 ExpectedType ToTypeOrErr = import(From.getNullPtrType());
828 ExpectedType ToTypeOrErr = import(From.getStructuralValueType());
831 Expected<APValue> ToValueOrErr = import(From.getAsStructuralValue());
839 Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate());
848 import(From.getAsTemplateOrTemplatePattern());
857 if (ExpectedExpr ToExpr = import(From.getAsExpr()))
878 ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
879 Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
888 ExpectedExpr E = import(FromInfo.getAsExpr());
893 if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo()))
899 import(FromInfo.getTemplateQualifierLoc());
902 auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
906 import(FromInfo.getTemplateEllipsisLoc());
918 Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
925 if (auto ToDOrErr = import(FromD))
937 ASTNodeImporter::import(const Designator &D) {
941 ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc());
945 ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc());
953 ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc());
957 ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc());
966 ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
977 Expected<ConceptReference *> ASTNodeImporter::import(ConceptReference *From) {
1004 Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
1007 if (auto VarOrErr = import(From.getCapturedVar()))
1013 auto LocationOrErr = import(From.getLocation());
1069 ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
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());
1237 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1288 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1298 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1310 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1320 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1327 ExpectedType TyOrErr = import(A);
1336 ExpectedType TyOrErr = import(E);
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());
1407 ExpectedType ToUnderlyingTypeOrErr = import(T->desugar());
1415 ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1422 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnmodifiedType());
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());
1470 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1474 ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
1492 Expected<TemplateName> ToTemplateNameOrErr = import(T->getTemplateName());
1495 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1505 Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
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());
1546 ExpectedType ToWrappedTypeOrErr = import(T->desugar());
1555 Expected<ValueDecl *> ToDeclOrErr = import(TI.getDecl());
1568 Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
1578 Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
1582 ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
1593 Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
1597 Expected<TemplateArgument> ToArgumentPack = import(T->getArgumentPack());
1607 auto ToTemplateOrErr = import(T->getTemplateName());
1620 if (ExpectedType TyOrErr = import(FromCanonType))
1632 auto ToQualifierOrErr = import(T->getQualifier());
1636 ExpectedType ToNamedTypeOrErr = import(T->getNamedType());
1640 Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl());
1652 ExpectedType ToPatternOrErr = import(T->getPattern());
1663 auto ToQualifierOrErr = import(T->getQualifier());
1680 auto ToQualifierOrErr = import(T->getQualifier());
1688 if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
1701 Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
1709 ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1715 if (ExpectedType TyOrErr = import(TypeArg))
1723 if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P))
1737 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1746 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1785 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1808 ExpectedExpr ToNumBitsExprOrErr = import(T->getNumBitsExpr());
1844 Expected<ObjCTypeParamDecl *> ToDeclOrErr = import(T->getDecl());
1850 Expected<ObjCProtocolDecl *> ToProtocolOrErr = import(FromProtocol);
1861 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1981 // We only have to import To.LocInfo.
1992 if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange()))
1999 if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc()))
2008 if (auto ToTInfoOrErr = import(From.getNamedTypeInfo()))
2046 ExpectedDecl ImportedOrErr = import(From);
2068 // e.g when we import a class like this:
2074 // During the import of `a` we import first the dependencies in sequence,
2087 // calling an import at this point would result in an uncontrolled import, we
2123 ExpectedDecl ImportedOrErr = import(From);
2137 // element is a RecordDecl and if so we need to import the definition.
2191 Expected<CXXMethodDecl *> ToMOrErr = import(FromM);
2213 // There are cases in LLDB when we first import a class without its
2227 // set in CXXRecordDecl::CreateLambda. We must import the contained
2235 if (auto ToCaptureOrErr = import(FromCapture))
2256 // import. Some AST constructs (expressions) require the record layout
2258 // constructed. Import of such AST node is possible during import of the
2260 // fields imported) at that time without multiple AST import passes.
2289 ExpectedType TyOrErr = import(Base1.getType());
2295 if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc()))
2306 auto RangeOrErr = import(Base1.getSourceRange());
2310 auto TSIOrErr = import(Base1.getTypeSourceInfo());
2343 ExpectedExpr ToInitOrErr = import(FromInit);
2352 // FIXME: Also import the initializer value.
2373 import(Importer.getFromContext().getTypeDeclType(From));
2377 ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType());
2397 if (auto ToOrErr = import(Arg))
2406 // FIXME: Do not forget to remove this and use only 'import'.
2409 return import(From);
2416 if (auto ToLocOrErr = import(FromLoc))
2432 // Eliminate a potential failure point where we attempt to re-import
2433 // something we're trying to import while completing ToRecord.
2466 ExpectedSLoc LocOrErr = import(D->getLocation());
2518 ExpectedSLoc LocOrErr = import(D->getLocation());
2521 auto ColonLocOrErr = import(D->getColonLoc());
2617 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2620 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
2695 // Do not import the DeclContext, we will import it once the TypedefNameDecl
2736 // a rename strategy at import.
2888 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2902 Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
2964 // was found, perform the import always.
3005 if (Expected<EnumDecl *> ToInstOrErr = import(FromInst))
3009 if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
3132 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
3141 auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
3150 ExpectedDecl CDeclOrErr = import(Numbering.ContextDecl);
3236 if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
3242 import(MemberInfo->getPointOfInstantiation()))
3258 if (auto BraceRangeOrErr = import(D->getBraceRange()))
3262 if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
3315 ExpectedType TypeOrErr = import(D->getType());
3319 ExpectedExpr InitOrErr = import(D->getInitExpr());
3344 import(FromD->getTemplateParameterList(I)))
3361 import(FromFD->getInstantiatedFromDecl()))
3368 import(FromFD->getInstantiatedFromMemberFunction()))
3373 if (ExpectedSLoc POIOrErr = import(
3399 ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
3417 if (Expected<FunctionTemplateDecl *> ToFTDOrErr = import(FTD))
3458 if (ExpectedStmt ToBodyOrErr = import(FromBody))
3703 // Import the first part of the decl chain. I.e. import all previous
3706 ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3800 // template. This avoids need for a similar check at import of the
3823 // Set to true if we do not import the type of the function as is. There are
3825 // the import. To avoid an infinite recursion when importing, we create the
3875 if (Expected<ParmVarDecl *> ToPOrErr = import(P))
3891 import(FromConstructor->getInheritedConstructor());
3976 auto Imported = import(Msg);
4022 auto ToFTOrErr = import(FromFT);
4044 // If it is a template, import all related things.
4062 if (ExpectedType TyOrErr = import(D->getType()))
4066 if (Expected<TypeSourceInfo *> TSIOrErr = import(D->getTypeSourceInfo()))
4076 // Import the rest of the chain. I.e. import all subsequent declarations.
4078 ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
4138 if (ExpectedExpr ToInitializerOrErr = import(FromInitializer)) {
4203 "Duplicate import of in-class initializer.");
4254 auto TypeOrErr = import(D->getType());
4263 if (Expected<NamedDecl *> ToD = import(PI))
4364 if (auto TSIOrErr = import(D->getFriendType()))
4373 if (auto ListOrErr = import(FromTPLists[I]))
4379 auto LocationOrErr = import(D->getLocation());
4382 auto FriendLocOrErr = import(D->getFriendLoc());
4453 // Import the first part of the decl chain. I.e. import all previous
4456 ExpectedDecl RedeclOrErr = import(*RedeclIt);
4516 if (auto TyOrErr = import(D->getType()))
4593 auto ToVTOrErr = import(D->getDescribedVarTemplate());
4599 if (Expected<VarDecl *> ToInstOrErr = import(FromInst))
4603 if (ExpectedSLoc POIOrErr = import(MSI->getPointOfInstantiation()))
4617 // Import the rest of the chain. I.e. import all subsequent declarations.
4619 ExpectedDecl RedeclOrErr = import(*RedeclIt);
4656 if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg()))
4663 if (auto ToDefArgOrErr = import(FromParam->getDefaultArg()))
4706 // Do not import the default expression before GetImportedOrCreateDecl call
4707 // to avoid possible infinite import loop because circular dependency.
4821 if (Expected<ParmVarDecl *> ToPOrErr = import(FromP))
4881 // Only import 'ObjCTypeParamType' after the decl is created.
4946 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4951 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4969 // If we have an implementation, import it as well.
4972 import(D->getImplementation()))
5002 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
5007 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
5028 // from, but this particular declaration is not that definition, import the
5032 if (ExpectedDecl ImportedDefOrErr = import(Definition))
5060 auto ToAtBeginLocOrErr = import(D->getAtStartLoc());
5087 ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
5091 ExpectedSLoc LangLocOrErr = import(D->getLocation());
5104 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
5119 if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow))
5161 if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern))
5199 if (Expected<UsingEnumDecl *> ToPatternOrErr = import(FromPattern))
5219 Expected<BaseUsingDecl *> ToIntroducerOrErr = import(D->getIntroducer());
5223 Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
5257 if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
5428 if (auto FromSuperOrErr = import(FromSuper))
5464 // If this class has a superclass, import it.
5466 if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo()))
5482 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
5487 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
5501 auto ToCatOrErr = import(Cat);
5506 // If we have an @implementation, import it as well.
5509 import(From->getImplementation()))
5529 if (auto toTypeParamOrErr = import(fromTypeParam))
5535 auto LAngleLocOrErr = import(list->getLAngleLoc());
5539 auto RAngleLocOrErr = import(list->getRAngleLoc());
5551 // but this particular declaration is not that definition, import the
5555 if (ExpectedDecl ImportedDefOrErr = import(Definition))
5585 ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc());
5898 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5902 ExpectedSLoc LocationOrErr = import(D->getLocation());
5930 import(D->getDefaultArgument());
5962 import(D->getDefaultArgument());
5974 auto NameOrErr = import(D->getDeclName());
5979 ExpectedSLoc LocationOrErr = import(D->getLocation());
5984 auto TemplateParamsOrErr = import(D->getTemplateParameters());
5999 import(D->getDefaultArgument());
6034 // imported ones only if strictly necessary, otherwise import these as new
6096 auto TemplateParamsOrErr = import(D->getTemplateParameters());
6123 // It is possible that during the import of the class template definition
6124 // we start the import of a fwd friend decl of the very same class template
6128 // import of the fwd friend decl) we start to import the definition again
6173 auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
6191 auto ToOrErr = import(FromField);
6199 auto ToOrErr = import(FromM);
6218 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
6221 ExpectedSLoc IdLocOrErr = import(D->getLocation());
6249 // Update InsertPos, because preceding import calls may have invalidated
6257 import(PartialSpec->getInstantiatedFromMember()))
6270 // Update InsertPos, because preceding import calls may have invalidated
6287 if (auto BraceRangeOrErr = import(D->getBraceRange()))
6296 if (auto LocOrErr = import(D->getQualifierLoc()))
6304 if (auto LocOrErr = import(D->getTemplateKeywordLoc()))
6309 if (auto LocOrErr = import(D->getExternKeywordLoc()))
6315 if (auto POIOrErr = import(D->getPointOfInstantiation()))
6325 if (auto CTDorErr = import(CTD))
6329 auto CTPSDOrErr = import(CTPSD);
6336 if (auto ArgOrErr = import(DArg))
6418 ExpectedType TypeOrErr = import(DTemplated->getType());
6428 auto TemplateParamsOrErr = import(D->getTemplateParameters());
6462 // A VarTemplateSpecializationDecl inherits from VarDecl, the import is done
6467 // Import the first part of the decl chain. I.e. import all previous
6470 ExpectedDecl RedeclOrErr = import(*RedeclIt);
6486 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
6490 auto IdLocOrErr = import(D->getLocation());
6540 auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
6552 import(FromPartial->getInstantiatedFromMember()))
6573 // Update InsertPos, because preceding import calls may have invalidated
6583 auto TInfoOrErr = import(D->getTypeSourceInfo());
6589 if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation()))
6600 if (auto LocOrErr = import(D->getQualifierLoc()))
6618 // Import the rest of the chain. I.e. import all subsequent declarations.
6620 ExpectedDecl RedeclOrErr = import(*RedeclIt);
6670 auto ParamsOrErr = import(D->getTemplateParameters());
6689 // for TemplateTemplateParmDecl. The same happens at import when the
6763 if (auto ClobberOrErr = import(S->getClobberStringLiteral(I)))
6772 if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I)))
6779 if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
6798 ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
6801 auto AsmStrOrErr = import(S->getAsmString());
6804 ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
6837 ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
6850 ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
6854 ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
6910 ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
6917 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6968 Expected<SwitchCase *> ToSCOrErr = import(SC);
7059 ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
7066 auto ToBreakLocOrErr = import(S->getBreakLoc());
7099 ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc());
7103 ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock());
7110 if (auto ToHandlerOrErr = import(FromHandler))
7176 ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc());
7179 ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
7198 if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt))
7225 ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc());
7228 ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
7237 ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
7240 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
7346 ExpectedType TypeOrErr = import(E->getType());
7350 ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
7437 auto FoundDOrErr = import(E->getFoundDecl());
7464 ExpectedType TypeOrErr = import(E->getType());
7472 ExpectedExpr ToInitOrErr = import(E->getInit());
7476 ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc());
7483 if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
7501 ExpectedType ToTypeOrErr = import(E->getType());
7505 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7514 ExpectedType ToTypeOrErr = import(E->getType());
7518 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7528 ExpectedType ToTypeOrErr = import(E->getType());
7532 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7542 auto ToTypeOrErr = import(E->getType());
7546 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7555 auto ToTypeOrErr = import(E->getType());
7559 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7569 ExpectedType ToTypeOrErr = import(E->getType());
7573 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7582 ExpectedType ToTypeOrErr = import(E->getType());
7669 ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
7673 ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
7728 import(E->getArgumentTypeInfo());
7737 ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
7887 if (auto SpecOrErr = import(*I))
7896 ExpectedType ToTypeOrErr = import(E->getType());
7900 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7929 ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc());
7932 ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc());
7943 ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc());
7946 ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc());
7957 ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc());
7960 ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc());
7969 ExpectedSLoc ToKWLocOrErr = import(BBC->getBeginLoc());
7972 ExpectedSLoc ToRParenLocOrErr = import(BBC->getEndLoc());
8006 auto ToBSOrErr = import(FromNode.getBase());
8013 auto ToFieldOrErr = import(FromNode.getField());
8029 ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I));
8080 ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation());
8084 auto ToParamOrErr = import(E->getParam());
8093 // This is needed because it can happen that during the import of the
8109 ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
8134 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8138 auto ToDtorOrErr = import(E->getTemporary()->getDestructor());
8318 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8349 ExpectedType ToTypeOrErr = import(E->getType());
8353 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
8362 ExpectedType ToTypeOrErr = import(E->getType());
8366 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
8424 ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc());
8429 if (auto ToTIOrErr = import(E->getDestroyedTypeInfo()))
8454 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
8538 Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
8542 auto ToQualifierLocOrErr = import(E->getQualifierLoc());
8559 if (auto ToDOrErr = import(D))
8571 ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
8611 if (auto ToDOrErr = import(D))
8628 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
8667 auto ToClassOrErr = import(FromClass);
8672 auto ToCallOpOrErr = import(E->getCallOperator());
8713 if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
8720 if (auto ToFDOrErr = import(FromFD))
8727 if (auto ToSyntFormOrErr = import(SyntForm))
8742 ExpectedType ToTypeOrErr = import(E->getType());
8746 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8781 ExpectedType ToTypeOrErr = import(E->getType());
8788 ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc());
8792 auto ToFieldOrErr = import(E->getField());
8809 import(E->getField()->getInClassInitializer());
8817 ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
8904 ExpectedType ToTypeOrErr = import(E->getType());
8908 auto ToSourceRangeOrErr = import(E->getSourceRange());
8913 if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
8920 ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand());
8951 if (auto ImportedOrErr = import(FromOverriddenMethod))
9028 // loading external decls during the import.
9113 // import of the data.
9131 // import of the data. The array data is accessible in a pointer form, this form
9190 // If an import error happens, the internal error is set to it, and any
9191 // further import attempt is ignored.
9196 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9222 // Create a clone of the 'FromAttr' and import its source range only.
9226 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9237 // Get the result of the previous import attempt (can be used only once).
9382 // The default branch works for attributes that have no arguments to import.
9383 // FIXME: Handle every attribute type that has arguments of type to import
9426 // Check whether there was a previous failed import.
9440 // If FromD has some updated flags after last import, apply it.
9442 // If we encounter a cycle during an import then we save the relevant part
9443 // of the import path associated to the Decl.
9452 // Failed to import.
9474 // then we import and set its DeclContext. So, the DC might not be set
9500 // The import path contains import-dependency nodes first.
9507 // We should not set import error on a node and all following nodes in
9508 // the path if child import errors are ignored.
9541 // We could import from the current TU without error. But previously we
10455 "Try to import an already imported Decl");
10463 // import and set its DeclContext. So, the DC is still not set when we reach