Lines Matching defs:Importer
31 ASTImporter &Importer;
34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
104 (IDK == IDK_Default && !Importer.isMinimalImport());
1426 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1435 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1448 if (Importer.getToContext().getLangOpts().CharIsSigned)
1449 return Importer.getToContext().UnsignedCharTy;
1451 return Importer.getToContext().CharTy;
1457 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1458 return Importer.getToContext().SignedCharTy;
1460 return Importer.getToContext().CharTy;
1466 return Importer.getToContext().WCharTy;
1473 QualType ToElementType = Importer.Import(T->getElementType());
1477 return Importer.getToContext().getComplexType(ToElementType);
1481 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1485 return Importer.getToContext().getPointerType(ToPointeeType);
1490 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1494 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1500 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1504 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1510 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1514 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1519 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1523 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1524 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1529 QualType ToElementType = Importer.Import(T->getElementType());
1533 return Importer.getToContext().getConstantArrayType(ToElementType,
1541 QualType ToElementType = Importer.Import(T->getElementType());
1545 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1551 QualType ToElementType = Importer.Import(T->getElementType());
1555 Expr *Size = Importer.Import(T->getSizeExpr());
1559 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1560 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1567 QualType ToElementType = Importer.Import(T->getElementType());
1571 return Importer.getToContext().getVectorType(ToElementType,
1577 QualType ToElementType = Importer.Import(T->getElementType());
1581 return Importer.getToContext().getExtVectorType(ToElementType,
1589 QualType ToResultType = Importer.Import(T->getResultType());
1593 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1598 QualType ToResultType = Importer.Import(T->getResultType());
1607 QualType ArgType = Importer.Import(*A);
1618 QualType ExceptionType = Importer.Import(*E);
1636 ToEPI.NoexceptExpr = Importer.Import(FromEPI.NoexceptExpr);
1638 Importer.Import(FromEPI.ExceptionSpecDecl));
1640 Importer.Import(FromEPI.ExceptionSpecTemplate));
1642 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1646 QualType ToInnerType = Importer.Import(T->getInnerType());
1650 return Importer.getToContext().getParenType(ToInnerType);
1655 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1659 return Importer.getToContext().getTypeDeclType(ToDecl);
1663 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1667 return Importer.getToContext().getTypeOfExprType(ToExpr);
1671 QualType ToUnderlyingType = Importer
1675 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1680 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1684 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1688 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1692 QualType ToBaseType = Importer.Import(T->getBaseType());
1693 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1697 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1707 ToDeduced = Importer.Import(FromDeduced);
1712 return Importer.getToContext().getAutoType(ToDeduced, T->isDecltypeAuto());
1717 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1721 return Importer.getToContext().getTagDeclType(ToDecl);
1726 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1730 return Importer.getToContext().getTagDeclType(ToDecl);
1735 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1746 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1747 ToCanonType =Importer.Import(FromCanonType);
1751 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1761 ToQualifier = Importer.Import(T->getQualifier());
1766 QualType ToNamedType = Importer.Import(T->getNamedType());
1770 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1776 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1780 return Importer.getToContext().getObjCInterfaceType(Class);
1784 QualType ToBaseType = Importer.Import(T->getBaseType());
1793 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
1799 return Importer.getToContext().getObjCObjectType(ToBaseType,
1806 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1810 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1821 DC = Importer.ImportContext(D->getDeclContext());
1827 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1833 Name = Importer.Import(D->getDeclName());
1838 Loc = Importer.Import(D->getLocation());
1847 ToD = Importer.Import(FromD);
1886 To.setCXXOperatorNameRange(Importer.Import(Range));
1891 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1898 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1906 if (Importer.isMinimalImport() && !ForceImport) {
1907 Importer.ImportContext(FromDC);
1915 Importer.Import(*From);
1996 QualType T = Importer.Import(Base1->getType());
2002 EllipsisLoc = Importer.Import(Base1->getEllipsisLoc());
2008 new (Importer.getToContext())
2009 CXXBaseSpecifier(Importer.Import(Base1->getSourceRange()),
2013 Importer.Import(Base1->getTypeSourceInfo()),
2035 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2052 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2056 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2078 Decl *To = Importer.Import(*P);
2085 return TemplateParameterList::Create(Importer.getToContext(),
2086 Importer.Import(Params->getTemplateLoc()),
2087 Importer.Import(Params->getLAngleLoc()),
2089 Importer.Import(Params->getRAngleLoc()));
2099 QualType ToType = Importer.Import(From.getAsType());
2106 QualType ToType = Importer.Import(From.getIntegralType());
2114 if (ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(FromD)))
2120 QualType ToType = Importer.Import(From.getNullPtrType());
2127 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2136 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2144 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2155 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2180 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2181 Importer.getToContext(),
2182 Importer.getNonEquivalentDecls(),
2190 Importer.getFromContext(), Importer.getToContext(),
2191 Importer.getNonEquivalentDecls(), false, Complain);
2196 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2197 Importer.getToContext(),
2198 Importer.getNonEquivalentDecls());
2215 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2216 Importer.getToContext(),
2217 Importer.getNonEquivalentDecls());
2223 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2224 Importer.getToContext(),
2225 Importer.getNonEquivalentDecls());
2230 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2237 Importer.getToContext().getTranslationUnitDecl();
2239 Importer.Imported(D, ToD);
2279 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2288 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2290 Importer.Import(D->getLocStart()),
2305 Importer.Imported(D, ToNamespace);
2333 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2335 return Importer.Imported(D, FoundTypedef);
2342 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2351 QualType T = Importer.Import(D->getUnderlyingType());
2356 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2357 SourceLocation StartL = Importer.Import(D->getLocStart());
2360 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2365 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2372 Importer.Imported(D, ToTypedef);
2398 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2400 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2420 return Importer.Imported(D, FoundEnum);
2427 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2434 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2435 Importer.Import(D->getLocStart()),
2440 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2443 Importer.Imported(D, D2);
2447 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2465 Decl *ImportedDef = Importer.Import(Definition);
2469 return Importer.Imported(D, ImportedDef);
2483 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2485 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2529 return Importer.Imported(D, FoundDef);
2545 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2553 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2556 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2563 D2 = RecordDecl::Create(Importer
2567 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2574 Importer.Imported(D, D2);
2590 QualType T = Importer.Import(D->getType());
2608 return Importer.Imported(D, FoundEnumConstant);
2615 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2623 Expr *Init = Importer.Import(D->getInitExpr());
2628 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2633 Importer.Imported(D, ToEnumerator);
2660 if (Importer.IsStructurallyEquivalent(D->getType(),
2663 return Importer.Imported(D, FoundFunction);
2670 if (Importer.getToContext().getLangOpts().CPlusPlus)
2674 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2676 Importer.ToDiag(FoundFunction->getLocation(),
2686 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2711 FromTy = Importer.getFromContext().getFunctionType(
2718 QualType T = Importer.Import(FromTy);
2726 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*P));
2734 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2737 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2746 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2754 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2761 Importer.Import(D->getLocEnd()));
2763 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2770 Importer.Import(D->getLocEnd()));
2772 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2781 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2787 Importer.Imported(D, ToFunction);
2798 QualType T = Importer.Import(D->getType());
2864 if (Importer.IsStructurallyEquivalent(D->getType(),
2866 Importer.Imported(D, FoundField);
2870 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2872 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2879 QualType T = Importer.Import(D->getType());
2883 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2884 Expr *BitWidth = Importer.Import(D->getBitWidth());
2888 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2889 Importer.Import(D->getInnerLocStart()),
2898 Importer.Imported(D, ToField);
2921 if (Importer.IsStructurallyEquivalent(D->getType(),
2924 Importer.Imported(D, FoundField);
2932 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2934 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2941 QualType T = Importer.Import(D->getType());
2946 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2951 Decl* D = Importer.Import(*PI);
2958 Importer.getToContext(), DC,
2963 Importer.Imported(D, ToIndirectField);
2981 if (Importer.IsStructurallyEquivalent(D->getType(),
2983 Importer.Imported(D, FoundIvar);
2987 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
2989 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
2996 QualType T = Importer.Import(D->getType());
3000 TypeSourceInfo *TInfo = Importer
3001 Expr *BitWidth = Importer.Import(D->getBitWidth());
3005 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3007 Importer.Import(D->getInnerLocStart()),
3012 Importer.Imported(D, ToIvar);
3042 if (Importer.IsStructurallyEquivalent(D->getType(),
3049 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3051 = Importer.getToContext().getAsArrayType(D->getType());
3056 QualType T = Importer.Import(D->getType());
3070 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3072 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3083 Importer.Imported(D, MergeWithVar);
3087 Importer.ToDiag(ExistingDef->getLocation(),
3090 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3092 Expr *Init = Importer.Import(DDef->getInit());
3106 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3115 QualType T = Importer.Import(D->getType());
3120 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3121 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3122 Importer.Import(D->getInnerLocStart()),
3126 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3129 Importer.Imported(D, ToVar);
3142 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3145 DeclarationName Name = Importer.Import(D->getDeclName());
3150 SourceLocation Loc = Importer.Import(D->getLocation());
3153 QualType T = Importer.Import(D->getType());
3159 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3162 return Importer.Imported(D, ToParm);
3168 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3171 DeclarationName Name = Importer.Import(D->getDeclName());
3176 SourceLocation Loc = Importer.Import(D->getLocation());
3179 QualType T = Importer.Import(D->getType());
3184 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3185 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3186 Importer.Import(D->getInnerLocStart()),
3191 return Importer.Imported(D, ToParm);
3210 if (!Importer.IsStructurallyEquivalent(D->getResultType(),
3212 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3215 Importer.ToDiag(FoundMethod->getLocation(),
3223 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3226 Importer.ToDiag(FoundMethod->getLocation(),
3236 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3238 Importer.FromDiag((*P)->getLocation(),
3242 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3251 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3253 Importer.ToDiag(FoundMethod->getLocation(),
3260 return Importer.Imported(D, FoundMethod);
3265 QualType ResultTy = Importer.Import(D->getResultType());
3269 TypeSourceInfo *ResultTInfo = Importer.Import(D->getResultTypeSourceInfo());
3272 = ObjCMethodDecl::Create(Importer.getToContext(),
3274 Importer.Import(D->getLocEnd()),
3294 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*FromP));
3308 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3311 Importer.Imported(D, ToMethod);
3325 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3334 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3335 Importer.Import(D->getAtStartLoc()),
3337 Importer.Import(D->getCategoryNameLoc()),
3340 Importer.Import(D->getIvarLBraceLoc()),
3341 Importer.Import(D->getIvarRBraceLoc()));
3344 Importer.Imported(D, ToCategory);
3356 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3360 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3365 ProtocolLocs.data(), Importer.getToContext());
3368 Importer.Imported(D, ToCategory);
3378 Importer.Import(D->getImplementation()));
3410 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3414 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3419 ProtocolLocs.data(), Importer.getToContext());
3434 Decl *ImportedDef = Importer.Import(Definition);
3438 return Importer.Imported(D, ImportedDef);
3461 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3463 Importer.Import(D->getAtStartLoc()),
3469 Importer.Imported(D, ToProto);
3484 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3492 Importer.ToDiag(To->getLocation(),
3496 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3499 Importer.ToDiag(To->getLocation(),
3502 Importer.FromDiag(From->getSuperClassLoc(),
3506 Importer.FromDiag(From->getLocation(),
3521 Importer.Import(From->getSuperClass()));
3526 To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3540 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3544 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3549 ProtocolLocs.data(), Importer.getToContext());
3557 Importer.Import(*Cat);
3563 Importer.Import(From->getImplementation()));
3583 Decl *ImportedDef = Importer.Import(Definition);
3587 return Importer.Imported(D, ImportedDef);
3612 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3613 Importer.Import(D->getAtStartLoc()),
3620 Importer.Imported(D, ToIface);
3630 Importer.Import(D->getCategoryDecl()));
3636 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3640 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3641 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3642 Importer.Import(D->getIdentifier()),
3644 Importer.Import(D->getLocation()),
3645 Importer.Import(D->getAtStartLoc()),
3650 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3661 Importer.Imported(D, ToImpl);
3669 Importer.Import(D->getClassInterface()));
3677 Importer.Import(D->getSuperClass()));
3686 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3687 Importer.ImportContext(D->getDeclContext()),
3689 Importer.Import(D->getLocation()),
3690 Importer.Import(D->getAtStartLoc()),
3691 Importer.Import(D->getSuperClassLoc()),
3692 Importer.Import(D->getIvarLBraceLoc()),
3693 Importer.Import(D->getIvarRBraceLoc()));
3697 = Importer.ImportContext(D->getLexicalDeclContext());
3705 Importer.Imported(D, Iface->getImplementation());
3707 Importer.Imported(D, Iface->getImplementation());
3714 Importer.ToDiag(Impl->getLocation(),
3720 Importer.ToDiag(Impl->getLocation(),
3724 Importer.ToDiag(Impl->getLocation(),
3727 Importer.FromDiag(D->getLocation(),
3731 Importer.FromDiag(D->getLocation(),
3758 if (!Importer.IsStructurallyEquivalent(D->getType(),
3760 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3762 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3770 Importer.Imported(D, FoundProp);
3776 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3782 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3784 Importer.Import(D->getAtLoc()),
3785 Importer.Import(D->getLParenLoc()),
3788 Importer.Imported(D, ToProperty);
3795 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3796 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3798 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3800 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3802 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3808 Importer.Import(D->getPropertyDecl()));
3812 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3819 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3832 Importer.Import(D->getPropertyIvarDecl()));
3840 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3841 Importer.Import(D->getLocStart()),
3842 Importer.Import(D->getLocation()),
3846 Importer.Import(D->getPropertyIvarDeclLoc()));
3848 Importer.Imported(D, ToImpl);
3854 Importer.ToDiag(ToImpl->getLocation(),
3859 Importer.FromDiag(D->getLocation(),
3869 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3874 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3881 Importer.Imported(D, ToImpl);
3893 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3894 Importer.getToContext().getTranslationUnitDecl(),
3895 Importer.Import(D->getLocStart()),
3896 Importer.Import(D->getLocation()),
3899 Importer.Import(D->getIdentifier()),
3907 DeclarationName Name = Importer.Import(D->getDeclName());
3912 SourceLocation Loc = Importer.Import(D->getLocation());
3915 QualType T = Importer.Import(D->getType());
3920 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3926 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3927 Importer.getToContext().getTranslationUnitDecl(),
3928 Importer.Import(D->getInnerLocStart()),
3937 DeclarationName Name = Importer.Import(D->getDeclName());
3942 SourceLocation Loc = Importer.Import(D->getLocation());
3952 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3953 Importer.getToContext().getTranslationUnitDecl(),
3968 = Importer.Import(Definition->getDescribedClassTemplate());
3972 return Importer.Imported(D, ImportedDef);
3998 Importer.Imported(D->getTemplatedDecl(),
4000 return Importer.Imported(D, FoundTemplate);
4008 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4020 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4021 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4022 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4027 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4036 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4047 Importer.Imported(D, D2);
4048 Importer.Imported(DTemplated, D2Templated);
4065 Decl *ImportedDef = Importer.Import(Definition);
4069 return Importer.Imported(D, ImportedDef);
4073 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4085 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4091 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4092 SourceLocation IdLoc = Importer.Import(D->getLocation());
4117 return Importer.Imported(D, FoundDef);
4122 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4135 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4141 Importer.Imported(D, D2);
4157 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4161 return Importer.Imported(D, ImportedDef);
4185 Importer.Imported(D->getTemplatedDecl(),
4187 return Importer.Imported(D, FoundTemplate);
4195 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4206 QualType T = Importer.Import(DTemplated->getType());
4211 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4212 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4213 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4214 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4218 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4221 // Importer.Imported(DTemplated, D2Templated);
4235 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated,
4244 Importer.Imported(D, D2);
4245 Importer.Imported(DTemplated, D2Templated);
4262 Decl *ImportedDef = Importer.Import(Definition);
4266 return Importer.Imported(D, ImportedDef);
4270 Importer.Import(D->getSpecializedTemplate()));
4281 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4287 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4288 SourceLocation IdLoc = Importer.Import(D->getLocation());
4312 return Importer.Imported(D, FoundDef);
4318 QualType T = Importer.Import(D->getType());
4321 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4325 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4334 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4340 Importer.Imported(D, D2);
4353 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4362 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4368 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4374 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4379 QualType T = Importer.Import(E->getType());
4383 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4384 Importer.Import(E->getQualifierLoc()),
4385 Importer.Import(E->getTemplateKeywordLoc()),
4388 Importer.Import(E->getLocation()),
4398 QualType T = Importer.Import(E->getType());
4402 return IntegerLiteral::Create(Importer.getToContext(),
4404 Importer.Import(E->getLocation()));
4408 QualType T = Importer.Import(E->getType());
4412 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4414 Importer.Import(E->getLocation()));
4418 Expr *SubExpr = Importer.Import(E->getSubExpr());
4422 return new (Importer.getToContext())
4423 ParenExpr(Importer.Import(E->getLParen()),
4424 Importer.Import(E->getRParen()),
4429 QualType T = Importer.Import(E->getType());
4433 Expr *SubExpr = Importer.Import(E->getSubExpr());
4437 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4440 Importer.Import(E->getOperatorLoc()));
4445 QualType ResultType = Importer.Import(E->getType());
4448 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4452 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4454 Importer.Import(E->getOperatorLoc()),
4455 Importer.Import(E->getRParenLoc()));
4458 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4462 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4464 Importer.Import(E->getOperatorLoc()),
4465 Importer.Import(E->getRParenLoc()));
4469 QualType T = Importer.Import(E->getType());
4473 Expr *LHS = Importer.Import(E->getLHS());
4477 Expr *RHS = Importer.Import(E->getRHS());
4481 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4484 Importer.Import(E->getOperatorLoc()),
4489 QualType T = Importer.Import(E->getType());
4493 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4497 QualType CompResultType = Importer.Import(E->getComputationResultType());
4501 Expr *LHS = Importer.Import(E->getLHS());
4505 Expr *RHS = Importer.Import(E->getRHS());
4509 return new (Importer.getToContext())
4514 Importer.Import(E->getOperatorLoc()),
4526 QualType T = Importer.Import(E->getType());
4530 Expr *SubExpr = Importer.Import(E->getSubExpr());
4538 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4543 QualType T = Importer.Import(E->getType());
4547 Expr *SubExpr = Importer.Import(E->getSubExpr());
4551 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4559 return CStyleCastExpr::Create(Importer.getToContext(), T,
4562 Importer.Import(E->getLParenLoc()),
4563 Importer.Import(E->getRParenLoc()));
4592 ASTNodeImporter Importer(*this);
4593 QualType ToT = Importer.Visit(fromTy);
4621 ASTNodeImporter Importer(*this);
4627 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4632 Decl *ToD = Importer.Visit(FromD);
4736 ASTNodeImporter Importer(*this);
4737 Stmt *ToS = Importer.Visit(FromS);
4873 ASTNodeImporter Importer(*this);
4875 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4953 ASTNodeImporter Importer(*this);
4957 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4965 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4973 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
4981 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
4987 Importer.ImportDeclContext(FromDC, true);
