Lines Matching refs:Importer
31 ASTImporter &Importer;
34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
105 (IDK == IDK_Default && !Importer.isMinimalImport());
1425 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1434 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1447 if (Importer.getToContext().getLangOpts().CharIsSigned)
1448 return Importer.getToContext().UnsignedCharTy;
1450 return Importer.getToContext().CharTy;
1456 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1457 return Importer.getToContext().SignedCharTy;
1459 return Importer.getToContext().CharTy;
1465 return Importer.getToContext().WCharTy;
1472 QualType ToElementType = Importer.Import(T->getElementType());
1476 return Importer.getToContext().getComplexType(ToElementType);
1480 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1484 return Importer.getToContext().getPointerType(ToPointeeType);
1489 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1493 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1499 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1503 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1509 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1513 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1518 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1522 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1523 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1528 QualType ToElementType = Importer.Import(T->getElementType());
1532 return Importer.getToContext().getConstantArrayType(ToElementType,
1540 QualType ToElementType = Importer.Import(T->getElementType());
1544 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1550 QualType ToElementType = Importer.Import(T->getElementType());
1554 Expr *Size = Importer.Import(T->getSizeExpr());
1558 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1559 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1566 QualType ToElementType = Importer.Import(T->getElementType());
1570 return Importer.getToContext().getVectorType(ToElementType,
1576 QualType ToElementType = Importer.Import(T->getElementType());
1580 return Importer.getToContext().getExtVectorType(ToElementType,
1588 QualType ToResultType = Importer.Import(T->getReturnType());
1592 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1597 QualType ToResultType = Importer.Import(T->getReturnType());
1604 QualType ArgType = Importer.Import(A);
1613 QualType ExceptionType = Importer.Import(E);
1630 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1632 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1634 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1636 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1640 QualType ToInnerType = Importer.Import(T->getInnerType());
1644 return Importer.getToContext().getParenType(ToInnerType);
1649 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1653 return Importer.getToContext().getTypeDeclType(ToDecl);
1657 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1661 return Importer.getToContext().getTypeOfExprType(ToExpr);
1665 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1669 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1674 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1678 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1682 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1686 QualType ToBaseType = Importer.Import(T->getBaseType());
1687 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1691 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1701 ToDeduced = Importer.Import(FromDeduced);
1706 return Importer.getToContext().getAutoType(ToDeduced, T->isDecltypeAuto(),
1712 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1716 return Importer.getToContext().getTagDeclType(ToDecl);
1721 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1725 return Importer.getToContext().getTagDeclType(ToDecl);
1735 ToModifiedType = Importer.Import(FromModifiedType);
1740 ToEquivalentType = Importer.Import(FromEquivalentType);
1745 return Importer.getToContext().getAttributedType(T->getAttrKind(),
1751 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1762 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1763 ToCanonType =Importer.Import(FromCanonType);
1767 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1777 ToQualifier = Importer.Import(T->getQualifier());
1782 QualType ToNamedType = Importer.Import(T->getNamedType());
1786 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1792 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1796 return Importer.getToContext().getObjCInterfaceType(Class);
1800 QualType ToBaseType = Importer.Import(T->getBaseType());
1807 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1813 return Importer.getToContext().getObjCObjectType(ToBaseType,
1820 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1824 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1835 DC = Importer.ImportContext(D->getDeclContext());
1841 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1847 Name = Importer.Import(D->getDeclName());
1852 Loc = Importer.Import(D->getLocation());
1861 ToD = Importer.Import(FromD);
1900 To.setCXXOperatorNameRange(Importer.Import(Range));
1905 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1912 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1920 if (Importer.isMinimalImport() && !ForceImport) {
1921 Importer.ImportContext(FromDC);
1926 Importer.Import(From);
2001 QualType T = Importer.Import(Base1.getType());
2007 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2013 new (Importer.getToContext())
2014 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2018 Importer.Import(Base1.getTypeSourceInfo()),
2040 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2057 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2061 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2083 Decl *To = Importer.Import(*P);
2090 return TemplateParameterList::Create(Importer.getToContext(),
2091 Importer.Import(Params->getTemplateLoc()),
2092 Importer.Import(Params->getLAngleLoc()),
2094 Importer.Import(Params->getRAngleLoc()));
2104 QualType ToType = Importer.Import(From.getAsType());
2111 QualType ToType = Importer.Import(From.getIntegralType());
2118 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2119 QualType ToType = Importer.Import(From.getParamTypeForDecl());
2126 QualType ToType = Importer.Import(From.getNullPtrType());
2133 Importer.Import(From.getAsTemplate());
2142 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2150 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2161 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2188 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2195 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2197 Importer.getNonEquivalentDecls(),
2205 Importer.getFromContext(), Importer.getToContext(),
2206 Importer.getNonEquivalentDecls(), false, Complain);
2211 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2212 Importer.getToContext(),
2213 Importer.getNonEquivalentDecls());
2230 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2231 Importer.getToContext(),
2232 Importer.getNonEquivalentDecls());
2238 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2239 Importer.getToContext(),
2240 Importer.getNonEquivalentDecls());
2245 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2252 Importer.getToContext().getTranslationUnitDecl();
2254 Importer.Imported(D, ToD);
2294 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2303 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2305 Importer.Import(D->getLocStart()),
2320 Importer.Imported(D, ToNamespace);
2348 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2350 return Importer.Imported(D, FoundTypedef);
2357 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2366 QualType T = Importer.Import(D->getUnderlyingType());
2371 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2372 SourceLocation StartL = Importer.Import(D->getLocStart());
2375 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2380 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2387 Importer.Imported(D, ToTypedef);
2413 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2415 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2435 return Importer.Imported(D, FoundEnum);
2442 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2449 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2450 Importer.Import(D->getLocStart()),
2455 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2458 Importer.Imported(D, D2);
2462 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2480 Decl *ImportedDef = Importer.Import(Definition);
2484 return Importer.Imported(D, ImportedDef);
2498 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2500 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2544 return Importer.Imported(D, FoundDef);
2575 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2583 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2586 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2593 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2597 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2604 Importer.Imported(D, D2);
2620 QualType T = Importer.Import(D->getType());
2638 return Importer.Imported(D, FoundEnumConstant);
2645 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2653 Expr *Init = Importer.Import(D->getInitExpr());
2658 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2663 Importer.Imported(D, ToEnumerator);
2690 if (Importer.IsStructurallyEquivalent(D->getType(),
2693 return Importer.Imported(D, FoundFunction);
2700 if (Importer.getToContext().getLangOpts().CPlusPlus)
2704 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2706 Importer.ToDiag(FoundFunction->getLocation(),
2716 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2742 FromTy = Importer.getFromContext().getFunctionType(
2749 QualType T = Importer.Import(FromTy);
2756 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2764 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2767 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2776 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2784 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2791 Importer.Import(D->getLocEnd()));
2793 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2800 Importer.Import(D->getLocEnd()));
2802 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2811 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2817 Importer.Imported(D, ToFunction);
2828 QualType T = Importer.Import(D->getType());
2892 if (Importer.IsStructurallyEquivalent(D->getType(),
2894 Importer.Imported(D, FoundField);
2898 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2900 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2907 QualType T = Importer.Import(D->getType());
2911 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2912 Expr *BitWidth = Importer.Import(D->getBitWidth());
2916 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2917 Importer.Import(D->getInnerLocStart()),
2926 Importer.Imported(D, ToField);
2949 if (Importer.IsStructurallyEquivalent(D->getType(),
2952 Importer.Imported(D, FoundField);
2960 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2962 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2969 QualType T = Importer.Import(D->getType());
2974 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2978 Decl *D = Importer.Import(PI);
2985 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
2989 ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
2993 Importer.Imported(D, ToIndirectField);
3011 if (Importer.IsStructurallyEquivalent(D->getType(),
3013 Importer.Imported(D, FoundIvar);
3017 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3019 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3026 QualType T = Importer.Import(D->getType());
3030 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3031 Expr *BitWidth = Importer.Import(D->getBitWidth());
3035 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3037 Importer.Import(D->getInnerLocStart()),
3042 Importer.Imported(D, ToIvar);
3072 if (Importer.IsStructurallyEquivalent(D->getType(),
3079 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3081 = Importer.getToContext().getAsArrayType(D->getType());
3086 QualType T = Importer.Import(D->getType());
3100 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3102 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3113 Importer.Imported(D, MergeWithVar);
3117 Importer.ToDiag(ExistingDef->getLocation(),
3120 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3122 Expr *Init = Importer.Import(DDef->getInit());
3136 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3145 QualType T = Importer.Import(D->getType());
3150 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3151 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3152 Importer.Import(D->getInnerLocStart()),
3156 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3159 Importer.Imported(D, ToVar);
3172 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3175 DeclarationName Name = Importer.Import(D->getDeclName());
3180 SourceLocation Loc = Importer.Import(D->getLocation());
3183 QualType T = Importer.Import(D->getType());
3189 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3192 return Importer.Imported(D, ToParm);
3198 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3201 DeclarationName Name = Importer.Import(D->getDeclName());
3206 SourceLocation Loc = Importer.Import(D->getLocation());
3209 QualType T = Importer.Import(D->getType());
3214 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3215 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3216 Importer.Import(D->getInnerLocStart()),
3221 return Importer.Imported(D, ToParm);
3240 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3242 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3245 Importer.ToDiag(FoundMethod->getLocation(),
3253 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3256 Importer.ToDiag(FoundMethod->getLocation(),
3266 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3268 Importer.FromDiag((*P)->getLocation(),
3272 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3281 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3283 Importer.ToDiag(FoundMethod->getLocation(),
3290 return Importer.Imported(D, FoundMethod);
3295 QualType ResultTy = Importer.Import(D->getReturnType());
3299 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3302 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3313 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3327 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3330 Importer.Imported(D, ToMethod);
3344 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3353 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3354 Importer.Import(D->getAtStartLoc()),
3356 Importer.Import(D->getCategoryNameLoc()),
3359 Importer.Import(D->getIvarLBraceLoc()),
3360 Importer.Import(D->getIvarRBraceLoc()));
3363 Importer.Imported(D, ToCategory);
3375 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3379 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3384 ProtocolLocs.data(), Importer.getToContext());
3387 Importer.Imported(D, ToCategory);
3397 Importer.Import(D->getImplementation()));
3429 Importer.Import(*FromProto));
3433 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3438 ProtocolLocs.data(), Importer.getToContext());
3453 Decl *ImportedDef = Importer.Import(Definition);
3457 return Importer.Imported(D, ImportedDef);
3480 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3482 Importer.Import(D->getAtStartLoc()),
3488 Importer.Imported(D, ToProto);
3497 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3498 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3500 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3501 SourceLocation LangLoc = Importer.Import(D->getLocation());
3506 LinkageSpecDecl::Create(Importer.getToContext(),
3514 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3521 Importer.Imported(D, ToLinkageSpec);
3533 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3541 Importer.ToDiag(To->getLocation(),
3545 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3548 Importer.ToDiag(To->getLocation(),
3551 Importer.FromDiag(From->getSuperClassLoc(),
3555 Importer.FromDiag(From->getLocation(),
3570 Importer.Import(From->getSuperClass()));
3575 To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3589 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3593 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3598 ProtocolLocs.data(), Importer.getToContext());
3603 Importer.Import(Cat);
3608 Importer.Import(From->getImplementation()));
3628 Decl *ImportedDef = Importer.Import(Definition);
3632 return Importer.Imported(D, ImportedDef);
3657 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3658 Importer.Import(D->getAtStartLoc()),
3665 Importer.Imported(D, ToIface);
3675 Importer.Import(D->getCategoryDecl()));
3681 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3685 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3686 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3687 Importer.Import(D->getIdentifier()),
3689 Importer.Import(D->getLocation()),
3690 Importer.Import(D->getAtStartLoc()),
3695 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3706 Importer.Imported(D, ToImpl);
3714 Importer.Import(D->getClassInterface()));
3722 Importer.Import(D->getSuperClass()));
3731 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3732 Importer.ImportContext(D->getDeclContext()),
3734 Importer.Import(D->getLocation()),
3735 Importer.Import(D->getAtStartLoc()),
3736 Importer.Import(D->getSuperClassLoc()),
3737 Importer.Import(D->getIvarLBraceLoc()),
3738 Importer.Import(D->getIvarRBraceLoc()));
3742 = Importer.ImportContext(D->getLexicalDeclContext());
3750 Importer.Imported(D, Iface->getImplementation());
3752 Importer.Imported(D, Iface->getImplementation());
3760 Importer.ToDiag(Impl->getLocation(),
3766 Importer.ToDiag(Impl->getLocation(),
3770 Importer.ToDiag(Impl->getLocation(),
3773 Importer.FromDiag(D->getLocation(),
3777 Importer.FromDiag(D->getLocation(),
3804 if (!Importer.IsStructurallyEquivalent(D->getType(),
3806 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3808 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3816 Importer.Imported(D, FoundProp);
3822 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3828 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3830 Importer.Import(D->getAtLoc()),
3831 Importer.Import(D->getLParenLoc()),
3834 Importer.Imported(D, ToProperty);
3841 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3842 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3844 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3846 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3848 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3854 Importer.Import(D->getPropertyDecl()));
3858 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3865 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3878 Importer.Import(D->getPropertyIvarDecl()));
3886 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3887 Importer.Import(D->getLocStart()),
3888 Importer.Import(D->getLocation()),
3892 Importer.Import(D->getPropertyIvarDeclLoc()));
3894 Importer.Imported(D, ToImpl);
3900 Importer.ToDiag(ToImpl->getLocation(),
3905 Importer.FromDiag(D->getLocation(),
3915 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3920 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3927 Importer.Imported(D, ToImpl);
3939 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3940 Importer.getToContext().getTranslationUnitDecl(),
3941 Importer.Import(D->getLocStart()),
3942 Importer.Import(D->getLocation()),
3945 Importer.Import(D->getIdentifier()),
3953 DeclarationName Name = Importer.Import(D->getDeclName());
3958 SourceLocation Loc = Importer.Import(D->getLocation());
3961 QualType T = Importer.Import(D->getType());
3966 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3972 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3973 Importer.getToContext().getTranslationUnitDecl(),
3974 Importer.Import(D->getInnerLocStart()),
3983 DeclarationName Name = Importer.Import(D->getDeclName());
3988 SourceLocation Loc = Importer.Import(D->getLocation());
3998 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3999 Importer.getToContext().getTranslationUnitDecl(),
4014 = Importer.Import(Definition->getDescribedClassTemplate());
4018 return Importer.Imported(D, ImportedDef);
4044 Importer.Imported(D->getTemplatedDecl(),
4046 return Importer.Imported(D, FoundTemplate);
4054 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4066 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4067 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4068 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4073 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4082 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4093 Importer.Imported(D, D2);
4094 Importer.Imported(DTemplated, D2Templated);
4111 Decl *ImportedDef = Importer.Import(Definition);
4115 return Importer.Imported(D, ImportedDef);
4119 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4131 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4137 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4138 SourceLocation IdLoc = Importer.Import(D->getLocation());
4162 return Importer.Imported(D, FoundDef);
4167 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4180 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4186 Importer.Imported(D, D2);
4202 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4206 return Importer.Imported(D, ImportedDef);
4230 Importer.Imported(D->getTemplatedDecl(),
4232 return Importer.Imported(D, FoundTemplate);
4240 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4251 QualType T = Importer.Import(DTemplated->getType());
4256 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4257 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4258 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4259 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4263 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4266 // Importer.Imported(DTemplated, D2Templated);
4280 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4288 Importer.Imported(D, D2);
4289 Importer.Imported(DTemplated, D2Templated);
4306 Decl *ImportedDef = Importer.Import(Definition);
4310 return Importer.Imported(D, ImportedDef);
4314 Importer.Import(D->getSpecializedTemplate()));
4325 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4331 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4332 SourceLocation IdLoc = Importer.Import(D->getLocation());
4356 return Importer.Imported(D, FoundDef);
4362 QualType T = Importer.Import(D->getType());
4365 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4369 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4378 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4384 Importer.Imported(D, D2);
4397 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4406 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4412 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4418 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4423 QualType T = Importer.Import(E->getType());
4427 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4428 Importer.Import(E->getQualifierLoc()),
4429 Importer.Import(E->getTemplateKeywordLoc()),
4432 Importer.Import(E->getLocation()),
4442 QualType T = Importer.Import(E->getType());
4446 return IntegerLiteral::Create(Importer.getToContext(),
4448 Importer.Import(E->getLocation()));
4452 QualType T = Importer.Import(E->getType());
4456 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4458 Importer.Import(E->getLocation()));
4462 Expr *SubExpr = Importer.Import(E->getSubExpr());
4466 return new (Importer.getToContext())
4467 ParenExpr(Importer.Import(E->getLParen()),
4468 Importer.Import(E->getRParen()),
4473 QualType T = Importer.Import(E->getType());
4477 Expr *SubExpr = Importer.Import(E->getSubExpr());
4481 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4484 Importer.Import(E->getOperatorLoc()));
4489 QualType ResultType = Importer.Import(E->getType());
4492 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4496 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4498 Importer.Import(E->getOperatorLoc()),
4499 Importer.Import(E->getRParenLoc()));
4502 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4506 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4508 Importer.Import(E->getOperatorLoc()),
4509 Importer.Import(E->getRParenLoc()));
4513 QualType T = Importer.Import(E->getType());
4517 Expr *LHS = Importer.Import(E->getLHS());
4521 Expr *RHS = Importer.Import(E->getRHS());
4525 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4528 Importer.Import(E->getOperatorLoc()),
4533 QualType T = Importer.Import(E->getType());
4537 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4541 QualType CompResultType = Importer.Import(E->getComputationResultType());
4545 Expr *LHS = Importer.Import(E->getLHS());
4549 Expr *RHS = Importer.Import(E->getRHS());
4553 return new (Importer.getToContext())
4558 Importer.Import(E->getOperatorLoc()),
4570 QualType T = Importer.Import(E->getType());
4574 Expr *SubExpr = Importer.Import(E->getSubExpr());
4582 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4587 QualType T = Importer.Import(E->getType());
4591 Expr *SubExpr = Importer.Import(E->getSubExpr());
4595 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4603 return CStyleCastExpr::Create(Importer.getToContext(), T,
4606 Importer.Import(E->getLParenLoc()),
4607 Importer.Import(E->getRParenLoc()));
4636 ASTNodeImporter Importer(*this);
4637 QualType ToT = Importer.Visit(fromTy);
4665 ASTNodeImporter Importer(*this);
4671 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4676 Decl *ToD = Importer.Visit(FromD);
4780 ASTNodeImporter Importer(*this);
4781 Stmt *ToS = Importer.Visit(FromS);
4924 ASTNodeImporter Importer(*this);
4926 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
5009 ASTNodeImporter Importer(*this);
5013 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
5021 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
5029 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
5037 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
5043 Importer.ImportDeclContext(FromDC, true);
