Lines Matching refs:Importer
34 ASTImporter &Importer;
37 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
1320 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1329 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1342 if (Importer.getToContext().getLangOptions().CharIsSigned)
1343 return Importer.getToContext().UnsignedCharTy;
1345 return Importer.getToContext().CharTy;
1351 if (!Importer.getToContext().getLangOptions().CharIsSigned)
1352 return Importer.getToContext().SignedCharTy;
1354 return Importer.getToContext().CharTy;
1360 return Importer.getToContext().WCharTy;
1367 QualType ToElementType = Importer.Import(T->getElementType());
1371 return Importer.getToContext().getComplexType(ToElementType);
1375 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1379 return Importer.getToContext().getPointerType(ToPointeeType);
1384 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1388 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1394 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1398 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1404 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1408 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1413 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1417 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1418 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1423 QualType ToElementType = Importer.Import(T->getElementType());
1427 return Importer.getToContext().getConstantArrayType(ToElementType,
1435 QualType ToElementType = Importer.Import(T->getElementType());
1439 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1445 QualType ToElementType = Importer.Import(T->getElementType());
1449 Expr *Size = Importer.Import(T->getSizeExpr());
1453 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1454 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1461 QualType ToElementType = Importer.Import(T->getElementType());
1465 return Importer.getToContext().getVectorType(ToElementType,
1471 QualType ToElementType = Importer.Import(T->getElementType());
1475 return Importer.getToContext().getExtVectorType(ToElementType,
1483 QualType ToResultType = Importer.Import(T->getResultType());
1487 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1492 QualType ToResultType = Importer.Import(T->getResultType());
1501 QualType ArgType = Importer.Import(*A);
1512 QualType ExceptionType = Importer.Import(*E);
1521 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes.data(),
1526 QualType ToInnerType = Importer.Import(T->getInnerType());
1530 return Importer.getToContext().getParenType(ToInnerType);
1535 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1539 return Importer.getToContext().getTypeDeclType(ToDecl);
1543 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1547 return Importer.getToContext().getTypeOfExprType(ToExpr);
1551 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1555 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1560 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1564 return Importer.getToContext().getDecltypeType(ToExpr);
1568 QualType ToBaseType = Importer.Import(T->getBaseType());
1569 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1573 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1583 ToDeduced = Importer.Import(FromDeduced);
1588 return Importer.getToContext().getAutoType(ToDeduced);
1593 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1597 return Importer.getToContext().getTagDeclType(ToDecl);
1602 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1606 return Importer.getToContext().getTagDeclType(ToDecl);
1611 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1622 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1623 ToCanonType =Importer.Import(FromCanonType);
1627 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1637 ToQualifier = Importer.Import(T->getQualifier());
1642 QualType ToNamedType = Importer.Import(T->getNamedType());
1646 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1652 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1656 return Importer.getToContext().getObjCInterfaceType(Class);
1660 QualType ToBaseType = Importer.Import(T->getBaseType());
1669 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
1675 return Importer.getToContext().getObjCObjectType(ToBaseType,
1682 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1686 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1697 DC = Importer.ImportContext(D->getDeclContext());
1703 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1709 Name = Importer.Import(D->getDeclName());
1714 Loc = Importer.Import(D->getLocation());
1723 ToD = Importer.Import(FromD);
1762 To.setCXXOperatorNameRange(Importer.Import(Range));
1767 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1774 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1782 if (Importer.isMinimalImport() && !ForceImport) {
1783 Importer.ImportContext(FromDC);
1791 Importer.Import(*From);
1811 QualType T = Importer.Import(Base1->getType());
1817 EllipsisLoc = Importer.Import(Base1->getEllipsisLoc());
1823 new (Importer.getToContext())
1824 CXXBaseSpecifier(Importer.Import(Base1->getSourceRange()),
1828 Importer.Import(Base1->getTypeSourceInfo()),
1847 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
1851 QualType ToPromotionType = Importer.Import(From->getPromotionType());
1872 Decl *To = Importer.Import(*P);
1879 return TemplateParameterList::Create(Importer.getToContext(),
1880 Importer.Import(Params->getTemplateLoc()),
1881 Importer.Import(Params->getLAngleLoc()),
1883 Importer.Import(Params->getRAngleLoc()));
1893 QualType ToType = Importer.Import(From.getAsType());
1900 QualType ToType = Importer.Import(From.getIntegralType());
1907 if (Decl *To = Importer.Import(From.getAsDecl()))
1912 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
1921 = Importer.Import(From.getAsTemplateOrTemplatePattern());
1929 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
1940 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
1966 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1967 Importer.getToContext(),
1968 Importer.getNonEquivalentDecls());
1973 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1974 Importer.getToContext(),
1975 Importer.getNonEquivalentDecls());
1981 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1982 Importer.getToContext(),
1983 Importer.getNonEquivalentDecls());
1988 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2028 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2037 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2038 Importer.Import(D->getLocStart()),
2052 Importer.Imported(D, ToNamespace);
2080 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2082 return Importer.Imported(D, FoundTypedef);
2089 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2098 QualType T = Importer.Import(D->getUnderlyingType());
2103 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2104 SourceLocation StartL = Importer.Import(D->getLocStart());
2107 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2112 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2119 Importer.Imported(D, ToTypedef);
2145 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2147 } else if (Importer.getToContext().getLangOptions().CPlusPlus)
2167 return Importer.Imported(D, FoundEnum);
2174 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2181 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2182 Importer.Import(D->getLocStart()),
2187 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2190 Importer.Imported(D, D2);
2194 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2212 Decl *ImportedDef = Importer.Import(Definition);
2216 return Importer.Imported(D, ImportedDef);
2230 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2232 } else if (Importer.getToContext().getLangOptions().CPlusPlus)
2258 return Importer.Imported(D, FoundDef);
2272 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2280 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2283 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2290 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2294 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2299 Importer.Imported(D, D2);
2315 QualType T = Importer.Import(D->getType());
2334 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2342 Expr *Init = Importer.Import(D->getInitExpr());
2347 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2352 Importer.Imported(D, ToEnumerator);
2379 if (Importer.IsStructurallyEquivalent(D->getType(),
2382 return Importer.Imported(D, FoundFunction);
2389 if (Importer.getToContext().getLangOptions().CPlusPlus)
2393 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2395 Importer.ToDiag(FoundFunction->getLocation(),
2405 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2418 QualType T = Importer.Import(D->getType());
2426 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*P));
2434 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2437 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2446 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2454 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2461 Importer.Import(D->getLocEnd()));
2463 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2471 Importer.Import(D->getLocEnd()));
2473 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2483 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2489 Importer.Imported(D, ToFunction);
2535 if (Importer.IsStructurallyEquivalent(D->getType(),
2537 Importer.Imported(D, FoundField);
2541 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2543 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2550 QualType T = Importer.Import(D->getType());
2554 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2555 Expr *BitWidth = Importer.Import(D->getBitWidth());
2559 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2560 Importer.Import(D->getInnerLocStart()),
2568 Importer.Imported(D, ToField);
2587 if (Importer.IsStructurallyEquivalent(D->getType(),
2589 Importer.Imported(D, FoundField);
2593 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2595 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2602 QualType T = Importer.Import(D->getType());
2607 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2612 Decl* D = Importer.Import(*PI);
2619 Importer.getToContext(), DC,
2624 Importer.Imported(D, ToIndirectField);
2642 if (Importer.IsStructurallyEquivalent(D->getType(),
2644 Importer.Imported(D, FoundIvar);
2648 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
2650 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
2657 QualType T = Importer.Import(D->getType());
2661 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2662 Expr *BitWidth = Importer.Import(D->getBitWidth());
2666 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
2668 Importer.Import(D->getInnerLocStart()),
2673 Importer.Imported(D, ToIvar);
2703 if (Importer.IsStructurallyEquivalent(D->getType(),
2710 = Importer.getToContext().getAsArrayType(FoundVar->getType());
2712 = Importer.getToContext().getAsArrayType(D->getType());
2717 QualType T = Importer.Import(D->getType());
2731 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
2733 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
2744 Importer.Imported(D, MergeWithVar);
2748 Importer.ToDiag(ExistingDef->getLocation(),
2751 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
2753 Expr *Init = Importer.Import(DDef->getInit());
2762 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2771 QualType T = Importer.Import(D->getType());
2776 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2777 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
2778 Importer.Import(D->getInnerLocStart()),
2783 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2786 Importer.Imported(D, ToVar);
2793 ToVar->setInit(Importer.Import(const_cast<Expr *>(D->getAnyInitializer())));
2803 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
2806 DeclarationName Name = Importer.Import(D->getDeclName());
2811 SourceLocation Loc = Importer.Import(D->getLocation());
2814 QualType T = Importer.Import(D->getType());
2820 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
2823 return Importer.Imported(D, ToParm);
2829 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
2832 DeclarationName Name = Importer.Import(D->getDeclName());
2837 SourceLocation Loc = Importer.Import(D->getLocation());
2840 QualType T = Importer.Import(D->getType());
2845 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2846 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
2847 Importer.Import(D->getInnerLocStart()),
2853 return Importer.Imported(D, ToParm);
2872 if (!Importer.IsStructurallyEquivalent(D->getResultType(),
2874 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
2877 Importer.ToDiag(FoundMethod->getLocation(),
2885 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
2888 Importer.ToDiag(FoundMethod->getLocation(),
2898 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
2900 Importer.FromDiag((*P)->getLocation(),
2904 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
2913 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
2915 Importer.ToDiag(FoundMethod->getLocation(),
2922 return Importer.Imported(D, FoundMethod);
2927 QualType ResultTy = Importer.Import(D->getResultType());
2931 TypeSourceInfo *ResultTInfo = Importer.Import(D->getResultTypeSourceInfo());
2934 = ObjCMethodDecl::Create(Importer.getToContext(),
2936 Importer.Import(D->getLocEnd()),
2956 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*FromP));
2970 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
2973 Importer.Imported(D, ToMethod);
2987 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
2996 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
2997 Importer.Import(D->getAtStartLoc()),
2999 Importer.Import(D->getCategoryNameLoc()),
3004 Importer.Imported(D, ToCategory);
3016 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3020 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3025 ProtocolLocs.data(), Importer.getToContext());
3028 Importer.Imported(D, ToCategory);
3038 Importer.Import(D->getImplementation()));
3070 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3072 Importer.Import(D->getAtStartLoc()),
3078 Importer.Imported(D, ToProto);
3090 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3094 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3099 ProtocolLocs.data(), Importer.getToContext());
3101 Importer.Imported(D, ToProto);
3132 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3133 Importer.Import(D->getAtStartLoc()),
3141 Importer.Imported(D, ToIface);
3145 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getSuperClass()));
3150 ToIface->setSuperClassLoc(Importer.Import(D->getSuperClassLoc()));
3165 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3169 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3174 ProtocolLocs.data(), Importer.getToContext());
3177 ToIface->setAtEndRange(Importer.Import(D->getAtEndRange()));
3179 Importer.Imported(D, ToIface);
3184 FromSuperName = Importer.Import(D->getSuperClass()->getDeclName());
3188 Importer.ToDiag(ToIface->getLocation(),
3192 Importer.ToDiag(ToIface->getSuperClassLoc(),
3196 Importer.ToDiag(ToIface->getLocation(),
3199 Importer.FromDiag(D->getSuperClassLoc(),
3203 Importer.FromDiag(D->getLocation(),
3213 Importer.Import(FromCat);
3221 Importer.Import(D->getImplementation()));
3233 Importer.Import(D->getCategoryDecl()));
3239 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3243 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3244 Importer.Import(D->getIdentifier()),
3246 Importer.Import(D->getLocation()),
3247 Importer.Import(D->getAtStartLoc()));
3251 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3262 Importer.Imported(D, ToImpl);
3270 Importer.Import(D->getClassInterface()));
3278 Importer.Import(D->getSuperClass()));
3287 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3288 Importer.ImportContext(D->getDeclContext()),
3290 Importer.Import(D->getLocation()),
3291 Importer.Import(D->getAtStartLoc()));
3295 = Importer.ImportContext(D->getLexicalDeclContext());
3303 Importer.Imported(D, Iface->getImplementation());
3305 Importer.Imported(D, Iface->getImplementation());
3312 Importer.ToDiag(Impl->getLocation(),
3318 Importer.ToDiag(Impl->getLocation(),
3322 Importer.ToDiag(Impl->getLocation(),
3325 Importer.FromDiag(D->getLocation(),
3329 Importer.FromDiag(D->getLocation(),
3356 if (!Importer.IsStructurallyEquivalent(D->getType(),
3358 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3360 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3368 Importer.Imported(D, FoundProp);
3374 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3380 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3382 Importer.Import(D->getAtLoc()),
3385 Importer.Imported(D, ToProperty);
3392 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3393 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3395 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3397 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3399 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3405 Importer.Import(D->getPropertyDecl()));
3409 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3416 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3429 Importer.Import(D->getPropertyIvarDecl()));
3437 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3438 Importer.Import(D->getLocStart()),
3439 Importer.Import(D->getLocation()),
3443 Importer.Import(D->getPropertyIvarDeclLoc()));
3445 Importer.Imported(D, ToImpl);
3451 Importer.ToDiag(ToImpl->getLocation(),
3456 Importer.FromDiag(D->getLocation(),
3466 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3471 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3478 Importer.Imported(D, ToImpl);
3487 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3493 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3499 SourceLocation Loc = Importer.Import(D->getLocation());
3510 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3515 Locations.push_back(Importer.Import(*FromProtoLoc));
3519 = ObjCForwardProtocolDecl::Create(Importer.getToContext(), DC, Loc,
3524 Importer.Imported(D, ToForward);
3530 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3536 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3542 SourceLocation Loc = Importer.Import(D->getLocation());
3545 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(From->getInterface()));
3546 ObjCClassDecl *ToClass = ObjCClassDecl::Create(Importer.getToContext(), DC,
3549 Importer.Import(From->getLocation()));
3553 Importer.Imported(D, ToClass);
3563 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3564 Importer.getToContext().getTranslationUnitDecl(),
3565 Importer.Import(D->getLocStart()),
3566 Importer.Import(D->getLocation()),
3569 Importer.Import(D->getIdentifier()),
3577 DeclarationName Name = Importer.Import(D->getDeclName());
3582 SourceLocation Loc = Importer.Import(D->getLocation());
3585 QualType T = Importer.Import(D->getType());
3590 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3596 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3597 Importer.getToContext().getTranslationUnitDecl(),
3598 Importer.Import(D->getInnerLocStart()),
3607 DeclarationName Name = Importer.Import(D->getDeclName());
3612 SourceLocation Loc = Importer.Import(D->getLocation());
3622 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3623 Importer.getToContext().getTranslationUnitDecl(),
3638 = Importer.Import(Definition->getDescribedClassTemplate());
3642 return Importer.Imported(D, ImportedDef);
3668 Importer.Imported(D->getTemplatedDecl(),
3670 return Importer.Imported(D, FoundTemplate);
3678 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
3690 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
3691 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
3692 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
3697 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
3706 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
3717 Importer.Imported(D, D2);
3718 Importer.Imported(DTemplated, D2Templated);
3735 Decl *ImportedDef = Importer.Import(Definition);
3739 return Importer.Imported(D, ImportedDef);
3743 = cast_or_null<ClassTemplateDecl>(Importer.Import(
3755 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3761 SourceLocation StartLoc = Importer.Import(D->getLocStart());
3762 SourceLocation IdLoc = Importer.Import(D->getLocation());
3787 return Importer.Imported(D, FoundDef);
3792 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
3805 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3811 Importer.Imported(D, D2);
3824 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
3833 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
3839 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
3845 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
3850 QualType T = Importer.Import(E->getType());
3854 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
3855 Importer.Import(E->getQualifierLoc()),
3857 Importer.Import(E->getLocation()),
3867 QualType T = Importer.Import(E->getType());
3871 return IntegerLiteral::Create(Importer.getToContext(),
3873 Importer.Import(E->getLocation()));
3877 QualType T = Importer.Import(E->getType());
3881 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
3883 Importer.Import(E->getLocation()));
3887 Expr *SubExpr = Importer.Import(E->getSubExpr());
3891 return new (Importer.getToContext())
3892 ParenExpr(Importer.Import(E->getLParen()),
3893 Importer.Import(E->getRParen()),
3898 QualType T = Importer.Import(E->getType());
3902 Expr *SubExpr = Importer.Import(E->getSubExpr());
3906 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
3909 Importer.Import(E->getOperatorLoc()));
3914 QualType ResultType = Importer.Import(E->getType());
3917 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
3921 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
3923 Importer.Import(E->getOperatorLoc()),
3924 Importer.Import(E->getRParenLoc()));
3927 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
3931 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
3933 Importer.Import(E->getOperatorLoc()),
3934 Importer.Import(E->getRParenLoc()));
3938 QualType T = Importer.Import(E->getType());
3942 Expr *LHS = Importer.Import(E->getLHS());
3946 Expr *RHS = Importer.Import(E->getRHS());
3950 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
3953 Importer.Import(E->getOperatorLoc()));
3957 QualType T = Importer.Import(E->getType());
3961 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
3965 QualType CompResultType = Importer.Import(E->getComputationResultType());
3969 Expr *LHS = Importer.Import(E->getLHS());
3973 Expr *RHS = Importer.Import(E->getRHS());
3977 return new (Importer.getToContext())
3982 Importer.Import(E->getOperatorLoc()));
3993 QualType T = Importer.Import(E->getType());
3997 Expr *SubExpr = Importer.Import(E->getSubExpr());
4005 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4010 QualType T = Importer.Import(E->getType());
4014 Expr *SubExpr = Importer.Import(E->getSubExpr());
4018 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4026 return CStyleCastExpr::Create(Importer.getToContext(), T,
4029 Importer.Import(E->getLParenLoc()),
4030 Importer.Import(E->getRParenLoc()));
4059 ASTNodeImporter Importer(*this);
4060 QualType ToT = Importer.Visit(fromTy);
4088 ASTNodeImporter Importer(*this);
4094 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4099 Decl *ToD = Importer.Visit(FromD);
4155 ASTNodeImporter Importer(*this);
4156 Stmt *ToS = Importer.Visit(FromS);
4293 ASTNodeImporter Importer(*this);
4295 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4373 Importer(*this);
4377 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4385 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4391 Importer.ImportDeclContext(FromDC, true);
