Lines Matching defs:Import
90 /// \brief What we should import from the definition.
92 /// \brief Import the default subset of the definition, which might be
93 /// nothing (if minimal import is set) or might be everything (if minimal
94 /// import is not set).
96 /// \brief Import everything.
98 /// \brief Import only the bare bones needed to establish a valid
1464 // Import Types
1515 QualType ToElementType = Importer.Import(T->getElementType());
1523 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1532 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1542 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1552 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1561 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1565 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1571 QualType ToElementType = Importer.Import(T->getElementType());
1583 QualType ToElementType = Importer.Import(T->getElementType());
1593 QualType ToElementType = Importer.Import(T->getElementType());
1597 Expr *Size = Importer.Import(T->getSizeExpr());
1601 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1609 QualType ToElementType = Importer.Import(T->getElementType());
1619 QualType ToElementType = Importer.Import(T->getElementType());
1631 QualType ToResultType = Importer.Import(T->getReturnType());
1640 QualType ToResultType = Importer.Import(T->getReturnType());
1644 // Import argument types
1647 QualType ArgType = Importer.Import(A);
1653 // Import exception types
1656 QualType ExceptionType = Importer.Import(E);
1673 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1675 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1677 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1683 QualType ToInnerType = Importer.Import(T->getInnerType());
1692 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1700 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1708 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1717 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1721 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1729 QualType ToBaseType = Importer.Import(T->getBaseType());
1730 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1744 ToDeduced = Importer.Import(FromDeduced);
1755 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1764 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1778 ToModifiedType = Importer.Import(FromModifiedType);
1783 ToEquivalentType = Importer.Import(FromEquivalentType);
1794 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1806 ToCanonType =Importer.Import(FromCanonType);
1820 ToQualifier = Importer.Import(T->getQualifier());
1825 QualType ToNamedType = Importer.Import(T->getNamedType());
1835 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1843 QualType ToBaseType = Importer.Import(T->getBaseType());
1849 QualType ImportedTypeArg = Importer.Import(TypeArg);
1859 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1872 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1880 // Import Declarations
1887 // Import the context of this declaration.
1899 // Import the name of this declaration.
1900 Name = Importer.Import(D->getDeclName());
1904 // Import the location of this declaration.
1905 Loc = Importer.Import(D->getLocation());
1915 ToD = Importer.Import(FromD);
1943 // We only have to import To.LocInfo.
1954 To.setCXXOperatorNameRange(Importer.Import(Range));
1959 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1966 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1980 Importer.Import(From);
2055 QualType T = Importer.Import(Base1.getType());
2061 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2068 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2072 Importer.Import(Base1.getTypeSourceInfo()),
2091 // FIXME: Can we really import any initializer? Alternatively, we could force
2092 // ourselves to import every declaration of a variable and then only use
2094 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2111 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2115 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2137 Decl *To = Importer.Import(*P);
2145 Importer.Import(Params->getTemplateLoc()),
2146 Importer.Import(Params->getLAngleLoc()),
2148 Importer.Import(Params->getRAngleLoc()));
2158 QualType ToType = Importer.Import(From.getAsType());
2165 QualType ToType = Importer.Import(From.getIntegralType());
2172 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2173 QualType ToType = Importer.Import(From.getParamTypeForDecl());
2180 QualType ToType = Importer.Import(From.getNullPtrType());
2187 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2196 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2204 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2238 // Eliminate a potential failure point where we attempt to re-import
2239 // something we're trying to import while completing ToRecord.
2312 // Import the major distinguishing characteristics of this namespace.
2360 Importer.Import(D->getLocStart()),
2383 // Import the major distinguishing characteristics of this typedef.
2423 // Import the underlying type of this typedef;
2424 QualType T = Importer.Import(D->getUnderlyingType());
2429 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2430 SourceLocation StartL = Importer.Import(D->getLocStart());
2460 // Import the major distinguishing characteristics of this enum.
2474 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2511 Importer.Import(D->getLocStart()),
2515 // Import the qualifier, if any.
2516 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2522 // Import the integer type.
2523 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2528 // Import the definition
2537 // but this particular declaration is not that definition, import the
2541 Decl *ImportedDef = Importer.Import(Definition);
2548 // Import the major distinguishing characteristics of this record.
2562 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2647 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2661 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2677 // Import the major distinguishing characteristics of this enumerator.
2687 QualType T = Importer.Import(D->getType());
2720 Expr *Init = Importer.Import(D->getInitExpr());
2736 // Import the major distinguishing characteristics of this function.
2795 // Import additional name location/type info.
2818 // Import the type.
2819 QualType T = Importer.Import(FromTy);
2823 // Import the function parameters.
2826 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2834 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2836 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
2862 Importer.Import(D->getLocEnd()));
2871 Importer.Import(D->getLocEnd()));
2881 // Import the qualifier, if any.
2882 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2899 QualType T = Importer.Import(D->getType());
2905 // Import the body, if any.
2907 if (Stmt *ToBody = Importer.Import(FromBody)) {
2954 // Import the major distinguishing characteristics of a variable.
2987 // Import the type.
2988 QualType T = Importer.Import(D->getType());
2992 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2993 Expr *BitWidth = Importer.Import(D->getBitWidth());
2998 Importer.Import(D->getInnerLocStart()),
3013 // Import the major distinguishing characteristics of a variable.
3052 // Import the type.
3053 QualType T = Importer.Import(D->getType());
3062 Decl *D = Importer.Import(PI);
3083 // Import the major distinguishing characteristics of an ivar.
3112 // Import the type.
3113 QualType T = Importer.Import(D->getType());
3117 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3118 Expr *BitWidth = Importer.Import(D->getBitWidth());
3124 Importer.Import(D->getInnerLocStart()),
3136 // Import the major distinguishing characteristics of a variable.
3175 // Import the type.
3176 QualType T = Importer.Import(D->getType());
3212 Expr *Init = Importer.Import(DDef->getInit());
3234 // Import the type.
3235 QualType T = Importer.Import(D->getType());
3240 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3242 Importer.Import(D->getInnerLocStart()),
3246 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3268 // Import the name of this declaration.
3269 DeclarationName Name = Importer.Import(D->getDeclName());
3273 // Import the location of this declaration.
3274 SourceLocation Loc = Importer.Import(D->getLocation());
3276 // Import the parameter's type.
3277 QualType T = Importer.Import(D->getType());
3294 // Import the name of this declaration.
3295 DeclarationName Name = Importer.Import(D->getDeclName());
3299 // Import the location of this declaration.
3300 SourceLocation Loc = Importer.Import(D->getLocation());
3302 // Import the parameter's type.
3303 QualType T = Importer.Import(D->getType());
3308 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3310 Importer.Import(D->getInnerLocStart()),
3323 // Import the major distinguishing characteristics of a method.
3395 // Import the result type.
3396 QualType ResultTy = Importer.Import(D->getReturnType());
3400 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3403 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3411 // Import the parameters
3414 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3437 // Import the major distinguishing characteristics of a category.
3447 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3454 Importer.Import(D->getVarianceLoc()),
3456 Importer.Import(D->getLocation()),
3458 Importer.Import(D->getColonLoc()),
3466 // Import the major distinguishing characteristics of a category.
3477 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3487 Importer.Import(D->getAtStartLoc()),
3489 Importer.Import(D->getCategoryNameLoc()),
3493 Importer.Import(D->getIvarLBraceLoc()),
3494 Importer.Import(D->getIvarRBraceLoc()));
3498 // Import the type parameter list after calling Imported, to avoid
3503 // Import protocols
3513 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3517 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3528 // Import all of the members of this category.
3531 // If we have an implementation, import it as well.
3535 Importer.Import(D->getImplementation()));
3557 // Import protocols
3567 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3571 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3579 // Import all of the members of this protocol.
3587 // from, but this particular declaration is not that definition, import the
3591 Decl *ImportedDef = Importer.Import(Definition);
3598 // Import the major distinguishing characteristics of a protocol.
3623 Importer.Import(D->getAtStartLoc()),
3641 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3642 SourceLocation LangLoc = Importer.Import(D->getLocation());
3655 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3674 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3708 // If this class has a superclass, import it.
3710 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3717 // Import protocols
3728 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3732 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3739 // Import categories. When the categories themselves are imported, they'll
3742 Importer.Import(Cat);
3744 // If we have an @implementation, import it as well.
3747 Importer.Import(From->getImplementation()));
3755 // Import all of the members of this class.
3769 Importer.Import(fromTypeParam));
3777 Importer.Import(list->getLAngleLoc()),
3779 Importer.Import(list->getRAngleLoc()));
3784 // but this particular declaration is not that definition, import the
3788 Decl *ImportedDef = Importer.Import(Definition);
3795 // Import the major distinguishing characteristics of an @interface.
3821 Importer.Import(D->getAtStartLoc()),
3830 // Import the type parameter list after calling Imported, to avoid
3843 Importer.Import(D->getCategoryDecl()));
3853 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3855 Importer.Import(D->getIdentifier()),
3857 Importer.Import(D->getLocation()),
3858 Importer.Import(D->getAtStartLoc()),
3882 Importer.Import(D->getClassInterface()));
3886 // Import the superclass, if any.
3890 Importer.Import(D->getSuperClass()));
3902 Importer.Import(D->getLocation()),
3903 Import(D->getAtStartLoc()),
3904 Importer.Import(D->getSuperClassLoc()),
3905 Importer.Import(D->getIvarLBraceLoc()),
3906 Importer.Import(D->getIvarRBraceLoc()));
3951 // Import all of the members of this @implementation.
3958 // Import the major distinguishing characteristics of an @property.
3992 // Import the type.
3993 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4001 Importer.Import(D->getAtLoc()),
4002 Importer.Import(D->getLParenLoc()),
4003 Importer.Import(D->getType()),
4013 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
4014 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
4016 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4018 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4020 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4026 Importer.Import(D->getPropertyDecl()));
4034 // Import the lexical declaration context.
4046 // Import the ivar (for an @synthesize).
4050 Importer.Import(D->getPropertyIvarDecl()));
4059 Importer.Import(D->getLocStart()),
4060 Importer.Import(D->getLocation()),
4064 Importer.Import(D->getPropertyIvarDeclLoc()));
4110 // FIXME: Import default argument.
4113 Importer.Import(D->getLocStart()),
4114 Importer.Import(D->getLocation()),
4117 Importer.Import(D->getIdentifier()),
4124 // Import the name of this declaration.
4125 DeclarationName Name = Importer.Import(D->getDeclName());
4129 // Import the location of this declaration.
4130 SourceLocation Loc = Importer.Import(D->getLocation());
4132 // Import the type of this declaration.
4133 QualType T = Importer.Import(D->getType());
4137 // Import type-source information.
4138 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4142 // FIXME: Import default argument.
4146 Importer.Import(D->getInnerLocStart()),
4154 // Import the name of this declaration.
4155 DeclarationName Name = Importer.Import(D->getDeclName());
4159 // Import the location of this declaration.
4160 SourceLocation Loc = Importer.Import(D->getLocation());
4162 // Import template parameters.
4168 // FIXME: Import default argument.
4180 // but this particular declaration is not that definition, import the
4186 = Importer.Import(Definition->getDescribedClassTemplate());
4193 // Import the major distinguishing characteristics of this class template.
4241 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4242 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4248 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4273 // FIXME: Import definition!
4282 // but this particular declaration is not that definition, import the
4286 Decl *ImportedDef = Importer.Import(Definition);
4294 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4299 // Import the context of this declaration.
4311 // Import the location of this declaration.
4312 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4313 SourceLocation IdLoc = Importer.Import(D->getLocation());
4315 // Import template arguments.
4354 // Import the qualifier, if any.
4355 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4372 // but this particular declaration is not that definition, import the
4377 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4384 // Import the major distinguishing characteristics of this variable template.
4428 // Import the type.
4429 QualType T = Importer.Import(DTemplated->getType());
4434 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4435 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4436 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4441 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4471 // FIXME: Import definition!
4480 // but this particular declaration is not that definition, import the
4484 Decl *ImportedDef = Importer.Import(Definition);
4492 Importer.Import(D->getSpecializedTemplate()));
4496 // Import the context of this declaration.
4508 // Import the location of this declaration.
4509 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4510 SourceLocation IdLoc = Importer.Import(D->getLocation());
4512 // Import template arguments.
4539 // Import the type.
4540 QualType T = Importer.Import(D->getType());
4543 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4555 // Import the qualifier, if any.
4556 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4571 // Import Statements
4582 return _Importer.Import(D);
4601 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4602 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
4607 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
4617 return _Importer.Import(CS);
4623 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
4624 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
4631 Expr *ToLHS = Importer.Import(S->getLHS());
4634 Expr *ToRHS = Importer.Import(S->getRHS());
4637 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
4638 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
4639 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4646 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
4647 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4648 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4656 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
4658 cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
4661 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4669 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
4681 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4689 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
4693 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4697 Expr *ToCondition = Importer.Import(S->getCond());
4700 Stmt *ToThenStmt = Importer.Import(S->getThen());
4703 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
4704 Stmt *ToElseStmt = Importer.Import(S->getElse());
4717 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4721 Expr *ToCondition = Importer.Import(S->getCond());
4727 Stmt *ToBody = Importer.Import(S->getBody());
4731 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
4736 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
4752 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4756 Expr *ToCondition = Importer.Import(S->getCond());
4759 Stmt *ToBody = Importer.Import(S->getBody());
4762 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4770 Stmt *ToBody = Importer.Import(S->getBody());
4773 Expr *ToCondition = Importer.Import(S->getCond());
4776 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
4777 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4778 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4785 Stmt *ToInit = Importer.Import(S->getInit());
4788 Expr *ToCondition = Importer.Import(S->getCond());
4794 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4798 Expr *ToInc = Importer.Import(S->getInc());
4801 Stmt *ToBody = Importer.Import(S->getBody());
4804 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4805 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
4806 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4818 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
4822 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4823 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
4829 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4830 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
4831 Expr *ToTarget = Importer.Import(S->getTarget());
4839 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
4844 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
4849 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
4850 Expr *ToRetExpr = Importer.Import(S->getRetValue());
4854 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
4862 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
4866 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4870 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
4879 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
4880 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
4886 if (Stmt *ToHandler = Importer.Import(FromHandler))
4897 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
4901 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginEndStmt()));
4904 Expr *ToCond = Importer.Import(S->getCond());
4907 Expr *ToInc = Importer.Import(S->getInc());
4911 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
4914 Stmt *ToBody = Importer.Import(S->getBody());
4917 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4918 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
4919 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4920 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4929 Stmt *ToElem = Importer.Import(S->getElement());
4932 Expr *ToCollect = Importer.Import(S->getCollection());
4935 Stmt *ToBody = Importer.Import(S->getBody());
4938 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4939 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4947 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
4948 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4952 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4956 Stmt *ToBody = Importer.Import(S->getCatchBody());
4966 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
4967 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
4975 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
4976 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
4982 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
4987 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
4999 Importer.Import(S->getAtSynchronizedLoc());
5000 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5003 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5011 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5012 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5020 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5021 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5029 // Import Expressions
5038 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5044 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5049 QualType T = Importer.Import(E->getType());
5054 Importer.Import(E->getQualifierLoc()),
5055 Importer.Import(E->getTemplateKeywordLoc()),
5058 Importer.Import(E->getLocation()),
5068 QualType T = Importer.Import(E->getType());
5074 Importer.Import(E->getLocation()));
5078 QualType T = Importer.Import(E->getType());
5084 Importer.Import(E->getLocation()));
5088 Expr *SubExpr = Importer.Import(E->getSubExpr());
5093 ParenExpr(Importer.Import(E->getLParen()),
5094 Importer.Import(E->getRParen()),
5099 QualType T = Importer.Import(E->getType());
5103 Expr *SubExpr = Importer.Import(E->getSubExpr());
5110 Importer.Import(E->getOperatorLoc()));
5115 QualType ResultType = Importer.Import(E->getType());
5118 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5124 Importer.Import(E->getOperatorLoc()),
5125 Importer.Import(E->getRParenLoc()));
5128 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5134 Importer.Import(E->getOperatorLoc()),
5135 Importer.Import(E->getRParenLoc()));
5139 QualType T = Importer.Import(E->getType());
5143 Expr *LHS = Importer.Import(E->getLHS());
5147 Expr *RHS = Importer.Import(E->getRHS());
5154 Importer.Import(E->getOperatorLoc()),
5159 QualType T = Importer.Import(E->getType());
5163 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5167 QualType CompResultType = Importer.Import(E->getComputationResultType());
5171 Expr *LHS = Importer.Import(E->getLHS());
5175 Expr *RHS = Importer.Import(E->getRHS());
5184 Importer.Import(E->getOperatorLoc()),
5191 // TODO: import cast paths
5196 QualType T = Importer.Import(E->getType());
5200 Expr *SubExpr = Importer.Import(E->getSubExpr());
5213 QualType T = Importer.Import(E->getType());
5217 Expr *SubExpr = Importer.Import(E->getSubExpr());
5221 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5232 Importer.Import(E->getLParenLoc()),
5233 Importer.Import(E->getRParenLoc()));
5237 QualType T = Importer.Import(E->getType());
5242 dyn_cast<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
5251 return _Importer.Import(AE);
5259 Importer.Import(E->getLocation()),
5266 Importer.Import(E->getParenOrBraceRange()));
5270 QualType T = Importer.Import(E->getType());
5274 Expr *ToBase = Importer.Import(E->getBase());
5278 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
5283 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
5287 Importer.Import(E->getMemberNameInfo().getName()),
5288 Importer.Import(E->getMemberNameInfo().getLoc()));
5296 Importer.Import(E->getOperatorLoc()),
5297 Importer.Import(E->getQualifierLoc()),
5298 Importer.Import(E->getTemplateKeywordLoc()),
5305 QualType T = Importer.Import(E->getType());
5309 Expr *ToCallee = Importer.Import(E->getCallee());
5319 Expr *ToArg = Importer.Import(FromArg);
5334 Importer.Import(E->getRParenLoc()));
5350 QualType ASTImporter::Import(QualType FromT) {
5362 // Import the type
5374 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
5380 QualType T = Import(FromTSI->getType());
5385 Import(FromTSI->getTypeLoc().getLocStart()));
5399 Decl *ASTImporter::Import(Decl *FromD) {
5413 // Import the type
5433 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
5450 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
5501 Expr *ASTImporter::Import(Expr *FromE) {
5505 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
5508 Stmt *ASTImporter::Import(Stmt *FromS) {
5517 // Import the type
5528 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
5532 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
5536 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
5543 cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
5550 cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
5560 cast<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
5567 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
5581 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
5586 TemplateName ASTImporter::Import(TemplateName From) {
5590 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
5601 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
5612 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
5617 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
5627 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
5633 Import(DTN->getIdentifier()));
5643 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
5647 TemplateName replacement = Import(subst->getReplacement());
5658 Import(SubstPack->getParameterPack()));
5675 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
5682 // don't have to import macro expansions.
5683 // FIXME: Import macro expansions!
5687 FileID ToFileID = Import(Decomposed.first);
5695 SourceRange ASTImporter::Import(SourceRange FromRange) {
5696 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
5699 FileID ASTImporter::Import(FileID FromID) {
5711 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
5743 Decl *To = Import(From);
5786 DeclarationName ASTImporter::Import(DeclarationName FromName) {
5792 return Import(FromName.getAsIdentifierInfo());
5797 return Import(FromName.getObjCSelector());
5800 QualType T = Import(FromName.getCXXNameType());
5809 QualType T = Import(FromName.getCXXNameType());
5818 QualType T = Import(FromName.getCXXNameType());
5832 Import(FromName.getCXXLiteralIdentifier()));
5842 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
5849 Selector ASTImporter::Import(Selector FromSel) {
5854 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
5856 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
5913 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
