Lines Matching defs:Importer
31 ASTImporter &Importer;
34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
104 (IDK == IDK_Default && !Importer.isMinimalImport());
1406 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1415 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1428 if (Importer.getToContext().getLangOpts().CharIsSigned)
1429 return Importer.getToContext().UnsignedCharTy;
1431 return Importer.getToContext().CharTy;
1437 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1438 return Importer.getToContext().SignedCharTy;
1440 return Importer.getToContext().CharTy;
1446 return Importer.getToContext().WCharTy;
1453 QualType ToElementType = Importer.Import(T->getElementType());
1457 return Importer.getToContext().getComplexType(ToElementType);
1461 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1465 return Importer.getToContext().getPointerType(ToPointeeType);
1470 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1474 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1480 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1484 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1490 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1494 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1499 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1503 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1504 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1509 QualType ToElementType = Importer.Import(T->getElementType());
1513 return Importer.getToContext().getConstantArrayType(ToElementType,
1521 QualType ToElementType = Importer.Import(T->getElementType());
1525 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1531 QualType ToElementType = Importer.Import(T->getElementType());
1535 Expr *Size = Importer.Import(T->getSizeExpr());
1539 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1540 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1547 QualType ToElementType = Importer.Import(T->getElementType());
1551 return Importer.getToContext().getVectorType(ToElementType,
1557 QualType ToElementType = Importer.Import(T->getElementType());
1561 return Importer.getToContext().getExtVectorType(ToElementType,
1569 QualType ToResultType = Importer.Import(T->getResultType());
1573 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1578 QualType ToResultType = Importer.Import(T->getResultType());
1587 QualType ArgType = Importer.Import(*A);
1598 QualType ExceptionType = Importer.Import(*E);
1616 ToEPI.NoexceptExpr = Importer.Import(FromEPI.NoexceptExpr);
1618 Importer.Import(FromEPI.ExceptionSpecDecl));
1620 Importer.Import(FromEPI.ExceptionSpecTemplate));
1622 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1626 QualType ToInnerType = Importer.Import(T->getInnerType());
1630 return Importer.getToContext().getParenType(ToInnerType);
1635 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1639 return Importer.getToContext().getTypeDeclType(ToDecl);
1643 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1647 return Importer.getToContext().getTypeOfExprType(ToExpr);
1651 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1655 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1660 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1664 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1668 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1672 QualType ToBaseType = Importer.Import(T->getBaseType());
1673 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1677 Importer.getToContext().getUnaryTransformType(ToBaseType,
1687 ToDeduced = Importer.Import(FromDeduced);
1692 return Importer.getToContext().getAutoType(ToDeduced);
1697 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1701 return Importer.getToContext().getTagDeclType(ToDecl);
1706 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1710 return Importer.getToContext().getTagDeclType(ToDecl);
1715 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1726 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1727 ToCanonType =Importer.Import(FromCanonType);
1731 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1741 ToQualifier = Importer.Import(T->getQualifier());
1746 QualType ToNamedType = Importer.Import(T->getNamedType());
1750 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1756 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1760 return Importer.getToContext().getObjCInterfaceType(Class);
1764 QualType ToBaseType = Importer.Import(T->getBaseType());
1773 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
1779 return Importer.getToContext().getObjCObjectType(ToBaseType,
1786 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1790 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1801 DC = Importer.ImportContext(D->getDeclContext());
1807 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1813 Name = Importer.Import(D->getDeclName());
1818 Loc = Importer.Import(D->getLocation());
1827 ToD = Importer.Import(FromD);
1866 To.setCXXOperatorNameRange(Importer.Import(Range));
1871 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1878 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1886 if (Importer.isMinimalImport() && !ForceImport) {
1887 Importer.ImportContext(FromDC);
1895 Importer.Import(*From);
1976 QualType T = Importer.Import(Base1->getType());
1982 EllipsisLoc = Importer.Import(Base1->getEllipsisLoc());
1988 new (Importer.getToContext())
1989 CXXBaseSpecifier(Importer.Import(Base1->getSourceRange()),
1993 Importer.Import(Base1->getTypeSourceInfo()),
2017 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2021 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2043 Decl *To = Importer.Import(*P);
2050 return TemplateParameterList::Create(Importer.getToContext(),
2051 Importer.Import(Params->getTemplateLoc()),
2052 Importer.Import(Params->getLAngleLoc()),
2054 Importer.Import(Params->getRAngleLoc()));
2064 QualType ToType = Importer.Import(From.getAsType());
2071 QualType ToType = Importer.Import(From.getIntegralType());
2079 if (ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(FromD)))
2085 QualType ToType = Importer.Import(From.getNullPtrType());
2092 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2101 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2109 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2120 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2145 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2146 Importer.getToContext(),
2147 Importer.getNonEquivalentDecls(),
2153 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2154 Importer.getToContext(),
2155 Importer.getNonEquivalentDecls());
2172 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2173 Importer.getToContext(),
2174 Importer.getNonEquivalentDecls());
2179 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2186 Importer.getToContext().getTranslationUnitDecl();
2188 Importer.Imported(D, ToD);
2228 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2237 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2239 Importer.Import(D->getLocStart()),
2254 Importer.Imported(D, ToNamespace);
2282 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2284 return Importer.Imported(D, FoundTypedef);
2291 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2300 QualType T = Importer.Import(D->getUnderlyingType());
2305 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2306 SourceLocation StartL = Importer.Import(D->getLocStart());
2309 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2314 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2321 Importer.Imported(D, ToTypedef);
2347 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2349 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2369 return Importer.Imported(D, FoundEnum);
2376 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2383 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2384 Importer.Import(D->getLocStart()),
2389 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2392 Importer.Imported(D, D2);
2396 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2414 Decl *ImportedDef = Importer.Import(Definition);
2418 return Importer.Imported(D, ImportedDef);
2432 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2434 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2478 return Importer.Imported(D, FoundDef);
2494 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2502 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2505 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2512 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2516 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2523 Importer.Imported(D, D2);
2539 QualType T = Importer.Import(D->getType());
2557 return Importer.Imported(D, FoundEnumConstant);
2564 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2572 Expr *Init = Importer.Import(D->getInitExpr());
2577 = EnumConstantDecl::Create(Importer
2582 Importer.Imported(D, ToEnumerator);
2609 if (Importer.IsStructurallyEquivalent(D->getType(),
2612 return Importer.Imported(D, FoundFunction);
2619 if (Importer.getToContext().getLangOpts().CPlusPlus)
2623 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2625 Importer.ToDiag(FoundFunction->getLocation(),
2635 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2660 FromTy = Importer.getFromContext().getFunctionType(
2670 QualType T = Importer.Import(FromTy);
2678 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*P));
2686 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2689 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2698 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2706 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2713 Importer.Import(D->getLocEnd()));
2715 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2723 Importer.Import(D->getLocEnd()));
2725 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2735 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2741 Importer.Imported(D, ToFunction);
2752 QualType T = Importer.Import(D->getType());
2818 if (Importer.IsStructurallyEquivalent(D->getType(),
2820 Importer.Imported(D, FoundField);
2824 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2826 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2833 QualType T = Importer.Import(D->getType());
2837 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2838 Expr *BitWidth = Importer.Import(D->getBitWidth());
2842 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2843 Importer.Import(D->getInnerLocStart()),
2852 Importer.Imported(D, ToField);
2875 if (Importer.IsStructurallyEquivalent(D->getType(),
2878 Importer.Imported(D, FoundField);
2886 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2888 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2895 QualType T = Importer.Import(D->getType());
2900 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2905 Decl* D = Importer.Import(*PI);
2912 Importer.getToContext(), DC,
2917 Importer.Imported(D, ToIndirectField);
2935 if (Importer.IsStructurallyEquivalent(D->getType(),
2937 Importer.Imported(D, FoundIvar);
2941 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
2943 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
2950 QualType T = Importer.Import(D->getType());
2954 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2955 Expr *BitWidth = Importer.Import(D->getBitWidth());
2959 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
2961 Importer.Import(D->getInnerLocStart()),
2966 Importer.Imported(D, ToIvar);
2996 Importer.IsStructurallyEquivalent(D->getType(),
3003 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3005 = Importer.getToContext().getAsArrayType(D->getType());
3010 QualType T = Importer.Import(D->getType());
3024 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3026 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3037 Importer.Imported(D, MergeWithVar);
3041 Importer.ToDiag(ExistingDef->getLocation(),
3044 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3046 Expr *Init = Importer.Import(DDef->getInit());
3060 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3069 QualType T = Importer.Import(D->getType());
3074 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3075 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3076 Importer.Import(D->getInnerLocStart()),
3081 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3084 Importer.Imported(D, ToVar);
3091 ToVar->setInit(Importer.Import(const_cast<Expr *>(D->getAnyInitializer())));
3101 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3104 DeclarationName Name = Importer.Import(D->getDeclName());
3109 SourceLocation Loc = Importer.Import(D->getLocation());
3112 QualType T = Importer.Import(D->getType());
3118 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3121 return Importer.Imported(D, ToParm);
3127 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3130 DeclarationName Name = Importer.Import(D->getDeclName());
3135 SourceLocation Loc = Importer.Import(D->getLocation());
3138 QualType T = Importer.Import(D->getType());
3143 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3144 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3145 Importer.Import(D->getInnerLocStart()),
3151 return Importer.Imported(D, ToParm);
3170 if (!Importer.IsStructurallyEquivalent(D->getResultType(),
3172 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3175 Importer.ToDiag(FoundMethod->getLocation(),
3183 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3186 Importer.ToDiag(FoundMethod->getLocation(),
3196 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3198 Importer.FromDiag((*P)->getLocation(),
3202 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3211 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3213 Importer.ToDiag(FoundMethod->getLocation(),
3220 return Importer.Imported(D, FoundMethod);
3225 QualType ResultTy = Importer.Import(D->getResultType());
3229 TypeSourceInfo *ResultTInfo = Importer.Import(D->getResultTypeSourceInfo());
3232 = ObjCMethodDecl::Create(Importer.getToContext(),
3234 Importer.Import(D->getLocEnd()),
3254 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*FromP));
3268 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3271 Importer.Imported(D, ToMethod);
3285 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3294 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3295 Importer.Import(D->getAtStartLoc()),
3297 Importer.Import(D->getCategoryNameLoc()),
3300 Importer.Import(D->getIvarLBraceLoc()),
3301 Importer.Import(D->getIvarRBraceLoc()));
3304 Importer.Imported(D, ToCategory);
3316 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3320 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3325 ProtocolLocs.data(), Importer.getToContext());
3328 Importer.Imported(D, ToCategory);
3338 Importer.Import(D->getImplementation()));
3370 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3374 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3379 ProtocolLocs.data(), Importer.getToContext());
3394 Decl *ImportedDef = Importer.Import(Definition);
3398 return Importer.Imported(D, ImportedDef);
3421 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3423 Importer.Import(D->getAtStartLoc()),
3429 Importer.Imported(D, ToProto);
3444 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3452 Importer.ToDiag(To->getLocation(),
3456 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3459 Importer.ToDiag(To->getLocation(),
3462 Importer.FromDiag(From->getSuperClassLoc(),
3466 Importer.FromDiag(From->getLocation(),
3481 Importer.Import(From->getSuperClass()));
3486 To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3500 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3504 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3509 ProtocolLocs.data(), Importer.getToContext());
3517 Importer.Import(*Cat);
3523 Importer.Import(From->getImplementation()));
3543 Decl *ImportedDef = Importer.Import(Definition);
3547 return Importer.Imported(D, ImportedDef);
3572 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3573 Importer.Import(D->getAtStartLoc()),
3580 Importer.Imported(D, ToIface);
3590 Importer.Import(D->getCategoryDecl()));
3596 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3600 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3601 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3602 Importer.Import(D->getIdentifier()),
3604 Importer.Import(D->getLocation()),
3605 Importer.Import(D->getAtStartLoc()),
3610 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3621 Importer.Imported(D, ToImpl);
3629 Importer.Import(D->getClassInterface()));
3637 Importer.Import(D->getSuperClass()));
3646 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3647 Importer.ImportContext(D->getDeclContext()),
3649 Importer.Import(D->getLocation()),
3650 Importer.Import(D->getAtStartLoc()),
3651 Importer.Import(D->getIvarLBraceLoc()),
3652 Importer.Import(D->getIvarRBraceLoc()));
3656 = Importer.ImportContext(D->getLexicalDeclContext());
3664 Importer.Imported(D, Iface->getImplementation());
3666 Importer.Imported(D, Iface->getImplementation());
3673 Importer.ToDiag(Impl->getLocation(),
3679 Importer.ToDiag(Impl->getLocation(),
3683 Importer.ToDiag(Impl->getLocation(),
3686 Importer.FromDiag(D->getLocation(),
3690 Importer.FromDiag(D->getLocation(),
3717 if (!Importer.IsStructurallyEquivalent(D->getType(),
3719 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3721 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3729 Importer.Imported(D, FoundProp);
3735 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3741 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3743 Importer.Import(D->getAtLoc()),
3744 Importer.Import(D->getLParenLoc()),
3747 Importer.Imported(D, ToProperty);
3754 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3755 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3757 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3759 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3761 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3767 Importer.Import(D->getPropertyDecl()));
3771 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3778 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3791 Importer.Import(D->getPropertyIvarDecl()));
3799 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3800 Importer.Import(D->getLocStart()),
3801 Importer.Import(D->getLocation()),
3805 Importer.Import(D->getPropertyIvarDeclLoc()));
3807 Importer.Imported(D, ToImpl);
3813 Importer.ToDiag(ToImpl->getLocation(),
3818 Importer.FromDiag(D->getLocation(),
3828 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3833 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3840 Importer.Imported(D, ToImpl);
3852 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3853 Importer.getToContext().getTranslationUnitDecl(),
3854 Importer.Import(D->getLocStart()),
3855 Importer.Import(D->getLocation()),
3858 Importer.Import(D->getIdentifier()),
3866 DeclarationName Name = Importer.Import(D->getDeclName());
3871 SourceLocation Loc = Importer.Import(D->getLocation());
3874 QualType T = Importer.Import(D->getType());
3879 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3885 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3886 Importer.getToContext().getTranslationUnitDecl(),
3887 Importer.Import(D->getInnerLocStart()),
3896 DeclarationName Name = Importer.Import(D->getDeclName());
3901 SourceLocation Loc = Importer.Import(D->getLocation());
3911 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3912 Importer.getToContext().getTranslationUnitDecl(),
3927 = Importer.Import(Definition->getDescribedClassTemplate());
3931 return Importer.Imported(D, ImportedDef);
3957 Importer.Imported(D->getTemplatedDecl(),
3959 return Importer.Imported(D, FoundTemplate);
3967 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
3979 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
3980 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
3981 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
3986 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
3995 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4006 Importer.Imported(D, D2);
4007 Importer.Imported(DTemplated, D2Templated);
4024 Decl *ImportedDef = Importer.Import(Definition);
4028 return Importer.Imported(D, ImportedDef);
4032 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4044 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4050 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4051 SourceLocation IdLoc = Importer.Import(D->getLocation());
4076 return Importer.Imported(D, FoundDef);
4081 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4094 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4100 Importer.Imported(D, D2);
4113 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4122 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4128 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4134 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4139 QualType T = Importer.Import(E->getType());
4143 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4144 Importer.Import(E->getQualifierLoc()),
4145 Importer.Import(E->getTemplateKeywordLoc()),
4148 Importer.Import(E->getLocation()),
4158 QualType T = Importer.Import(E->getType());
4162 return IntegerLiteral::Create(Importer.getToContext(),
4164 Importer.Import(E->getLocation()));
4168 QualType T = Importer.Import(E->getType());
4172 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4174 Importer.Import(E->getLocation()));
4178 Expr *SubExpr = Importer.Import(E->getSubExpr());
4182 return new (Importer.getToContext())
4183 ParenExpr(Importer.Import(E->getLParen()),
4184 Importer.Import(E->getRParen()),
4189 QualType T = Importer.Import(E->getType());
4193 Expr *SubExpr = Importer.Import(E->getSubExpr());
4197 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4200 Importer.Import(E->getOperatorLoc()));
4205 QualType ResultType = Importer.Import(E->getType());
4208 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4212 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4214 Importer.Import(E->getOperatorLoc()),
4215 Importer.Import(E->getRParenLoc()));
4218 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4222 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4224 Importer.Import(E->getOperatorLoc()),
4225 Importer.Import(E->getRParenLoc()));
4229 QualType T = Importer.Import(E->getType());
4233 Expr *LHS = Importer.Import(E->getLHS());
4237 Expr *RHS = Importer.Import(E->getRHS());
4241 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4244 Importer.Import(E->getOperatorLoc()),
4249 QualType T = Importer.Import(E->getType());
4253 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4257 QualType CompResultType = Importer.Import(E->getComputationResultType());
4261 Expr *LHS = Importer.Import(E->getLHS());
4265 Expr *RHS = Importer.Import(E->getRHS());
4269 return new (Importer.getToContext())
4274 Importer.Import(E->getOperatorLoc()),
4286 QualType T = Importer.Import(E->getType());
4290 Expr *SubExpr = Importer.Import(E->getSubExpr());
4298 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4303 QualType T = Importer.Import(E->getType());
4307 Expr *SubExpr = Importer.Import(E->getSubExpr());
4311 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4319 return CStyleCastExpr::Create(Importer.getToContext(), T,
4322 Importer.Import(E->getLParenLoc()),
4323 Importer.Import(E->getRParenLoc()));
4352 ASTNodeImporter Importer(*this);
4353 QualType ToT = Importer.Visit(fromTy);
4381 ASTNodeImporter Importer(*this);
4387 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4392 Decl *ToD = Importer.Visit(FromD);
4496 ASTNodeImporter Importer(*this);
4497 Stmt *ToS = Importer.Visit(FromS);
4633 ASTNodeImporter Importer(*this);
4635 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4713 ASTNodeImporter Importer(*this);
4717 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4725 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4733 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
4741 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
4747 Importer.ImportDeclContext(FromDC, true);
