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.Import(T->getUnderlyingType());
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(),
1718 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1722 return Importer.getToContext().getTagDeclType(ToDecl);
1727 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1731 return Importer.getToContext().getTagDeclType(ToDecl);
1736 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1747 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1748 ToCanonType =Importer.Import(FromCanonType);
1752 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1762 ToQualifier = Importer.Import(T->getQualifier());
1767 QualType ToNamedType = Importer.Import(T->getNamedType());
1771 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1777 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1781 return Importer.getToContext().getObjCInterfaceType(Class);
1785 QualType ToBaseType = Importer.Import(T->getBaseType());
1794 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
1800 return Importer.getToContext().getObjCObjectType(ToBaseType,
1807 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1811 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1822 DC = Importer.ImportContext(D->getDeclContext());
1828 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1834 Name = Importer.Import(D->getDeclName());
1839 Loc = Importer.Import(D->getLocation());
1848 ToD = Importer.Import(FromD);
1887 To.setCXXOperatorNameRange(Importer.Import(Range));
1892 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1899 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1907 if (Importer.isMinimalImport() && !ForceImport) {
1908 Importer.ImportContext(FromDC);
1916 Importer.Import(*From);
1994 QualType T = Importer.Import(Base1->getType());
2000 EllipsisLoc = Importer.Import(Base1->getEllipsisLoc());
2006 new (Importer.getToContext())
2007 CXXBaseSpecifier(Importer.Import(Base1->getSourceRange()),
2011 Importer.Import(Base1->getTypeSourceInfo()),
2033 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2050 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2054 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2076 Decl *To = Importer.Import(*P);
2083 return TemplateParameterList::Create(Importer.getToContext(),
2084 Importer.Import(Params->getTemplateLoc()),
2085 Importer.Import(Params->getLAngleLoc()),
2087 Importer.Import(Params->getRAngleLoc()));
2097 QualType ToType = Importer.Import(From.getAsType());
2104 QualType ToType = Importer.Import(From.getIntegralType());
2112 if (ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(FromD)))
2118 QualType ToType = Importer.Import(From.getNullPtrType());
2125 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2134 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2142 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2153 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2180 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2187 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2189 Importer.getNonEquivalentDecls(),
2197 Importer.getFromContext(), Importer.getToContext(),
2198 Importer.getNonEquivalentDecls(), false, Complain);
2203 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2204 Importer.getToContext(),
2205 Importer.getNonEquivalentDecls());
2222 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2223 Importer.getToContext(),
2224 Importer.getNonEquivalentDecls());
2230 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2231 Importer.getToContext(),
2232 Importer.getNonEquivalentDecls());
2237 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2244 Importer.getToContext().getTranslationUnitDecl();
2246 Importer.Imported(D, ToD);
2286 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2295 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2297 Importer.Import(D->getLocStart()),
2312 Importer.Imported(D, ToNamespace);
2340 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2342 return Importer.Imported(D, FoundTypedef);
2349 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2358 QualType T = Importer.Import(D->getUnderlyingType());
2363 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2364 SourceLocation StartL = Importer.Import(D->getLocStart());
2367 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2372 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2379 Importer.Imported(D, ToTypedef);
2405 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2407 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2427 return Importer.Imported(D, FoundEnum);
2434 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2441 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2442 Importer.Import(D->getLocStart()),
2447 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2450 Importer.Imported(D, D2);
2454 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2472 Decl *ImportedDef = Importer.Import(Definition);
2476 return Importer.Imported(D, ImportedDef);
2490 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2492 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2536 return Importer.Imported(D, FoundDef);
2552 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2560 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2563 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2570 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2574 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2581 Importer.Imported(D, D2);
2597 QualType T = Importer.Import(D->getType());
2615 return Importer.Imported(D, FoundEnumConstant);
2622 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2630 Expr *Init = Importer.Import(D->getInitExpr());
2635 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2640 Importer.Imported(D, ToEnumerator);
2667 if (Importer.IsStructurallyEquivalent(D->getType(),
2670 return Importer.Imported(D, FoundFunction);
2677 if (Importer.getToContext().getLangOpts().CPlusPlus)
2681 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2683 Importer.ToDiag(FoundFunction->getLocation(),
2693 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2718 FromTy = Importer.getFromContext().getFunctionType(
2725 QualType T = Importer.Import(FromTy);
2733 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*P));
2741 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2744 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2753 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2761 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2768 Importer.Import(D->getLocEnd()));
2770 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2777 Importer.Import(D->getLocEnd()));
2779 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2788 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2794 Importer.Imported(D, ToFunction);
2805 QualType T = Importer.Import(D->getType());
2871 if (Importer.IsStructurallyEquivalent(D->getType(),
2873 Importer.Imported(D, FoundField);
2877 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2879 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2886 QualType T = Importer.Import(D->getType());
2890 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2891 Expr *BitWidth = Importer.Import(D->getBitWidth());
2895 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2896 Importer.Import(D->getInnerLocStart()),
2905 Importer.Imported(D, ToField);
2928 if (Importer.IsStructurallyEquivalent(D->getType(),
2931 Importer.Imported(D, FoundField);
2939 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2941 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2948 QualType T = Importer.Import(D->getType());
2953 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2958 Decl* D = Importer.Import(*PI);
2965 Importer.getToContext(), DC,
2970 Importer.Imported(D, ToIndirectField);
2988 if (Importer.IsStructurallyEquivalent(D->getType(),
2990 Importer.Imported(D, FoundIvar);
2994 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
2996 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3003 QualType T = Importer.Import(D->getType());
3007 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3008 Expr *BitWidth = Importer.Import(D->getBitWidth());
3012 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3014 Importer.Import(D->getInnerLocStart()),
3020 Importer.Imported(D, ToIvar);
3050 if (Importer.IsStructurallyEquivalent(D->getType(),
3057 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3059 = Importer.getToContext().getAsArrayType(D->getType());
3064 QualType T = Importer.Import(D->getType());
3078 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3080 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3091 Importer.Imported(D, MergeWithVar);
3095 Importer.ToDiag(ExistingDef->getLocation(),
3098 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3100 Expr *Init = Importer.Import(DDef->getInit());
3114 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3123 QualType T = Importer.Import(D->getType());
3128 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3129 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3130 Importer.Import(D->getInnerLocStart()),
3134 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3137 Importer.Imported(D, ToVar);
3150 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3153 DeclarationName Name = Importer.Import(D->getDeclName());
3158 SourceLocation Loc = Importer.Import(D->getLocation());
3161 QualType T = Importer.Import(D->getType());
3167 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3170 return Importer.Imported(D, ToParm);
3176 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3179 DeclarationName Name = Importer.Import(D->getDeclName());
3184 SourceLocation Loc = Importer.Import(D->getLocation());
3187 QualType T = Importer.Import(D->getType());
3192 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3193 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3194 Importer.Import(D->getInnerLocStart()),
3199 return Importer.Imported(D, ToParm);
3218 if (!Importer.IsStructurallyEquivalent(D->getResultType(),
3220 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3223 Importer.ToDiag(FoundMethod->getLocation(),
3231 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3234 Importer.ToDiag(FoundMethod->getLocation(),
3244 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3246 Importer.FromDiag((*P)->getLocation(),
3250 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3259 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3261 Importer.ToDiag(FoundMethod->getLocation(),
3268 return Importer.Imported(D, FoundMethod);
3273 QualType ResultTy = Importer.Import(D->getResultType());
3277 TypeSourceInfo *ResultTInfo = Importer.Import(D->getResultTypeSourceInfo());
3280 = ObjCMethodDecl::Create(Importer.getToContext(),
3282 Importer.Import(D->getLocEnd()),
3302 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*FromP));
3316 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3319 Importer.Imported(D, ToMethod);
3333 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3342 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3343 Importer.Import(D->getAtStartLoc()),
3345 Importer.Import(D->getCategoryNameLoc()),
3348 Importer.Import(D->getIvarLBraceLoc()),
3349 Importer.Import(D->getIvarRBraceLoc()));
3352 Importer.Imported(D, ToCategory);
3364 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3368 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3373 ProtocolLocs.data(), Importer.getToContext());
3376 Importer.Imported(D, ToCategory);
3386 Importer.Import(D->getImplementation()));
3418 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3422 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3427 ProtocolLocs.data(), Importer.getToContext());
3442 Decl *ImportedDef = Importer.Import(Definition);
3446 return Importer.Imported(D, ImportedDef);
3469 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3471 Importer.Import(D->getAtStartLoc()),
3477 Importer.Imported(D, ToProto);
3492 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3500 Importer.ToDiag(To->getLocation(),
3504 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3507 Importer.ToDiag(To->getLocation(),
3510 Importer.FromDiag(From->getSuperClassLoc(),
3514 Importer.FromDiag(From->getLocation(),
3529 Importer.Import(From->getSuperClass()));
3534 To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3548 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3552 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3557 ProtocolLocs.data(), Importer.getToContext());
3565 Importer.Import(*Cat);
3571 Importer.Import(From->getImplementation()));
3591 Decl *ImportedDef = Importer.Import(Definition);
3595 return Importer.Imported(D, ImportedDef);
3620 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3621 Importer.Import(D->getAtStartLoc()),
3628 Importer.Imported(D, ToIface);
3638 Importer.Import(D->getCategoryDecl()));
3644 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3648 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3649 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3650 Importer.Import(D->getIdentifier()),
3652 Importer.Import(D->getLocation()),
3653 Importer.Import(D->getAtStartLoc()),
3658 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3669 Importer.Imported(D, ToImpl);
3677 Importer.Import(D->getClassInterface()));
3685 Importer.Import(D->getSuperClass()));
3694 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3695 Importer.ImportContext(D->getDeclContext()),
3697 Importer.Import(D->getLocation()),
3698 Importer.Import(D->getAtStartLoc()),
3699 Importer.Import(D->getSuperClassLoc()),
3700 Importer.Import(D->getIvarLBraceLoc()),
3701 Importer.Import(D->getIvarRBraceLoc()));
3705 = Importer.ImportContext(D->getLexicalDeclContext());
3713 Importer.Imported(D, Iface->getImplementation());
3715 Importer.Imported(D, Iface->getImplementation());
3722 Importer.ToDiag(Impl->getLocation(),
3728 Importer.ToDiag(Impl->getLocation(),
3732 Importer.ToDiag(Impl->getLocation(),
3735 Importer.FromDiag(D->getLocation(),
3739 Importer.FromDiag(D->getLocation(),
3766 if (!Importer.IsStructurallyEquivalent(D->getType(),
3768 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3770 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3778 Importer.Imported(D, FoundProp);
3784 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3790 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3792 Importer.Import(D->getAtLoc()),
3793 Importer.Import(D->getLParenLoc()),
3796 Importer.Imported(D, ToProperty);
3803 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3804 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3806 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3808 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3810 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3816 Importer.Import(D->getPropertyDecl()));
3820 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3827 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3840 Importer.Import(D->getPropertyIvarDecl()));
3848 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3849 Importer.Import(D->getLocStart()),
3850 Importer.Import(D->getLocation()),
3854 Importer.Import(D->getPropertyIvarDeclLoc()));
3856 Importer.Imported(D, ToImpl);
3862 Importer.ToDiag(ToImpl->getLocation(),
3867 Importer.FromDiag(D->getLocation(),
3877 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3882 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3889 Importer.Imported(D, ToImpl);
3901 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3902 Importer.getToContext().getTranslationUnitDecl(),
3903 Importer.Import(D->getLocStart()),
3904 Importer.Import(D->getLocation()),
3907 Importer.Import(D->getIdentifier()),
3915 DeclarationName Name = Importer.Import(D->getDeclName());
3920 SourceLocation Loc = Importer.Import(D->getLocation());
3923 QualType T = Importer.Import(D->getType());
3928 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3934 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3935 Importer.getToContext().getTranslationUnitDecl(),
3936 Importer.Import(D->getInnerLocStart()),
3945 DeclarationName Name = Importer.Import(D->getDeclName());
3950 SourceLocation Loc = Importer.Import(D->getLocation());
3960 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3961 Importer.getToContext().getTranslationUnitDecl(),
3976 = Importer.Import(Definition->getDescribedClassTemplate());
3980 return Importer.Imported(D, ImportedDef);
4006 Importer.Imported(D->getTemplatedDecl(),
4008 return Importer.Imported(D, FoundTemplate);
4016 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4028 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4029 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4030 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4035 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4044 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4055 Importer.Imported(D, D2);
4056 Importer.Imported(DTemplated, D2Templated);
4073 Decl *ImportedDef = Importer.Import(Definition);
4077 return Importer.Imported(D, ImportedDef);
4081 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4093 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4099 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4100 SourceLocation IdLoc = Importer.Import(D->getLocation());
4125 return Importer.Imported(D, FoundDef);
4130 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4143 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4149 Importer.Imported(D, D2);
4165 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4169 return Importer.Imported(D, ImportedDef);
4193 Importer.Imported(D->getTemplatedDecl(),
4195 return Importer.Imported(D, FoundTemplate);
4203 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4214 QualType T = Importer.Import(DTemplated->getType());
4219 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4220 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4221 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4222 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4226 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4229 // Importer.Imported(DTemplated, D2Templated);
4243 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated,
4252 Importer.Imported(D, D2);
4253 Importer.Imported(DTemplated, D2Templated);
4270 Decl *ImportedDef = Importer.Import(Definition);
4274 return Importer.Imported(D, ImportedDef);
4278 Importer.Import(D->getSpecializedTemplate()));
4289 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4295 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4296 SourceLocation IdLoc = Importer.Import(D->getLocation());
4320 return Importer.Imported(D, FoundDef);
4326 QualType T = Importer.Import(D->getType());
4329 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4333 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4342 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4348 Importer.Imported(D, D2);
4361 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4370 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4376 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4382 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4387 QualType T = Importer.Import(E->getType());
4391 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4392 Importer.Import(E->getQualifierLoc()),
4393 Importer.Import(E->getTemplateKeywordLoc()),
4396 Importer.Import(E->getLocation()),
4406 QualType T = Importer.Import(E->getType());
4410 return IntegerLiteral::Create(Importer.getToContext(),
4412 Importer.Import(E->getLocation()));
4416 QualType T = Importer.Import(E->getType());
4420 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4422 Importer.Import(E->getLocation()));
4426 Expr *SubExpr = Importer.Import(E->getSubExpr());
4430 return new (Importer.getToContext())
4431 ParenExpr(Importer.Import(E->getLParen()),
4432 Importer.Import(E->getRParen()),
4437 QualType T = Importer.Import(E->getType());
4441 Expr *SubExpr = Importer.Import(E->getSubExpr());
4445 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4448 Importer.Import(E->getOperatorLoc()));
4453 QualType ResultType = Importer.Import(E->getType());
4456 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4460 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4462 Importer.Import(E->getOperatorLoc()),
4463 Importer.Import(E->getRParenLoc()));
4466 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4470 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4472 Importer.Import(E->getOperatorLoc()),
4473 Importer.Import(E->getRParenLoc()));
4477 QualType T = Importer.Import(E->getType());
4481 Expr *LHS = Importer.Import(E->getLHS());
4485 Expr *RHS = Importer.Import(E->getRHS());
4489 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4492 Importer.Import(E->getOperatorLoc()),
4497 QualType T = Importer.Import(E->getType());
4501 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4505 QualType CompResultType = Importer.Import(E->getComputationResultType());
4509 Expr *LHS = Importer.Import(E->getLHS());
4513 Expr *RHS = Importer.Import(E->getRHS());
4517 return new (Importer.getToContext())
4522 Importer.Import(E->getOperatorLoc()),
4534 QualType T = Importer.Import(E->getType());
4538 Expr *SubExpr = Importer.Import(E->getSubExpr());
4546 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4551 QualType T = Importer.Import(E->getType());
4555 Expr *SubExpr = Importer.Import(E->getSubExpr());
4559 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4567 return CStyleCastExpr::Create(Importer.getToContext(), T,
4570 Importer.Import(E->getLParenLoc()),
4571 Importer.Import(E->getRParenLoc()));
4600 ASTNodeImporter Importer(*this);
4601 QualType ToT = Importer.Visit(fromTy);
4629 ASTNodeImporter Importer(*this);
4635 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4640 Decl *ToD = Importer.Visit(FromD);
4744 ASTNodeImporter Importer(*this);
4745 Stmt *ToS = Importer.Visit(FromS);
4881 ASTNodeImporter Importer(*this);
4883 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4961 ASTNodeImporter Importer(*this);
4965 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4973 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4981 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
4989 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
4995 Importer.ImportDeclContext(FromDC, true);