Lines Matching full:importer
31 ASTImporter &Importer;
34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
110 (IDK == IDK_Default && !Importer.isMinimalImport());
261 ASTImporter &ImporterRef = Importer;
271 ASTImporter &ImporterRef = Importer;
1547 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1556 return Importer.getToContext().SingletonId;
1560 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1573 if (Importer.getToContext().getLangOpts().CharIsSigned)
1574 return Importer.getToContext().UnsignedCharTy;
1576 return Importer.getToContext().CharTy;
1582 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1583 return Importer.getToContext().SignedCharTy;
1585 return Importer.getToContext().CharTy;
1591 return Importer.getToContext().WCharTy;
1598 QualType ToElementType = Importer.Import(T->getElementType());
1602 return Importer.getToContext().getComplexType(ToElementType);
1606 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1610 return Importer.getToContext().getPointerType(ToPointeeType);
1615 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1619 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1625 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1629 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1635 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1639 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1644 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1648 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1649 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1654 QualType ToElementType = Importer.Import(T->getElementType());
1658 return Importer.getToContext().getConstantArrayType(ToElementType,
1666 QualType ToElementType = Importer.Import(T->getElementType());
1670 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1676 QualType ToElementType = Importer.Import(T->getElementType());
1680 Expr *Size = Importer.Import(T->getSizeExpr());
1684 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1685 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1692 QualType ToElementType = Importer.Import(T->getElementType());
1696 return Importer.getToContext().getVectorType(ToElementType,
1702 QualType ToElementType = Importer.Import(T->getElementType());
1706 return Importer.getToContext().getExtVectorType(ToElementType,
1714 QualType ToResultType = Importer.Import(T->getReturnType());
1718 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1723 QualType ToResultType = Importer.Import(T->getReturnType());
1730 QualType ArgType = Importer.Import(A);
1739 QualType ExceptionType = Importer.Import(E);
1756 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1758 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1760 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1762 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1766 QualType ToInnerType = Importer.Import(T->getInnerType());
1770 return Importer.getToContext().getParenType(ToInnerType);
1775 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1779 return Importer.getToContext().getTypeDeclType(ToDecl);
1783 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1787 return Importer.getToContext().getTypeOfExprType(ToExpr);
1791 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1795 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1800 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1804 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1808 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1812 QualType ToBaseType = Importer.Import(T->getBaseType());
1813 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1817 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1827 ToDeduced = Importer.Import(FromDeduced);
1832 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
1838 CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
1842 QualType InjType = Importer.Import(T->getInjectedSpecializationType());
1848 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
1854 return QualType(new (Importer.getToContext(), TypeAlignment)
1860 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1864 return Importer.getToContext().getTagDeclType(ToDecl);
1869 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1873 return Importer.getToContext().getTagDeclType(ToDecl);
1883 ToModifiedType = Importer.Import(FromModifiedType);
1888 ToEquivalentType = Importer.Import(FromEquivalentType);
1893 return Importer.getToContext().getAttributedType(T->getAttrKind(),
1901 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
1905 return Importer.getToContext().getTemplateTypeParmType(
1911 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1922 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1923 ToCanonType =Importer.Import(FromCanonType);
1927 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1936 ToQualifier = Importer.Import(T->getQualifier());
1941 QualType ToNamedType = Importer.Import(T->getNamedType());
1945 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1951 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1955 return Importer.getToContext().getObjCInterfaceType(Class);
1959 QualType ToBaseType = Importer.Import(T->getBaseType());
1965 QualType ImportedTypeArg = Importer.Import(TypeArg);
1975 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1981 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
1988 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1992 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
2004 DC = Importer.ImportContext(D->getDeclContext());
2010 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
2016 Name = Importer.Import(D->getDeclName());
2021 Loc = Importer.Import(D->getLocation());
2022 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
2031 ToD = Importer.Import(FromD);
2070 To.setCXXOperatorNameRange(Importer.Import(Range));
2075 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
2082 To.setNamedTypeInfo(Importer.Import(FromTInfo));
2090 if (Importer.isMinimalImport() && !ForceImport) {
2091 Importer.ImportContext(FromDC);
2096 Importer.Import(From);
2176 QualType T = Importer.Import(Base1.getType());
2182 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2188 new (Importer.getToContext())
2189 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2193 Importer.Import(Base1.getTypeSourceInfo()),
2215 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2232 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2236 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2258 Decl *To = Importer.Import(*P);
2265 return TemplateParameterList::Create(Importer.getToContext(),
2266 Importer.Import(Params->getTemplateLoc()),
2267 Importer.Import(Params->getLAngleLoc()),
2269 Importer.Import(Params->getRAngleLoc()));
2279 QualType ToType = Importer.Import(From.getAsType());
2286 QualType ToType = Importer.Import(From.getIntegralType());
2293 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2294 QualType ToType = Importer.Import(From.getParamTypeForDecl());
2301 QualType ToType = Importer.Import(From.getNullPtrType());
2308 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2317 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2325 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2336 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
2361 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2368 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2370 Importer.getNonEquivalentDecls(),
2378 Importer.getFromContext(), Importer.getToContext(),
2379 Importer.getNonEquivalentDecls(), false, Complain);
2384 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2385 Importer.getToContext(),
2386 Importer.getNonEquivalentDecls());
2403 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2404 Importer.getToContext(),
2405 Importer.getNonEquivalentDecls());
2411 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2412 Importer.getToContext(),
2413 Importer.getNonEquivalentDecls());
2418 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2425 Importer.getToContext().getTranslationUnitDecl();
2427 Importer.Imported(D, ToD);
2434 SourceLocation Loc = Importer.Import(D->getLocation());
2435 SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
2438 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2443 = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(),
2495 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2504 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2506 Importer.Import(D->getLocStart()),
2521 Importer.Imported(D, ToNamespace);
2552 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2554 return Importer.Imported(D, FoundTypedef);
2561 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2570 QualType T = Importer.Import(D->getUnderlyingType());
2575 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2576 SourceLocation StartL = Importer.Import(D->getLocStart());
2579 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2584 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2591 Importer.Imported(D, ToTypedef);
2619 ? LabelDecl::Create(Importer.getToContext(),
2620 DC, Importer.Import(D->getLocation()),
2622 Importer.Import(D->getLocStart()))
2623 : LabelDecl::Create(Importer.getToContext(),
2624 DC, Importer.Import(D->getLocation()),
2626 Importer.Imported(D, ToLabel);
2628 LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2653 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2655 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2675 return Importer.Imported(D, FoundEnum);
2682 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2689 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2690 Importer.Import(D->getLocStart()),
2695 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2698 Importer.Imported(D, D2);
2702 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2720 Decl *ImportedDef = Importer.Import(Definition);
2724 return Importer.Imported(D, ImportedDef);
2741 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2743 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2787 return Importer.Imported(D, FoundDef);
2818 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2826 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2831 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
2832 D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
2837 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
2847 Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
2849 Importer.getToContext().getTypeDeclType(
2852 D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2860 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2864 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2871 Importer.Imported(D, D2);
2890 QualType T = Importer.Import(D->getType());
2908 return Importer.Imported(D, FoundEnumConstant);
2915 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2923 Expr *Init = Importer.Import(D->getInitExpr());
2928 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2933 Importer.Imported(D, ToEnumerator);
2963 if (Importer.IsStructurallyEquivalent(D->getType(),
2966 return Importer.Imported(D, FoundFunction);
2973 if (Importer.getToContext().getLangOpts().CPlusPlus)
2977 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2979 Importer.ToDiag(FoundFunction->getLocation(),
2989 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3015 FromTy = Importer.getFromContext().getFunctionType(
3022 QualType T = Importer.Import(FromTy);
3029 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
3037 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3039 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
3041 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
3053 cast_or_null<CXXCtorInitializer>(Importer.Import(I));
3059 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3066 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
3074 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
3081 Importer.Import(D->getLocEnd()));
3083 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
3090 Importer.Import(D->getLocEnd()));
3092 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
3101 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3107 Importer.Imported(D, ToFunction);
3118 QualType T = Importer.Import(D->getType());
3126 if (Stmt *ToBody = Importer.Import(FromBody)) {
3192 if (Importer.IsStructurallyEquivalent(D->getType(),
3194 Importer.Imported(D, FoundField);
3198 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3200 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3207 QualType T = Importer.Import(D->getType());
3211 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3212 Expr *BitWidth = Importer.Import(D->getBitWidth());
3216 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3217 Importer.Import(D->getInnerLocStart()),
3224 Expr *ToInitializer = Importer.Import(FromInitializer);
3231 Importer.Imported(D, ToField);
3257 if (Importer.IsStructurallyEquivalent(D->getType(),
3260 Importer.Imported(D, FoundField);
3268 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3270 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3277 QualType T = Importer.Import(D->getType());
3282 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3286 Decl *D = Importer.Import(PI);
3293 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3297 ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3301 Importer.Imported(D, ToIndirectField);
3322 if (Importer.IsStructurallyEquivalent(D->getType(),
3324 Importer.Imported(D, FoundIvar);
3328 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3330 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3337 QualType T = Importer.Import(D->getType());
3341 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3342 Expr *BitWidth = Importer.Import(D->getBitWidth());
3346 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3348 Importer.Import(D->getInnerLocStart()),
3353 Importer.Imported(D, ToIvar);
3386 if (Importer.IsStructurallyEquivalent(D->getType(),
3393 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3395 = Importer.getToContext().getAsArrayType(D->getType());
3400 QualType T = Importer.Import(D->getType());
3414 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3416 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3427 Importer.Imported(D, MergeWithVar);
3431 Importer.ToDiag(ExistingDef->getLocation(),
3434 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3436 Expr *Init = Importer.Import(DDef->getInit());
3450 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3459 QualType T = Importer.Import(D->getType());
3464 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3465 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3466 Importer.Import(D->getInnerLocStart()),
3470 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3473 Importer.Imported(D, ToVar);
3490 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3493 DeclarationName Name = Importer.Import(D->getDeclName());
3498 SourceLocation Loc = Importer.Import(D->getLocation());
3501 QualType T = Importer.Import(D->getType());
3507 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3510 return Importer.Imported(D, ToParm);
3516 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3519 DeclarationName Name = Importer.Import(D->getDeclName());
3524 SourceLocation Loc = Importer.Import(D->getLocation());
3527 QualType T = Importer.Import(D->getType());
3532 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3533 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3534 Importer.Import(D->getInnerLocStart()),
3543 return Importer.Imported(D, ToParm);
3565 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3567 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3570 Importer.ToDiag(FoundMethod->getLocation(),
3578 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3581 Importer.ToDiag(FoundMethod->getLocation(),
3591 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3593 Importer.FromDiag((*P)->getLocation(),
3597 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3606 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3608 Importer.ToDiag(FoundMethod->getLocation(),
3615 return Importer.Imported(D, FoundMethod);
3620 QualType ResultTy = Importer.Import(D->getReturnType());
3624 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3627 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3638 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3652 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3655 Importer.Imported(D, ToMethod);
3671 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3676 Importer.getToContext(), DC,
3678 Importer.Import(D->getVarianceLoc()),
3680 Importer.Import(D->getLocation()),
3682 Importer.Import(D->getColonLoc()),
3684 Importer.Imported(D, Result);
3701 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3710 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3711 Importer.Import(D->getAtStartLoc()),
3713 Importer.Import(D->getCategoryNameLoc()),
3717 Importer.Import(D->getIvarLBraceLoc()),
3718 Importer.Import(D->getIvarRBraceLoc()));
3721 Importer.Imported(D, ToCategory);
3737 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3741 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3746 ProtocolLocs.data(), Importer.getToContext());
3749 Importer.Imported(D, ToCategory);
3759 Importer.Import(D->getImplementation()));
3791 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3795 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3800 ProtocolLocs.data(), Importer.getToContext());
3815 Decl *ImportedDef = Importer.Import(Definition);
3819 return Importer.Imported(D, ImportedDef);
3845 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3847 Importer.Import(D->getAtStartLoc()),
3853 Importer.Imported(D, ToProto);
3862 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3863 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3865 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3866 SourceLocation LangLoc = Importer.Import(D->getLocation());
3871 LinkageSpecDecl::Create(Importer.getToContext(),
3879 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3886 Importer.Imported(D, ToLinkageSpec);
3898 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3906 Importer.ToDiag(To->getLocation(),
3910 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3913 Importer.ToDiag(To->getLocation(),
3916 Importer.FromDiag(From->getSuperClassLoc(),
3920 Importer.FromDiag(From->getLocation(),
3934 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3952 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3956 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3961 ProtocolLocs.data(), Importer.getToContext());
3966 Importer.Import(Cat);
3971 Importer.Import(From->getImplementation()));
3993 Importer.Import(fromTypeParam));
4000 return ObjCTypeParamList::create(Importer.getToContext(),
4001 Importer.Import(list->getLAngleLoc()),
4003 Importer.Import(list->getRAngleLoc()));
4012 Decl *ImportedDef = Importer.Import(Definition);
4016 return Importer.Imported(D, ImportedDef);
4044 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
4045 Importer.Import(D->getAtStartLoc()),
4053 Importer.Imported(D, ToIface);
4067 Importer.Import(D->getCategoryDecl()));
4073 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4077 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4078 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
4079 Importer.Import(D->getIdentifier()),
4081 Importer.Import(D->getLocation()),
4082 Importer.Import(D->getAtStartLoc()),
4087 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4098 Importer.Imported(D, ToImpl);
4106 Importer.Import(D->getClassInterface()));
4114 Importer.Import(D->getSuperClass()));
4123 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
4124 Importer.ImportContext(D->getDeclContext()),
4126 Importer.Import(D->getLocation()),
4127 Importer.Import(D->getAtStartLoc()),
4128 Importer.Import(D->getSuperClassLoc()),
4129 Importer.Import(D->getIvarLBraceLoc()),
4130 Importer.Import(D->getIvarRBraceLoc()));
4134 = Importer.ImportContext(D->getLexicalDeclContext());
4142 Importer.Imported(D, Iface->getImplementation());
4144 Importer.Imported(D, Iface->getImplementation());
4152 Importer.ToDiag(Impl->getLocation(),
4158 Importer.ToDiag(Impl->getLocation(),
4162 Importer.ToDiag(Impl->getLocation(),
4165 Importer.FromDiag(D->getLocation(),
4169 Importer.FromDiag(D->getLocation(),
4199 if (!Importer.IsStructurallyEquivalent(D->getType(),
4201 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4203 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4211 Importer.Imported(D, FoundProp);
4217 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4223 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4225 Importer.Import(D->getAtLoc()),
4226 Importer.Import(D->getLParenLoc()),
4227 Importer.Import(D->getType()),
4230 Importer.Imported(D, ToProperty);
4237 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
4238 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
4240 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4242 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4244 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4250 Importer.Import(D->getPropertyDecl()));
4254 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4261 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4274 Importer.Import(D->getPropertyIvarDecl()));
4283 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4284 Importer.Import(D->getLocStart()),
4285 Importer.Import(D->getLocation()),
4289 Importer.Import(D->getPropertyIvarDeclLoc()));
4291 Importer.Imported(D, ToImpl);
4297 Importer.ToDiag(ToImpl->getLocation(),
4302 Importer.FromDiag(D->getLocation(),
4312 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4317 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4324 Importer.Imported(D, ToImpl);
4336 return TemplateTypeParmDecl::Create(Importer.getToContext(),
4337 Importer.getToContext().getTranslationUnitDecl(),
4338 Importer.Import(D->getLocStart()),
4339 Importer.Import(D->getLocation()),
4342 Importer.Import(D->getIdentifier()),
4350 DeclarationName Name = Importer.Import(D->getDeclName());
4355 SourceLocation Loc = Importer.Import(D->getLocation());
4358 QualType T = Importer.Import(D->getType());
4363 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4369 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4370 Importer.getToContext().getTranslationUnitDecl(),
4371 Importer.Import(D->getInnerLocStart()),
4380 DeclarationName Name = Importer.Import(D->getDeclName());
4385 SourceLocation Loc = Importer.Import(D->getLocation());
4395 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4396 Importer.getToContext().getTranslationUnitDecl(),
4411 = Importer.Import(Definition->getDescribedClassTemplate());
4415 return Importer.Imported(D, ImportedDef);
4444 Importer.Imported(D->getTemplatedDecl(),
4446 return Importer.Imported(D, FoundTemplate);
4454 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4468 Importer.Import(DTemplated));
4473 if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
4482 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4493 Importer.Imported(D, D2);
4494 Importer.Imported(DTemplated, D2Templated);
4511 Decl *ImportedDef = Importer.Import(Definition);
4515 return Importer.Imported(D, ImportedDef);
4519 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4531 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4537 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4538 SourceLocation IdLoc = Importer.Import(D->getLocation());
4562 return Importer.Imported(D, FoundDef);
4567 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4579 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4585 Importer.Imported(D, D2);
4601 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4605 return Importer.Imported(D, ImportedDef);
4632 Importer.Imported(D->getTemplatedDecl(),
4634 return Importer.Imported(D, FoundTemplate);
4642 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4653 QualType T = Importer.Import(DTemplated->getType());
4658 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4659 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4660 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4661 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4665 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4668 // Importer.Imported(DTemplated, D2Templated);
4682 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4690 Importer.Imported(D, D2);
4691 Importer.Imported(DTemplated, D2Templated);
4708 Decl *ImportedDef = Importer.Import(Definition);
4712 return Importer.Imported(D, ImportedDef);
4716 Importer.Import(D->getSpecializedTemplate()));
4727 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4733 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4734 SourceLocation IdLoc = Importer.Import(D->getLocation());
4758 return Importer.Imported(D, FoundDef);
4764 QualType T = Importer.Import(D->getType());
4767 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4771 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4780 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4786 Importer.Imported(D, D2);
4800 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4803 auto &_Importer = this->Importer;
4808 return DeclGroupRef::Create(Importer.getToContext(),
4814 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4823 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
4829 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
4838 Importer.Import(S->getClobberStringLiteral(I)));
4847 Importer.Import(S->getOutputConstraintLiteral(I)));
4855 Importer.Import(S->getInputConstraintLiteral(I)));
4870 Importer.Import(S->getAsmString()));
4874 return new (Importer.getToContext()) GCCAsmStmt(
4875 Importer.getToContext(),
4876 Importer.Import(S->getAsmLoc()),
4887 Importer.Import(S->getRParenLoc()));
4896 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4897 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
4898 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
4902 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
4903 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
4913 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
4914 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
4915 return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
4921 Expr *ToLHS = Importer.Import(S->getLHS());
4924 Expr *ToRHS = Importer.Import(S->getRHS());
4927 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
4928 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
4929 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4930 return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
4936 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
4937 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4938 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4941 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
4946 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
4948 cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
4951 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4954 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
4959 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
4962 ASTContext &_ToContext = Importer.getToContext();
4971 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4974 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
4979 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
4980 Stmt *ToInit = Importer.Import(S->getInit());
4986 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4990 Expr *ToCondition = Importer.Import(S->getCond());
4993 Stmt *ToThenStmt = Importer.Import(S->getThen());
4996 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
4997 Stmt *ToElseStmt = Importer.Import(S->getElse());
5000 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5009 Stmt *ToInit = Importer.Import(S->getInit());
5015 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5019 Expr *ToCondition = Importer.Import(S->getCond());
5022 SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
5023 Importer.getToContext(), ToInit,
5025 Stmt *ToBody = Importer.Import(S->getBody());
5029 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5034 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5050 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5054 Expr *ToCondition = Importer.Import(S->getCond());
5057 Stmt *ToBody = Importer.Import(S->getBody());
5060 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5061 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5068 Stmt *ToBody = Importer.Import(S->getBody());
5071 Expr *ToCondition = Importer.Import(S->getCond());
5074 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5075 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5076 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5077 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5083 Stmt *ToInit = Importer.Import(S->getInit());
5086 Expr *ToCondition = Importer.Import(S->getCond());
5092 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5096 Expr *ToInc = Importer.Import(S->getInc());
5099 Stmt *ToBody = Importer.Import(S->getBody());
5102 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5103 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5104 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5105 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5116 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5120 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5121 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5122 return new (Importer.getToContext()) GotoStmt(ToLabel,
5127 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5128 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5129 Expr *ToTarget = Importer.Import(S->getTarget());
5132 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5137 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5138 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5142 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5143 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5147 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5148 Expr *ToRetExpr = Importer.Import(S->getRetValue());
5152 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5155 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5160 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5164 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5168 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5171 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5177 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5178 Stmt *ToTryBlock = Importer
5184 if (Stmt *ToHandler = Importer.Import(FromHandler))
5189 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5195 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5199 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5203 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5206 Expr *ToCond = Importer.Import(S->getCond());
5209 Expr *ToInc = Importer.Import(S->getInc());
5213 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5216 Stmt *ToBody = Importer.Import(S->getBody());
5219 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5220 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5221 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5222 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5223 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5231 Stmt *ToElem = Importer.Import(S->getElement());
5234 Expr *ToCollect = Importer.Import(S->getCollection());
5237 Stmt *ToBody = Importer.Import(S->getBody());
5240 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5241 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5242 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5249 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5250 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5254 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5258 Stmt *ToBody = Importer.Import(S->getCatchBody());
5261 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5268 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5269 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5272 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5277 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5278 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5284 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5289 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5292 return ObjCAtTryStmt::Create(Importer.getToContext(),
5301 Importer.Import(S->getAtSynchronizedLoc());
5302 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5305 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5308 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5313 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5314 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5317 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5322 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5323 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5326 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5334 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5340 QualType T = Importer.Import(E->getType());
5344 Expr *SubExpr = Importer.Import(E->getSubExpr());
5348 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5352 return new (Importer.getToContext()) VAArgExpr(
5353 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5354 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5359 QualType T = Importer.Import(E->getType());
5363 return new (Importer.getToContext()) GNUNullExpr(
5364 T, Importer.Import(E->getExprLoc()));
5368 QualType T = Importer.Import(E->getType());
5373 Importer.Import(E->getFunctionName()));
5377 return new (Importer.getToContext()) PredefinedExpr(
5378 Importer.Import(E->getExprLoc()), T, E->getIdentType(), SL);
5382 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5388 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5393 QualType T = Importer.Import(E->getType());
5397 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5398 Importer.Import(E->getQualifierLoc()),
5399 Importer.Import(E->getTemplateKeywordLoc()),
5402 Importer.Import(E->getLocation()),
5412 QualType T = Importer.Import(E->getType());
5416 return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5422 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5424 return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5425 Importer.Import(D.getFieldLoc()));
5429 Importer.Import(D.getLBracketLoc()),
5430 Importer.Import(D.getRBracketLoc()));
5434 Importer.Import(D.getLBracketLoc()),
5435 Importer.Import(D.getEllipsisLoc()),
5436 Importer.Import(D.getRBracketLoc()));
5441 Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5448 if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5465 Importer.getToContext(), Designators,
5466 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5471 QualType T = Importer.Import(E->getType());
5475 return new (Importer.getToContext())
5476 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5480 QualType T = Importer.Import(E->getType());
5484 return IntegerLiteral::Create(Importer.getToContext(),
5486 Importer.Import(E->getLocation()));
5490 QualType T = Importer.Import(E->getType());
5494 return FloatingLiteral::Create(Importer.getToContext(),
5496 Importer.Import(E->getLocation()));
5500 QualType T = Importer.Import(E->getType());
5504 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5506 Importer.Import(E->getLocation()));
5510 QualType T = Importer.Import(E->getType());
5517 return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5523 QualType T = Importer.Import(E->getType());
5527 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5531 Expr *Init = Importer.Import(E->getInitializer());
5535 return new (Importer.getToContext()) CompoundLiteralExpr(
5536 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5541 QualType T = Importer.Import(E->getType());
5551 return new (Importer.getToContext()) AtomicExpr(
5552 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5553 Importer.Import(E->getRParenLoc()));
5557 QualType T = Importer.Import(E->getType());
5561 LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5565 return new (Importer.getToContext()) AddrLabelExpr(
5566 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5571 Expr *SubExpr = Importer.Import(E->getSubExpr());
5575 return new (Importer.getToContext())
5576 ParenExpr(Importer.Import(E->getLParen()),
5577 Importer.Import(E->getRParen()),
5587 return new (Importer.getToContext()) ParenListExpr(
5588 Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5589 Exprs, Importer.Import(E->getLParenLoc()));
5593 QualType T = Importer.Import(E->getType());
5598 Importer.Import(E->getSubStmt()));
5602 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5603 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5607 QualType T = Importer.Import(E->getType());
5611 Expr *SubExpr = Importer.Import(E->getSubExpr());
5615 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
5618 Importer.Import(E->getOperatorLoc()));
5623 Importer.Import(E->getType());
5626 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5630 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5632 Importer.Import(E->getOperatorLoc()),
5633 Importer.Import(E->getRParenLoc()));
5636 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5640 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5642 Importer.Import(E->getOperatorLoc()),
5643 Importer.Import(E->getRParenLoc()));
5647 QualType T = Importer.Import(E->getType());
5651 Expr *LHS = Importer.Import(E->getLHS());
5655 Expr *RHS = Importer.Import(E->getRHS());
5659 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5662 Importer.Import(E->getOperatorLoc()),
5667 QualType T = Importer.Import(E->getType());
5671 Expr *ToLHS = Importer.Import(E->getLHS());
5675 Expr *ToRHS = Importer.Import(E->getRHS());
5679 Expr *ToCond = Importer.Import(E->getCond());
5683 return new (Importer.getToContext()) ConditionalOperator(
5684 ToCond, Importer.Import(E->getQuestionLoc()),
5685 ToLHS, Importer.Import(E->getColonLoc()),
5691 QualType T = Importer.Import(E->getType());
5695 Expr *Common = Importer.Import(E->getCommon());
5699 Expr *Cond = Importer.Import(E->getCond());
5704 Importer.Import(E->getOpaqueValue()));
5708 Expr *TrueExpr = Importer.Import(E->getTrueExpr());
5712 Expr *FalseExpr = Importer.Import(E->getFalseExpr());
5716 return new (Importer.getToContext()) BinaryConditionalOperator(
5718 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
5723 QualType T = Importer.Import(E->getType());
5727 Expr *SourceExpr = Importer.Import(E->getSourceExpr());
5731 return new (Importer.getToContext()) OpaqueValueExpr(
5732 Importer.Import(E->getExprLoc()), T, E->getValueKind(),
5737 QualType T = Importer.Import(E->getType());
5741 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5745 QualType CompResultType = Importer.Import(E->getComputationResultType());
5749 Expr *LHS = Importer.Import(E->getLHS());
5753 Expr *RHS = Importer.Import(E->getRHS());
5757 return new (Importer.getToContext())
5762 Importer.Import(E->getOperatorLoc()),
5774 QualType T = Importer.Import(E->getType());
5778 Expr *SubExpr = Importer.Import(E->getSubExpr());
5786 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5791 QualType T = Importer.Import(E->getType());
5795 Expr *SubExpr = Importer.Import(E->getSubExpr());
5799 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5807 return CStyleCastExpr::Create(Importer.getToContext(), T,
5810 Importer.Import(E->getLParenLoc()),
5811 Importer.Import(E->getRParenLoc()));
5815 QualType T = Importer.Import(E->getType());
5820 dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
5829 return CXXConstructExpr::Create(Importer.getToContext(), T,
5830 Importer.Import(E->getLocation()),
5837 Importer.Import(E->getParenOrBraceRange()));
5841 QualType T = Importer.Import(E->getType());
5845 Expr *ToFn = Importer.Import(E->getCallee());
5854 return new (Importer.getToContext()) CXXMemberCallExpr(
5855 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
5856 Importer.Import(E->getRParenLoc()));
5860 QualType T = Importer.Import(E->getType());
5864 return new (Importer.getToContext())
5865 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
5869 QualType T = Importer.Import(E->getType());
5873 return new (Importer.getToContext())
5874 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
5879 QualType T = Importer.Import(E->getType());
5883 Expr *ToBase = Importer.Import(E->getBase());
5887 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
5892 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
5896 Importer.Import(E->getMemberNameInfo().getName()),
5897 Importer.Import(E->getMemberNameInfo().getLoc()));
5903 return MemberExpr::Create(Importer.getToContext(), ToBase,
5905 Importer.Import(E->getOperatorLoc()),
5906 Importer.Import(E->getQualifierLoc()),
5907 Importer.Import(E->getTemplateKeywordLoc()),
5914 QualType T = Importer.Import(E->getType());
5918 Expr *ToCallee = Importer.Import(E->getCallee());
5928 Expr *ToArg = Importer.Import(FromArg);
5934 Expr **ToArgs_Copied = new (Importer.getToContext())
5940 return new (Importer.getToContext())
5941 CallExpr(Importer.getToContext(), ToCallee,
5943 Importer.Import(E->getRParenLoc()));
5947 QualType T = Importer.Import(ILE->getType());
5956 ASTContext &ToCtx = Importer.getToContext();
5958 ToCtx, Importer.Import(ILE->getLBraceLoc()),
5959 Exprs, Importer.Import(ILE->getLBraceLoc()));
5963 Expr *Filler = Importer.Import(ILE->getArrayFiller());
5970 FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
5978 Importer.Import(SyntForm));
5993 Importer.Import(DIE->getField()));
5998 Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6002 QualType ToType = Importer.Import(E->getType());
6007 Expr *ToOp = Importer.Import(E->getSubExpr());
6013 TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6014 SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6015 SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6016 SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6020 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6024 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6028 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6061 ASTNodeImporter Importer(*this);
6062 QualType ToT = Importer.Visit(fromTy);
6101 ASTNodeImporter Importer(*this);
6107 Importer.ImportDefinitionIfNeeded(FromD, ToD);
6112 Decl *ToD = Importer.Visit(FromD);
6216 ASTNodeImporter Importer(*this);
6217 Stmt *ToS = Importer.Visit(FromS);
6360 ASTNodeImporter Importer(*this);
6362 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
6512 ASTNodeImporter Importer(*this);
6516 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
6524 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
6532 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
6540 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
6546 Importer.ImportDeclContext(FromDC, true);
