Lines Matching refs:Importer
31 ASTImporter &Importer;
34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
105 (IDK == IDK_Default && !Importer.isMinimalImport());
1476 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1485 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1498 if (Importer.getToContext().getLangOpts().CharIsSigned)
1499 return Importer.getToContext().UnsignedCharTy;
1501 return Importer.getToContext().CharTy;
1507 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1508 return Importer.getToContext().SignedCharTy;
1510 return Importer.getToContext().CharTy;
1516 return Importer.getToContext().WCharTy;
1523 QualType ToElementType = Importer.Import(T->getElementType());
1527 return Importer.getToContext().getComplexType(ToElementType);
1531 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1535 return Importer.getToContext().getPointerType(ToPointeeType);
1540 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1544 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1550 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1554 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1560 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1564 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1569 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1573 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1574 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1579 QualType ToElementType = Importer.Import(T->getElementType());
1583 return Importer.getToContext().getConstantArrayType(ToElementType,
1591 QualType ToElementType = Importer.Import(T->getElementType());
1595 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1601 QualType ToElementType = Importer.Import(T->getElementType());
1605 Expr *Size = Importer.Import(T->getSizeExpr());
1609 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1610 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1617 QualType ToElementType = Importer.Import(T->getElementType());
1621 return Importer.getToContext().getVectorType(ToElementType,
1627 QualType ToElementType = Importer.Import(T->getElementType());
1631 return Importer.getToContext().getExtVectorType(ToElementType,
1639 QualType ToResultType = Importer.Import(T->getReturnType());
1643 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1648 QualType ToResultType = Importer.Import(T->getReturnType());
1655 QualType ArgType = Importer.Import(A);
1664 QualType ExceptionType = Importer.Import(E);
1681 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1683 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1685 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1687 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1691 QualType ToInnerType = Importer.Import(T->getInnerType());
1695 return Importer.getToContext().getParenType(ToInnerType);
1700 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1704 return Importer.getToContext().getTypeDeclType(ToDecl);
1708 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1712 return Importer.getToContext().getTypeOfExprType(ToExpr);
1716 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1720 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1725 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1729 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1733 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1737 QualType ToBaseType = Importer.Import(T->getBaseType());
1738 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1742 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1752 ToDeduced = Importer.Import(FromDeduced);
1757 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
1763 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1767 return Importer.getToContext().getTagDeclType(ToDecl);
1772 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1776 return Importer.getToContext().getTagDeclType(ToDecl);
1786 ToModifiedType = Importer.Import(FromModifiedType);
1791 ToEquivalentType = Importer.Import(FromEquivalentType);
1796 return Importer.getToContext().getAttributedType(T->getAttrKind(),
1802 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1813 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1814 ToCanonType =Importer.Import(FromCanonType);
1818 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1828 ToQualifier = Importer.Import(T->getQualifier());
1833 QualType ToNamedType = Importer.Import(T->getNamedType());
1837 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1843 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1847 return Importer.getToContext().getObjCInterfaceType(Class);
1851 QualType ToBaseType = Importer.Import(T->getBaseType());
1857 QualType ImportedTypeArg = Importer.Import(TypeArg);
1867 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1873 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
1880 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1884 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1896 DC = Importer.ImportContext(D->getDeclContext());
1902 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1908 Name = Importer.Import(D->getDeclName());
1913 Loc = Importer.Import(D->getLocation());
1914 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1923 ToD = Importer.Import(FromD);
1962 To.setCXXOperatorNameRange(Importer.Import(Range));
1967 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1974 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1982 if (Importer.isMinimalImport() && !ForceImport) {
1983 Importer.ImportContext(FromDC);
1988 Importer.Import(From);
2063 QualType T = Importer.Import(Base1.getType());
2069 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2075 new (Importer.getToContext())
2076 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2080 Importer.Import(Base1.getTypeSourceInfo()),
2102 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2119 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2123 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2145 Decl *To = Importer.Import(*P);
2152 return TemplateParameterList::Create(Importer.getToContext(),
2153 Importer.Import(Params->getTemplateLoc()),
2154 Importer.Import(Params->getLAngleLoc()),
2156 Importer.Import(Params->getRAngleLoc()));
2166 QualType ToType = Importer.Import(From.getAsType());
2173 QualType ToType = Importer.Import(From.getIntegralType());
2180 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2181 QualType ToType = Importer.Import(From.getParamTypeForDecl());
2188 QualType ToType = Importer.Import(From.getNullPtrType());
2195 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2204 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2212 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2223 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
2248 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2255 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2257 Importer.getNonEquivalentDecls(),
2265 Importer.getFromContext(), Importer.getToContext(),
2266 Importer.getNonEquivalentDecls(), false, Complain);
2271 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2272 Importer.getToContext(),
2273 Importer.getNonEquivalentDecls());
2290 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2291 Importer.getToContext(),
2292 Importer.getNonEquivalentDecls());
2298 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2299 Importer.getToContext(),
2300 Importer.getNonEquivalentDecls());
2305 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2312 Importer.getToContext().getTranslationUnitDecl();
2314 Importer.Imported(D, ToD);
2357 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2366 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2368 Importer.Import(D->getLocStart()),
2383 Importer.Imported(D, ToNamespace);
2414 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2416 return Importer.Imported(D, FoundTypedef);
2423 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2432 QualType T = Importer.Import(D->getUnderlyingType());
2437 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2438 SourceLocation StartL = Importer.Import(D->getLocStart());
2441 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2446 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2453 Importer.Imported(D, ToTypedef);
2482 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2484 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2504 return Importer.Imported(D, FoundEnum);
2511 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2518 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2519 Importer.Import(D->getLocStart()),
2524 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2527 Importer.Imported(D, D2);
2531 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2549 Decl *ImportedDef = Importer.Import(Definition);
2553 return Importer.Imported(D, ImportedDef);
2570 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2572 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2616 return Importer.Imported(D, FoundDef);
2647 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2655 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2658 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2665 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2669 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2676 Importer.Imported(D, D2);
2695 QualType T = Importer.Import(D->getType());
2713 return Importer.Imported(D, FoundEnumConstant);
2720 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2728 Expr *Init = Importer.Import(D->getInitExpr());
2733 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2738 Importer.Imported(D, ToEnumerator);
2768 if (Importer.IsStructurallyEquivalent(D->getType(),
2771 return Importer.Imported(D, FoundFunction);
2778 if (Importer.getToContext().getLangOpts().CPlusPlus)
2782 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2784 Importer.ToDiag(FoundFunction->getLocation(),
2794 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2820 FromTy = Importer.getFromContext().getFunctionType(
2827 QualType T = Importer.Import(FromTy);
2834 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2842 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2844 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
2846 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2855 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2863 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2870 Importer.Import(D->getLocEnd()));
2872 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2879 Importer.Import(D->getLocEnd()));
2881 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2890 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2896 Importer.Imported(D, ToFunction);
2907 QualType T = Importer.Import(D->getType());
2915 if (Stmt *ToBody = Importer.Import(FromBody)) {
2981 if (Importer.IsStructurallyEquivalent(D->getType(),
2983 Importer.Imported(D, FoundField);
2987 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2989 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2996 QualType T = Importer.Import(D->getType());
3000 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3001 Expr *BitWidth = Importer.Import(D->getBitWidth());
3005 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3006 Importer.Import(D->getInnerLocStart()),
3015 Importer.Imported(D, ToField);
3041 if (Importer.IsStructurallyEquivalent(D->getType(),
3044 Importer.Imported(D, FoundField);
3052 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3054 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3061 QualType T = Importer.Import(D->getType());
3066 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3070 Decl *D = Importer.Import(PI);
3077 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3081 ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3085 Importer.Imported(D, ToIndirectField);
3106 if (Importer.IsStructurallyEquivalent(D->getType(),
3108 Importer.Imported(D, FoundIvar);
3112 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3114 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3121 QualType T = Importer.Import(D->getType());
3125 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3126 Expr *BitWidth = Importer.Import(D->getBitWidth());
3130 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3132 Importer.Import(D->getInnerLocStart()),
3137 Importer.Imported(D, ToIvar);
3170 if (Importer.IsStructurallyEquivalent(D->getType(),
3177 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3179 = Importer.getToContext().getAsArrayType(D->getType());
3184 QualType T = Importer.Import(D->getType());
3198 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3200 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3211 Importer.Imported(D, MergeWithVar);
3215 Importer.ToDiag(ExistingDef->getLocation(),
3218 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3220 Expr *Init = Importer.Import(DDef->getInit());
3234 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3243 QualType T = Importer.Import(D->getType());
3248 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3249 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3250 Importer.Import(D->getInnerLocStart()),
3254 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3257 Importer.Imported(D, ToVar);
3274 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3277 DeclarationName Name = Importer.Import(D->getDeclName());
3282 SourceLocation Loc = Importer.Import(D->getLocation());
3285 QualType T = Importer.Import(D->getType());
3291 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3294 return Importer.Imported(D, ToParm);
3300 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3303 DeclarationName Name = Importer.Import(D->getDeclName());
3308 SourceLocation Loc = Importer.Import(D->getLocation());
3311 QualType T = Importer.Import(D->getType());
3316 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3317 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3318 Importer.Import(D->getInnerLocStart()),
3327 return Importer.Imported(D, ToParm);
3349 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3351 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3354 Importer.ToDiag(FoundMethod->getLocation(),
3362 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3365 Importer.ToDiag(FoundMethod->getLocation(),
3375 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3377 Importer.FromDiag((*P)->getLocation(),
3381 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3390 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3392 Importer.ToDiag(FoundMethod->getLocation(),
3399 return Importer.Imported(D, FoundMethod);
3404 QualType ResultTy = Importer.Import(D->getReturnType());
3408 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3411 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3422 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3436 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3439 Importer.Imported(D, ToMethod);
3455 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3460 Importer.getToContext(), DC,
3462 Importer.Import(D->getVarianceLoc()),
3464 Importer.Import(D->getLocation()),
3466 Importer.Import(D->getColonLoc()),
3468 Importer.Imported(D, Result);
3485 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3494 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3495 Importer.Import(D->getAtStartLoc()),
3497 Importer.Import(D->getCategoryNameLoc()),
3501 Importer.Import(D->getIvarLBraceLoc()),
3502 Importer.Import(D->getIvarRBraceLoc()));
3505 Importer.Imported(D, ToCategory);
3521 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3525 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3530 ProtocolLocs.data(), Importer.getToContext());
3533 Importer.Imported(D, ToCategory);
3543 Importer.Import(D->getImplementation()));
3575 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3579 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3584 ProtocolLocs.data(), Importer.getToContext());
3599 Decl *ImportedDef = Importer.Import(Definition);
3603 return Importer.Imported(D, ImportedDef);
3629 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3631 Importer.Import(D->getAtStartLoc()),
3637 Importer.Imported(D, ToProto);
3646 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3647 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3649 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3650 SourceLocation LangLoc = Importer.Import(D->getLocation());
3655 LinkageSpecDecl::Create(Importer.getToContext(),
3663 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3670 Importer.Imported(D, ToLinkageSpec);
3682 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3690 Importer.ToDiag(To->getLocation(),
3694 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3697 Importer.ToDiag(To->getLocation(),
3700 Importer.FromDiag(From->getSuperClassLoc(),
3704 Importer.FromDiag(From->getLocation(),
3718 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3736 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3740 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3745 ProtocolLocs.data(), Importer.getToContext());
3750 Importer.Import(Cat);
3755 Importer.Import(From->getImplementation()));
3777 Importer.Import(fromTypeParam));
3784 return ObjCTypeParamList::create(Importer.getToContext(),
3785 Importer.Import(list->getLAngleLoc()),
3787 Importer.Import(list->getRAngleLoc()));
3796 Decl *ImportedDef = Importer.Import(Definition);
3800 return Importer.Imported(D, ImportedDef);
3828 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3829 Importer.Import(D->getAtStartLoc()),
3837 Importer.Imported(D, ToIface);
3851 Importer.Import(D->getCategoryDecl()));
3857 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3861 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3862 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3863 Importer.Import(D->getIdentifier()),
3865 Importer.Import(D->getLocation()),
3866 Importer.Import(D->getAtStartLoc()),
3871 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3882 Importer.Imported(D, ToImpl);
3890 Importer.Import(D->getClassInterface()));
3898 Importer.Import(D->getSuperClass()));
3907 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3908 Importer.ImportContext(D->getDeclContext()),
3910 Importer.Import(D->getLocation()),
3911 Importer.Import(D->getAtStartLoc()),
3912 Importer.Import(D->getSuperClassLoc()),
3913 Importer.Import(D->getIvarLBraceLoc()),
3914 Importer.Import(D->getIvarRBraceLoc()));
3918 = Importer.ImportContext(D->getLexicalDeclContext());
3926 Importer.Imported(D, Iface->getImplementation());
3928 Importer.Imported(D, Iface->getImplementation());
3936 Importer.ToDiag(Impl->getLocation(),
3942 Importer.ToDiag(Impl->getLocation(),
3946 Importer.ToDiag(Impl->getLocation(),
3949 Importer.FromDiag(D->getLocation(),
3953 Importer.FromDiag(D->getLocation(),
3983 if (!Importer.IsStructurallyEquivalent(D->getType(),
3985 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3987 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3995 Importer.Imported(D, FoundProp);
4001 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4007 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4009 Importer.Import(D->getAtLoc()),
4010 Importer.Import(D->getLParenLoc()),
4011 Importer.Import(D->getType()),
4014 Importer.Imported(D, ToProperty);
4021 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
4022 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
4024 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4026 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4028 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4034 Importer.Import(D->getPropertyDecl()));
4038 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4045 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4058 Importer.Import(D->getPropertyIvarDecl()));
4066 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4067 Importer.Import(D->getLocStart()),
4068 Importer.Import(D->getLocation()),
4072 Importer.Import(D->getPropertyIvarDeclLoc()));
4074 Importer.Imported(D, ToImpl);
4080 Importer.ToDiag(ToImpl->getLocation(),
4085 Importer.FromDiag(D->getLocation(),
4095 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4100 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4107 Importer.Imported(D, ToImpl);
4119 return TemplateTypeParmDecl::Create(Importer.getToContext(),
4120 Importer.getToContext().getTranslationUnitDecl(),
4121 Importer.Import(D->getLocStart()),
4122 Importer.Import(D->getLocation()),
4125 Importer.Import(D->getIdentifier()),
4133 DeclarationName Name = Importer.Import(D->getDeclName());
4138 SourceLocation Loc = Importer.Import(D->getLocation());
4141 QualType T = Importer.Import(D->getType());
4146 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4152 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4153 Importer.getToContext().getTranslationUnitDecl(),
4154 Importer.Import(D->getInnerLocStart()),
4163 DeclarationName Name = Importer.Import(D->getDeclName());
4168 SourceLocation Loc = Importer.Import(D->getLocation());
4178 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4179 Importer.getToContext().getTranslationUnitDecl(),
4194 = Importer.Import(Definition->getDescribedClassTemplate());
4198 return Importer.Imported(D, ImportedDef);
4227 Importer.Imported(D->getTemplatedDecl(),
4229 return Importer.Imported(D, FoundTemplate);
4237 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4249 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4250 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4251 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4256 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4265 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4276 Importer.Imported(D, D2);
4277 Importer.Imported(DTemplated, D2Templated);
4294 Decl *ImportedDef = Importer.Import(Definition);
4298 return Importer.Imported(D, ImportedDef);
4302 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4314 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4320 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4321 SourceLocation IdLoc = Importer.Import(D->getLocation());
4345 return Importer.Imported(D, FoundDef);
4350 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4363 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4369 Importer.Imported(D, D2);
4385 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4389 return Importer.Imported(D, ImportedDef);
4416 Importer.Imported(D->getTemplatedDecl(),
4418 return Importer.Imported(D, FoundTemplate);
4426 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4437 QualType T = Importer.Import(DTemplated->getType());
4442 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4443 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4444 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4445 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4449 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4452 // Importer.Imported(DTemplated, D2Templated);
4466 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4474 Importer.Imported(D, D2);
4475 Importer.Imported(DTemplated, D2Templated);
4492 Decl *ImportedDef = Importer.Import(Definition);
4496 return Importer.Imported(D, ImportedDef);
4500 Importer.Import(D->getSpecializedTemplate()));
4511 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4517 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4518 SourceLocation IdLoc = Importer.Import(D->getLocation());
4542 return Importer.Imported(D, FoundDef);
4548 QualType T = Importer.Import(D->getType());
4551 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4555 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4564 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4570 Importer.Imported(D, D2);
4584 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4587 auto &_Importer = this->Importer;
4592 return DeclGroupRef::Create(Importer.getToContext(),
4598 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4609 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4610 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
4611 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
4615 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
4616 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
4622 auto &_Importer = this->Importer;
4631 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
4632 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
4633 return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
4639 Expr *ToLHS = Importer.Import(S->getLHS());
4642 Expr *ToRHS = Importer.Import(S->getRHS());
4645 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
4646 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
4647 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4648 return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
4654 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
4655 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4656 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4659 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
4664 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
4666 cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
4669 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4672 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
4677 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
4680 ASTContext &_ToContext = Importer.getToContext();
4689 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4692 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
4697 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
4701 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4705 Expr *ToCondition = Importer.Import(S->getCond());
4708 Stmt *ToThenStmt = Importer.Import(S->getThen());
4711 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
4712 Stmt *ToElseStmt = Importer.Import(S->getElse());
4715 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
4725 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4729 Expr *ToCondition = Importer.Import(S->getCond());
4732 SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
4733 Importer.getToContext(), ToConditionVariable,
4735 Stmt *ToBody = Importer.Import(S->getBody());
4739 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
4744 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
4760 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4764 Expr *ToCondition = Importer.Import(S->getCond());
4767 Stmt *ToBody = Importer.Import(S->getBody());
4770 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4771 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
4778 Stmt *ToBody = Importer.Import(S->getBody());
4781 Expr *ToCondition = Importer.Import(S->getCond());
4784 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
4785 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4786 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4787 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
4793 Stmt *ToInit = Importer.Import(S->getInit());
4796 Expr *ToCondition = Importer.Import(S->getCond());
4802 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4806 Expr *ToInc = Importer.Import(S->getInc());
4809 Stmt *ToBody = Importer.Import(S->getBody());
4812 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4813 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
4814 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4815 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
4826 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
4830 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4831 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
4832 return new (Importer.getToContext()) GotoStmt(ToLabel,
4837 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4838 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
4839 Expr *ToTarget = Importer.Import(S->getTarget());
4842 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
4847 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
4848 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
4852 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
4853 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
4857 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
4858 Expr *ToRetExpr = Importer.Import(S->getRetValue());
4862 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
4865 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
4870 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
4874 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4878 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
4881 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
4887 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
4888 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
4894 if (Stmt *ToHandler = Importer.Import(FromHandler))
4899 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
4905 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
4909 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginEndStmt()));
4912 Expr *ToCond = Importer.Import(S->getCond());
4915 Expr *ToInc = Importer.Import(S->getInc());
4919 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
4922 Stmt *ToBody = Importer.Import(S->getBody());
4925 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4926 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
4927 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4928 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4929 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBeginEnd,
4937 Stmt *ToElem = Importer.Import(S->getElement());
4940 Expr *ToCollect = Importer.Import(S->getCollection());
4943 Stmt *ToBody = Importer.Import(S->getBody());
4946 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4947 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4948 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
4955 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
4956 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4960 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4964 Stmt *ToBody = Importer.Import(S->getCatchBody());
4967 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
4974 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
4975 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
4978 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
4983 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
4984 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
4990 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
4995 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
4998 return ObjCAtTryStmt::Create(Importer.getToContext(),
5007 Importer.Import(S->getAtSynchronizedLoc());
5008 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5011 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5014 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5019 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5020 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5023 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5028 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5029 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5032 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5040 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5046 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5052 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5057 QualType T = Importer.Import(E->getType());
5061 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5062 Importer.Import(E->getQualifierLoc()),
5063 Importer.Import(E->getTemplateKeywordLoc()),
5066 Importer.Import(E->getLocation()),
5076 QualType T = Importer.Import(E->getType());
5080 return IntegerLiteral::Create(Importer.getToContext(),
5082 Importer.Import(E->getLocation()));
5086 QualType T = Importer.Import(E->getType());
5090 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5092 Importer.Import(E->getLocation()));
5096 Expr *SubExpr = Importer.Import(E->getSubExpr());
5100 return new (Importer.getToContext())
5101 ParenExpr(Importer.Import(E->getLParen()),
5102 Importer.Import(E->getRParen()),
5107 QualType T = Importer.Import(E->getType());
5111 Expr *SubExpr = Importer.Import(E->getSubExpr());
5115 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
5118 Importer.Import(E->getOperatorLoc()));
5123 QualType ResultType = Importer.Import(E->getType());
5126 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5130 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5132 Importer.Import(E->getOperatorLoc()),
5133 Importer.Import(E->getRParenLoc()));
5136 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5140 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5142 Importer.Import(E->getOperatorLoc()),
5143 Importer.Import(E->getRParenLoc()));
5147 QualType T = Importer.Import(E->getType());
5151 Expr *LHS = Importer.Import(E->getLHS());
5155 Expr *RHS = Importer.Import(E->getRHS());
5159 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5162 Importer.Import(E->getOperatorLoc()),
5167 QualType T = Importer.Import(E->getType());
5171 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5175 QualType CompResultType = Importer.Import(E->getComputationResultType());
5179 Expr *LHS = Importer.Import(E->getLHS());
5183 Expr *RHS = Importer.Import(E->getRHS());
5187 return new (Importer.getToContext())
5192 Importer.Import(E->getOperatorLoc()),
5204 QualType T = Importer.Import(E->getType());
5208 Expr *SubExpr = Importer.Import(E->getSubExpr());
5216 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5221 QualType T = Importer.Import(E->getType());
5225 Expr *SubExpr = Importer.Import(E->getSubExpr());
5229 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5237 return CStyleCastExpr::Create(Importer.getToContext(), T,
5240 Importer.Import(E->getLParenLoc()),
5241 Importer.Import(E->getRParenLoc()));
5245 QualType T = Importer.Import(E->getType());
5250 dyn_cast<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
5256 ASTImporter &_Importer = Importer;
5266 return CXXConstructExpr::Create(Importer.getToContext(), T,
5267 Importer.Import(E->getLocation()),
5274 Importer.Import(E->getParenOrBraceRange()));
5278 QualType T = Importer.Import(E->getType());
5282 Expr *ToBase = Importer.Import(E->getBase());
5286 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
5291 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
5295 Importer.Import(E->getMemberNameInfo().getName()),
5296 Importer.Import(E->getMemberNameInfo().getLoc()));
5302 return MemberExpr::Create(Importer.getToContext(), ToBase,
5304 Importer.Import(E->getOperatorLoc()),
5305 Importer.Import(E->getQualifierLoc()),
5306 Importer.Import(E->getTemplateKeywordLoc()),
5313 QualType T = Importer.Import(E->getType());
5317 Expr *ToCallee = Importer.Import(E->getCallee());
5327 Expr *ToArg = Importer.Import(FromArg);
5333 Expr **ToArgs_Copied = new (Importer.getToContext())
5339 return new (Importer.getToContext())
5340 CallExpr(Importer.getToContext(), ToCallee,
5342 Importer.Import(E->getRParenLoc()));
5371 ASTNodeImporter Importer(*this);
5372 QualType ToT = Importer.Visit(fromTy);
5411 ASTNodeImporter Importer(*this);
5417 Importer.ImportDefinitionIfNeeded(FromD, ToD);
5422 Decl *ToD = Importer.Visit(FromD);
5526 ASTNodeImporter Importer(*this);
5527 Stmt *ToS = Importer.Visit(FromS);
5670 ASTNodeImporter Importer(*this);
5672 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
5756 ASTNodeImporter Importer(*this);
5760 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
5768 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
5776 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
5784 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
5790 Importer.ImportDeclContext(FromDC, true);