ASTImporter.cpp revision 327952
1203955Srdivacky//===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- C++ -*-===// 2203955Srdivacky// 3203955Srdivacky// The LLVM Compiler Infrastructure 4203955Srdivacky// 5203955Srdivacky// This file is distributed under the University of Illinois Open Source 6203955Srdivacky// License. See LICENSE.TXT for details. 7203955Srdivacky// 8203955Srdivacky//===----------------------------------------------------------------------===// 9203955Srdivacky// 10203955Srdivacky// This file defines the ASTImporter class which imports AST nodes from one 11203955Srdivacky// context into another context. 12203955Srdivacky// 13203955Srdivacky//===----------------------------------------------------------------------===// 14203955Srdivacky#include "clang/AST/ASTImporter.h" 15203955Srdivacky#include "clang/AST/ASTContext.h" 16203955Srdivacky#include "clang/AST/ASTDiagnostic.h" 17321369Sdim#include "clang/AST/ASTStructuralEquivalence.h" 18203955Srdivacky#include "clang/AST/DeclCXX.h" 19203955Srdivacky#include "clang/AST/DeclObjC.h" 20203955Srdivacky#include "clang/AST/DeclVisitor.h" 21203955Srdivacky#include "clang/AST/StmtVisitor.h" 22203955Srdivacky#include "clang/AST/TypeVisitor.h" 23203955Srdivacky#include "clang/Basic/FileManager.h" 24203955Srdivacky#include "clang/Basic/SourceManager.h" 25203955Srdivacky#include "llvm/Support/MemoryBuffer.h" 26203955Srdivacky#include <deque> 27203955Srdivacky 28234353Sdimnamespace clang { 29203955Srdivacky class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>, 30203955Srdivacky public DeclVisitor<ASTNodeImporter, Decl *>, 31203955Srdivacky public StmtVisitor<ASTNodeImporter, Stmt *> { 32203955Srdivacky ASTImporter &Importer; 33309124Sdim 34203955Srdivacky public: 35203955Srdivacky explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { } 36203955Srdivacky 37203955Srdivacky using TypeVisitor<ASTNodeImporter, QualType>::Visit; 38203955Srdivacky using DeclVisitor<ASTNodeImporter, Decl *>::Visit; 39203955Srdivacky using StmtVisitor<ASTNodeImporter, Stmt *>::Visit; 40203955Srdivacky 41203955Srdivacky // Importing types 42218893Sdim QualType VisitType(const Type *T); 43314564Sdim QualType VisitAtomicType(const AtomicType *T); 44218893Sdim QualType VisitBuiltinType(const BuiltinType *T); 45314564Sdim QualType VisitDecayedType(const DecayedType *T); 46218893Sdim QualType VisitComplexType(const ComplexType *T); 47218893Sdim QualType VisitPointerType(const PointerType *T); 48218893Sdim QualType VisitBlockPointerType(const BlockPointerType *T); 49218893Sdim QualType VisitLValueReferenceType(const LValueReferenceType *T); 50218893Sdim QualType VisitRValueReferenceType(const RValueReferenceType *T); 51218893Sdim QualType VisitMemberPointerType(const MemberPointerType *T); 52218893Sdim QualType VisitConstantArrayType(const ConstantArrayType *T); 53218893Sdim QualType VisitIncompleteArrayType(const IncompleteArrayType *T); 54218893Sdim QualType VisitVariableArrayType(const VariableArrayType *T); 55203955Srdivacky // FIXME: DependentSizedArrayType 56203955Srdivacky // FIXME: DependentSizedExtVectorType 57218893Sdim QualType VisitVectorType(const VectorType *T); 58218893Sdim QualType VisitExtVectorType(const ExtVectorType *T); 59218893Sdim QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T); 60218893Sdim QualType VisitFunctionProtoType(const FunctionProtoType *T); 61327952Sdim QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T); 62226633Sdim QualType VisitParenType(const ParenType *T); 63218893Sdim QualType VisitTypedefType(const TypedefType *T); 64218893Sdim QualType VisitTypeOfExprType(const TypeOfExprType *T); 65203955Srdivacky // FIXME: DependentTypeOfExprType 66218893Sdim QualType VisitTypeOfType(const TypeOfType *T); 67218893Sdim QualType VisitDecltypeType(const DecltypeType *T); 68223017Sdim QualType VisitUnaryTransformType(const UnaryTransformType *T); 69218893Sdim QualType VisitAutoType(const AutoType *T); 70309124Sdim QualType VisitInjectedClassNameType(const InjectedClassNameType *T); 71203955Srdivacky // FIXME: DependentDecltypeType 72218893Sdim QualType VisitRecordType(const RecordType *T); 73218893Sdim QualType VisitEnumType(const EnumType *T); 74288943Sdim QualType VisitAttributedType(const AttributedType *T); 75309124Sdim QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T); 76321369Sdim QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T); 77218893Sdim QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T); 78218893Sdim QualType VisitElaboratedType(const ElaboratedType *T); 79206084Srdivacky // FIXME: DependentNameType 80327952Sdim QualType VisitPackExpansionType(const PackExpansionType *T); 81210299Sed // FIXME: DependentTemplateSpecializationType 82218893Sdim QualType VisitObjCInterfaceType(const ObjCInterfaceType *T); 83218893Sdim QualType VisitObjCObjectType(const ObjCObjectType *T); 84218893Sdim QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T); 85203955Srdivacky 86234353Sdim // Importing declarations 87203955Srdivacky bool ImportDeclParts(NamedDecl *D, DeclContext *&DC, 88203955Srdivacky DeclContext *&LexicalDC, DeclarationName &Name, 89288943Sdim NamedDecl *&ToD, SourceLocation &Loc); 90276479Sdim void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr); 91212904Sdim void ImportDeclarationNameLoc(const DeclarationNameInfo &From, 92212904Sdim DeclarationNameInfo& To); 93218893Sdim void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false); 94309124Sdim 95314564Sdim bool ImportCastPath(CastExpr *E, CXXCastPath &Path); 96314564Sdim 97309124Sdim typedef DesignatedInitExpr::Designator Designator; 98309124Sdim Designator ImportDesignator(const Designator &D); 99309124Sdim 100234353Sdim 101234353Sdim /// \brief What we should import from the definition. 102234353Sdim enum ImportDefinitionKind { 103234353Sdim /// \brief Import the default subset of the definition, which might be 104234353Sdim /// nothing (if minimal import is set) or might be everything (if minimal 105234353Sdim /// import is not set). 106234353Sdim IDK_Default, 107234353Sdim /// \brief Import everything. 108234353Sdim IDK_Everything, 109234353Sdim /// \brief Import only the bare bones needed to establish a valid 110234353Sdim /// DeclContext. 111234353Sdim IDK_Basic 112234353Sdim }; 113234353Sdim 114234353Sdim bool shouldForceImportDeclContext(ImportDefinitionKind IDK) { 115234353Sdim return IDK == IDK_Everything || 116234353Sdim (IDK == IDK_Default && !Importer.isMinimalImport()); 117234353Sdim } 118234353Sdim 119226633Sdim bool ImportDefinition(RecordDecl *From, RecordDecl *To, 120234353Sdim ImportDefinitionKind Kind = IDK_Default); 121261991Sdim bool ImportDefinition(VarDecl *From, VarDecl *To, 122261991Sdim ImportDefinitionKind Kind = IDK_Default); 123226633Sdim bool ImportDefinition(EnumDecl *From, EnumDecl *To, 124234353Sdim ImportDefinitionKind Kind = IDK_Default); 125234353Sdim bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, 126234353Sdim ImportDefinitionKind Kind = IDK_Default); 127234353Sdim bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To, 128234353Sdim ImportDefinitionKind Kind = IDK_Default); 129218893Sdim TemplateParameterList *ImportTemplateParameterList( 130218893Sdim TemplateParameterList *Params); 131218893Sdim TemplateArgument ImportTemplateArgument(const TemplateArgument &From); 132327952Sdim Optional<TemplateArgumentLoc> ImportTemplateArgumentLoc( 133327952Sdim const TemplateArgumentLoc &TALoc); 134218893Sdim bool ImportTemplateArguments(const TemplateArgument *FromArgs, 135218893Sdim unsigned NumFromArgs, 136226633Sdim SmallVectorImpl<TemplateArgument> &ToArgs); 137327952Sdim template <typename InContainerTy> 138327952Sdim bool ImportTemplateArgumentListInfo(const InContainerTy &Container, 139327952Sdim TemplateArgumentListInfo &ToTAInfo); 140239462Sdim bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord, 141239462Sdim bool Complain = true); 142261991Sdim bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 143261991Sdim bool Complain = true); 144203955Srdivacky bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord); 145249423Sdim bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC); 146327952Sdim bool IsStructuralMatch(FunctionTemplateDecl *From, 147327952Sdim FunctionTemplateDecl *To); 148218893Sdim bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To); 149261991Sdim bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To); 150203955Srdivacky Decl *VisitDecl(Decl *D); 151327952Sdim Decl *VisitEmptyDecl(EmptyDecl *D); 152309124Sdim Decl *VisitAccessSpecDecl(AccessSpecDecl *D); 153314564Sdim Decl *VisitStaticAssertDecl(StaticAssertDecl *D); 154234353Sdim Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 155204643Srdivacky Decl *VisitNamespaceDecl(NamespaceDecl *D); 156327952Sdim Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 157221345Sdim Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias); 158203955Srdivacky Decl *VisitTypedefDecl(TypedefDecl *D); 159221345Sdim Decl *VisitTypeAliasDecl(TypeAliasDecl *D); 160327952Sdim Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 161309124Sdim Decl *VisitLabelDecl(LabelDecl *D); 162203955Srdivacky Decl *VisitEnumDecl(EnumDecl *D); 163203955Srdivacky Decl *VisitRecordDecl(RecordDecl *D); 164203955Srdivacky Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 165203955Srdivacky Decl *VisitFunctionDecl(FunctionDecl *D); 166204643Srdivacky Decl *VisitCXXMethodDecl(CXXMethodDecl *D); 167204643Srdivacky Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 168204643Srdivacky Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 169204643Srdivacky Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 170203955Srdivacky Decl *VisitFieldDecl(FieldDecl *D); 171218893Sdim Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D); 172314564Sdim Decl *VisitFriendDecl(FriendDecl *D); 173204643Srdivacky Decl *VisitObjCIvarDecl(ObjCIvarDecl *D); 174203955Srdivacky Decl *VisitVarDecl(VarDecl *D); 175204643Srdivacky Decl *VisitImplicitParamDecl(ImplicitParamDecl *D); 176203955Srdivacky Decl *VisitParmVarDecl(ParmVarDecl *D); 177204643Srdivacky Decl *VisitObjCMethodDecl(ObjCMethodDecl *D); 178288943Sdim Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D); 179204643Srdivacky Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D); 180204643Srdivacky Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D); 181280031Sdim Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D); 182327952Sdim Decl *VisitUsingDecl(UsingDecl *D); 183327952Sdim Decl *VisitUsingShadowDecl(UsingShadowDecl *D); 184327952Sdim Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 185327952Sdim Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 186327952Sdim Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 187288943Sdim 188327952Sdim 189288943Sdim ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list); 190203955Srdivacky Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 191218893Sdim Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 192218893Sdim Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D); 193204643Srdivacky Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D); 194218893Sdim Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 195218893Sdim Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 196218893Sdim Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 197218893Sdim Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 198218893Sdim Decl *VisitClassTemplateDecl(ClassTemplateDecl *D); 199218893Sdim Decl *VisitClassTemplateSpecializationDecl( 200218893Sdim ClassTemplateSpecializationDecl *D); 201261991Sdim Decl *VisitVarTemplateDecl(VarTemplateDecl *D); 202261991Sdim Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); 203327952Sdim Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 204261991Sdim 205203955Srdivacky // Importing statements 206288943Sdim DeclGroupRef ImportDeclGroup(DeclGroupRef DG); 207288943Sdim 208203955Srdivacky Stmt *VisitStmt(Stmt *S); 209309124Sdim Stmt *VisitGCCAsmStmt(GCCAsmStmt *S); 210288943Sdim Stmt *VisitDeclStmt(DeclStmt *S); 211288943Sdim Stmt *VisitNullStmt(NullStmt *S); 212288943Sdim Stmt *VisitCompoundStmt(CompoundStmt *S); 213288943Sdim Stmt *VisitCaseStmt(CaseStmt *S); 214288943Sdim Stmt *VisitDefaultStmt(DefaultStmt *S); 215288943Sdim Stmt *VisitLabelStmt(LabelStmt *S); 216288943Sdim Stmt *VisitAttributedStmt(AttributedStmt *S); 217288943Sdim Stmt *VisitIfStmt(IfStmt *S); 218288943Sdim Stmt *VisitSwitchStmt(SwitchStmt *S); 219288943Sdim Stmt *VisitWhileStmt(WhileStmt *S); 220288943Sdim Stmt *VisitDoStmt(DoStmt *S); 221288943Sdim Stmt *VisitForStmt(ForStmt *S); 222288943Sdim Stmt *VisitGotoStmt(GotoStmt *S); 223288943Sdim Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S); 224288943Sdim Stmt *VisitContinueStmt(ContinueStmt *S); 225288943Sdim Stmt *VisitBreakStmt(BreakStmt *S); 226288943Sdim Stmt *VisitReturnStmt(ReturnStmt *S); 227288943Sdim // FIXME: MSAsmStmt 228288943Sdim // FIXME: SEHExceptStmt 229288943Sdim // FIXME: SEHFinallyStmt 230288943Sdim // FIXME: SEHTryStmt 231288943Sdim // FIXME: SEHLeaveStmt 232288943Sdim // FIXME: CapturedStmt 233288943Sdim Stmt *VisitCXXCatchStmt(CXXCatchStmt *S); 234288943Sdim Stmt *VisitCXXTryStmt(CXXTryStmt *S); 235288943Sdim Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S); 236288943Sdim // FIXME: MSDependentExistsStmt 237288943Sdim Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S); 238288943Sdim Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S); 239288943Sdim Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S); 240288943Sdim Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S); 241288943Sdim Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S); 242288943Sdim Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S); 243288943Sdim Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S); 244203955Srdivacky 245203955Srdivacky // Importing expressions 246203955Srdivacky Expr *VisitExpr(Expr *E); 247309124Sdim Expr *VisitVAArgExpr(VAArgExpr *E); 248309124Sdim Expr *VisitGNUNullExpr(GNUNullExpr *E); 249309124Sdim Expr *VisitPredefinedExpr(PredefinedExpr *E); 250204643Srdivacky Expr *VisitDeclRefExpr(DeclRefExpr *E); 251309124Sdim Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE); 252309124Sdim Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E); 253309124Sdim Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); 254203955Srdivacky Expr *VisitIntegerLiteral(IntegerLiteral *E); 255309124Sdim Expr *VisitFloatingLiteral(FloatingLiteral *E); 256204643Srdivacky Expr *VisitCharacterLiteral(CharacterLiteral *E); 257309124Sdim Expr *VisitStringLiteral(StringLiteral *E); 258309124Sdim Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 259309124Sdim Expr *VisitAtomicExpr(AtomicExpr *E); 260309124Sdim Expr *VisitAddrLabelExpr(AddrLabelExpr *E); 261204643Srdivacky Expr *VisitParenExpr(ParenExpr *E); 262309124Sdim Expr *VisitParenListExpr(ParenListExpr *E); 263309124Sdim Expr *VisitStmtExpr(StmtExpr *E); 264204643Srdivacky Expr *VisitUnaryOperator(UnaryOperator *E); 265221345Sdim Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 266204643Srdivacky Expr *VisitBinaryOperator(BinaryOperator *E); 267309124Sdim Expr *VisitConditionalOperator(ConditionalOperator *E); 268309124Sdim Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E); 269309124Sdim Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E); 270314564Sdim Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 271314564Sdim Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E); 272314564Sdim Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 273204643Srdivacky Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E); 274203955Srdivacky Expr *VisitImplicitCastExpr(ImplicitCastExpr *E); 275314564Sdim Expr *VisitExplicitCastExpr(ExplicitCastExpr *E); 276314564Sdim Expr *VisitOffsetOfExpr(OffsetOfExpr *OE); 277314564Sdim Expr *VisitCXXThrowExpr(CXXThrowExpr *E); 278314564Sdim Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E); 279314564Sdim Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E); 280314564Sdim Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 281314564Sdim Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 282314564Sdim Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE); 283314564Sdim Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 284327952Sdim Expr *VisitPackExpansionExpr(PackExpansionExpr *E); 285314564Sdim Expr *VisitCXXNewExpr(CXXNewExpr *CE); 286314564Sdim Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E); 287288943Sdim Expr *VisitCXXConstructExpr(CXXConstructExpr *E); 288309124Sdim Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E); 289327952Sdim Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); 290314564Sdim Expr *VisitExprWithCleanups(ExprWithCleanups *EWC); 291309124Sdim Expr *VisitCXXThisExpr(CXXThisExpr *E); 292309124Sdim Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); 293327952Sdim Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); 294288943Sdim Expr *VisitMemberExpr(MemberExpr *E); 295288943Sdim Expr *VisitCallExpr(CallExpr *E); 296309124Sdim Expr *VisitInitListExpr(InitListExpr *E); 297314564Sdim Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E); 298314564Sdim Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E); 299309124Sdim Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E); 300309124Sdim Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E); 301321369Sdim Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E); 302327952Sdim Expr *VisitTypeTraitExpr(TypeTraitExpr *E); 303309124Sdim 304321369Sdim 305309124Sdim template<typename IIter, typename OIter> 306309124Sdim void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) { 307309124Sdim typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT; 308309124Sdim ASTImporter &ImporterRef = Importer; 309309124Sdim std::transform(Ibegin, Iend, Obegin, 310309124Sdim [&ImporterRef](ItemT From) -> ItemT { 311309124Sdim return ImporterRef.Import(From); 312309124Sdim }); 313309124Sdim } 314309124Sdim 315309124Sdim template<typename IIter, typename OIter> 316309124Sdim bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) { 317309124Sdim typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT; 318309124Sdim ASTImporter &ImporterRef = Importer; 319309124Sdim bool Failed = false; 320309124Sdim std::transform(Ibegin, Iend, Obegin, 321309124Sdim [&ImporterRef, &Failed](ItemT *From) -> ItemT * { 322314564Sdim ItemT *To = cast_or_null<ItemT>( 323314564Sdim ImporterRef.Import(From)); 324309124Sdim if (!To && From) 325309124Sdim Failed = true; 326309124Sdim return To; 327309124Sdim }); 328309124Sdim return Failed; 329309124Sdim } 330314564Sdim 331314564Sdim template<typename InContainerTy, typename OutContainerTy> 332314564Sdim bool ImportContainerChecked(const InContainerTy &InContainer, 333314564Sdim OutContainerTy &OutContainer) { 334314564Sdim return ImportArrayChecked(InContainer.begin(), InContainer.end(), 335314564Sdim OutContainer.begin()); 336314564Sdim } 337314564Sdim 338314564Sdim template<typename InContainerTy, typename OIter> 339314564Sdim bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) { 340314564Sdim return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin); 341314564Sdim } 342309124Sdim 343321369Sdim // Importing overrides. 344321369Sdim void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod); 345203955Srdivacky }; 346203955Srdivacky} 347203955Srdivacky 348203955Srdivacky//---------------------------------------------------------------------------- 349203955Srdivacky// Import Types 350203955Srdivacky//---------------------------------------------------------------------------- 351203955Srdivacky 352321369Sdimusing namespace clang; 353321369Sdim 354218893SdimQualType ASTNodeImporter::VisitType(const Type *T) { 355203955Srdivacky Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node) 356203955Srdivacky << T->getTypeClassName(); 357203955Srdivacky return QualType(); 358203955Srdivacky} 359203955Srdivacky 360314564SdimQualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){ 361314564Sdim QualType UnderlyingType = Importer.Import(T->getValueType()); 362314564Sdim if(UnderlyingType.isNull()) 363314564Sdim return QualType(); 364314564Sdim 365314564Sdim return Importer.getToContext().getAtomicType(UnderlyingType); 366314564Sdim} 367314564Sdim 368218893SdimQualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) { 369203955Srdivacky switch (T->getKind()) { 370309124Sdim#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 371309124Sdim case BuiltinType::Id: \ 372309124Sdim return Importer.getToContext().SingletonId; 373309124Sdim#include "clang/Basic/OpenCLImageTypes.def" 374234353Sdim#define SHARED_SINGLETON_TYPE(Expansion) 375234353Sdim#define BUILTIN_TYPE(Id, SingletonId) \ 376234353Sdim case BuiltinType::Id: return Importer.getToContext().SingletonId; 377234353Sdim#include "clang/AST/BuiltinTypes.def" 378234353Sdim 379234353Sdim // FIXME: for Char16, Char32, and NullPtr, make sure that the "to" 380234353Sdim // context supports C++. 381234353Sdim 382234353Sdim // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to" 383234353Sdim // context supports ObjC. 384234353Sdim 385203955Srdivacky case BuiltinType::Char_U: 386203955Srdivacky // The context we're importing from has an unsigned 'char'. If we're 387203955Srdivacky // importing into a context with a signed 'char', translate to 388203955Srdivacky // 'unsigned char' instead. 389234353Sdim if (Importer.getToContext().getLangOpts().CharIsSigned) 390203955Srdivacky return Importer.getToContext().UnsignedCharTy; 391203955Srdivacky 392203955Srdivacky return Importer.getToContext().CharTy; 393203955Srdivacky 394203955Srdivacky case BuiltinType::Char_S: 395203955Srdivacky // The context we're importing from has an unsigned 'char'. If we're 396203955Srdivacky // importing into a context with a signed 'char', translate to 397203955Srdivacky // 'unsigned char' instead. 398234353Sdim if (!Importer.getToContext().getLangOpts().CharIsSigned) 399203955Srdivacky return Importer.getToContext().SignedCharTy; 400203955Srdivacky 401203955Srdivacky return Importer.getToContext().CharTy; 402203955Srdivacky 403218893Sdim case BuiltinType::WChar_S: 404218893Sdim case BuiltinType::WChar_U: 405203955Srdivacky // FIXME: If not in C++, shall we translate to the C equivalent of 406203955Srdivacky // wchar_t? 407203955Srdivacky return Importer.getToContext().WCharTy; 408234353Sdim } 409203955Srdivacky 410234353Sdim llvm_unreachable("Invalid BuiltinType Kind!"); 411203955Srdivacky} 412203955Srdivacky 413314564SdimQualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) { 414314564Sdim QualType OrigT = Importer.Import(T->getOriginalType()); 415314564Sdim if (OrigT.isNull()) 416314564Sdim return QualType(); 417314564Sdim 418314564Sdim return Importer.getToContext().getDecayedType(OrigT); 419314564Sdim} 420314564Sdim 421218893SdimQualType ASTNodeImporter::VisitComplexType(const ComplexType *T) { 422203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 423203955Srdivacky if (ToElementType.isNull()) 424203955Srdivacky return QualType(); 425203955Srdivacky 426203955Srdivacky return Importer.getToContext().getComplexType(ToElementType); 427203955Srdivacky} 428203955Srdivacky 429218893SdimQualType ASTNodeImporter::VisitPointerType(const PointerType *T) { 430203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 431203955Srdivacky if (ToPointeeType.isNull()) 432203955Srdivacky return QualType(); 433203955Srdivacky 434203955Srdivacky return Importer.getToContext().getPointerType(ToPointeeType); 435203955Srdivacky} 436203955Srdivacky 437218893SdimQualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) { 438203955Srdivacky // FIXME: Check for blocks support in "to" context. 439203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 440203955Srdivacky if (ToPointeeType.isNull()) 441203955Srdivacky return QualType(); 442203955Srdivacky 443203955Srdivacky return Importer.getToContext().getBlockPointerType(ToPointeeType); 444203955Srdivacky} 445203955Srdivacky 446218893SdimQualType 447218893SdimASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) { 448203955Srdivacky // FIXME: Check for C++ support in "to" context. 449203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 450203955Srdivacky if (ToPointeeType.isNull()) 451203955Srdivacky return QualType(); 452203955Srdivacky 453203955Srdivacky return Importer.getToContext().getLValueReferenceType(ToPointeeType); 454203955Srdivacky} 455203955Srdivacky 456218893SdimQualType 457218893SdimASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) { 458203955Srdivacky // FIXME: Check for C++0x support in "to" context. 459203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 460203955Srdivacky if (ToPointeeType.isNull()) 461203955Srdivacky return QualType(); 462203955Srdivacky 463203955Srdivacky return Importer.getToContext().getRValueReferenceType(ToPointeeType); 464203955Srdivacky} 465203955Srdivacky 466218893SdimQualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) { 467203955Srdivacky // FIXME: Check for C++ support in "to" context. 468203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 469203955Srdivacky if (ToPointeeType.isNull()) 470203955Srdivacky return QualType(); 471203955Srdivacky 472203955Srdivacky QualType ClassType = Importer.Import(QualType(T->getClass(), 0)); 473203955Srdivacky return Importer.getToContext().getMemberPointerType(ToPointeeType, 474203955Srdivacky ClassType.getTypePtr()); 475203955Srdivacky} 476203955Srdivacky 477218893SdimQualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) { 478203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 479203955Srdivacky if (ToElementType.isNull()) 480203955Srdivacky return QualType(); 481203955Srdivacky 482203955Srdivacky return Importer.getToContext().getConstantArrayType(ToElementType, 483203955Srdivacky T->getSize(), 484203955Srdivacky T->getSizeModifier(), 485203955Srdivacky T->getIndexTypeCVRQualifiers()); 486203955Srdivacky} 487203955Srdivacky 488218893SdimQualType 489218893SdimASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 490203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 491203955Srdivacky if (ToElementType.isNull()) 492203955Srdivacky return QualType(); 493203955Srdivacky 494203955Srdivacky return Importer.getToContext().getIncompleteArrayType(ToElementType, 495203955Srdivacky T->getSizeModifier(), 496203955Srdivacky T->getIndexTypeCVRQualifiers()); 497203955Srdivacky} 498203955Srdivacky 499218893SdimQualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) { 500203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 501203955Srdivacky if (ToElementType.isNull()) 502203955Srdivacky return QualType(); 503203955Srdivacky 504203955Srdivacky Expr *Size = Importer.Import(T->getSizeExpr()); 505203955Srdivacky if (!Size) 506203955Srdivacky return QualType(); 507203955Srdivacky 508203955Srdivacky SourceRange Brackets = Importer.Import(T->getBracketsRange()); 509203955Srdivacky return Importer.getToContext().getVariableArrayType(ToElementType, Size, 510203955Srdivacky T->getSizeModifier(), 511203955Srdivacky T->getIndexTypeCVRQualifiers(), 512203955Srdivacky Brackets); 513203955Srdivacky} 514203955Srdivacky 515218893SdimQualType ASTNodeImporter::VisitVectorType(const VectorType *T) { 516203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 517203955Srdivacky if (ToElementType.isNull()) 518203955Srdivacky return QualType(); 519203955Srdivacky 520203955Srdivacky return Importer.getToContext().getVectorType(ToElementType, 521203955Srdivacky T->getNumElements(), 522218893Sdim T->getVectorKind()); 523203955Srdivacky} 524203955Srdivacky 525218893SdimQualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) { 526203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 527203955Srdivacky if (ToElementType.isNull()) 528203955Srdivacky return QualType(); 529203955Srdivacky 530203955Srdivacky return Importer.getToContext().getExtVectorType(ToElementType, 531203955Srdivacky T->getNumElements()); 532203955Srdivacky} 533203955Srdivacky 534218893SdimQualType 535218893SdimASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 536203955Srdivacky // FIXME: What happens if we're importing a function without a prototype 537203955Srdivacky // into C++? Should we make it variadic? 538276479Sdim QualType ToResultType = Importer.Import(T->getReturnType()); 539203955Srdivacky if (ToResultType.isNull()) 540203955Srdivacky return QualType(); 541206084Srdivacky 542203955Srdivacky return Importer.getToContext().getFunctionNoProtoType(ToResultType, 543206084Srdivacky T->getExtInfo()); 544203955Srdivacky} 545203955Srdivacky 546218893SdimQualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) { 547276479Sdim QualType ToResultType = Importer.Import(T->getReturnType()); 548203955Srdivacky if (ToResultType.isNull()) 549203955Srdivacky return QualType(); 550203955Srdivacky 551203955Srdivacky // Import argument types 552226633Sdim SmallVector<QualType, 4> ArgTypes; 553276479Sdim for (const auto &A : T->param_types()) { 554276479Sdim QualType ArgType = Importer.Import(A); 555203955Srdivacky if (ArgType.isNull()) 556203955Srdivacky return QualType(); 557203955Srdivacky ArgTypes.push_back(ArgType); 558203955Srdivacky } 559203955Srdivacky 560203955Srdivacky // Import exception types 561226633Sdim SmallVector<QualType, 4> ExceptionTypes; 562276479Sdim for (const auto &E : T->exceptions()) { 563276479Sdim QualType ExceptionType = Importer.Import(E); 564203955Srdivacky if (ExceptionType.isNull()) 565203955Srdivacky return QualType(); 566203955Srdivacky ExceptionTypes.push_back(ExceptionType); 567203955Srdivacky } 568218893Sdim 569243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo(); 570243830Sdim FunctionProtoType::ExtProtoInfo ToEPI; 571243830Sdim 572243830Sdim ToEPI.ExtInfo = FromEPI.ExtInfo; 573243830Sdim ToEPI.Variadic = FromEPI.Variadic; 574243830Sdim ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn; 575243830Sdim ToEPI.TypeQuals = FromEPI.TypeQuals; 576243830Sdim ToEPI.RefQualifier = FromEPI.RefQualifier; 577280031Sdim ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type; 578280031Sdim ToEPI.ExceptionSpec.Exceptions = ExceptionTypes; 579280031Sdim ToEPI.ExceptionSpec.NoexceptExpr = 580280031Sdim Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr); 581280031Sdim ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>( 582280031Sdim Importer.Import(FromEPI.ExceptionSpec.SourceDecl)); 583280031Sdim ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>( 584280031Sdim Importer.Import(FromEPI.ExceptionSpec.SourceTemplate)); 585243830Sdim 586249423Sdim return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI); 587203955Srdivacky} 588203955Srdivacky 589327952SdimQualType ASTNodeImporter::VisitUnresolvedUsingType( 590327952Sdim const UnresolvedUsingType *T) { 591327952Sdim UnresolvedUsingTypenameDecl *ToD = cast_or_null<UnresolvedUsingTypenameDecl>( 592327952Sdim Importer.Import(T->getDecl())); 593327952Sdim if (!ToD) 594327952Sdim return QualType(); 595327952Sdim 596327952Sdim UnresolvedUsingTypenameDecl *ToPrevD = 597327952Sdim cast_or_null<UnresolvedUsingTypenameDecl>( 598327952Sdim Importer.Import(T->getDecl()->getPreviousDecl())); 599327952Sdim if (!ToPrevD && T->getDecl()->getPreviousDecl()) 600327952Sdim return QualType(); 601327952Sdim 602327952Sdim return Importer.getToContext().getTypeDeclType(ToD, ToPrevD); 603327952Sdim} 604327952Sdim 605226633SdimQualType ASTNodeImporter::VisitParenType(const ParenType *T) { 606226633Sdim QualType ToInnerType = Importer.Import(T->getInnerType()); 607226633Sdim if (ToInnerType.isNull()) 608226633Sdim return QualType(); 609226633Sdim 610226633Sdim return Importer.getToContext().getParenType(ToInnerType); 611226633Sdim} 612226633Sdim 613218893SdimQualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) { 614221345Sdim TypedefNameDecl *ToDecl 615221345Sdim = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl())); 616203955Srdivacky if (!ToDecl) 617203955Srdivacky return QualType(); 618203955Srdivacky 619203955Srdivacky return Importer.getToContext().getTypeDeclType(ToDecl); 620203955Srdivacky} 621203955Srdivacky 622218893SdimQualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) { 623203955Srdivacky Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 624203955Srdivacky if (!ToExpr) 625203955Srdivacky return QualType(); 626203955Srdivacky 627203955Srdivacky return Importer.getToContext().getTypeOfExprType(ToExpr); 628203955Srdivacky} 629203955Srdivacky 630218893SdimQualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) { 631203955Srdivacky QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 632203955Srdivacky if (ToUnderlyingType.isNull()) 633203955Srdivacky return QualType(); 634203955Srdivacky 635203955Srdivacky return Importer.getToContext().getTypeOfType(ToUnderlyingType); 636203955Srdivacky} 637203955Srdivacky 638218893SdimQualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) { 639218893Sdim // FIXME: Make sure that the "to" context supports C++0x! 640203955Srdivacky Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 641203955Srdivacky if (!ToExpr) 642203955Srdivacky return QualType(); 643203955Srdivacky 644234353Sdim QualType UnderlyingType = Importer.Import(T->getUnderlyingType()); 645234353Sdim if (UnderlyingType.isNull()) 646234353Sdim return QualType(); 647234353Sdim 648234353Sdim return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType); 649203955Srdivacky} 650203955Srdivacky 651223017SdimQualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) { 652223017Sdim QualType ToBaseType = Importer.Import(T->getBaseType()); 653223017Sdim QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 654223017Sdim if (ToBaseType.isNull() || ToUnderlyingType.isNull()) 655223017Sdim return QualType(); 656223017Sdim 657223017Sdim return Importer.getToContext().getUnaryTransformType(ToBaseType, 658223017Sdim ToUnderlyingType, 659223017Sdim T->getUTTKind()); 660223017Sdim} 661223017Sdim 662218893SdimQualType ASTNodeImporter::VisitAutoType(const AutoType *T) { 663251662Sdim // FIXME: Make sure that the "to" context supports C++11! 664218893Sdim QualType FromDeduced = T->getDeducedType(); 665218893Sdim QualType ToDeduced; 666218893Sdim if (!FromDeduced.isNull()) { 667218893Sdim ToDeduced = Importer.Import(FromDeduced); 668218893Sdim if (ToDeduced.isNull()) 669218893Sdim return QualType(); 670218893Sdim } 671218893Sdim 672296417Sdim return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(), 673261991Sdim /*IsDependent*/false); 674218893Sdim} 675218893Sdim 676309124SdimQualType ASTNodeImporter::VisitInjectedClassNameType( 677309124Sdim const InjectedClassNameType *T) { 678309124Sdim CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl())); 679309124Sdim if (!D) 680309124Sdim return QualType(); 681309124Sdim 682309124Sdim QualType InjType = Importer.Import(T->getInjectedSpecializationType()); 683309124Sdim if (InjType.isNull()) 684309124Sdim return QualType(); 685309124Sdim 686309124Sdim // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading 687309124Sdim // See comments in InjectedClassNameType definition for details 688309124Sdim // return Importer.getToContext().getInjectedClassNameType(D, InjType); 689309124Sdim enum { 690309124Sdim TypeAlignmentInBits = 4, 691309124Sdim TypeAlignment = 1 << TypeAlignmentInBits 692309124Sdim }; 693309124Sdim 694309124Sdim return QualType(new (Importer.getToContext(), TypeAlignment) 695309124Sdim InjectedClassNameType(D, InjType), 0); 696309124Sdim} 697309124Sdim 698218893SdimQualType ASTNodeImporter::VisitRecordType(const RecordType *T) { 699203955Srdivacky RecordDecl *ToDecl 700203955Srdivacky = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl())); 701203955Srdivacky if (!ToDecl) 702203955Srdivacky return QualType(); 703203955Srdivacky 704203955Srdivacky return Importer.getToContext().getTagDeclType(ToDecl); 705203955Srdivacky} 706203955Srdivacky 707218893SdimQualType ASTNodeImporter::VisitEnumType(const EnumType *T) { 708203955Srdivacky EnumDecl *ToDecl 709203955Srdivacky = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl())); 710203955Srdivacky if (!ToDecl) 711203955Srdivacky return QualType(); 712203955Srdivacky 713203955Srdivacky return Importer.getToContext().getTagDeclType(ToDecl); 714203955Srdivacky} 715203955Srdivacky 716288943SdimQualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) { 717288943Sdim QualType FromModifiedType = T->getModifiedType(); 718288943Sdim QualType FromEquivalentType = T->getEquivalentType(); 719288943Sdim QualType ToModifiedType; 720288943Sdim QualType ToEquivalentType; 721288943Sdim 722288943Sdim if (!FromModifiedType.isNull()) { 723288943Sdim ToModifiedType = Importer.Import(FromModifiedType); 724288943Sdim if (ToModifiedType.isNull()) 725288943Sdim return QualType(); 726288943Sdim } 727288943Sdim if (!FromEquivalentType.isNull()) { 728288943Sdim ToEquivalentType = Importer.Import(FromEquivalentType); 729288943Sdim if (ToEquivalentType.isNull()) 730288943Sdim return QualType(); 731288943Sdim } 732288943Sdim 733288943Sdim return Importer.getToContext().getAttributedType(T->getAttrKind(), 734288943Sdim ToModifiedType, ToEquivalentType); 735288943Sdim} 736288943Sdim 737309124Sdim 738309124SdimQualType ASTNodeImporter::VisitTemplateTypeParmType( 739309124Sdim const TemplateTypeParmType *T) { 740309124Sdim TemplateTypeParmDecl *ParmDecl = 741309124Sdim cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl())); 742309124Sdim if (!ParmDecl && T->getDecl()) 743309124Sdim return QualType(); 744309124Sdim 745309124Sdim return Importer.getToContext().getTemplateTypeParmType( 746309124Sdim T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl); 747309124Sdim} 748309124Sdim 749321369SdimQualType ASTNodeImporter::VisitSubstTemplateTypeParmType( 750321369Sdim const SubstTemplateTypeParmType *T) { 751321369Sdim const TemplateTypeParmType *Replaced = 752321369Sdim cast_or_null<TemplateTypeParmType>(Importer.Import( 753321369Sdim QualType(T->getReplacedParameter(), 0)).getTypePtr()); 754321369Sdim if (!Replaced) 755321369Sdim return QualType(); 756321369Sdim 757321369Sdim QualType Replacement = Importer.Import(T->getReplacementType()); 758321369Sdim if (Replacement.isNull()) 759321369Sdim return QualType(); 760321369Sdim Replacement = Replacement.getCanonicalType(); 761321369Sdim 762321369Sdim return Importer.getToContext().getSubstTemplateTypeParmType( 763321369Sdim Replaced, Replacement); 764321369Sdim} 765321369Sdim 766218893SdimQualType ASTNodeImporter::VisitTemplateSpecializationType( 767218893Sdim const TemplateSpecializationType *T) { 768218893Sdim TemplateName ToTemplate = Importer.Import(T->getTemplateName()); 769218893Sdim if (ToTemplate.isNull()) 770218893Sdim return QualType(); 771218893Sdim 772226633Sdim SmallVector<TemplateArgument, 2> ToTemplateArgs; 773218893Sdim if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs)) 774218893Sdim return QualType(); 775218893Sdim 776218893Sdim QualType ToCanonType; 777218893Sdim if (!QualType(T, 0).isCanonical()) { 778218893Sdim QualType FromCanonType 779218893Sdim = Importer.getFromContext().getCanonicalType(QualType(T, 0)); 780218893Sdim ToCanonType =Importer.Import(FromCanonType); 781218893Sdim if (ToCanonType.isNull()) 782218893Sdim return QualType(); 783218893Sdim } 784218893Sdim return Importer.getToContext().getTemplateSpecializationType(ToTemplate, 785309124Sdim ToTemplateArgs, 786218893Sdim ToCanonType); 787218893Sdim} 788218893Sdim 789218893SdimQualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) { 790276479Sdim NestedNameSpecifier *ToQualifier = nullptr; 791208600Srdivacky // Note: the qualifier in an ElaboratedType is optional. 792208600Srdivacky if (T->getQualifier()) { 793208600Srdivacky ToQualifier = Importer.Import(T->getQualifier()); 794208600Srdivacky if (!ToQualifier) 795208600Srdivacky return QualType(); 796208600Srdivacky } 797203955Srdivacky 798203955Srdivacky QualType ToNamedType = Importer.Import(T->getNamedType()); 799203955Srdivacky if (ToNamedType.isNull()) 800203955Srdivacky return QualType(); 801203955Srdivacky 802208600Srdivacky return Importer.getToContext().getElaboratedType(T->getKeyword(), 803208600Srdivacky ToQualifier, ToNamedType); 804203955Srdivacky} 805203955Srdivacky 806327952SdimQualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) { 807327952Sdim QualType Pattern = Importer.Import(T->getPattern()); 808327952Sdim if (Pattern.isNull()) 809327952Sdim return QualType(); 810327952Sdim 811327952Sdim return Importer.getToContext().getPackExpansionType(Pattern, 812327952Sdim T->getNumExpansions()); 813327952Sdim} 814327952Sdim 815218893SdimQualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 816203955Srdivacky ObjCInterfaceDecl *Class 817203955Srdivacky = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl())); 818203955Srdivacky if (!Class) 819203955Srdivacky return QualType(); 820203955Srdivacky 821208600Srdivacky return Importer.getToContext().getObjCInterfaceType(Class); 822208600Srdivacky} 823208600Srdivacky 824218893SdimQualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) { 825208600Srdivacky QualType ToBaseType = Importer.Import(T->getBaseType()); 826208600Srdivacky if (ToBaseType.isNull()) 827208600Srdivacky return QualType(); 828208600Srdivacky 829288943Sdim SmallVector<QualType, 4> TypeArgs; 830288943Sdim for (auto TypeArg : T->getTypeArgsAsWritten()) { 831288943Sdim QualType ImportedTypeArg = Importer.Import(TypeArg); 832288943Sdim if (ImportedTypeArg.isNull()) 833288943Sdim return QualType(); 834288943Sdim 835288943Sdim TypeArgs.push_back(ImportedTypeArg); 836288943Sdim } 837288943Sdim 838226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 839276479Sdim for (auto *P : T->quals()) { 840203955Srdivacky ObjCProtocolDecl *Protocol 841276479Sdim = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P)); 842203955Srdivacky if (!Protocol) 843203955Srdivacky return QualType(); 844203955Srdivacky Protocols.push_back(Protocol); 845203955Srdivacky } 846203955Srdivacky 847288943Sdim return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs, 848288943Sdim Protocols, 849288943Sdim T->isKindOfTypeAsWritten()); 850203955Srdivacky} 851203955Srdivacky 852218893SdimQualType 853218893SdimASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 854203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 855203955Srdivacky if (ToPointeeType.isNull()) 856203955Srdivacky return QualType(); 857203955Srdivacky 858208600Srdivacky return Importer.getToContext().getObjCObjectPointerType(ToPointeeType); 859203955Srdivacky} 860203955Srdivacky 861203955Srdivacky//---------------------------------------------------------------------------- 862203955Srdivacky// Import Declarations 863203955Srdivacky//---------------------------------------------------------------------------- 864203955Srdivackybool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC, 865203955Srdivacky DeclContext *&LexicalDC, 866203955Srdivacky DeclarationName &Name, 867288943Sdim NamedDecl *&ToD, 868203955Srdivacky SourceLocation &Loc) { 869203955Srdivacky // Import the context of this declaration. 870203955Srdivacky DC = Importer.ImportContext(D->getDeclContext()); 871203955Srdivacky if (!DC) 872203955Srdivacky return true; 873203955Srdivacky 874203955Srdivacky LexicalDC = DC; 875203955Srdivacky if (D->getDeclContext() != D->getLexicalDeclContext()) { 876203955Srdivacky LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 877203955Srdivacky if (!LexicalDC) 878203955Srdivacky return true; 879203955Srdivacky } 880203955Srdivacky 881203955Srdivacky // Import the name of this declaration. 882203955Srdivacky Name = Importer.Import(D->getDeclName()); 883203955Srdivacky if (D->getDeclName() && !Name) 884203955Srdivacky return true; 885203955Srdivacky 886203955Srdivacky // Import the location of this declaration. 887203955Srdivacky Loc = Importer.Import(D->getLocation()); 888288943Sdim ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D)); 889203955Srdivacky return false; 890203955Srdivacky} 891203955Srdivacky 892226633Sdimvoid ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) { 893226633Sdim if (!FromD) 894226633Sdim return; 895226633Sdim 896226633Sdim if (!ToD) { 897226633Sdim ToD = Importer.Import(FromD); 898226633Sdim if (!ToD) 899226633Sdim return; 900226633Sdim } 901226633Sdim 902226633Sdim if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) { 903226633Sdim if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) { 904249423Sdim if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) { 905226633Sdim ImportDefinition(FromRecord, ToRecord); 906226633Sdim } 907226633Sdim } 908226633Sdim return; 909226633Sdim } 910226633Sdim 911226633Sdim if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) { 912226633Sdim if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) { 913226633Sdim if (FromEnum->getDefinition() && !ToEnum->getDefinition()) { 914226633Sdim ImportDefinition(FromEnum, ToEnum); 915226633Sdim } 916226633Sdim } 917226633Sdim return; 918226633Sdim } 919226633Sdim} 920226633Sdim 921212904Sdimvoid 922212904SdimASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From, 923212904Sdim DeclarationNameInfo& To) { 924212904Sdim // NOTE: To.Name and To.Loc are already imported. 925212904Sdim // We only have to import To.LocInfo. 926212904Sdim switch (To.getName().getNameKind()) { 927212904Sdim case DeclarationName::Identifier: 928212904Sdim case DeclarationName::ObjCZeroArgSelector: 929212904Sdim case DeclarationName::ObjCOneArgSelector: 930212904Sdim case DeclarationName::ObjCMultiArgSelector: 931212904Sdim case DeclarationName::CXXUsingDirective: 932321369Sdim case DeclarationName::CXXDeductionGuideName: 933212904Sdim return; 934212904Sdim 935212904Sdim case DeclarationName::CXXOperatorName: { 936212904Sdim SourceRange Range = From.getCXXOperatorNameRange(); 937212904Sdim To.setCXXOperatorNameRange(Importer.Import(Range)); 938212904Sdim return; 939212904Sdim } 940212904Sdim case DeclarationName::CXXLiteralOperatorName: { 941212904Sdim SourceLocation Loc = From.getCXXLiteralOperatorNameLoc(); 942212904Sdim To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc)); 943212904Sdim return; 944212904Sdim } 945212904Sdim case DeclarationName::CXXConstructorName: 946212904Sdim case DeclarationName::CXXDestructorName: 947212904Sdim case DeclarationName::CXXConversionFunctionName: { 948212904Sdim TypeSourceInfo *FromTInfo = From.getNamedTypeInfo(); 949212904Sdim To.setNamedTypeInfo(Importer.Import(FromTInfo)); 950212904Sdim return; 951212904Sdim } 952212904Sdim } 953234353Sdim llvm_unreachable("Unknown name kind."); 954212904Sdim} 955212904Sdim 956234353Sdimvoid ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) { 957218893Sdim if (Importer.isMinimalImport() && !ForceImport) { 958226633Sdim Importer.ImportContext(FromDC); 959218893Sdim return; 960218893Sdim } 961218893Sdim 962276479Sdim for (auto *From : FromDC->decls()) 963276479Sdim Importer.Import(From); 964204643Srdivacky} 965204643Srdivacky 966226633Sdimbool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To, 967234353Sdim ImportDefinitionKind Kind) { 968234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 969234353Sdim if (Kind == IDK_Everything) 970234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 971234353Sdim 972218893Sdim return false; 973234353Sdim } 974218893Sdim 975218893Sdim To->startDefinition(); 976218893Sdim 977218893Sdim // Add base classes. 978218893Sdim if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) { 979218893Sdim CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From); 980234353Sdim 981234353Sdim struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data(); 982234353Sdim struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data(); 983234353Sdim ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor; 984249423Sdim ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers; 985234353Sdim ToData.Aggregate = FromData.Aggregate; 986234353Sdim ToData.PlainOldData = FromData.PlainOldData; 987234353Sdim ToData.Empty = FromData.Empty; 988234353Sdim ToData.Polymorphic = FromData.Polymorphic; 989234353Sdim ToData.Abstract = FromData.Abstract; 990234353Sdim ToData.IsStandardLayout = FromData.IsStandardLayout; 991234353Sdim ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases; 992234353Sdim ToData.HasPrivateFields = FromData.HasPrivateFields; 993234353Sdim ToData.HasProtectedFields = FromData.HasProtectedFields; 994234353Sdim ToData.HasPublicFields = FromData.HasPublicFields; 995234353Sdim ToData.HasMutableFields = FromData.HasMutableFields; 996276479Sdim ToData.HasVariantMembers = FromData.HasVariantMembers; 997234353Sdim ToData.HasOnlyCMembers = FromData.HasOnlyCMembers; 998239462Sdim ToData.HasInClassInitializer = FromData.HasInClassInitializer; 999249423Sdim ToData.HasUninitializedReferenceMember 1000249423Sdim = FromData.HasUninitializedReferenceMember; 1001309124Sdim ToData.HasUninitializedFields = FromData.HasUninitializedFields; 1002309124Sdim ToData.HasInheritedConstructor = FromData.HasInheritedConstructor; 1003309124Sdim ToData.HasInheritedAssignment = FromData.HasInheritedAssignment; 1004322855Sdim ToData.NeedOverloadResolutionForCopyConstructor 1005322855Sdim = FromData.NeedOverloadResolutionForCopyConstructor; 1006249423Sdim ToData.NeedOverloadResolutionForMoveConstructor 1007249423Sdim = FromData.NeedOverloadResolutionForMoveConstructor; 1008249423Sdim ToData.NeedOverloadResolutionForMoveAssignment 1009249423Sdim = FromData.NeedOverloadResolutionForMoveAssignment; 1010249423Sdim ToData.NeedOverloadResolutionForDestructor 1011249423Sdim = FromData.NeedOverloadResolutionForDestructor; 1012322855Sdim ToData.DefaultedCopyConstructorIsDeleted 1013322855Sdim = FromData.DefaultedCopyConstructorIsDeleted; 1014249423Sdim ToData.DefaultedMoveConstructorIsDeleted 1015249423Sdim = FromData.DefaultedMoveConstructorIsDeleted; 1016249423Sdim ToData.DefaultedMoveAssignmentIsDeleted 1017249423Sdim = FromData.DefaultedMoveAssignmentIsDeleted; 1018249423Sdim ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted; 1019249423Sdim ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers; 1020249423Sdim ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor; 1021234353Sdim ToData.HasConstexprNonCopyMoveConstructor 1022234353Sdim = FromData.HasConstexprNonCopyMoveConstructor; 1023309124Sdim ToData.HasDefaultedDefaultConstructor 1024309124Sdim = FromData.HasDefaultedDefaultConstructor; 1025322855Sdim ToData.CanPassInRegisters = FromData.CanPassInRegisters; 1026234353Sdim ToData.DefaultedDefaultConstructorIsConstexpr 1027234353Sdim = FromData.DefaultedDefaultConstructorIsConstexpr; 1028234353Sdim ToData.HasConstexprDefaultConstructor 1029234353Sdim = FromData.HasConstexprDefaultConstructor; 1030234353Sdim ToData.HasNonLiteralTypeFieldsOrBases 1031234353Sdim = FromData.HasNonLiteralTypeFieldsOrBases; 1032234353Sdim // ComputedVisibleConversions not imported. 1033234353Sdim ToData.UserProvidedDefaultConstructor 1034234353Sdim = FromData.UserProvidedDefaultConstructor; 1035249423Sdim ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers; 1036321369Sdim ToData.ImplicitCopyConstructorCanHaveConstParamForVBase 1037321369Sdim = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase; 1038321369Sdim ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase 1039321369Sdim = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase; 1040249423Sdim ToData.ImplicitCopyAssignmentHasConstParam 1041249423Sdim = FromData.ImplicitCopyAssignmentHasConstParam; 1042249423Sdim ToData.HasDeclaredCopyConstructorWithConstParam 1043249423Sdim = FromData.HasDeclaredCopyConstructorWithConstParam; 1044249423Sdim ToData.HasDeclaredCopyAssignmentWithConstParam 1045249423Sdim = FromData.HasDeclaredCopyAssignmentWithConstParam; 1046234353Sdim ToData.IsLambda = FromData.IsLambda; 1047234353Sdim 1048226633Sdim SmallVector<CXXBaseSpecifier *, 4> Bases; 1049276479Sdim for (const auto &Base1 : FromCXX->bases()) { 1050276479Sdim QualType T = Importer.Import(Base1.getType()); 1051218893Sdim if (T.isNull()) 1052218893Sdim return true; 1053218893Sdim 1054218893Sdim SourceLocation EllipsisLoc; 1055276479Sdim if (Base1.isPackExpansion()) 1056276479Sdim EllipsisLoc = Importer.Import(Base1.getEllipsisLoc()); 1057226633Sdim 1058226633Sdim // Ensure that we have a definition for the base. 1059276479Sdim ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()); 1060226633Sdim 1061218893Sdim Bases.push_back( 1062218893Sdim new (Importer.getToContext()) 1063276479Sdim CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()), 1064276479Sdim Base1.isVirtual(), 1065276479Sdim Base1.isBaseOfClass(), 1066276479Sdim Base1.getAccessSpecifierAsWritten(), 1067276479Sdim Importer.Import(Base1.getTypeSourceInfo()), 1068218893Sdim EllipsisLoc)); 1069218893Sdim } 1070218893Sdim if (!Bases.empty()) 1071218893Sdim ToCXX->setBases(Bases.data(), Bases.size()); 1072218893Sdim } 1073218893Sdim 1074234353Sdim if (shouldForceImportDeclContext(Kind)) 1075234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 1076234353Sdim 1077218893Sdim To->completeDefinition(); 1078218893Sdim return false; 1079218893Sdim} 1080218893Sdim 1081261991Sdimbool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To, 1082261991Sdim ImportDefinitionKind Kind) { 1083288943Sdim if (To->getAnyInitializer()) 1084261991Sdim return false; 1085261991Sdim 1086261991Sdim // FIXME: Can we really import any initializer? Alternatively, we could force 1087261991Sdim // ourselves to import every declaration of a variable and then only use 1088261991Sdim // getInit() here. 1089261991Sdim To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer()))); 1090261991Sdim 1091261991Sdim // FIXME: Other bits to merge? 1092261991Sdim 1093261991Sdim return false; 1094261991Sdim} 1095261991Sdim 1096226633Sdimbool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To, 1097234353Sdim ImportDefinitionKind Kind) { 1098234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 1099234353Sdim if (Kind == IDK_Everything) 1100234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 1101226633Sdim return false; 1102234353Sdim } 1103226633Sdim 1104226633Sdim To->startDefinition(); 1105226633Sdim 1106226633Sdim QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From)); 1107226633Sdim if (T.isNull()) 1108226633Sdim return true; 1109226633Sdim 1110226633Sdim QualType ToPromotionType = Importer.Import(From->getPromotionType()); 1111226633Sdim if (ToPromotionType.isNull()) 1112226633Sdim return true; 1113234353Sdim 1114234353Sdim if (shouldForceImportDeclContext(Kind)) 1115234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 1116226633Sdim 1117226633Sdim // FIXME: we might need to merge the number of positive or negative bits 1118226633Sdim // if the enumerator lists don't match. 1119226633Sdim To->completeDefinition(T, ToPromotionType, 1120226633Sdim From->getNumPositiveBits(), 1121226633Sdim From->getNumNegativeBits()); 1122226633Sdim return false; 1123226633Sdim} 1124226633Sdim 1125218893SdimTemplateParameterList *ASTNodeImporter::ImportTemplateParameterList( 1126218893Sdim TemplateParameterList *Params) { 1127314564Sdim SmallVector<NamedDecl *, 4> ToParams(Params->size()); 1128314564Sdim if (ImportContainerChecked(*Params, ToParams)) 1129314564Sdim return nullptr; 1130314564Sdim 1131314564Sdim Expr *ToRequiresClause; 1132314564Sdim if (Expr *const R = Params->getRequiresClause()) { 1133314564Sdim ToRequiresClause = Importer.Import(R); 1134314564Sdim if (!ToRequiresClause) 1135276479Sdim return nullptr; 1136314564Sdim } else { 1137314564Sdim ToRequiresClause = nullptr; 1138314564Sdim } 1139276479Sdim 1140218893Sdim return TemplateParameterList::Create(Importer.getToContext(), 1141218893Sdim Importer.Import(Params->getTemplateLoc()), 1142218893Sdim Importer.Import(Params->getLAngleLoc()), 1143296417Sdim ToParams, 1144314564Sdim Importer.Import(Params->getRAngleLoc()), 1145314564Sdim ToRequiresClause); 1146218893Sdim} 1147218893Sdim 1148218893SdimTemplateArgument 1149218893SdimASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) { 1150218893Sdim switch (From.getKind()) { 1151218893Sdim case TemplateArgument::Null: 1152218893Sdim return TemplateArgument(); 1153218893Sdim 1154218893Sdim case TemplateArgument::Type: { 1155218893Sdim QualType ToType = Importer.Import(From.getAsType()); 1156218893Sdim if (ToType.isNull()) 1157218893Sdim return TemplateArgument(); 1158218893Sdim return TemplateArgument(ToType); 1159218893Sdim } 1160218893Sdim 1161218893Sdim case TemplateArgument::Integral: { 1162218893Sdim QualType ToType = Importer.Import(From.getIntegralType()); 1163218893Sdim if (ToType.isNull()) 1164218893Sdim return TemplateArgument(); 1165239462Sdim return TemplateArgument(From, ToType); 1166218893Sdim } 1167218893Sdim 1168243830Sdim case TemplateArgument::Declaration: { 1169280031Sdim ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl())); 1170280031Sdim QualType ToType = Importer.Import(From.getParamTypeForDecl()); 1171280031Sdim if (!To || ToType.isNull()) 1172280031Sdim return TemplateArgument(); 1173280031Sdim return TemplateArgument(To, ToType); 1174243830Sdim } 1175243830Sdim 1176243830Sdim case TemplateArgument::NullPtr: { 1177243830Sdim QualType ToType = Importer.Import(From.getNullPtrType()); 1178243830Sdim if (ToType.isNull()) 1179243830Sdim return TemplateArgument(); 1180243830Sdim return TemplateArgument(ToType, /*isNullPtr*/true); 1181243830Sdim } 1182243830Sdim 1183218893Sdim case TemplateArgument::Template: { 1184218893Sdim TemplateName ToTemplate = Importer.Import(From.getAsTemplate()); 1185218893Sdim if (ToTemplate.isNull()) 1186218893Sdim return TemplateArgument(); 1187218893Sdim 1188218893Sdim return TemplateArgument(ToTemplate); 1189218893Sdim } 1190218893Sdim 1191218893Sdim case TemplateArgument::TemplateExpansion: { 1192218893Sdim TemplateName ToTemplate 1193218893Sdim = Importer.Import(From.getAsTemplateOrTemplatePattern()); 1194218893Sdim if (ToTemplate.isNull()) 1195218893Sdim return TemplateArgument(); 1196218893Sdim 1197218893Sdim return TemplateArgument(ToTemplate, From.getNumTemplateExpansions()); 1198218893Sdim } 1199218893Sdim 1200218893Sdim case TemplateArgument::Expression: 1201218893Sdim if (Expr *ToExpr = Importer.Import(From.getAsExpr())) 1202218893Sdim return TemplateArgument(ToExpr); 1203218893Sdim return TemplateArgument(); 1204218893Sdim 1205218893Sdim case TemplateArgument::Pack: { 1206226633Sdim SmallVector<TemplateArgument, 2> ToPack; 1207218893Sdim ToPack.reserve(From.pack_size()); 1208218893Sdim if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack)) 1209218893Sdim return TemplateArgument(); 1210296417Sdim 1211296417Sdim return TemplateArgument( 1212296417Sdim llvm::makeArrayRef(ToPack).copy(Importer.getToContext())); 1213218893Sdim } 1214218893Sdim } 1215218893Sdim 1216218893Sdim llvm_unreachable("Invalid template argument kind"); 1217218893Sdim} 1218218893Sdim 1219327952SdimOptional<TemplateArgumentLoc> 1220327952SdimASTNodeImporter::ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc) { 1221314564Sdim TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument()); 1222314564Sdim TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo(); 1223314564Sdim TemplateArgumentLocInfo ToInfo; 1224314564Sdim if (Arg.getKind() == TemplateArgument::Expression) { 1225314564Sdim Expr *E = Importer.Import(FromInfo.getAsExpr()); 1226314564Sdim ToInfo = TemplateArgumentLocInfo(E); 1227314564Sdim if (!E) 1228327952Sdim return None; 1229314564Sdim } else if (Arg.getKind() == TemplateArgument::Type) { 1230314564Sdim if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo())) 1231314564Sdim ToInfo = TemplateArgumentLocInfo(TSI); 1232314564Sdim else 1233327952Sdim return None; 1234314564Sdim } else { 1235314564Sdim ToInfo = TemplateArgumentLocInfo( 1236314564Sdim Importer.Import(FromInfo.getTemplateQualifierLoc()), 1237314564Sdim Importer.Import(FromInfo.getTemplateNameLoc()), 1238314564Sdim Importer.Import(FromInfo.getTemplateEllipsisLoc())); 1239314564Sdim } 1240314564Sdim return TemplateArgumentLoc(Arg, ToInfo); 1241314564Sdim} 1242314564Sdim 1243218893Sdimbool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs, 1244218893Sdim unsigned NumFromArgs, 1245226633Sdim SmallVectorImpl<TemplateArgument> &ToArgs) { 1246218893Sdim for (unsigned I = 0; I != NumFromArgs; ++I) { 1247218893Sdim TemplateArgument To = ImportTemplateArgument(FromArgs[I]); 1248218893Sdim if (To.isNull() && !FromArgs[I].isNull()) 1249218893Sdim return true; 1250218893Sdim 1251218893Sdim ToArgs.push_back(To); 1252218893Sdim } 1253218893Sdim 1254218893Sdim return false; 1255218893Sdim} 1256218893Sdim 1257327952Sdimtemplate <typename InContainerTy> 1258327952Sdimbool ASTNodeImporter::ImportTemplateArgumentListInfo( 1259327952Sdim const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) { 1260327952Sdim for (const auto &FromLoc : Container) { 1261327952Sdim if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc)) 1262327952Sdim ToTAInfo.addArgument(*ToLoc); 1263327952Sdim else 1264327952Sdim return true; 1265327952Sdim } 1266327952Sdim return false; 1267327952Sdim} 1268327952Sdim 1269203955Srdivackybool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord, 1270239462Sdim RecordDecl *ToRecord, bool Complain) { 1271261991Sdim // Eliminate a potential failure point where we attempt to re-import 1272261991Sdim // something we're trying to import while completing ToRecord. 1273261991Sdim Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord); 1274261991Sdim if (ToOrigin) { 1275261991Sdim RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin); 1276261991Sdim if (ToOriginRecord) 1277261991Sdim ToRecord = ToOriginRecord; 1278261991Sdim } 1279261991Sdim 1280204643Srdivacky StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1281261991Sdim ToRecord->getASTContext(), 1282239462Sdim Importer.getNonEquivalentDecls(), 1283239462Sdim false, Complain); 1284204643Srdivacky return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord); 1285203955Srdivacky} 1286203955Srdivacky 1287261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 1288261991Sdim bool Complain) { 1289261991Sdim StructuralEquivalenceContext Ctx( 1290261991Sdim Importer.getFromContext(), Importer.getToContext(), 1291261991Sdim Importer.getNonEquivalentDecls(), false, Complain); 1292261991Sdim return Ctx.IsStructurallyEquivalent(FromVar, ToVar); 1293261991Sdim} 1294261991Sdim 1295203955Srdivackybool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) { 1296204643Srdivacky StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1297203955Srdivacky Importer.getToContext(), 1298203955Srdivacky Importer.getNonEquivalentDecls()); 1299204643Srdivacky return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum); 1300203955Srdivacky} 1301203955Srdivacky 1302327952Sdimbool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From, 1303327952Sdim FunctionTemplateDecl *To) { 1304327952Sdim StructuralEquivalenceContext Ctx( 1305327952Sdim Importer.getFromContext(), Importer.getToContext(), 1306327952Sdim Importer.getNonEquivalentDecls(), false, false); 1307327952Sdim return Ctx.IsStructurallyEquivalent(From, To); 1308327952Sdim} 1309327952Sdim 1310249423Sdimbool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC, 1311249423Sdim EnumConstantDecl *ToEC) 1312249423Sdim{ 1313249423Sdim const llvm::APSInt &FromVal = FromEC->getInitVal(); 1314249423Sdim const llvm::APSInt &ToVal = ToEC->getInitVal(); 1315249423Sdim 1316249423Sdim return FromVal.isSigned() == ToVal.isSigned() && 1317249423Sdim FromVal.getBitWidth() == ToVal.getBitWidth() && 1318249423Sdim FromVal == ToVal; 1319249423Sdim} 1320249423Sdim 1321249423Sdimbool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From, 1322218893Sdim ClassTemplateDecl *To) { 1323218893Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1324218893Sdim Importer.getToContext(), 1325218893Sdim Importer.getNonEquivalentDecls()); 1326321369Sdim return Ctx.IsStructurallyEquivalent(From, To); 1327218893Sdim} 1328218893Sdim 1329261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From, 1330261991Sdim VarTemplateDecl *To) { 1331261991Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1332261991Sdim Importer.getToContext(), 1333261991Sdim Importer.getNonEquivalentDecls()); 1334261991Sdim return Ctx.IsStructurallyEquivalent(From, To); 1335261991Sdim} 1336261991Sdim 1337203955SrdivackyDecl *ASTNodeImporter::VisitDecl(Decl *D) { 1338203955Srdivacky Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 1339203955Srdivacky << D->getDeclKindName(); 1340276479Sdim return nullptr; 1341203955Srdivacky} 1342203955Srdivacky 1343327952SdimDecl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) { 1344327952Sdim // Import the context of this declaration. 1345327952Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1346327952Sdim if (!DC) 1347327952Sdim return nullptr; 1348327952Sdim 1349327952Sdim DeclContext *LexicalDC = DC; 1350327952Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 1351327952Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 1352327952Sdim if (!LexicalDC) 1353327952Sdim return nullptr; 1354327952Sdim } 1355327952Sdim 1356327952Sdim // Import the location of this declaration. 1357327952Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 1358327952Sdim 1359327952Sdim EmptyDecl *ToD = EmptyDecl::Create(Importer.getToContext(), DC, Loc); 1360327952Sdim ToD->setLexicalDeclContext(LexicalDC); 1361327952Sdim Importer.Imported(D, ToD); 1362327952Sdim LexicalDC->addDeclInternal(ToD); 1363327952Sdim return ToD; 1364327952Sdim} 1365327952Sdim 1366234353SdimDecl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 1367234353Sdim TranslationUnitDecl *ToD = 1368234353Sdim Importer.getToContext().getTranslationUnitDecl(); 1369234353Sdim 1370234353Sdim Importer.Imported(D, ToD); 1371234353Sdim 1372234353Sdim return ToD; 1373234353Sdim} 1374234353Sdim 1375309124SdimDecl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) { 1376309124Sdim 1377309124Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 1378309124Sdim SourceLocation ColonLoc = Importer.Import(D->getColonLoc()); 1379309124Sdim 1380309124Sdim // Import the context of this declaration. 1381309124Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1382309124Sdim if (!DC) 1383309124Sdim return nullptr; 1384309124Sdim 1385309124Sdim AccessSpecDecl *accessSpecDecl 1386309124Sdim = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(), 1387309124Sdim DC, Loc, ColonLoc); 1388309124Sdim 1389309124Sdim if (!accessSpecDecl) 1390309124Sdim return nullptr; 1391309124Sdim 1392309124Sdim // Lexical DeclContext and Semantic DeclContext 1393309124Sdim // is always the same for the accessSpec. 1394309124Sdim accessSpecDecl->setLexicalDeclContext(DC); 1395309124Sdim DC->addDeclInternal(accessSpecDecl); 1396309124Sdim 1397309124Sdim return accessSpecDecl; 1398309124Sdim} 1399309124Sdim 1400314564SdimDecl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) { 1401314564Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1402314564Sdim if (!DC) 1403314564Sdim return nullptr; 1404314564Sdim 1405314564Sdim DeclContext *LexicalDC = DC; 1406314564Sdim 1407314564Sdim // Import the location of this declaration. 1408314564Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 1409314564Sdim 1410314564Sdim Expr *AssertExpr = Importer.Import(D->getAssertExpr()); 1411314564Sdim if (!AssertExpr) 1412314564Sdim return nullptr; 1413314564Sdim 1414314564Sdim StringLiteral *FromMsg = D->getMessage(); 1415314564Sdim StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg)); 1416314564Sdim if (!ToMsg && FromMsg) 1417314564Sdim return nullptr; 1418314564Sdim 1419314564Sdim StaticAssertDecl *ToD = StaticAssertDecl::Create( 1420314564Sdim Importer.getToContext(), DC, Loc, AssertExpr, ToMsg, 1421314564Sdim Importer.Import(D->getRParenLoc()), D->isFailed()); 1422314564Sdim 1423314564Sdim ToD->setLexicalDeclContext(LexicalDC); 1424314564Sdim LexicalDC->addDeclInternal(ToD); 1425314564Sdim Importer.Imported(D, ToD); 1426314564Sdim return ToD; 1427314564Sdim} 1428314564Sdim 1429204643SrdivackyDecl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) { 1430204643Srdivacky // Import the major distinguishing characteristics of this namespace. 1431204643Srdivacky DeclContext *DC, *LexicalDC; 1432204643Srdivacky DeclarationName Name; 1433204643Srdivacky SourceLocation Loc; 1434288943Sdim NamedDecl *ToD; 1435288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1436276479Sdim return nullptr; 1437288943Sdim if (ToD) 1438288943Sdim return ToD; 1439276479Sdim 1440276479Sdim NamespaceDecl *MergeWithNamespace = nullptr; 1441204643Srdivacky if (!Name) { 1442204643Srdivacky // This is an anonymous namespace. Adopt an existing anonymous 1443204643Srdivacky // namespace if we can. 1444204643Srdivacky // FIXME: Not testable. 1445204643Srdivacky if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC)) 1446204643Srdivacky MergeWithNamespace = TU->getAnonymousNamespace(); 1447204643Srdivacky else 1448204643Srdivacky MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace(); 1449204643Srdivacky } else { 1450226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1451249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1452280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1453226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1454226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace)) 1455204643Srdivacky continue; 1456204643Srdivacky 1457226633Sdim if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) { 1458204643Srdivacky MergeWithNamespace = FoundNS; 1459204643Srdivacky ConflictingDecls.clear(); 1460204643Srdivacky break; 1461204643Srdivacky } 1462204643Srdivacky 1463226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1464204643Srdivacky } 1465204643Srdivacky 1466204643Srdivacky if (!ConflictingDecls.empty()) { 1467207619Srdivacky Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace, 1468204643Srdivacky ConflictingDecls.data(), 1469204643Srdivacky ConflictingDecls.size()); 1470204643Srdivacky } 1471204643Srdivacky } 1472204643Srdivacky 1473204643Srdivacky // Create the "to" namespace, if needed. 1474204643Srdivacky NamespaceDecl *ToNamespace = MergeWithNamespace; 1475204643Srdivacky if (!ToNamespace) { 1476221345Sdim ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC, 1477234353Sdim D->isInline(), 1478221345Sdim Importer.Import(D->getLocStart()), 1479234353Sdim Loc, Name.getAsIdentifierInfo(), 1480276479Sdim /*PrevDecl=*/nullptr); 1481204643Srdivacky ToNamespace->setLexicalDeclContext(LexicalDC); 1482234353Sdim LexicalDC->addDeclInternal(ToNamespace); 1483204643Srdivacky 1484204643Srdivacky // If this is an anonymous namespace, register it as the anonymous 1485204643Srdivacky // namespace within its context. 1486204643Srdivacky if (!Name) { 1487204643Srdivacky if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC)) 1488204643Srdivacky TU->setAnonymousNamespace(ToNamespace); 1489204643Srdivacky else 1490204643Srdivacky cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace); 1491204643Srdivacky } 1492204643Srdivacky } 1493204643Srdivacky Importer.Imported(D, ToNamespace); 1494204643Srdivacky 1495204643Srdivacky ImportDeclContext(D); 1496204643Srdivacky 1497204643Srdivacky return ToNamespace; 1498204643Srdivacky} 1499204643Srdivacky 1500327952SdimDecl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1501327952Sdim // Import the major distinguishing characteristics of this namespace. 1502327952Sdim DeclContext *DC, *LexicalDC; 1503327952Sdim DeclarationName Name; 1504327952Sdim SourceLocation Loc; 1505327952Sdim NamedDecl *LookupD; 1506327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc)) 1507327952Sdim return nullptr; 1508327952Sdim if (LookupD) 1509327952Sdim return LookupD; 1510327952Sdim 1511327952Sdim // NOTE: No conflict resolution is done for namespace aliases now. 1512327952Sdim 1513327952Sdim NamespaceDecl *TargetDecl = cast_or_null<NamespaceDecl>( 1514327952Sdim Importer.Import(D->getNamespace())); 1515327952Sdim if (!TargetDecl) 1516327952Sdim return nullptr; 1517327952Sdim 1518327952Sdim IdentifierInfo *ToII = Importer.Import(D->getIdentifier()); 1519327952Sdim if (!ToII) 1520327952Sdim return nullptr; 1521327952Sdim 1522327952Sdim NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc()); 1523327952Sdim if (D->getQualifierLoc() && !ToQLoc) 1524327952Sdim return nullptr; 1525327952Sdim 1526327952Sdim NamespaceAliasDecl *ToD = NamespaceAliasDecl::Create( 1527327952Sdim Importer.getToContext(), DC, Importer.Import(D->getNamespaceLoc()), 1528327952Sdim Importer.Import(D->getAliasLoc()), ToII, ToQLoc, 1529327952Sdim Importer.Import(D->getTargetNameLoc()), TargetDecl); 1530327952Sdim 1531327952Sdim ToD->setLexicalDeclContext(LexicalDC); 1532327952Sdim Importer.Imported(D, ToD); 1533327952Sdim LexicalDC->addDeclInternal(ToD); 1534327952Sdim 1535327952Sdim return ToD; 1536327952Sdim} 1537327952Sdim 1538221345SdimDecl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) { 1539203955Srdivacky // Import the major distinguishing characteristics of this typedef. 1540203955Srdivacky DeclContext *DC, *LexicalDC; 1541203955Srdivacky DeclarationName Name; 1542203955Srdivacky SourceLocation Loc; 1543288943Sdim NamedDecl *ToD; 1544288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1545276479Sdim return nullptr; 1546288943Sdim if (ToD) 1547288943Sdim return ToD; 1548276479Sdim 1549203955Srdivacky // If this typedef is not in block scope, determine whether we've 1550203955Srdivacky // seen a typedef with the same name (that we can merge with) or any 1551203955Srdivacky // other entity by that name (which name lookup could conflict with). 1552203955Srdivacky if (!DC->isFunctionOrMethod()) { 1553226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1554203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 1555249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1556280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1557226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1558226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1559203955Srdivacky continue; 1560221345Sdim if (TypedefNameDecl *FoundTypedef = 1561226633Sdim dyn_cast<TypedefNameDecl>(FoundDecls[I])) { 1562203955Srdivacky if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(), 1563203955Srdivacky FoundTypedef->getUnderlyingType())) 1564203955Srdivacky return Importer.Imported(D, FoundTypedef); 1565203955Srdivacky } 1566321369Sdim 1567226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1568203955Srdivacky } 1569321369Sdim 1570203955Srdivacky if (!ConflictingDecls.empty()) { 1571203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1572203955Srdivacky ConflictingDecls.data(), 1573203955Srdivacky ConflictingDecls.size()); 1574203955Srdivacky if (!Name) 1575276479Sdim return nullptr; 1576203955Srdivacky } 1577203955Srdivacky } 1578321369Sdim 1579203955Srdivacky // Import the underlying type of this typedef; 1580203955Srdivacky QualType T = Importer.Import(D->getUnderlyingType()); 1581203955Srdivacky if (T.isNull()) 1582276479Sdim return nullptr; 1583276479Sdim 1584203955Srdivacky // Create the new typedef node. 1585203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 1586221345Sdim SourceLocation StartL = Importer.Import(D->getLocStart()); 1587221345Sdim TypedefNameDecl *ToTypedef; 1588221345Sdim if (IsAlias) 1589226633Sdim ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC, 1590226633Sdim StartL, Loc, 1591226633Sdim Name.getAsIdentifierInfo(), 1592226633Sdim TInfo); 1593226633Sdim else 1594221345Sdim ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC, 1595221345Sdim StartL, Loc, 1596221345Sdim Name.getAsIdentifierInfo(), 1597221345Sdim TInfo); 1598321369Sdim 1599204643Srdivacky ToTypedef->setAccess(D->getAccess()); 1600203955Srdivacky ToTypedef->setLexicalDeclContext(LexicalDC); 1601203955Srdivacky Importer.Imported(D, ToTypedef); 1602234353Sdim LexicalDC->addDeclInternal(ToTypedef); 1603321369Sdim 1604203955Srdivacky return ToTypedef; 1605203955Srdivacky} 1606203955Srdivacky 1607221345SdimDecl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) { 1608221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/false); 1609221345Sdim} 1610221345Sdim 1611221345SdimDecl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) { 1612221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/true); 1613221345Sdim} 1614221345Sdim 1615327952SdimDecl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 1616327952Sdim // Import the major distinguishing characteristics of this typedef. 1617327952Sdim DeclContext *DC, *LexicalDC; 1618327952Sdim DeclarationName Name; 1619327952Sdim SourceLocation Loc; 1620327952Sdim NamedDecl *ToD; 1621327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1622327952Sdim return nullptr; 1623327952Sdim if (ToD) 1624327952Sdim return ToD; 1625327952Sdim 1626327952Sdim // If this typedef is not in block scope, determine whether we've 1627327952Sdim // seen a typedef with the same name (that we can merge with) or any 1628327952Sdim // other entity by that name (which name lookup could conflict with). 1629327952Sdim if (!DC->isFunctionOrMethod()) { 1630327952Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1631327952Sdim unsigned IDNS = Decl::IDNS_Ordinary; 1632327952Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1633327952Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1634327952Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1635327952Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1636327952Sdim continue; 1637327952Sdim if (auto *FoundAlias = 1638327952Sdim dyn_cast<TypeAliasTemplateDecl>(FoundDecls[I])) 1639327952Sdim return Importer.Imported(D, FoundAlias); 1640327952Sdim ConflictingDecls.push_back(FoundDecls[I]); 1641327952Sdim } 1642327952Sdim 1643327952Sdim if (!ConflictingDecls.empty()) { 1644327952Sdim Name = Importer.HandleNameConflict(Name, DC, IDNS, 1645327952Sdim ConflictingDecls.data(), 1646327952Sdim ConflictingDecls.size()); 1647327952Sdim if (!Name) 1648327952Sdim return nullptr; 1649327952Sdim } 1650327952Sdim } 1651327952Sdim 1652327952Sdim TemplateParameterList *Params = ImportTemplateParameterList( 1653327952Sdim D->getTemplateParameters()); 1654327952Sdim if (!Params) 1655327952Sdim return nullptr; 1656327952Sdim 1657327952Sdim NamedDecl *TemplDecl = cast_or_null<NamedDecl>( 1658327952Sdim Importer.Import(D->getTemplatedDecl())); 1659327952Sdim if (!TemplDecl) 1660327952Sdim return nullptr; 1661327952Sdim 1662327952Sdim TypeAliasTemplateDecl *ToAlias = TypeAliasTemplateDecl::Create( 1663327952Sdim Importer.getToContext(), DC, Loc, Name, Params, TemplDecl); 1664327952Sdim 1665327952Sdim ToAlias->setAccess(D->getAccess()); 1666327952Sdim ToAlias->setLexicalDeclContext(LexicalDC); 1667327952Sdim Importer.Imported(D, ToAlias); 1668327952Sdim LexicalDC->addDeclInternal(ToAlias); 1669327952Sdim return ToD; 1670327952Sdim} 1671327952Sdim 1672309124SdimDecl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) { 1673309124Sdim // Import the major distinguishing characteristics of this label. 1674309124Sdim DeclContext *DC, *LexicalDC; 1675309124Sdim DeclarationName Name; 1676309124Sdim SourceLocation Loc; 1677309124Sdim NamedDecl *ToD; 1678309124Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1679309124Sdim return nullptr; 1680309124Sdim if (ToD) 1681309124Sdim return ToD; 1682309124Sdim 1683309124Sdim assert(LexicalDC->isFunctionOrMethod()); 1684309124Sdim 1685309124Sdim LabelDecl *ToLabel = D->isGnuLocal() 1686309124Sdim ? LabelDecl::Create(Importer.getToContext(), 1687309124Sdim DC, Importer.Import(D->getLocation()), 1688309124Sdim Name.getAsIdentifierInfo(), 1689309124Sdim Importer.Import(D->getLocStart())) 1690309124Sdim : LabelDecl::Create(Importer.getToContext(), 1691309124Sdim DC, Importer.Import(D->getLocation()), 1692309124Sdim Name.getAsIdentifierInfo()); 1693309124Sdim Importer.Imported(D, ToLabel); 1694309124Sdim 1695309124Sdim LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt())); 1696309124Sdim if (!Label) 1697309124Sdim return nullptr; 1698309124Sdim 1699309124Sdim ToLabel->setStmt(Label); 1700309124Sdim ToLabel->setLexicalDeclContext(LexicalDC); 1701309124Sdim LexicalDC->addDeclInternal(ToLabel); 1702309124Sdim return ToLabel; 1703309124Sdim} 1704309124Sdim 1705203955SrdivackyDecl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) { 1706203955Srdivacky // Import the major distinguishing characteristics of this enum. 1707203955Srdivacky DeclContext *DC, *LexicalDC; 1708203955Srdivacky DeclarationName Name; 1709203955Srdivacky SourceLocation Loc; 1710288943Sdim NamedDecl *ToD; 1711288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1712276479Sdim return nullptr; 1713288943Sdim if (ToD) 1714288943Sdim return ToD; 1715276479Sdim 1716203955Srdivacky // Figure out what enum name we're looking for. 1717203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 1718203955Srdivacky DeclarationName SearchName = Name; 1719221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 1720221345Sdim SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 1721203955Srdivacky IDNS = Decl::IDNS_Ordinary; 1722234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 1723203955Srdivacky IDNS |= Decl::IDNS_Ordinary; 1724203955Srdivacky 1725203955Srdivacky // We may already have an enum of the same name; try to find and match it. 1726203955Srdivacky if (!DC->isFunctionOrMethod() && SearchName) { 1727226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1728249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1729321369Sdim DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls); 1730226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1731226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1732203955Srdivacky continue; 1733203955Srdivacky 1734226633Sdim Decl *Found = FoundDecls[I]; 1735221345Sdim if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 1736203955Srdivacky if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 1737203955Srdivacky Found = Tag->getDecl(); 1738203955Srdivacky } 1739203955Srdivacky 1740203955Srdivacky if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) { 1741203955Srdivacky if (IsStructuralMatch(D, FoundEnum)) 1742203955Srdivacky return Importer.Imported(D, FoundEnum); 1743203955Srdivacky } 1744203955Srdivacky 1745226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1746203955Srdivacky } 1747203955Srdivacky 1748203955Srdivacky if (!ConflictingDecls.empty()) { 1749203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1750203955Srdivacky ConflictingDecls.data(), 1751203955Srdivacky ConflictingDecls.size()); 1752203955Srdivacky } 1753203955Srdivacky } 1754203955Srdivacky 1755203955Srdivacky // Create the enum declaration. 1756221345Sdim EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC, 1757221345Sdim Importer.Import(D->getLocStart()), 1758276479Sdim Loc, Name.getAsIdentifierInfo(), nullptr, 1759218893Sdim D->isScoped(), D->isScopedUsingClassTag(), 1760218893Sdim D->isFixed()); 1761205219Srdivacky // Import the qualifier, if any. 1762219077Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 1763204643Srdivacky D2->setAccess(D->getAccess()); 1764203955Srdivacky D2->setLexicalDeclContext(LexicalDC); 1765203955Srdivacky Importer.Imported(D, D2); 1766234353Sdim LexicalDC->addDeclInternal(D2); 1767203955Srdivacky 1768203955Srdivacky // Import the integer type. 1769203955Srdivacky QualType ToIntegerType = Importer.Import(D->getIntegerType()); 1770203955Srdivacky if (ToIntegerType.isNull()) 1771276479Sdim return nullptr; 1772203955Srdivacky D2->setIntegerType(ToIntegerType); 1773203955Srdivacky 1774203955Srdivacky // Import the definition 1775226633Sdim if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 1776276479Sdim return nullptr; 1777203955Srdivacky 1778203955Srdivacky return D2; 1779203955Srdivacky} 1780203955Srdivacky 1781203955SrdivackyDecl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) { 1782203955Srdivacky // If this record has a definition in the translation unit we're coming from, 1783203955Srdivacky // but this particular declaration is not that definition, import the 1784203955Srdivacky // definition and map to that. 1785203955Srdivacky TagDecl *Definition = D->getDefinition(); 1786203955Srdivacky if (Definition && Definition != D) { 1787203955Srdivacky Decl *ImportedDef = Importer.Import(Definition); 1788203955Srdivacky if (!ImportedDef) 1789276479Sdim return nullptr; 1790276479Sdim 1791203955Srdivacky return Importer.Imported(D, ImportedDef); 1792203955Srdivacky } 1793203955Srdivacky 1794203955Srdivacky // Import the major distinguishing characteristics of this record. 1795203955Srdivacky DeclContext *DC, *LexicalDC; 1796203955Srdivacky DeclarationName Name; 1797203955Srdivacky SourceLocation Loc; 1798288943Sdim NamedDecl *ToD; 1799288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1800276479Sdim return nullptr; 1801288943Sdim if (ToD) 1802288943Sdim return ToD; 1803276479Sdim 1804203955Srdivacky // Figure out what structure name we're looking for. 1805203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 1806203955Srdivacky DeclarationName SearchName = Name; 1807221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 1808221345Sdim SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 1809203955Srdivacky IDNS = Decl::IDNS_Ordinary; 1810234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 1811203955Srdivacky IDNS |= Decl::IDNS_Ordinary; 1812203955Srdivacky 1813203955Srdivacky // We may already have a record of the same name; try to find and match it. 1814276479Sdim RecordDecl *AdoptDecl = nullptr; 1815321369Sdim RecordDecl *PrevDecl = nullptr; 1816239462Sdim if (!DC->isFunctionOrMethod()) { 1817226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1818249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1819321369Sdim DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls); 1820321369Sdim 1821321369Sdim if (!FoundDecls.empty()) { 1822321369Sdim // We're going to have to compare D against potentially conflicting Decls, so complete it. 1823321369Sdim if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition()) 1824321369Sdim D->getASTContext().getExternalSource()->CompleteType(D); 1825321369Sdim } 1826321369Sdim 1827226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1828226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1829203955Srdivacky continue; 1830203955Srdivacky 1831226633Sdim Decl *Found = FoundDecls[I]; 1832221345Sdim if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 1833203955Srdivacky if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 1834203955Srdivacky Found = Tag->getDecl(); 1835203955Srdivacky } 1836203955Srdivacky 1837203955Srdivacky if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) { 1838243830Sdim if (D->isAnonymousStructOrUnion() && 1839243830Sdim FoundRecord->isAnonymousStructOrUnion()) { 1840243830Sdim // If both anonymous structs/unions are in a record context, make sure 1841243830Sdim // they occur in the same location in the context records. 1842321369Sdim if (Optional<unsigned> Index1 = 1843321369Sdim StructuralEquivalenceContext::findUntaggedStructOrUnionIndex( 1844321369Sdim D)) { 1845321369Sdim if (Optional<unsigned> Index2 = StructuralEquivalenceContext:: 1846309124Sdim findUntaggedStructOrUnionIndex(FoundRecord)) { 1847243830Sdim if (*Index1 != *Index2) 1848243830Sdim continue; 1849243830Sdim } 1850243830Sdim } 1851243830Sdim } 1852243830Sdim 1853321369Sdim PrevDecl = FoundRecord; 1854321369Sdim 1855203955Srdivacky if (RecordDecl *FoundDef = FoundRecord->getDefinition()) { 1856239462Sdim if ((SearchName && !D->isCompleteDefinition()) 1857239462Sdim || (D->isCompleteDefinition() && 1858239462Sdim D->isAnonymousStructOrUnion() 1859239462Sdim == FoundDef->isAnonymousStructOrUnion() && 1860239462Sdim IsStructuralMatch(D, FoundDef))) { 1861203955Srdivacky // The record types structurally match, or the "from" translation 1862203955Srdivacky // unit only had a forward declaration anyway; call it the same 1863203955Srdivacky // function. 1864203955Srdivacky // FIXME: For C++, we should also merge methods here. 1865203955Srdivacky return Importer.Imported(D, FoundDef); 1866203955Srdivacky } 1867239462Sdim } else if (!D->isCompleteDefinition()) { 1868203955Srdivacky // We have a forward declaration of this type, so adopt that forward 1869203955Srdivacky // declaration rather than building a new one. 1870276479Sdim 1871276479Sdim // If one or both can be completed from external storage then try one 1872276479Sdim // last time to complete and compare them before doing this. 1873276479Sdim 1874276479Sdim if (FoundRecord->hasExternalLexicalStorage() && 1875276479Sdim !FoundRecord->isCompleteDefinition()) 1876276479Sdim FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord); 1877276479Sdim if (D->hasExternalLexicalStorage()) 1878276479Sdim D->getASTContext().getExternalSource()->CompleteType(D); 1879276479Sdim 1880276479Sdim if (FoundRecord->isCompleteDefinition() && 1881276479Sdim D->isCompleteDefinition() && 1882276479Sdim !IsStructuralMatch(D, FoundRecord)) 1883276479Sdim continue; 1884276479Sdim 1885203955Srdivacky AdoptDecl = FoundRecord; 1886203955Srdivacky continue; 1887239462Sdim } else if (!SearchName) { 1888239462Sdim continue; 1889239462Sdim } 1890203955Srdivacky } 1891203955Srdivacky 1892226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1893203955Srdivacky } 1894203955Srdivacky 1895239462Sdim if (!ConflictingDecls.empty() && SearchName) { 1896203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1897203955Srdivacky ConflictingDecls.data(), 1898203955Srdivacky ConflictingDecls.size()); 1899203955Srdivacky } 1900203955Srdivacky } 1901203955Srdivacky 1902203955Srdivacky // Create the record declaration. 1903203955Srdivacky RecordDecl *D2 = AdoptDecl; 1904221345Sdim SourceLocation StartLoc = Importer.Import(D->getLocStart()); 1905203955Srdivacky if (!D2) { 1906309124Sdim CXXRecordDecl *D2CXX = nullptr; 1907309124Sdim if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) { 1908309124Sdim if (DCXX->isLambda()) { 1909309124Sdim TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo()); 1910309124Sdim D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(), 1911309124Sdim DC, TInfo, Loc, 1912309124Sdim DCXX->isDependentLambda(), 1913309124Sdim DCXX->isGenericLambda(), 1914309124Sdim DCXX->getLambdaCaptureDefault()); 1915309124Sdim Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl()); 1916309124Sdim if (DCXX->getLambdaContextDecl() && !CDecl) 1917309124Sdim return nullptr; 1918309124Sdim D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl); 1919309124Sdim } else if (DCXX->isInjectedClassName()) { 1920309124Sdim // We have to be careful to do a similar dance to the one in 1921309124Sdim // Sema::ActOnStartCXXMemberDeclarations 1922309124Sdim CXXRecordDecl *const PrevDecl = nullptr; 1923309124Sdim const bool DelayTypeCreation = true; 1924309124Sdim D2CXX = CXXRecordDecl::Create( 1925309124Sdim Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc, 1926309124Sdim Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation); 1927309124Sdim Importer.getToContext().getTypeDeclType( 1928309124Sdim D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC)); 1929309124Sdim } else { 1930309124Sdim D2CXX = CXXRecordDecl::Create(Importer.getToContext(), 1931309124Sdim D->getTagKind(), 1932309124Sdim DC, StartLoc, Loc, 1933309124Sdim Name.getAsIdentifierInfo()); 1934309124Sdim } 1935203955Srdivacky D2 = D2CXX; 1936204643Srdivacky D2->setAccess(D->getAccess()); 1937327952Sdim 1938327952Sdim Importer.Imported(D, D2); 1939327952Sdim 1940327952Sdim if (ClassTemplateDecl *FromDescribed = 1941327952Sdim DCXX->getDescribedClassTemplate()) { 1942327952Sdim ClassTemplateDecl *ToDescribed = cast_or_null<ClassTemplateDecl>( 1943327952Sdim Importer.Import(FromDescribed)); 1944327952Sdim if (!ToDescribed) 1945327952Sdim return nullptr; 1946327952Sdim D2CXX->setDescribedClassTemplate(ToDescribed); 1947327952Sdim 1948327952Sdim } else if (MemberSpecializationInfo *MemberInfo = 1949327952Sdim DCXX->getMemberSpecializationInfo()) { 1950327952Sdim TemplateSpecializationKind SK = 1951327952Sdim MemberInfo->getTemplateSpecializationKind(); 1952327952Sdim CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass(); 1953327952Sdim CXXRecordDecl *ToInst = 1954327952Sdim cast_or_null<CXXRecordDecl>(Importer.Import(FromInst)); 1955327952Sdim if (FromInst && !ToInst) 1956327952Sdim return nullptr; 1957327952Sdim D2CXX->setInstantiationOfMemberClass(ToInst, SK); 1958327952Sdim D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation( 1959327952Sdim Importer.Import(MemberInfo->getPointOfInstantiation())); 1960327952Sdim } 1961327952Sdim 1962203955Srdivacky } else { 1963203955Srdivacky D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(), 1964221345Sdim DC, StartLoc, Loc, Name.getAsIdentifierInfo()); 1965203955Srdivacky } 1966219077Sdim 1967219077Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 1968203955Srdivacky D2->setLexicalDeclContext(LexicalDC); 1969234353Sdim LexicalDC->addDeclInternal(D2); 1970239462Sdim if (D->isAnonymousStructOrUnion()) 1971239462Sdim D2->setAnonymousStructOrUnion(true); 1972321369Sdim if (PrevDecl) { 1973321369Sdim // FIXME: do this for all Redeclarables, not just RecordDecls. 1974321369Sdim D2->setPreviousDecl(PrevDecl); 1975321369Sdim } 1976203955Srdivacky } 1977203955Srdivacky 1978203955Srdivacky Importer.Imported(D, D2); 1979203955Srdivacky 1980234353Sdim if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default)) 1981276479Sdim return nullptr; 1982276479Sdim 1983203955Srdivacky return D2; 1984203955Srdivacky} 1985203955Srdivacky 1986203955SrdivackyDecl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) { 1987203955Srdivacky // Import the major distinguishing characteristics of this enumerator. 1988203955Srdivacky DeclContext *DC, *LexicalDC; 1989203955Srdivacky DeclarationName Name; 1990203955Srdivacky SourceLocation Loc; 1991288943Sdim NamedDecl *ToD; 1992288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1993276479Sdim return nullptr; 1994288943Sdim if (ToD) 1995288943Sdim return ToD; 1996203955Srdivacky 1997203955Srdivacky QualType T = Importer.Import(D->getType()); 1998203955Srdivacky if (T.isNull()) 1999276479Sdim return nullptr; 2000203955Srdivacky 2001203955Srdivacky // Determine whether there are any other declarations with the same name and 2002203955Srdivacky // in the same context. 2003203955Srdivacky if (!LexicalDC->isFunctionOrMethod()) { 2004226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2005203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2006249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2007280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2008226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2009226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2010203955Srdivacky continue; 2011249423Sdim 2012249423Sdim if (EnumConstantDecl *FoundEnumConstant 2013249423Sdim = dyn_cast<EnumConstantDecl>(FoundDecls[I])) { 2014249423Sdim if (IsStructuralMatch(D, FoundEnumConstant)) 2015249423Sdim return Importer.Imported(D, FoundEnumConstant); 2016249423Sdim } 2017249423Sdim 2018226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 2019203955Srdivacky } 2020203955Srdivacky 2021203955Srdivacky if (!ConflictingDecls.empty()) { 2022203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 2023203955Srdivacky ConflictingDecls.data(), 2024203955Srdivacky ConflictingDecls.size()); 2025203955Srdivacky if (!Name) 2026276479Sdim return nullptr; 2027203955Srdivacky } 2028203955Srdivacky } 2029203955Srdivacky 2030203955Srdivacky Expr *Init = Importer.Import(D->getInitExpr()); 2031203955Srdivacky if (D->getInitExpr() && !Init) 2032276479Sdim return nullptr; 2033276479Sdim 2034203955Srdivacky EnumConstantDecl *ToEnumerator 2035203955Srdivacky = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc, 2036203955Srdivacky Name.getAsIdentifierInfo(), T, 2037203955Srdivacky Init, D->getInitVal()); 2038204643Srdivacky ToEnumerator->setAccess(D->getAccess()); 2039203955Srdivacky ToEnumerator->setLexicalDeclContext(LexicalDC); 2040203955Srdivacky Importer.Imported(D, ToEnumerator); 2041234353Sdim LexicalDC->addDeclInternal(ToEnumerator); 2042203955Srdivacky return ToEnumerator; 2043203955Srdivacky} 2044203955Srdivacky 2045203955SrdivackyDecl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) { 2046203955Srdivacky // Import the major distinguishing characteristics of this function. 2047203955Srdivacky DeclContext *DC, *LexicalDC; 2048203955Srdivacky DeclarationName Name; 2049203955Srdivacky SourceLocation Loc; 2050288943Sdim NamedDecl *ToD; 2051288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2052276479Sdim return nullptr; 2053288943Sdim if (ToD) 2054288943Sdim return ToD; 2055212904Sdim 2056327952Sdim const FunctionDecl *FoundWithoutBody = nullptr; 2057327952Sdim 2058203955Srdivacky // Try to find a function in our own ("to") context with the same name, same 2059203955Srdivacky // type, and in the same context as the function we're importing. 2060203955Srdivacky if (!LexicalDC->isFunctionOrMethod()) { 2061226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2062203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2063249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2064280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2065226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2066226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2067203955Srdivacky continue; 2068321369Sdim 2069226633Sdim if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) { 2070261991Sdim if (FoundFunction->hasExternalFormalLinkage() && 2071261991Sdim D->hasExternalFormalLinkage()) { 2072203955Srdivacky if (Importer.IsStructurallyEquivalent(D->getType(), 2073203955Srdivacky FoundFunction->getType())) { 2074203955Srdivacky // FIXME: Actually try to merge the body and other attributes. 2075327952Sdim const FunctionDecl *FromBodyDecl = nullptr; 2076327952Sdim D->hasBody(FromBodyDecl); 2077327952Sdim if (D == FromBodyDecl && !FoundFunction->hasBody()) { 2078327952Sdim // This function is needed to merge completely. 2079327952Sdim FoundWithoutBody = FoundFunction; 2080327952Sdim break; 2081327952Sdim } 2082203955Srdivacky return Importer.Imported(D, FoundFunction); 2083203955Srdivacky } 2084321369Sdim 2085203955Srdivacky // FIXME: Check for overloading more carefully, e.g., by boosting 2086203955Srdivacky // Sema::IsOverload out to the AST library. 2087321369Sdim 2088203955Srdivacky // Function overloading is okay in C++. 2089234353Sdim if (Importer.getToContext().getLangOpts().CPlusPlus) 2090203955Srdivacky continue; 2091321369Sdim 2092203955Srdivacky // Complain about inconsistent function types. 2093203955Srdivacky Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent) 2094203955Srdivacky << Name << D->getType() << FoundFunction->getType(); 2095203955Srdivacky Importer.ToDiag(FoundFunction->getLocation(), 2096203955Srdivacky diag::note_odr_value_here) 2097203955Srdivacky << FoundFunction->getType(); 2098203955Srdivacky } 2099203955Srdivacky } 2100321369Sdim 2101226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 2102203955Srdivacky } 2103321369Sdim 2104203955Srdivacky if (!ConflictingDecls.empty()) { 2105203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 2106203955Srdivacky ConflictingDecls.data(), 2107203955Srdivacky ConflictingDecls.size()); 2108203955Srdivacky if (!Name) 2109276479Sdim return nullptr; 2110203955Srdivacky } 2111203955Srdivacky } 2112203955Srdivacky 2113212904Sdim DeclarationNameInfo NameInfo(Name, Loc); 2114212904Sdim // Import additional name location/type info. 2115212904Sdim ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 2116212904Sdim 2117243830Sdim QualType FromTy = D->getType(); 2118243830Sdim bool usedDifferentExceptionSpec = false; 2119243830Sdim 2120243830Sdim if (const FunctionProtoType * 2121243830Sdim FromFPT = D->getType()->getAs<FunctionProtoType>()) { 2122243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo(); 2123243830Sdim // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the 2124243830Sdim // FunctionDecl that we are importing the FunctionProtoType for. 2125243830Sdim // To avoid an infinite recursion when importing, create the FunctionDecl 2126243830Sdim // with a simplified function type and update it afterwards. 2127280031Sdim if (FromEPI.ExceptionSpec.SourceDecl || 2128280031Sdim FromEPI.ExceptionSpec.SourceTemplate || 2129280031Sdim FromEPI.ExceptionSpec.NoexceptExpr) { 2130243830Sdim FunctionProtoType::ExtProtoInfo DefaultEPI; 2131243830Sdim FromTy = Importer.getFromContext().getFunctionType( 2132276479Sdim FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI); 2133243830Sdim usedDifferentExceptionSpec = true; 2134243830Sdim } 2135243830Sdim } 2136243830Sdim 2137203955Srdivacky // Import the type. 2138243830Sdim QualType T = Importer.Import(FromTy); 2139203955Srdivacky if (T.isNull()) 2140276479Sdim return nullptr; 2141276479Sdim 2142203955Srdivacky // Import the function parameters. 2143226633Sdim SmallVector<ParmVarDecl *, 8> Parameters; 2144309124Sdim for (auto P : D->parameters()) { 2145276479Sdim ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P)); 2146203955Srdivacky if (!ToP) 2147276479Sdim return nullptr; 2148276479Sdim 2149203955Srdivacky Parameters.push_back(ToP); 2150203955Srdivacky } 2151203955Srdivacky 2152203955Srdivacky // Create the imported function. 2153203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2154276479Sdim FunctionDecl *ToFunction = nullptr; 2155288943Sdim SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart()); 2156204643Srdivacky if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 2157204643Srdivacky ToFunction = CXXConstructorDecl::Create(Importer.getToContext(), 2158204643Srdivacky cast<CXXRecordDecl>(DC), 2159288943Sdim InnerLocStart, 2160212904Sdim NameInfo, T, TInfo, 2161204643Srdivacky FromConstructor->isExplicit(), 2162204643Srdivacky D->isInlineSpecified(), 2163226633Sdim D->isImplicit(), 2164226633Sdim D->isConstexpr()); 2165309124Sdim if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) { 2166309124Sdim SmallVector<CXXCtorInitializer *, 4> CtorInitializers; 2167309124Sdim for (CXXCtorInitializer *I : FromConstructor->inits()) { 2168309124Sdim CXXCtorInitializer *ToI = 2169309124Sdim cast_or_null<CXXCtorInitializer>(Importer.Import(I)); 2170309124Sdim if (!ToI && I) 2171309124Sdim return nullptr; 2172309124Sdim CtorInitializers.push_back(ToI); 2173309124Sdim } 2174309124Sdim CXXCtorInitializer **Memory = 2175309124Sdim new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers]; 2176309124Sdim std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory); 2177309124Sdim CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction); 2178309124Sdim ToCtor->setCtorInitializers(Memory); 2179309124Sdim ToCtor->setNumCtorInitializers(NumInitializers); 2180309124Sdim } 2181204643Srdivacky } else if (isa<CXXDestructorDecl>(D)) { 2182204643Srdivacky ToFunction = CXXDestructorDecl::Create(Importer.getToContext(), 2183204643Srdivacky cast<CXXRecordDecl>(DC), 2184288943Sdim InnerLocStart, 2185218893Sdim NameInfo, T, TInfo, 2186204643Srdivacky D->isInlineSpecified(), 2187204643Srdivacky D->isImplicit()); 2188204643Srdivacky } else if (CXXConversionDecl *FromConversion 2189204643Srdivacky = dyn_cast<CXXConversionDecl>(D)) { 2190204643Srdivacky ToFunction = CXXConversionDecl::Create(Importer.getToContext(), 2191204643Srdivacky cast<CXXRecordDecl>(DC), 2192288943Sdim InnerLocStart, 2193212904Sdim NameInfo, T, TInfo, 2194204643Srdivacky D->isInlineSpecified(), 2195221345Sdim FromConversion->isExplicit(), 2196226633Sdim D->isConstexpr(), 2197221345Sdim Importer.Import(D->getLocEnd())); 2198218893Sdim } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 2199218893Sdim ToFunction = CXXMethodDecl::Create(Importer.getToContext(), 2200218893Sdim cast<CXXRecordDecl>(DC), 2201288943Sdim InnerLocStart, 2202218893Sdim NameInfo, T, TInfo, 2203249423Sdim Method->getStorageClass(), 2204221345Sdim Method->isInlineSpecified(), 2205226633Sdim D->isConstexpr(), 2206221345Sdim Importer.Import(D->getLocEnd())); 2207204643Srdivacky } else { 2208212904Sdim ToFunction = FunctionDecl::Create(Importer.getToContext(), DC, 2209288943Sdim InnerLocStart, 2210212904Sdim NameInfo, T, TInfo, D->getStorageClass(), 2211204643Srdivacky D->isInlineSpecified(), 2212226633Sdim D->hasWrittenPrototype(), 2213226633Sdim D->isConstexpr()); 2214204643Srdivacky } 2215205219Srdivacky 2216205219Srdivacky // Import the qualifier, if any. 2217219077Sdim ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2218204643Srdivacky ToFunction->setAccess(D->getAccess()); 2219204643Srdivacky ToFunction->setLexicalDeclContext(LexicalDC); 2220218893Sdim ToFunction->setVirtualAsWritten(D->isVirtualAsWritten()); 2221218893Sdim ToFunction->setTrivial(D->isTrivial()); 2222218893Sdim ToFunction->setPure(D->isPure()); 2223204643Srdivacky Importer.Imported(D, ToFunction); 2224203955Srdivacky 2225203955Srdivacky // Set the parameters. 2226203955Srdivacky for (unsigned I = 0, N = Parameters.size(); I != N; ++I) { 2227204643Srdivacky Parameters[I]->setOwningFunction(ToFunction); 2228234353Sdim ToFunction->addDeclInternal(Parameters[I]); 2229203955Srdivacky } 2230226633Sdim ToFunction->setParams(Parameters); 2231203955Srdivacky 2232327952Sdim if (FoundWithoutBody) { 2233327952Sdim auto *Recent = const_cast<FunctionDecl *>( 2234327952Sdim FoundWithoutBody->getMostRecentDecl()); 2235327952Sdim ToFunction->setPreviousDecl(Recent); 2236327952Sdim } 2237327952Sdim 2238243830Sdim if (usedDifferentExceptionSpec) { 2239243830Sdim // Update FunctionProtoType::ExtProtoInfo. 2240243830Sdim QualType T = Importer.Import(D->getType()); 2241243830Sdim if (T.isNull()) 2242276479Sdim return nullptr; 2243243830Sdim ToFunction->setType(T); 2244243830Sdim } 2245243830Sdim 2246288943Sdim // Import the body, if any. 2247288943Sdim if (Stmt *FromBody = D->getBody()) { 2248288943Sdim if (Stmt *ToBody = Importer.Import(FromBody)) { 2249288943Sdim ToFunction->setBody(ToBody); 2250288943Sdim } 2251288943Sdim } 2252288943Sdim 2253203955Srdivacky // FIXME: Other bits to merge? 2254218893Sdim 2255218893Sdim // Add this function to the lexical context. 2256234353Sdim LexicalDC->addDeclInternal(ToFunction); 2257218893Sdim 2258321369Sdim if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D)) 2259321369Sdim ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod); 2260321369Sdim 2261204643Srdivacky return ToFunction; 2262203955Srdivacky} 2263203955Srdivacky 2264204643SrdivackyDecl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) { 2265204643Srdivacky return VisitFunctionDecl(D); 2266204643Srdivacky} 2267204643Srdivacky 2268204643SrdivackyDecl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 2269204643Srdivacky return VisitCXXMethodDecl(D); 2270204643Srdivacky} 2271204643Srdivacky 2272204643SrdivackyDecl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 2273204643Srdivacky return VisitCXXMethodDecl(D); 2274204643Srdivacky} 2275204643Srdivacky 2276204643SrdivackyDecl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) { 2277204643Srdivacky return VisitCXXMethodDecl(D); 2278204643Srdivacky} 2279204643Srdivacky 2280243830Sdimstatic unsigned getFieldIndex(Decl *F) { 2281243830Sdim RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext()); 2282243830Sdim if (!Owner) 2283243830Sdim return 0; 2284243830Sdim 2285243830Sdim unsigned Index = 1; 2286276479Sdim for (const auto *D : Owner->noload_decls()) { 2287276479Sdim if (D == F) 2288243830Sdim return Index; 2289243830Sdim 2290243830Sdim if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) 2291243830Sdim ++Index; 2292243830Sdim } 2293243830Sdim 2294243830Sdim return Index; 2295243830Sdim} 2296243830Sdim 2297203955SrdivackyDecl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) { 2298203955Srdivacky // Import the major distinguishing characteristics of a variable. 2299203955Srdivacky DeclContext *DC, *LexicalDC; 2300203955Srdivacky DeclarationName Name; 2301203955Srdivacky SourceLocation Loc; 2302288943Sdim NamedDecl *ToD; 2303288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2304276479Sdim return nullptr; 2305288943Sdim if (ToD) 2306288943Sdim return ToD; 2307276479Sdim 2308226633Sdim // Determine whether we've already imported this field. 2309249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2310280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2311226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2312226633Sdim if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) { 2313243830Sdim // For anonymous fields, match up by index. 2314243830Sdim if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 2315243830Sdim continue; 2316243830Sdim 2317321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2318226633Sdim FoundField->getType())) { 2319226633Sdim Importer.Imported(D, FoundField); 2320226633Sdim return FoundField; 2321226633Sdim } 2322321369Sdim 2323226633Sdim Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 2324226633Sdim << Name << D->getType() << FoundField->getType(); 2325226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 2326226633Sdim << FoundField->getType(); 2327276479Sdim return nullptr; 2328226633Sdim } 2329226633Sdim } 2330226633Sdim 2331203955Srdivacky // Import the type. 2332203955Srdivacky QualType T = Importer.Import(D->getType()); 2333203955Srdivacky if (T.isNull()) 2334276479Sdim return nullptr; 2335276479Sdim 2336203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2337203955Srdivacky Expr *BitWidth = Importer.Import(D->getBitWidth()); 2338203955Srdivacky if (!BitWidth && D->getBitWidth()) 2339276479Sdim return nullptr; 2340276479Sdim 2341221345Sdim FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC, 2342221345Sdim Importer.Import(D->getInnerLocStart()), 2343203955Srdivacky Loc, Name.getAsIdentifierInfo(), 2344223017Sdim T, TInfo, BitWidth, D->isMutable(), 2345239462Sdim D->getInClassInitStyle()); 2346204643Srdivacky ToField->setAccess(D->getAccess()); 2347203955Srdivacky ToField->setLexicalDeclContext(LexicalDC); 2348309124Sdim if (Expr *FromInitializer = D->getInClassInitializer()) { 2349309124Sdim Expr *ToInitializer = Importer.Import(FromInitializer); 2350309124Sdim if (ToInitializer) 2351309124Sdim ToField->setInClassInitializer(ToInitializer); 2352309124Sdim else 2353309124Sdim return nullptr; 2354309124Sdim } 2355243830Sdim ToField->setImplicit(D->isImplicit()); 2356203955Srdivacky Importer.Imported(D, ToField); 2357234353Sdim LexicalDC->addDeclInternal(ToField); 2358203955Srdivacky return ToField; 2359203955Srdivacky} 2360203955Srdivacky 2361218893SdimDecl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 2362218893Sdim // Import the major distinguishing characteristics of a variable. 2363218893Sdim DeclContext *DC, *LexicalDC; 2364218893Sdim DeclarationName Name; 2365218893Sdim SourceLocation Loc; 2366288943Sdim NamedDecl *ToD; 2367288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2368276479Sdim return nullptr; 2369288943Sdim if (ToD) 2370288943Sdim return ToD; 2371218893Sdim 2372226633Sdim // Determine whether we've already imported this field. 2373249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2374280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2375226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2376226633Sdim if (IndirectFieldDecl *FoundField 2377226633Sdim = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) { 2378243830Sdim // For anonymous indirect fields, match up by index. 2379243830Sdim if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 2380243830Sdim continue; 2381243830Sdim 2382321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2383239462Sdim FoundField->getType(), 2384261991Sdim !Name.isEmpty())) { 2385226633Sdim Importer.Imported(D, FoundField); 2386226633Sdim return FoundField; 2387226633Sdim } 2388239462Sdim 2389239462Sdim // If there are more anonymous fields to check, continue. 2390239462Sdim if (!Name && I < N-1) 2391239462Sdim continue; 2392239462Sdim 2393226633Sdim Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 2394226633Sdim << Name << D->getType() << FoundField->getType(); 2395226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 2396226633Sdim << FoundField->getType(); 2397276479Sdim return nullptr; 2398226633Sdim } 2399226633Sdim } 2400226633Sdim 2401218893Sdim // Import the type. 2402218893Sdim QualType T = Importer.Import(D->getType()); 2403218893Sdim if (T.isNull()) 2404276479Sdim return nullptr; 2405218893Sdim 2406218893Sdim NamedDecl **NamedChain = 2407218893Sdim new (Importer.getToContext())NamedDecl*[D->getChainingSize()]; 2408218893Sdim 2409218893Sdim unsigned i = 0; 2410276479Sdim for (auto *PI : D->chain()) { 2411276479Sdim Decl *D = Importer.Import(PI); 2412218893Sdim if (!D) 2413276479Sdim return nullptr; 2414218893Sdim NamedChain[i++] = cast<NamedDecl>(D); 2415218893Sdim } 2416218893Sdim 2417218893Sdim IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create( 2418280031Sdim Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T, 2419309124Sdim {NamedChain, D->getChainingSize()}); 2420280031Sdim 2421280031Sdim for (const auto *Attr : D->attrs()) 2422280031Sdim ToIndirectField->addAttr(Attr->clone(Importer.getToContext())); 2423280031Sdim 2424218893Sdim ToIndirectField->setAccess(D->getAccess()); 2425218893Sdim ToIndirectField->setLexicalDeclContext(LexicalDC); 2426218893Sdim Importer.Imported(D, ToIndirectField); 2427234353Sdim LexicalDC->addDeclInternal(ToIndirectField); 2428218893Sdim return ToIndirectField; 2429218893Sdim} 2430218893Sdim 2431314564SdimDecl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) { 2432314564Sdim // Import the major distinguishing characteristics of a declaration. 2433314564Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 2434314564Sdim DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext() 2435314564Sdim ? DC : Importer.ImportContext(D->getLexicalDeclContext()); 2436314564Sdim if (!DC || !LexicalDC) 2437314564Sdim return nullptr; 2438314564Sdim 2439314564Sdim // Determine whether we've already imported this decl. 2440314564Sdim // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup. 2441314564Sdim auto *RD = cast<CXXRecordDecl>(DC); 2442314564Sdim FriendDecl *ImportedFriend = RD->getFirstFriend(); 2443314564Sdim StructuralEquivalenceContext Context( 2444314564Sdim Importer.getFromContext(), Importer.getToContext(), 2445314564Sdim Importer.getNonEquivalentDecls(), false, false); 2446314564Sdim 2447314564Sdim while (ImportedFriend) { 2448314564Sdim if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) { 2449314564Sdim if (Context.IsStructurallyEquivalent(D->getFriendDecl(), 2450314564Sdim ImportedFriend->getFriendDecl())) 2451314564Sdim return Importer.Imported(D, ImportedFriend); 2452314564Sdim 2453314564Sdim } else if (D->getFriendType() && ImportedFriend->getFriendType()) { 2454314564Sdim if (Importer.IsStructurallyEquivalent( 2455314564Sdim D->getFriendType()->getType(), 2456314564Sdim ImportedFriend->getFriendType()->getType(), true)) 2457314564Sdim return Importer.Imported(D, ImportedFriend); 2458314564Sdim } 2459314564Sdim ImportedFriend = ImportedFriend->getNextFriend(); 2460314564Sdim } 2461314564Sdim 2462314564Sdim // Not found. Create it. 2463314564Sdim FriendDecl::FriendUnion ToFU; 2464314564Sdim if (NamedDecl *FriendD = D->getFriendDecl()) 2465314564Sdim ToFU = cast_or_null<NamedDecl>(Importer.Import(FriendD)); 2466314564Sdim else 2467314564Sdim ToFU = Importer.Import(D->getFriendType()); 2468314564Sdim if (!ToFU) 2469314564Sdim return nullptr; 2470314564Sdim 2471314564Sdim SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists); 2472314564Sdim TemplateParameterList **FromTPLists = 2473314564Sdim D->getTrailingObjects<TemplateParameterList *>(); 2474314564Sdim for (unsigned I = 0; I < D->NumTPLists; I++) { 2475314564Sdim TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]); 2476314564Sdim if (!List) 2477314564Sdim return nullptr; 2478314564Sdim ToTPLists[I] = List; 2479314564Sdim } 2480314564Sdim 2481314564Sdim FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC, 2482314564Sdim Importer.Import(D->getLocation()), 2483314564Sdim ToFU, Importer.Import(D->getFriendLoc()), 2484314564Sdim ToTPLists); 2485314564Sdim 2486314564Sdim Importer.Imported(D, FrD); 2487314564Sdim RD->pushFriendDecl(FrD); 2488314564Sdim 2489314564Sdim FrD->setAccess(D->getAccess()); 2490314564Sdim FrD->setLexicalDeclContext(LexicalDC); 2491314564Sdim LexicalDC->addDeclInternal(FrD); 2492314564Sdim return FrD; 2493314564Sdim} 2494314564Sdim 2495204643SrdivackyDecl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 2496204643Srdivacky // Import the major distinguishing characteristics of an ivar. 2497204643Srdivacky DeclContext *DC, *LexicalDC; 2498204643Srdivacky DeclarationName Name; 2499204643Srdivacky SourceLocation Loc; 2500288943Sdim NamedDecl *ToD; 2501288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2502276479Sdim return nullptr; 2503288943Sdim if (ToD) 2504288943Sdim return ToD; 2505276479Sdim 2506321369Sdim // Determine whether we've already imported this ivar 2507249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2508280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2509226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2510226633Sdim if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) { 2511321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2512204643Srdivacky FoundIvar->getType())) { 2513204643Srdivacky Importer.Imported(D, FoundIvar); 2514204643Srdivacky return FoundIvar; 2515204643Srdivacky } 2516204643Srdivacky 2517204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent) 2518204643Srdivacky << Name << D->getType() << FoundIvar->getType(); 2519204643Srdivacky Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here) 2520204643Srdivacky << FoundIvar->getType(); 2521276479Sdim return nullptr; 2522204643Srdivacky } 2523204643Srdivacky } 2524204643Srdivacky 2525204643Srdivacky // Import the type. 2526204643Srdivacky QualType T = Importer.Import(D->getType()); 2527204643Srdivacky if (T.isNull()) 2528276479Sdim return nullptr; 2529276479Sdim 2530204643Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2531204643Srdivacky Expr *BitWidth = Importer.Import(D->getBitWidth()); 2532204643Srdivacky if (!BitWidth && D->getBitWidth()) 2533276479Sdim return nullptr; 2534276479Sdim 2535206125Srdivacky ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(), 2536206125Srdivacky cast<ObjCContainerDecl>(DC), 2537221345Sdim Importer.Import(D->getInnerLocStart()), 2538204643Srdivacky Loc, Name.getAsIdentifierInfo(), 2539204643Srdivacky T, TInfo, D->getAccessControl(), 2540276479Sdim BitWidth, D->getSynthesize()); 2541204643Srdivacky ToIvar->setLexicalDeclContext(LexicalDC); 2542204643Srdivacky Importer.Imported(D, ToIvar); 2543234353Sdim LexicalDC->addDeclInternal(ToIvar); 2544204643Srdivacky return ToIvar; 2545204643Srdivacky 2546204643Srdivacky} 2547204643Srdivacky 2548203955SrdivackyDecl *ASTNodeImporter::VisitVarDecl(VarDecl *D) { 2549203955Srdivacky // Import the major distinguishing characteristics of a variable. 2550203955Srdivacky DeclContext *DC, *LexicalDC; 2551203955Srdivacky DeclarationName Name; 2552203955Srdivacky SourceLocation Loc; 2553288943Sdim NamedDecl *ToD; 2554288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2555276479Sdim return nullptr; 2556288943Sdim if (ToD) 2557288943Sdim return ToD; 2558276479Sdim 2559203955Srdivacky // Try to find a variable in our own ("to") context with the same name and 2560203955Srdivacky // in the same context as the variable we're importing. 2561203955Srdivacky if (D->isFileVarDecl()) { 2562276479Sdim VarDecl *MergeWithVar = nullptr; 2563226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2564203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2565249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2566280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2567226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2568226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2569203955Srdivacky continue; 2570321369Sdim 2571226633Sdim if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) { 2572203955Srdivacky // We have found a variable that we may need to merge with. Check it. 2573261991Sdim if (FoundVar->hasExternalFormalLinkage() && 2574261991Sdim D->hasExternalFormalLinkage()) { 2575321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2576203955Srdivacky FoundVar->getType())) { 2577203955Srdivacky MergeWithVar = FoundVar; 2578203955Srdivacky break; 2579203955Srdivacky } 2580203955Srdivacky 2581203955Srdivacky const ArrayType *FoundArray 2582203955Srdivacky = Importer.getToContext().getAsArrayType(FoundVar->getType()); 2583203955Srdivacky const ArrayType *TArray 2584203955Srdivacky = Importer.getToContext().getAsArrayType(D->getType()); 2585203955Srdivacky if (FoundArray && TArray) { 2586203955Srdivacky if (isa<IncompleteArrayType>(FoundArray) && 2587203955Srdivacky isa<ConstantArrayType>(TArray)) { 2588203955Srdivacky // Import the type. 2589203955Srdivacky QualType T = Importer.Import(D->getType()); 2590203955Srdivacky if (T.isNull()) 2591276479Sdim return nullptr; 2592276479Sdim 2593203955Srdivacky FoundVar->setType(T); 2594203955Srdivacky MergeWithVar = FoundVar; 2595203955Srdivacky break; 2596203955Srdivacky } else if (isa<IncompleteArrayType>(TArray) && 2597203955Srdivacky isa<ConstantArrayType>(FoundArray)) { 2598203955Srdivacky MergeWithVar = FoundVar; 2599203955Srdivacky break; 2600203955Srdivacky } 2601203955Srdivacky } 2602203955Srdivacky 2603203955Srdivacky Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent) 2604203955Srdivacky << Name << D->getType() << FoundVar->getType(); 2605203955Srdivacky Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here) 2606203955Srdivacky << FoundVar->getType(); 2607203955Srdivacky } 2608203955Srdivacky } 2609203955Srdivacky 2610226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 2611203955Srdivacky } 2612203955Srdivacky 2613203955Srdivacky if (MergeWithVar) { 2614203955Srdivacky // An equivalent variable with external linkage has been found. Link 2615203955Srdivacky // the two declarations, then merge them. 2616203955Srdivacky Importer.Imported(D, MergeWithVar); 2617203955Srdivacky 2618203955Srdivacky if (VarDecl *DDef = D->getDefinition()) { 2619203955Srdivacky if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) { 2620203955Srdivacky Importer.ToDiag(ExistingDef->getLocation(), 2621203955Srdivacky diag::err_odr_variable_multiple_def) 2622203955Srdivacky << Name; 2623203955Srdivacky Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here); 2624203955Srdivacky } else { 2625203955Srdivacky Expr *Init = Importer.Import(DDef->getInit()); 2626203955Srdivacky MergeWithVar->setInit(Init); 2627234353Sdim if (DDef->isInitKnownICE()) { 2628234353Sdim EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt(); 2629234353Sdim Eval->CheckedICE = true; 2630234353Sdim Eval->IsICE = DDef->isInitICE(); 2631234353Sdim } 2632203955Srdivacky } 2633203955Srdivacky } 2634203955Srdivacky 2635203955Srdivacky return MergeWithVar; 2636203955Srdivacky } 2637203955Srdivacky 2638203955Srdivacky if (!ConflictingDecls.empty()) { 2639203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 2640203955Srdivacky ConflictingDecls.data(), 2641203955Srdivacky ConflictingDecls.size()); 2642203955Srdivacky if (!Name) 2643276479Sdim return nullptr; 2644203955Srdivacky } 2645203955Srdivacky } 2646203955Srdivacky 2647203955Srdivacky // Import the type. 2648203955Srdivacky QualType T = Importer.Import(D->getType()); 2649203955Srdivacky if (T.isNull()) 2650276479Sdim return nullptr; 2651276479Sdim 2652203955Srdivacky // Create the imported variable. 2653203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2654221345Sdim VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC, 2655221345Sdim Importer.Import(D->getInnerLocStart()), 2656221345Sdim Loc, Name.getAsIdentifierInfo(), 2657221345Sdim T, TInfo, 2658249423Sdim D->getStorageClass()); 2659219077Sdim ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2660204643Srdivacky ToVar->setAccess(D->getAccess()); 2661203955Srdivacky ToVar->setLexicalDeclContext(LexicalDC); 2662203955Srdivacky Importer.Imported(D, ToVar); 2663234353Sdim LexicalDC->addDeclInternal(ToVar); 2664203955Srdivacky 2665288943Sdim if (!D->isFileVarDecl() && 2666288943Sdim D->isUsed()) 2667288943Sdim ToVar->setIsUsed(); 2668288943Sdim 2669203955Srdivacky // Merge the initializer. 2670261991Sdim if (ImportDefinition(D, ToVar)) 2671276479Sdim return nullptr; 2672203955Srdivacky 2673321369Sdim if (D->isConstexpr()) 2674321369Sdim ToVar->setConstexpr(true); 2675321369Sdim 2676203955Srdivacky return ToVar; 2677203955Srdivacky} 2678203955Srdivacky 2679204643SrdivackyDecl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 2680204643Srdivacky // Parameters are created in the translation unit's context, then moved 2681204643Srdivacky // into the function declaration's context afterward. 2682204643Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 2683204643Srdivacky 2684204643Srdivacky // Import the name of this declaration. 2685204643Srdivacky DeclarationName Name = Importer.Import(D->getDeclName()); 2686204643Srdivacky if (D->getDeclName() && !Name) 2687276479Sdim return nullptr; 2688276479Sdim 2689204643Srdivacky // Import the location of this declaration. 2690204643Srdivacky SourceLocation Loc = Importer.Import(D->getLocation()); 2691204643Srdivacky 2692204643Srdivacky // Import the parameter's type. 2693204643Srdivacky QualType T = Importer.Import(D->getType()); 2694204643Srdivacky if (T.isNull()) 2695276479Sdim return nullptr; 2696276479Sdim 2697204643Srdivacky // Create the imported parameter. 2698321369Sdim auto *ToParm = ImplicitParamDecl::Create(Importer.getToContext(), DC, Loc, 2699321369Sdim Name.getAsIdentifierInfo(), T, 2700321369Sdim D->getParameterKind()); 2701204643Srdivacky return Importer.Imported(D, ToParm); 2702204643Srdivacky} 2703204643Srdivacky 2704203955SrdivackyDecl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) { 2705203955Srdivacky // Parameters are created in the translation unit's context, then moved 2706203955Srdivacky // into the function declaration's context afterward. 2707203955Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 2708203955Srdivacky 2709203955Srdivacky // Import the name of this declaration. 2710203955Srdivacky DeclarationName Name = Importer.Import(D->getDeclName()); 2711203955Srdivacky if (D->getDeclName() && !Name) 2712276479Sdim return nullptr; 2713276479Sdim 2714203955Srdivacky // Import the location of this declaration. 2715203955Srdivacky SourceLocation Loc = Importer.Import(D->getLocation()); 2716203955Srdivacky 2717203955Srdivacky // Import the parameter's type. 2718203955Srdivacky QualType T = Importer.Import(D->getType()); 2719203955Srdivacky if (T.isNull()) 2720276479Sdim return nullptr; 2721276479Sdim 2722203955Srdivacky // Create the imported parameter. 2723203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2724203955Srdivacky ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC, 2725221345Sdim Importer.Import(D->getInnerLocStart()), 2726203955Srdivacky Loc, Name.getAsIdentifierInfo(), 2727203955Srdivacky T, TInfo, D->getStorageClass(), 2728321369Sdim /*DefaultArg*/ nullptr); 2729321369Sdim 2730321369Sdim // Set the default argument. 2731205219Srdivacky ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg()); 2732321369Sdim ToParm->setKNRPromoted(D->isKNRPromoted()); 2733288943Sdim 2734321369Sdim Expr *ToDefArg = nullptr; 2735321369Sdim Expr *FromDefArg = nullptr; 2736321369Sdim if (D->hasUninstantiatedDefaultArg()) { 2737321369Sdim FromDefArg = D->getUninstantiatedDefaultArg(); 2738321369Sdim ToDefArg = Importer.Import(FromDefArg); 2739321369Sdim ToParm->setUninstantiatedDefaultArg(ToDefArg); 2740321369Sdim } else if (D->hasUnparsedDefaultArg()) { 2741321369Sdim ToParm->setUnparsedDefaultArg(); 2742321369Sdim } else if (D->hasDefaultArg()) { 2743321369Sdim FromDefArg = D->getDefaultArg(); 2744321369Sdim ToDefArg = Importer.Import(FromDefArg); 2745321369Sdim ToParm->setDefaultArg(ToDefArg); 2746321369Sdim } 2747321369Sdim if (FromDefArg && !ToDefArg) 2748321369Sdim return nullptr; 2749321369Sdim 2750288943Sdim if (D->isUsed()) 2751288943Sdim ToParm->setIsUsed(); 2752288943Sdim 2753203955Srdivacky return Importer.Imported(D, ToParm); 2754203955Srdivacky} 2755203955Srdivacky 2756204643SrdivackyDecl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 2757204643Srdivacky // Import the major distinguishing characteristics of a method. 2758204643Srdivacky DeclContext *DC, *LexicalDC; 2759204643Srdivacky DeclarationName Name; 2760204643Srdivacky SourceLocation Loc; 2761288943Sdim NamedDecl *ToD; 2762288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2763276479Sdim return nullptr; 2764288943Sdim if (ToD) 2765288943Sdim return ToD; 2766276479Sdim 2767249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2768280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2769226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2770226633Sdim if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) { 2771204643Srdivacky if (FoundMethod->isInstanceMethod() != D->isInstanceMethod()) 2772204643Srdivacky continue; 2773204643Srdivacky 2774204643Srdivacky // Check return types. 2775276479Sdim if (!Importer.IsStructurallyEquivalent(D->getReturnType(), 2776276479Sdim FoundMethod->getReturnType())) { 2777204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent) 2778276479Sdim << D->isInstanceMethod() << Name << D->getReturnType() 2779276479Sdim << FoundMethod->getReturnType(); 2780204643Srdivacky Importer.ToDiag(FoundMethod->getLocation(), 2781204643Srdivacky diag::note_odr_objc_method_here) 2782204643Srdivacky << D->isInstanceMethod() << Name; 2783276479Sdim return nullptr; 2784204643Srdivacky } 2785204643Srdivacky 2786204643Srdivacky // Check the number of parameters. 2787204643Srdivacky if (D->param_size() != FoundMethod->param_size()) { 2788204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent) 2789204643Srdivacky << D->isInstanceMethod() << Name 2790204643Srdivacky << D->param_size() << FoundMethod->param_size(); 2791204643Srdivacky Importer.ToDiag(FoundMethod->getLocation(), 2792204643Srdivacky diag::note_odr_objc_method_here) 2793204643Srdivacky << D->isInstanceMethod() << Name; 2794276479Sdim return nullptr; 2795204643Srdivacky } 2796204643Srdivacky 2797204643Srdivacky // Check parameter types. 2798321369Sdim for (ObjCMethodDecl::param_iterator P = D->param_begin(), 2799204643Srdivacky PEnd = D->param_end(), FoundP = FoundMethod->param_begin(); 2800204643Srdivacky P != PEnd; ++P, ++FoundP) { 2801321369Sdim if (!Importer.IsStructurallyEquivalent((*P)->getType(), 2802204643Srdivacky (*FoundP)->getType())) { 2803321369Sdim Importer.FromDiag((*P)->getLocation(), 2804204643Srdivacky diag::err_odr_objc_method_param_type_inconsistent) 2805204643Srdivacky << D->isInstanceMethod() << Name 2806204643Srdivacky << (*P)->getType() << (*FoundP)->getType(); 2807204643Srdivacky Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here) 2808204643Srdivacky << (*FoundP)->getType(); 2809276479Sdim return nullptr; 2810204643Srdivacky } 2811204643Srdivacky } 2812204643Srdivacky 2813204643Srdivacky // Check variadic/non-variadic. 2814204643Srdivacky // Check the number of parameters. 2815204643Srdivacky if (D->isVariadic() != FoundMethod->isVariadic()) { 2816204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent) 2817204643Srdivacky << D->isInstanceMethod() << Name; 2818204643Srdivacky Importer.ToDiag(FoundMethod->getLocation(), 2819204643Srdivacky diag::note_odr_objc_method_here) 2820204643Srdivacky << D->isInstanceMethod() << Name; 2821276479Sdim return nullptr; 2822204643Srdivacky } 2823204643Srdivacky 2824204643Srdivacky // FIXME: Any other bits we need to merge? 2825204643Srdivacky return Importer.Imported(D, FoundMethod); 2826204643Srdivacky } 2827204643Srdivacky } 2828204643Srdivacky 2829204643Srdivacky // Import the result type. 2830276479Sdim QualType ResultTy = Importer.Import(D->getReturnType()); 2831204643Srdivacky if (ResultTy.isNull()) 2832276479Sdim return nullptr; 2833204643Srdivacky 2834276479Sdim TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo()); 2835204962Srdivacky 2836276479Sdim ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create( 2837276479Sdim Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()), 2838276479Sdim Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(), 2839276479Sdim D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(), 2840276479Sdim D->getImplementationControl(), D->hasRelatedResultType()); 2841204643Srdivacky 2842204643Srdivacky // FIXME: When we decide to merge method definitions, we'll need to 2843204643Srdivacky // deal with implicit parameters. 2844204643Srdivacky 2845204643Srdivacky // Import the parameters 2846226633Sdim SmallVector<ParmVarDecl *, 5> ToParams; 2847309124Sdim for (auto *FromP : D->parameters()) { 2848276479Sdim ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP)); 2849204643Srdivacky if (!ToP) 2850276479Sdim return nullptr; 2851276479Sdim 2852204643Srdivacky ToParams.push_back(ToP); 2853204643Srdivacky } 2854204643Srdivacky 2855204643Srdivacky // Set the parameters. 2856204643Srdivacky for (unsigned I = 0, N = ToParams.size(); I != N; ++I) { 2857204643Srdivacky ToParams[I]->setOwningFunction(ToMethod); 2858234353Sdim ToMethod->addDeclInternal(ToParams[I]); 2859204643Srdivacky } 2860226633Sdim SmallVector<SourceLocation, 12> SelLocs; 2861226633Sdim D->getSelectorLocs(SelLocs); 2862226633Sdim ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs); 2863204643Srdivacky 2864204643Srdivacky ToMethod->setLexicalDeclContext(LexicalDC); 2865204643Srdivacky Importer.Imported(D, ToMethod); 2866234353Sdim LexicalDC->addDeclInternal(ToMethod); 2867204643Srdivacky return ToMethod; 2868204643Srdivacky} 2869204643Srdivacky 2870288943SdimDecl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 2871288943Sdim // Import the major distinguishing characteristics of a category. 2872288943Sdim DeclContext *DC, *LexicalDC; 2873288943Sdim DeclarationName Name; 2874288943Sdim SourceLocation Loc; 2875288943Sdim NamedDecl *ToD; 2876288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2877288943Sdim return nullptr; 2878288943Sdim if (ToD) 2879288943Sdim return ToD; 2880288943Sdim 2881288943Sdim TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo()); 2882288943Sdim if (!BoundInfo) 2883288943Sdim return nullptr; 2884288943Sdim 2885288943Sdim ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create( 2886288943Sdim Importer.getToContext(), DC, 2887288943Sdim D->getVariance(), 2888288943Sdim Importer.Import(D->getVarianceLoc()), 2889288943Sdim D->getIndex(), 2890288943Sdim Importer.Import(D->getLocation()), 2891288943Sdim Name.getAsIdentifierInfo(), 2892288943Sdim Importer.Import(D->getColonLoc()), 2893288943Sdim BoundInfo); 2894288943Sdim Importer.Imported(D, Result); 2895288943Sdim Result->setLexicalDeclContext(LexicalDC); 2896288943Sdim return Result; 2897288943Sdim} 2898288943Sdim 2899204643SrdivackyDecl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 2900204643Srdivacky // Import the major distinguishing characteristics of a category. 2901204643Srdivacky DeclContext *DC, *LexicalDC; 2902204643Srdivacky DeclarationName Name; 2903204643Srdivacky SourceLocation Loc; 2904288943Sdim NamedDecl *ToD; 2905288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2906276479Sdim return nullptr; 2907288943Sdim if (ToD) 2908288943Sdim return ToD; 2909276479Sdim 2910204643Srdivacky ObjCInterfaceDecl *ToInterface 2911204643Srdivacky = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface())); 2912204643Srdivacky if (!ToInterface) 2913276479Sdim return nullptr; 2914276479Sdim 2915204643Srdivacky // Determine if we've already encountered this category. 2916204643Srdivacky ObjCCategoryDecl *MergeWithCategory 2917204643Srdivacky = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo()); 2918204643Srdivacky ObjCCategoryDecl *ToCategory = MergeWithCategory; 2919204643Srdivacky if (!ToCategory) { 2920204643Srdivacky ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC, 2921226633Sdim Importer.Import(D->getAtStartLoc()), 2922204643Srdivacky Loc, 2923204643Srdivacky Importer.Import(D->getCategoryNameLoc()), 2924226633Sdim Name.getAsIdentifierInfo(), 2925234353Sdim ToInterface, 2926288943Sdim /*TypeParamList=*/nullptr, 2927234353Sdim Importer.Import(D->getIvarLBraceLoc()), 2928234353Sdim Importer.Import(D->getIvarRBraceLoc())); 2929204643Srdivacky ToCategory->setLexicalDeclContext(LexicalDC); 2930234353Sdim LexicalDC->addDeclInternal(ToCategory); 2931204643Srdivacky Importer.Imported(D, ToCategory); 2932288943Sdim // Import the type parameter list after calling Imported, to avoid 2933288943Sdim // loops when bringing in their DeclContext. 2934288943Sdim ToCategory->setTypeParamList(ImportObjCTypeParamList( 2935288943Sdim D->getTypeParamList())); 2936204643Srdivacky 2937204643Srdivacky // Import protocols 2938226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 2939226633Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 2940204643Srdivacky ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc 2941204643Srdivacky = D->protocol_loc_begin(); 2942204643Srdivacky for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(), 2943204643Srdivacky FromProtoEnd = D->protocol_end(); 2944204643Srdivacky FromProto != FromProtoEnd; 2945204643Srdivacky ++FromProto, ++FromProtoLoc) { 2946204643Srdivacky ObjCProtocolDecl *ToProto 2947204643Srdivacky = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 2948204643Srdivacky if (!ToProto) 2949276479Sdim return nullptr; 2950204643Srdivacky Protocols.push_back(ToProto); 2951204643Srdivacky ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 2952204643Srdivacky } 2953204643Srdivacky 2954204643Srdivacky // FIXME: If we're merging, make sure that the protocol list is the same. 2955204643Srdivacky ToCategory->setProtocolList(Protocols.data(), Protocols.size(), 2956204643Srdivacky ProtocolLocs.data(), Importer.getToContext()); 2957204643Srdivacky 2958204643Srdivacky } else { 2959204643Srdivacky Importer.Imported(D, ToCategory); 2960204643Srdivacky } 2961204643Srdivacky 2962204643Srdivacky // Import all of the members of this category. 2963204643Srdivacky ImportDeclContext(D); 2964204643Srdivacky 2965204643Srdivacky // If we have an implementation, import it as well. 2966204643Srdivacky if (D->getImplementation()) { 2967204643Srdivacky ObjCCategoryImplDecl *Impl 2968218893Sdim = cast_or_null<ObjCCategoryImplDecl>( 2969218893Sdim Importer.Import(D->getImplementation())); 2970204643Srdivacky if (!Impl) 2971276479Sdim return nullptr; 2972276479Sdim 2973204643Srdivacky ToCategory->setImplementation(Impl); 2974204643Srdivacky } 2975204643Srdivacky 2976204643Srdivacky return ToCategory; 2977204643Srdivacky} 2978204643Srdivacky 2979234353Sdimbool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From, 2980234353Sdim ObjCProtocolDecl *To, 2981234353Sdim ImportDefinitionKind Kind) { 2982234353Sdim if (To->getDefinition()) { 2983234353Sdim if (shouldForceImportDeclContext(Kind)) 2984234353Sdim ImportDeclContext(From); 2985234353Sdim return false; 2986234353Sdim } 2987234353Sdim 2988234353Sdim // Start the protocol definition 2989234353Sdim To->startDefinition(); 2990234353Sdim 2991234353Sdim // Import protocols 2992234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 2993234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 2994234353Sdim ObjCProtocolDecl::protocol_loc_iterator 2995234353Sdim FromProtoLoc = From->protocol_loc_begin(); 2996234353Sdim for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(), 2997234353Sdim FromProtoEnd = From->protocol_end(); 2998234353Sdim FromProto != FromProtoEnd; 2999234353Sdim ++FromProto, ++FromProtoLoc) { 3000234353Sdim ObjCProtocolDecl *ToProto 3001234353Sdim = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3002234353Sdim if (!ToProto) 3003234353Sdim return true; 3004234353Sdim Protocols.push_back(ToProto); 3005234353Sdim ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3006234353Sdim } 3007234353Sdim 3008234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 3009234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 3010234353Sdim ProtocolLocs.data(), Importer.getToContext()); 3011234353Sdim 3012234353Sdim if (shouldForceImportDeclContext(Kind)) { 3013234353Sdim // Import all of the members of this protocol. 3014234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 3015234353Sdim } 3016234353Sdim return false; 3017234353Sdim} 3018234353Sdim 3019204643SrdivackyDecl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 3020234353Sdim // If this protocol has a definition in the translation unit we're coming 3021234353Sdim // from, but this particular declaration is not that definition, import the 3022234353Sdim // definition and map to that. 3023234353Sdim ObjCProtocolDecl *Definition = D->getDefinition(); 3024234353Sdim if (Definition && Definition != D) { 3025234353Sdim Decl *ImportedDef = Importer.Import(Definition); 3026234353Sdim if (!ImportedDef) 3027276479Sdim return nullptr; 3028276479Sdim 3029234353Sdim return Importer.Imported(D, ImportedDef); 3030234353Sdim } 3031234353Sdim 3032204643Srdivacky // Import the major distinguishing characteristics of a protocol. 3033204643Srdivacky DeclContext *DC, *LexicalDC; 3034204643Srdivacky DeclarationName Name; 3035204643Srdivacky SourceLocation Loc; 3036288943Sdim NamedDecl *ToD; 3037288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3038276479Sdim return nullptr; 3039288943Sdim if (ToD) 3040288943Sdim return ToD; 3041204643Srdivacky 3042276479Sdim ObjCProtocolDecl *MergeWithProtocol = nullptr; 3043249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3044280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3045226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3046226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol)) 3047204643Srdivacky continue; 3048204643Srdivacky 3049226633Sdim if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I]))) 3050204643Srdivacky break; 3051204643Srdivacky } 3052204643Srdivacky 3053204643Srdivacky ObjCProtocolDecl *ToProto = MergeWithProtocol; 3054234353Sdim if (!ToProto) { 3055234353Sdim ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC, 3056234353Sdim Name.getAsIdentifierInfo(), Loc, 3057234353Sdim Importer.Import(D->getAtStartLoc()), 3058276479Sdim /*PrevDecl=*/nullptr); 3059234353Sdim ToProto->setLexicalDeclContext(LexicalDC); 3060234353Sdim LexicalDC->addDeclInternal(ToProto); 3061234353Sdim } 3062234353Sdim 3063234353Sdim Importer.Imported(D, ToProto); 3064234353Sdim 3065234353Sdim if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto)) 3066276479Sdim return nullptr; 3067276479Sdim 3068234353Sdim return ToProto; 3069234353Sdim} 3070234353Sdim 3071280031SdimDecl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 3072280031Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3073280031Sdim DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3074280031Sdim 3075280031Sdim SourceLocation ExternLoc = Importer.Import(D->getExternLoc()); 3076280031Sdim SourceLocation LangLoc = Importer.Import(D->getLocation()); 3077280031Sdim 3078280031Sdim bool HasBraces = D->hasBraces(); 3079280031Sdim 3080280031Sdim LinkageSpecDecl *ToLinkageSpec = 3081280031Sdim LinkageSpecDecl::Create(Importer.getToContext(), 3082280031Sdim DC, 3083280031Sdim ExternLoc, 3084280031Sdim LangLoc, 3085280031Sdim D->getLanguage(), 3086280031Sdim HasBraces); 3087280031Sdim 3088280031Sdim if (HasBraces) { 3089280031Sdim SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc()); 3090280031Sdim ToLinkageSpec->setRBraceLoc(RBraceLoc); 3091280031Sdim } 3092280031Sdim 3093280031Sdim ToLinkageSpec->setLexicalDeclContext(LexicalDC); 3094280031Sdim LexicalDC->addDeclInternal(ToLinkageSpec); 3095280031Sdim 3096280031Sdim Importer.Imported(D, ToLinkageSpec); 3097280031Sdim 3098280031Sdim return ToLinkageSpec; 3099280031Sdim} 3100280031Sdim 3101327952SdimDecl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) { 3102327952Sdim DeclContext *DC, *LexicalDC; 3103327952Sdim DeclarationName Name; 3104327952Sdim SourceLocation Loc; 3105327952Sdim NamedDecl *ToD = nullptr; 3106327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3107327952Sdim return nullptr; 3108327952Sdim if (ToD) 3109327952Sdim return ToD; 3110327952Sdim 3111327952Sdim DeclarationNameInfo NameInfo(Name, 3112327952Sdim Importer.Import(D->getNameInfo().getLoc())); 3113327952Sdim ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 3114327952Sdim 3115327952Sdim UsingDecl *ToUsing = UsingDecl::Create(Importer.getToContext(), DC, 3116327952Sdim Importer.Import(D->getUsingLoc()), 3117327952Sdim Importer.Import(D->getQualifierLoc()), 3118327952Sdim NameInfo, D->hasTypename()); 3119327952Sdim ToUsing->setLexicalDeclContext(LexicalDC); 3120327952Sdim LexicalDC->addDeclInternal(ToUsing); 3121327952Sdim Importer.Imported(D, ToUsing); 3122327952Sdim 3123327952Sdim if (NamedDecl *FromPattern = 3124327952Sdim Importer.getFromContext().getInstantiatedFromUsingDecl(D)) { 3125327952Sdim if (NamedDecl *ToPattern = 3126327952Sdim dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern))) 3127327952Sdim Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern); 3128327952Sdim else 3129327952Sdim return nullptr; 3130327952Sdim } 3131327952Sdim 3132327952Sdim for (UsingShadowDecl *FromShadow : D->shadows()) { 3133327952Sdim if (UsingShadowDecl *ToShadow = 3134327952Sdim dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow))) 3135327952Sdim ToUsing->addShadowDecl(ToShadow); 3136327952Sdim else 3137327952Sdim // FIXME: We return a nullptr here but the definition is already created 3138327952Sdim // and available with lookups. How to fix this?.. 3139327952Sdim return nullptr; 3140327952Sdim } 3141327952Sdim return ToUsing; 3142327952Sdim} 3143327952Sdim 3144327952SdimDecl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) { 3145327952Sdim DeclContext *DC, *LexicalDC; 3146327952Sdim DeclarationName Name; 3147327952Sdim SourceLocation Loc; 3148327952Sdim NamedDecl *ToD = nullptr; 3149327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3150327952Sdim return nullptr; 3151327952Sdim if (ToD) 3152327952Sdim return ToD; 3153327952Sdim 3154327952Sdim UsingDecl *ToUsing = dyn_cast_or_null<UsingDecl>( 3155327952Sdim Importer.Import(D->getUsingDecl())); 3156327952Sdim if (!ToUsing) 3157327952Sdim return nullptr; 3158327952Sdim 3159327952Sdim NamedDecl *ToTarget = dyn_cast_or_null<NamedDecl>( 3160327952Sdim Importer.Import(D->getTargetDecl())); 3161327952Sdim if (!ToTarget) 3162327952Sdim return nullptr; 3163327952Sdim 3164327952Sdim UsingShadowDecl *ToShadow = UsingShadowDecl::Create( 3165327952Sdim Importer.getToContext(), DC, Loc, ToUsing, ToTarget); 3166327952Sdim 3167327952Sdim ToShadow->setLexicalDeclContext(LexicalDC); 3168327952Sdim ToShadow->setAccess(D->getAccess()); 3169327952Sdim Importer.Imported(D, ToShadow); 3170327952Sdim 3171327952Sdim if (UsingShadowDecl *FromPattern = 3172327952Sdim Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) { 3173327952Sdim if (UsingShadowDecl *ToPattern = 3174327952Sdim dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern))) 3175327952Sdim Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow, 3176327952Sdim ToPattern); 3177327952Sdim else 3178327952Sdim // FIXME: We return a nullptr here but the definition is already created 3179327952Sdim // and available with lookups. How to fix this?.. 3180327952Sdim return nullptr; 3181327952Sdim } 3182327952Sdim 3183327952Sdim LexicalDC->addDeclInternal(ToShadow); 3184327952Sdim 3185327952Sdim return ToShadow; 3186327952Sdim} 3187327952Sdim 3188327952Sdim 3189327952SdimDecl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 3190327952Sdim DeclContext *DC, *LexicalDC; 3191327952Sdim DeclarationName Name; 3192327952Sdim SourceLocation Loc; 3193327952Sdim NamedDecl *ToD = nullptr; 3194327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3195327952Sdim return nullptr; 3196327952Sdim if (ToD) 3197327952Sdim return ToD; 3198327952Sdim 3199327952Sdim DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor()); 3200327952Sdim if (!ToComAncestor) 3201327952Sdim return nullptr; 3202327952Sdim 3203327952Sdim NamespaceDecl *ToNominated = cast_or_null<NamespaceDecl>( 3204327952Sdim Importer.Import(D->getNominatedNamespace())); 3205327952Sdim if (!ToNominated) 3206327952Sdim return nullptr; 3207327952Sdim 3208327952Sdim UsingDirectiveDecl *ToUsingDir = UsingDirectiveDecl::Create( 3209327952Sdim Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()), 3210327952Sdim Importer.Import(D->getNamespaceKeyLocation()), 3211327952Sdim Importer.Import(D->getQualifierLoc()), 3212327952Sdim Importer.Import(D->getIdentLocation()), ToNominated, ToComAncestor); 3213327952Sdim ToUsingDir->setLexicalDeclContext(LexicalDC); 3214327952Sdim LexicalDC->addDeclInternal(ToUsingDir); 3215327952Sdim Importer.Imported(D, ToUsingDir); 3216327952Sdim 3217327952Sdim return ToUsingDir; 3218327952Sdim} 3219327952Sdim 3220327952SdimDecl *ASTNodeImporter::VisitUnresolvedUsingValueDecl( 3221327952Sdim UnresolvedUsingValueDecl *D) { 3222327952Sdim DeclContext *DC, *LexicalDC; 3223327952Sdim DeclarationName Name; 3224327952Sdim SourceLocation Loc; 3225327952Sdim NamedDecl *ToD = nullptr; 3226327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3227327952Sdim return nullptr; 3228327952Sdim if (ToD) 3229327952Sdim return ToD; 3230327952Sdim 3231327952Sdim DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc())); 3232327952Sdim ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 3233327952Sdim 3234327952Sdim UnresolvedUsingValueDecl *ToUsingValue = UnresolvedUsingValueDecl::Create( 3235327952Sdim Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()), 3236327952Sdim Importer.Import(D->getQualifierLoc()), NameInfo, 3237327952Sdim Importer.Import(D->getEllipsisLoc())); 3238327952Sdim 3239327952Sdim Importer.Imported(D, ToUsingValue); 3240327952Sdim ToUsingValue->setAccess(D->getAccess()); 3241327952Sdim ToUsingValue->setLexicalDeclContext(LexicalDC); 3242327952Sdim LexicalDC->addDeclInternal(ToUsingValue); 3243327952Sdim 3244327952Sdim return ToUsingValue; 3245327952Sdim} 3246327952Sdim 3247327952SdimDecl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl( 3248327952Sdim UnresolvedUsingTypenameDecl *D) { 3249327952Sdim DeclContext *DC, *LexicalDC; 3250327952Sdim DeclarationName Name; 3251327952Sdim SourceLocation Loc; 3252327952Sdim NamedDecl *ToD = nullptr; 3253327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3254327952Sdim return nullptr; 3255327952Sdim if (ToD) 3256327952Sdim return ToD; 3257327952Sdim 3258327952Sdim UnresolvedUsingTypenameDecl *ToUsing = UnresolvedUsingTypenameDecl::Create( 3259327952Sdim Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()), 3260327952Sdim Importer.Import(D->getTypenameLoc()), 3261327952Sdim Importer.Import(D->getQualifierLoc()), Loc, Name, 3262327952Sdim Importer.Import(D->getEllipsisLoc())); 3263327952Sdim 3264327952Sdim Importer.Imported(D, ToUsing); 3265327952Sdim ToUsing->setAccess(D->getAccess()); 3266327952Sdim ToUsing->setLexicalDeclContext(LexicalDC); 3267327952Sdim LexicalDC->addDeclInternal(ToUsing); 3268327952Sdim 3269327952Sdim return ToUsing; 3270327952Sdim} 3271327952Sdim 3272327952Sdim 3273234353Sdimbool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, 3274234353Sdim ObjCInterfaceDecl *To, 3275234353Sdim ImportDefinitionKind Kind) { 3276234353Sdim if (To->getDefinition()) { 3277234353Sdim // Check consistency of superclass. 3278234353Sdim ObjCInterfaceDecl *FromSuper = From->getSuperClass(); 3279234353Sdim if (FromSuper) { 3280234353Sdim FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper)); 3281234353Sdim if (!FromSuper) 3282234353Sdim return true; 3283204643Srdivacky } 3284234353Sdim 3285234353Sdim ObjCInterfaceDecl *ToSuper = To->getSuperClass(); 3286234353Sdim if ((bool)FromSuper != (bool)ToSuper || 3287234353Sdim (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) { 3288234353Sdim Importer.ToDiag(To->getLocation(), 3289234353Sdim diag::err_odr_objc_superclass_inconsistent) 3290234353Sdim << To->getDeclName(); 3291234353Sdim if (ToSuper) 3292234353Sdim Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass) 3293234353Sdim << To->getSuperClass()->getDeclName(); 3294234353Sdim else 3295234353Sdim Importer.ToDiag(To->getLocation(), 3296234353Sdim diag::note_odr_objc_missing_superclass); 3297234353Sdim if (From->getSuperClass()) 3298234353Sdim Importer.FromDiag(From->getSuperClassLoc(), 3299234353Sdim diag::note_odr_objc_superclass) 3300234353Sdim << From->getSuperClass()->getDeclName(); 3301234353Sdim else 3302234353Sdim Importer.FromDiag(From->getLocation(), 3303234353Sdim diag::note_odr_objc_missing_superclass); 3304234353Sdim } 3305234353Sdim 3306234353Sdim if (shouldForceImportDeclContext(Kind)) 3307234353Sdim ImportDeclContext(From); 3308234353Sdim return false; 3309234353Sdim } 3310234353Sdim 3311234353Sdim // Start the definition. 3312234353Sdim To->startDefinition(); 3313234353Sdim 3314234353Sdim // If this class has a superclass, import it. 3315234353Sdim if (From->getSuperClass()) { 3316288943Sdim TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo()); 3317288943Sdim if (!SuperTInfo) 3318234353Sdim return true; 3319288943Sdim 3320288943Sdim To->setSuperClass(SuperTInfo); 3321234353Sdim } 3322234353Sdim 3323234353Sdim // Import protocols 3324234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 3325234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 3326234353Sdim ObjCInterfaceDecl::protocol_loc_iterator 3327234353Sdim FromProtoLoc = From->protocol_loc_begin(); 3328234353Sdim 3329234353Sdim for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(), 3330234353Sdim FromProtoEnd = From->protocol_end(); 3331204643Srdivacky FromProto != FromProtoEnd; 3332204643Srdivacky ++FromProto, ++FromProtoLoc) { 3333234353Sdim ObjCProtocolDecl *ToProto 3334234353Sdim = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3335234353Sdim if (!ToProto) 3336234353Sdim return true; 3337234353Sdim Protocols.push_back(ToProto); 3338234353Sdim ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3339234353Sdim } 3340234353Sdim 3341234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 3342234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 3343234353Sdim ProtocolLocs.data(), Importer.getToContext()); 3344234353Sdim 3345234353Sdim // Import categories. When the categories themselves are imported, they'll 3346234353Sdim // hook themselves into this interface. 3347276479Sdim for (auto *Cat : From->known_categories()) 3348276479Sdim Importer.Import(Cat); 3349249423Sdim 3350234353Sdim // If we have an @implementation, import it as well. 3351234353Sdim if (From->getImplementation()) { 3352234353Sdim ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>( 3353234353Sdim Importer.Import(From->getImplementation())); 3354234353Sdim if (!Impl) 3355234353Sdim return true; 3356204643Srdivacky 3357234353Sdim To->setImplementation(Impl); 3358204643Srdivacky } 3359204643Srdivacky 3360234353Sdim if (shouldForceImportDeclContext(Kind)) { 3361234353Sdim // Import all of the members of this class. 3362234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 3363234353Sdim } 3364234353Sdim return false; 3365204643Srdivacky} 3366204643Srdivacky 3367288943SdimObjCTypeParamList * 3368288943SdimASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) { 3369288943Sdim if (!list) 3370288943Sdim return nullptr; 3371288943Sdim 3372288943Sdim SmallVector<ObjCTypeParamDecl *, 4> toTypeParams; 3373288943Sdim for (auto fromTypeParam : *list) { 3374288943Sdim auto toTypeParam = cast_or_null<ObjCTypeParamDecl>( 3375288943Sdim Importer.Import(fromTypeParam)); 3376288943Sdim if (!toTypeParam) 3377288943Sdim return nullptr; 3378288943Sdim 3379288943Sdim toTypeParams.push_back(toTypeParam); 3380288943Sdim } 3381288943Sdim 3382288943Sdim return ObjCTypeParamList::create(Importer.getToContext(), 3383288943Sdim Importer.Import(list->getLAngleLoc()), 3384288943Sdim toTypeParams, 3385288943Sdim Importer.Import(list->getRAngleLoc())); 3386288943Sdim} 3387288943Sdim 3388203955SrdivackyDecl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 3389234353Sdim // If this class has a definition in the translation unit we're coming from, 3390234353Sdim // but this particular declaration is not that definition, import the 3391234353Sdim // definition and map to that. 3392234353Sdim ObjCInterfaceDecl *Definition = D->getDefinition(); 3393234353Sdim if (Definition && Definition != D) { 3394234353Sdim Decl *ImportedDef = Importer.Import(Definition); 3395234353Sdim if (!ImportedDef) 3396276479Sdim return nullptr; 3397276479Sdim 3398234353Sdim return Importer.Imported(D, ImportedDef); 3399234353Sdim } 3400234353Sdim 3401203955Srdivacky // Import the major distinguishing characteristics of an @interface. 3402203955Srdivacky DeclContext *DC, *LexicalDC; 3403203955Srdivacky DeclarationName Name; 3404203955Srdivacky SourceLocation Loc; 3405288943Sdim NamedDecl *ToD; 3406288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3407276479Sdim return nullptr; 3408288943Sdim if (ToD) 3409288943Sdim return ToD; 3410203955Srdivacky 3411234353Sdim // Look for an existing interface with the same name. 3412276479Sdim ObjCInterfaceDecl *MergeWithIface = nullptr; 3413249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3414280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3415226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3416226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 3417203955Srdivacky continue; 3418203955Srdivacky 3419226633Sdim if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I]))) 3420203955Srdivacky break; 3421203955Srdivacky } 3422203955Srdivacky 3423234353Sdim // Create an interface declaration, if one does not already exist. 3424203955Srdivacky ObjCInterfaceDecl *ToIface = MergeWithIface; 3425234353Sdim if (!ToIface) { 3426234353Sdim ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC, 3427234353Sdim Importer.Import(D->getAtStartLoc()), 3428288943Sdim Name.getAsIdentifierInfo(), 3429288943Sdim /*TypeParamList=*/nullptr, 3430276479Sdim /*PrevDecl=*/nullptr, Loc, 3431234353Sdim D->isImplicitInterfaceDecl()); 3432234353Sdim ToIface->setLexicalDeclContext(LexicalDC); 3433234353Sdim LexicalDC->addDeclInternal(ToIface); 3434203955Srdivacky } 3435234353Sdim Importer.Imported(D, ToIface); 3436288943Sdim // Import the type parameter list after calling Imported, to avoid 3437288943Sdim // loops when bringing in their DeclContext. 3438288943Sdim ToIface->setTypeParamList(ImportObjCTypeParamList( 3439288943Sdim D->getTypeParamListAsWritten())); 3440203955Srdivacky 3441234353Sdim if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface)) 3442276479Sdim return nullptr; 3443276479Sdim 3444204643Srdivacky return ToIface; 3445203955Srdivacky} 3446203955Srdivacky 3447218893SdimDecl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 3448218893Sdim ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>( 3449218893Sdim Importer.Import(D->getCategoryDecl())); 3450218893Sdim if (!Category) 3451276479Sdim return nullptr; 3452276479Sdim 3453218893Sdim ObjCCategoryImplDecl *ToImpl = Category->getImplementation(); 3454218893Sdim if (!ToImpl) { 3455218893Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3456218893Sdim if (!DC) 3457276479Sdim return nullptr; 3458276479Sdim 3459234353Sdim SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc()); 3460218893Sdim ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC, 3461226633Sdim Importer.Import(D->getIdentifier()), 3462226633Sdim Category->getClassInterface(), 3463218893Sdim Importer.Import(D->getLocation()), 3464234353Sdim Importer.Import(D->getAtStartLoc()), 3465234353Sdim CategoryNameLoc); 3466218893Sdim 3467218893Sdim DeclContext *LexicalDC = DC; 3468218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3469218893Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3470218893Sdim if (!LexicalDC) 3471276479Sdim return nullptr; 3472276479Sdim 3473218893Sdim ToImpl->setLexicalDeclContext(LexicalDC); 3474218893Sdim } 3475218893Sdim 3476234353Sdim LexicalDC->addDeclInternal(ToImpl); 3477218893Sdim Category->setImplementation(ToImpl); 3478218893Sdim } 3479218893Sdim 3480218893Sdim Importer.Imported(D, ToImpl); 3481218893Sdim ImportDeclContext(D); 3482218893Sdim return ToImpl; 3483218893Sdim} 3484218893Sdim 3485218893SdimDecl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 3486218893Sdim // Find the corresponding interface. 3487218893Sdim ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>( 3488218893Sdim Importer.Import(D->getClassInterface())); 3489218893Sdim if (!Iface) 3490276479Sdim return nullptr; 3491218893Sdim 3492218893Sdim // Import the superclass, if any. 3493276479Sdim ObjCInterfaceDecl *Super = nullptr; 3494218893Sdim if (D->getSuperClass()) { 3495218893Sdim Super = cast_or_null<ObjCInterfaceDecl>( 3496218893Sdim Importer.Import(D->getSuperClass())); 3497218893Sdim if (!Super) 3498276479Sdim return nullptr; 3499218893Sdim } 3500218893Sdim 3501218893Sdim ObjCImplementationDecl *Impl = Iface->getImplementation(); 3502218893Sdim if (!Impl) { 3503218893Sdim // We haven't imported an implementation yet. Create a new @implementation 3504218893Sdim // now. 3505218893Sdim Impl = ObjCImplementationDecl::Create(Importer.getToContext(), 3506218893Sdim Importer.ImportContext(D->getDeclContext()), 3507226633Sdim Iface, Super, 3508218893Sdim Importer.Import(D->getLocation()), 3509234353Sdim Importer.Import(D->getAtStartLoc()), 3510251662Sdim Importer.Import(D->getSuperClassLoc()), 3511234353Sdim Importer.Import(D->getIvarLBraceLoc()), 3512234353Sdim Importer.Import(D->getIvarRBraceLoc())); 3513218893Sdim 3514218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3515218893Sdim DeclContext *LexicalDC 3516218893Sdim = Importer.ImportContext(D->getLexicalDeclContext()); 3517218893Sdim if (!LexicalDC) 3518276479Sdim return nullptr; 3519218893Sdim Impl->setLexicalDeclContext(LexicalDC); 3520218893Sdim } 3521218893Sdim 3522218893Sdim // Associate the implementation with the class it implements. 3523218893Sdim Iface->setImplementation(Impl); 3524218893Sdim Importer.Imported(D, Iface->getImplementation()); 3525218893Sdim } else { 3526218893Sdim Importer.Imported(D, Iface->getImplementation()); 3527218893Sdim 3528218893Sdim // Verify that the existing @implementation has the same superclass. 3529218893Sdim if ((Super && !Impl->getSuperClass()) || 3530218893Sdim (!Super && Impl->getSuperClass()) || 3531276479Sdim (Super && Impl->getSuperClass() && 3532276479Sdim !declaresSameEntity(Super->getCanonicalDecl(), 3533276479Sdim Impl->getSuperClass()))) { 3534276479Sdim Importer.ToDiag(Impl->getLocation(), 3535276479Sdim diag::err_odr_objc_superclass_inconsistent) 3536276479Sdim << Iface->getDeclName(); 3537276479Sdim // FIXME: It would be nice to have the location of the superclass 3538276479Sdim // below. 3539276479Sdim if (Impl->getSuperClass()) 3540276479Sdim Importer.ToDiag(Impl->getLocation(), 3541276479Sdim diag::note_odr_objc_superclass) 3542276479Sdim << Impl->getSuperClass()->getDeclName(); 3543276479Sdim else 3544276479Sdim Importer.ToDiag(Impl->getLocation(), 3545276479Sdim diag::note_odr_objc_missing_superclass); 3546276479Sdim if (D->getSuperClass()) 3547276479Sdim Importer.FromDiag(D->getLocation(), 3548218893Sdim diag::note_odr_objc_superclass) 3549276479Sdim << D->getSuperClass()->getDeclName(); 3550276479Sdim else 3551276479Sdim Importer.FromDiag(D->getLocation(), 3552218893Sdim diag::note_odr_objc_missing_superclass); 3553276479Sdim return nullptr; 3554218893Sdim } 3555218893Sdim } 3556218893Sdim 3557218893Sdim // Import all of the members of this @implementation. 3558218893Sdim ImportDeclContext(D); 3559218893Sdim 3560218893Sdim return Impl; 3561218893Sdim} 3562218893Sdim 3563204643SrdivackyDecl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 3564204643Srdivacky // Import the major distinguishing characteristics of an @property. 3565204643Srdivacky DeclContext *DC, *LexicalDC; 3566204643Srdivacky DeclarationName Name; 3567204643Srdivacky SourceLocation Loc; 3568288943Sdim NamedDecl *ToD; 3569288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3570276479Sdim return nullptr; 3571288943Sdim if (ToD) 3572288943Sdim return ToD; 3573204643Srdivacky 3574204643Srdivacky // Check whether we have already imported this property. 3575249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3576280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3577226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3578204643Srdivacky if (ObjCPropertyDecl *FoundProp 3579226633Sdim = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) { 3580204643Srdivacky // Check property types. 3581321369Sdim if (!Importer.IsStructurallyEquivalent(D->getType(), 3582204643Srdivacky FoundProp->getType())) { 3583204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent) 3584204643Srdivacky << Name << D->getType() << FoundProp->getType(); 3585204643Srdivacky Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here) 3586204643Srdivacky << FoundProp->getType(); 3587276479Sdim return nullptr; 3588204643Srdivacky } 3589204643Srdivacky 3590204643Srdivacky // FIXME: Check property attributes, getters, setters, etc.? 3591204643Srdivacky 3592204643Srdivacky // Consider these properties to be equivalent. 3593204643Srdivacky Importer.Imported(D, FoundProp); 3594204643Srdivacky return FoundProp; 3595204643Srdivacky } 3596204643Srdivacky } 3597204643Srdivacky 3598204643Srdivacky // Import the type. 3599288943Sdim TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo()); 3600288943Sdim if (!TSI) 3601276479Sdim return nullptr; 3602204643Srdivacky 3603204643Srdivacky // Create the new property. 3604204643Srdivacky ObjCPropertyDecl *ToProperty 3605204643Srdivacky = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc, 3606204643Srdivacky Name.getAsIdentifierInfo(), 3607204643Srdivacky Importer.Import(D->getAtLoc()), 3608234353Sdim Importer.Import(D->getLParenLoc()), 3609288943Sdim Importer.Import(D->getType()), 3610288943Sdim TSI, 3611204643Srdivacky D->getPropertyImplementation()); 3612204643Srdivacky Importer.Imported(D, ToProperty); 3613204643Srdivacky ToProperty->setLexicalDeclContext(LexicalDC); 3614234353Sdim LexicalDC->addDeclInternal(ToProperty); 3615204643Srdivacky 3616204643Srdivacky ToProperty->setPropertyAttributes(D->getPropertyAttributes()); 3617210299Sed ToProperty->setPropertyAttributesAsWritten( 3618210299Sed D->getPropertyAttributesAsWritten()); 3619321369Sdim ToProperty->setGetterName(Importer.Import(D->getGetterName()), 3620321369Sdim Importer.Import(D->getGetterNameLoc())); 3621321369Sdim ToProperty->setSetterName(Importer.Import(D->getSetterName()), 3622321369Sdim Importer.Import(D->getSetterNameLoc())); 3623204643Srdivacky ToProperty->setGetterMethodDecl( 3624204643Srdivacky cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl()))); 3625204643Srdivacky ToProperty->setSetterMethodDecl( 3626204643Srdivacky cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl()))); 3627204643Srdivacky ToProperty->setPropertyIvarDecl( 3628204643Srdivacky cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl()))); 3629204643Srdivacky return ToProperty; 3630204643Srdivacky} 3631204643Srdivacky 3632218893SdimDecl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 3633218893Sdim ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>( 3634218893Sdim Importer.Import(D->getPropertyDecl())); 3635218893Sdim if (!Property) 3636276479Sdim return nullptr; 3637218893Sdim 3638218893Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3639218893Sdim if (!DC) 3640276479Sdim return nullptr; 3641276479Sdim 3642218893Sdim // Import the lexical declaration context. 3643218893Sdim DeclContext *LexicalDC = DC; 3644218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3645218893Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3646218893Sdim if (!LexicalDC) 3647276479Sdim return nullptr; 3648218893Sdim } 3649218893Sdim 3650218893Sdim ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC); 3651218893Sdim if (!InImpl) 3652276479Sdim return nullptr; 3653218893Sdim 3654218893Sdim // Import the ivar (for an @synthesize). 3655276479Sdim ObjCIvarDecl *Ivar = nullptr; 3656218893Sdim if (D->getPropertyIvarDecl()) { 3657218893Sdim Ivar = cast_or_null<ObjCIvarDecl>( 3658218893Sdim Importer.Import(D->getPropertyIvarDecl())); 3659218893Sdim if (!Ivar) 3660276479Sdim return nullptr; 3661218893Sdim } 3662218893Sdim 3663218893Sdim ObjCPropertyImplDecl *ToImpl 3664309124Sdim = InImpl->FindPropertyImplDecl(Property->getIdentifier(), 3665309124Sdim Property->getQueryKind()); 3666218893Sdim if (!ToImpl) { 3667218893Sdim ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC, 3668218893Sdim Importer.Import(D->getLocStart()), 3669218893Sdim Importer.Import(D->getLocation()), 3670218893Sdim Property, 3671218893Sdim D->getPropertyImplementation(), 3672218893Sdim Ivar, 3673218893Sdim Importer.Import(D->getPropertyIvarDeclLoc())); 3674218893Sdim ToImpl->setLexicalDeclContext(LexicalDC); 3675218893Sdim Importer.Imported(D, ToImpl); 3676234353Sdim LexicalDC->addDeclInternal(ToImpl); 3677218893Sdim } else { 3678218893Sdim // Check that we have the same kind of property implementation (@synthesize 3679218893Sdim // vs. @dynamic). 3680218893Sdim if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) { 3681218893Sdim Importer.ToDiag(ToImpl->getLocation(), 3682218893Sdim diag::err_odr_objc_property_impl_kind_inconsistent) 3683218893Sdim << Property->getDeclName() 3684218893Sdim << (ToImpl->getPropertyImplementation() 3685218893Sdim == ObjCPropertyImplDecl::Dynamic); 3686218893Sdim Importer.FromDiag(D->getLocation(), 3687218893Sdim diag::note_odr_objc_property_impl_kind) 3688218893Sdim << D->getPropertyDecl()->getDeclName() 3689218893Sdim << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic); 3690276479Sdim return nullptr; 3691218893Sdim } 3692218893Sdim 3693218893Sdim // For @synthesize, check that we have the same 3694218893Sdim if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && 3695218893Sdim Ivar != ToImpl->getPropertyIvarDecl()) { 3696218893Sdim Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), 3697218893Sdim diag::err_odr_objc_synthesize_ivar_inconsistent) 3698218893Sdim << Property->getDeclName() 3699218893Sdim << ToImpl->getPropertyIvarDecl()->getDeclName() 3700218893Sdim << Ivar->getDeclName(); 3701218893Sdim Importer.FromDiag(D->getPropertyIvarDeclLoc(), 3702218893Sdim diag::note_odr_objc_synthesize_ivar_here) 3703218893Sdim << D->getPropertyIvarDecl()->getDeclName(); 3704276479Sdim return nullptr; 3705218893Sdim } 3706218893Sdim 3707218893Sdim // Merge the existing implementation with the new implementation. 3708218893Sdim Importer.Imported(D, ToImpl); 3709218893Sdim } 3710218893Sdim 3711218893Sdim return ToImpl; 3712218893Sdim} 3713218893Sdim 3714218893SdimDecl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 3715218893Sdim // For template arguments, we adopt the translation unit as our declaration 3716218893Sdim // context. This context will be fixed when the actual template declaration 3717218893Sdim // is created. 3718218893Sdim 3719218893Sdim // FIXME: Import default argument. 3720218893Sdim return TemplateTypeParmDecl::Create(Importer.getToContext(), 3721218893Sdim Importer.getToContext().getTranslationUnitDecl(), 3722221345Sdim Importer.Import(D->getLocStart()), 3723218893Sdim Importer.Import(D->getLocation()), 3724218893Sdim D->getDepth(), 3725218893Sdim D->getIndex(), 3726218893Sdim Importer.Import(D->getIdentifier()), 3727218893Sdim D->wasDeclaredWithTypename(), 3728218893Sdim D->isParameterPack()); 3729218893Sdim} 3730218893Sdim 3731218893SdimDecl * 3732218893SdimASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 3733218893Sdim // Import the name of this declaration. 3734218893Sdim DeclarationName Name = Importer.Import(D->getDeclName()); 3735218893Sdim if (D->getDeclName() && !Name) 3736276479Sdim return nullptr; 3737276479Sdim 3738218893Sdim // Import the location of this declaration. 3739218893Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 3740218893Sdim 3741218893Sdim // Import the type of this declaration. 3742218893Sdim QualType T = Importer.Import(D->getType()); 3743218893Sdim if (T.isNull()) 3744276479Sdim return nullptr; 3745276479Sdim 3746218893Sdim // Import type-source information. 3747218893Sdim TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 3748218893Sdim if (D->getTypeSourceInfo() && !TInfo) 3749276479Sdim return nullptr; 3750276479Sdim 3751218893Sdim // FIXME: Import default argument. 3752218893Sdim 3753218893Sdim return NonTypeTemplateParmDecl::Create(Importer.getToContext(), 3754218893Sdim Importer.getToContext().getTranslationUnitDecl(), 3755221345Sdim Importer.Import(D->getInnerLocStart()), 3756218893Sdim Loc, D->getDepth(), D->getPosition(), 3757218893Sdim Name.getAsIdentifierInfo(), 3758218893Sdim T, D->isParameterPack(), TInfo); 3759218893Sdim} 3760218893Sdim 3761218893SdimDecl * 3762218893SdimASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 3763218893Sdim // Import the name of this declaration. 3764218893Sdim DeclarationName Name = Importer.Import(D->getDeclName()); 3765218893Sdim if (D->getDeclName() && !Name) 3766276479Sdim return nullptr; 3767276479Sdim 3768218893Sdim // Import the location of this declaration. 3769218893Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 3770218893Sdim 3771218893Sdim // Import template parameters. 3772218893Sdim TemplateParameterList *TemplateParams 3773218893Sdim = ImportTemplateParameterList(D->getTemplateParameters()); 3774218893Sdim if (!TemplateParams) 3775276479Sdim return nullptr; 3776276479Sdim 3777218893Sdim // FIXME: Import default argument. 3778218893Sdim 3779218893Sdim return TemplateTemplateParmDecl::Create(Importer.getToContext(), 3780218893Sdim Importer.getToContext().getTranslationUnitDecl(), 3781218893Sdim Loc, D->getDepth(), D->getPosition(), 3782218893Sdim D->isParameterPack(), 3783218893Sdim Name.getAsIdentifierInfo(), 3784218893Sdim TemplateParams); 3785218893Sdim} 3786218893Sdim 3787218893SdimDecl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 3788218893Sdim // If this record has a definition in the translation unit we're coming from, 3789218893Sdim // but this particular declaration is not that definition, import the 3790218893Sdim // definition and map to that. 3791218893Sdim CXXRecordDecl *Definition 3792218893Sdim = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition()); 3793218893Sdim if (Definition && Definition != D->getTemplatedDecl()) { 3794218893Sdim Decl *ImportedDef 3795218893Sdim = Importer.Import(Definition->getDescribedClassTemplate()); 3796218893Sdim if (!ImportedDef) 3797276479Sdim return nullptr; 3798276479Sdim 3799218893Sdim return Importer.Imported(D, ImportedDef); 3800218893Sdim } 3801218893Sdim 3802218893Sdim // Import the major distinguishing characteristics of this class template. 3803218893Sdim DeclContext *DC, *LexicalDC; 3804218893Sdim DeclarationName Name; 3805218893Sdim SourceLocation Loc; 3806288943Sdim NamedDecl *ToD; 3807288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3808276479Sdim return nullptr; 3809288943Sdim if (ToD) 3810288943Sdim return ToD; 3811276479Sdim 3812218893Sdim // We may already have a template of the same name; try to find and match it. 3813218893Sdim if (!DC->isFunctionOrMethod()) { 3814226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 3815249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3816280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3817226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3818226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 3819218893Sdim continue; 3820218893Sdim 3821226633Sdim Decl *Found = FoundDecls[I]; 3822218893Sdim if (ClassTemplateDecl *FoundTemplate 3823218893Sdim = dyn_cast<ClassTemplateDecl>(Found)) { 3824218893Sdim if (IsStructuralMatch(D, FoundTemplate)) { 3825218893Sdim // The class templates structurally match; call it the same template. 3826218893Sdim // FIXME: We may be filling in a forward declaration here. Handle 3827218893Sdim // this case! 3828218893Sdim Importer.Imported(D->getTemplatedDecl(), 3829218893Sdim FoundTemplate->getTemplatedDecl()); 3830218893Sdim return Importer.Imported(D, FoundTemplate); 3831218893Sdim } 3832218893Sdim } 3833218893Sdim 3834226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 3835218893Sdim } 3836218893Sdim 3837218893Sdim if (!ConflictingDecls.empty()) { 3838218893Sdim Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 3839218893Sdim ConflictingDecls.data(), 3840218893Sdim ConflictingDecls.size()); 3841218893Sdim } 3842218893Sdim 3843218893Sdim if (!Name) 3844276479Sdim return nullptr; 3845218893Sdim } 3846218893Sdim 3847218893Sdim CXXRecordDecl *DTemplated = D->getTemplatedDecl(); 3848218893Sdim 3849218893Sdim // Create the declaration that is being templated. 3850309124Sdim CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>( 3851309124Sdim Importer.Import(DTemplated)); 3852309124Sdim if (!D2Templated) 3853309124Sdim return nullptr; 3854309124Sdim 3855309124Sdim // Resolve possible cyclic import. 3856309124Sdim if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D)) 3857309124Sdim return AlreadyImported; 3858309124Sdim 3859218893Sdim // Create the class template declaration itself. 3860218893Sdim TemplateParameterList *TemplateParams 3861218893Sdim = ImportTemplateParameterList(D->getTemplateParameters()); 3862218893Sdim if (!TemplateParams) 3863276479Sdim return nullptr; 3864276479Sdim 3865218893Sdim ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC, 3866218893Sdim Loc, Name, TemplateParams, 3867314564Sdim D2Templated); 3868218893Sdim D2Templated->setDescribedClassTemplate(D2); 3869218893Sdim 3870218893Sdim D2->setAccess(D->getAccess()); 3871218893Sdim D2->setLexicalDeclContext(LexicalDC); 3872234353Sdim LexicalDC->addDeclInternal(D2); 3873218893Sdim 3874218893Sdim // Note the relationship between the class templates. 3875218893Sdim Importer.Imported(D, D2); 3876218893Sdim Importer.Imported(DTemplated, D2Templated); 3877218893Sdim 3878226633Sdim if (DTemplated->isCompleteDefinition() && 3879226633Sdim !D2Templated->isCompleteDefinition()) { 3880218893Sdim // FIXME: Import definition! 3881218893Sdim } 3882218893Sdim 3883218893Sdim return D2; 3884218893Sdim} 3885218893Sdim 3886218893SdimDecl *ASTNodeImporter::VisitClassTemplateSpecializationDecl( 3887218893Sdim ClassTemplateSpecializationDecl *D) { 3888218893Sdim // If this record has a definition in the translation unit we're coming from, 3889218893Sdim // but this particular declaration is not that definition, import the 3890218893Sdim // definition and map to that. 3891218893Sdim TagDecl *Definition = D->getDefinition(); 3892218893Sdim if (Definition && Definition != D) { 3893218893Sdim Decl *ImportedDef = Importer.Import(Definition); 3894218893Sdim if (!ImportedDef) 3895276479Sdim return nullptr; 3896276479Sdim 3897218893Sdim return Importer.Imported(D, ImportedDef); 3898218893Sdim } 3899218893Sdim 3900218893Sdim ClassTemplateDecl *ClassTemplate 3901218893Sdim = cast_or_null<ClassTemplateDecl>(Importer.Import( 3902218893Sdim D->getSpecializedTemplate())); 3903218893Sdim if (!ClassTemplate) 3904276479Sdim return nullptr; 3905276479Sdim 3906218893Sdim // Import the context of this declaration. 3907218893Sdim DeclContext *DC = ClassTemplate->getDeclContext(); 3908218893Sdim if (!DC) 3909276479Sdim return nullptr; 3910276479Sdim 3911218893Sdim DeclContext *LexicalDC = DC; 3912218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3913218893Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3914218893Sdim if (!LexicalDC) 3915276479Sdim return nullptr; 3916218893Sdim } 3917218893Sdim 3918218893Sdim // Import the location of this declaration. 3919221345Sdim SourceLocation StartLoc = Importer.Import(D->getLocStart()); 3920221345Sdim SourceLocation IdLoc = Importer.Import(D->getLocation()); 3921218893Sdim 3922218893Sdim // Import template arguments. 3923226633Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 3924218893Sdim if (ImportTemplateArguments(D->getTemplateArgs().data(), 3925218893Sdim D->getTemplateArgs().size(), 3926218893Sdim TemplateArgs)) 3927276479Sdim return nullptr; 3928276479Sdim 3929218893Sdim // Try to find an existing specialization with these template arguments. 3930276479Sdim void *InsertPos = nullptr; 3931218893Sdim ClassTemplateSpecializationDecl *D2 3932276479Sdim = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); 3933218893Sdim if (D2) { 3934218893Sdim // We already have a class template specialization with these template 3935218893Sdim // arguments. 3936218893Sdim 3937218893Sdim // FIXME: Check for specialization vs. instantiation errors. 3938218893Sdim 3939218893Sdim if (RecordDecl *FoundDef = D2->getDefinition()) { 3940226633Sdim if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) { 3941218893Sdim // The record types structurally match, or the "from" translation 3942218893Sdim // unit only had a forward declaration anyway; call it the same 3943218893Sdim // function. 3944218893Sdim return Importer.Imported(D, FoundDef); 3945218893Sdim } 3946218893Sdim } 3947218893Sdim } else { 3948218893Sdim // Create a new specialization. 3949321369Sdim if (ClassTemplatePartialSpecializationDecl *PartialSpec = 3950321369Sdim dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) { 3951321369Sdim 3952321369Sdim // Import TemplateArgumentListInfo 3953321369Sdim TemplateArgumentListInfo ToTAInfo; 3954321369Sdim auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten(); 3955321369Sdim for (unsigned I = 0, E = ASTTemplateArgs.NumTemplateArgs; I < E; ++I) { 3956327952Sdim if (auto ToLoc = ImportTemplateArgumentLoc(ASTTemplateArgs[I])) 3957327952Sdim ToTAInfo.addArgument(*ToLoc); 3958327952Sdim else 3959321369Sdim return nullptr; 3960321369Sdim } 3961321369Sdim 3962321369Sdim QualType CanonInjType = Importer.Import( 3963321369Sdim PartialSpec->getInjectedSpecializationType()); 3964321369Sdim if (CanonInjType.isNull()) 3965321369Sdim return nullptr; 3966321369Sdim CanonInjType = CanonInjType.getCanonicalType(); 3967321369Sdim 3968321369Sdim TemplateParameterList *ToTPList = ImportTemplateParameterList( 3969321369Sdim PartialSpec->getTemplateParameters()); 3970321369Sdim if (!ToTPList && PartialSpec->getTemplateParameters()) 3971321369Sdim return nullptr; 3972321369Sdim 3973321369Sdim D2 = ClassTemplatePartialSpecializationDecl::Create( 3974321369Sdim Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc, 3975321369Sdim ToTPList, ClassTemplate, 3976321369Sdim llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()), 3977321369Sdim ToTAInfo, CanonInjType, nullptr); 3978321369Sdim 3979321369Sdim } else { 3980321369Sdim D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(), 3981321369Sdim D->getTagKind(), DC, 3982321369Sdim StartLoc, IdLoc, 3983321369Sdim ClassTemplate, 3984321369Sdim TemplateArgs, 3985321369Sdim /*PrevDecl=*/nullptr); 3986321369Sdim } 3987321369Sdim 3988218893Sdim D2->setSpecializationKind(D->getSpecializationKind()); 3989218893Sdim 3990218893Sdim // Add this specialization to the class template. 3991218893Sdim ClassTemplate->AddSpecialization(D2, InsertPos); 3992218893Sdim 3993218893Sdim // Import the qualifier, if any. 3994219077Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 3995321369Sdim 3996321369Sdim Importer.Imported(D, D2); 3997321369Sdim 3998321369Sdim if (auto *TSI = D->getTypeAsWritten()) { 3999321369Sdim TypeSourceInfo *TInfo = Importer.Import(TSI); 4000321369Sdim if (!TInfo) 4001321369Sdim return nullptr; 4002321369Sdim D2->setTypeAsWritten(TInfo); 4003321369Sdim D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc())); 4004321369Sdim D2->setExternLoc(Importer.Import(D->getExternLoc())); 4005321369Sdim } 4006321369Sdim 4007321369Sdim SourceLocation POI = Importer.Import(D->getPointOfInstantiation()); 4008321369Sdim if (POI.isValid()) 4009321369Sdim D2->setPointOfInstantiation(POI); 4010321369Sdim else if (D->getPointOfInstantiation().isValid()) 4011321369Sdim return nullptr; 4012321369Sdim 4013321369Sdim D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind()); 4014321369Sdim 4015218893Sdim // Add the specialization to this context. 4016218893Sdim D2->setLexicalDeclContext(LexicalDC); 4017234353Sdim LexicalDC->addDeclInternal(D2); 4018218893Sdim } 4019218893Sdim Importer.Imported(D, D2); 4020226633Sdim if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 4021276479Sdim return nullptr; 4022276479Sdim 4023218893Sdim return D2; 4024218893Sdim} 4025218893Sdim 4026261991SdimDecl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) { 4027261991Sdim // If this variable has a definition in the translation unit we're coming 4028261991Sdim // from, 4029261991Sdim // but this particular declaration is not that definition, import the 4030261991Sdim // definition and map to that. 4031261991Sdim VarDecl *Definition = 4032261991Sdim cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition()); 4033261991Sdim if (Definition && Definition != D->getTemplatedDecl()) { 4034261991Sdim Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate()); 4035261991Sdim if (!ImportedDef) 4036276479Sdim return nullptr; 4037261991Sdim 4038261991Sdim return Importer.Imported(D, ImportedDef); 4039261991Sdim } 4040261991Sdim 4041261991Sdim // Import the major distinguishing characteristics of this variable template. 4042261991Sdim DeclContext *DC, *LexicalDC; 4043261991Sdim DeclarationName Name; 4044261991Sdim SourceLocation Loc; 4045288943Sdim NamedDecl *ToD; 4046288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4047276479Sdim return nullptr; 4048288943Sdim if (ToD) 4049288943Sdim return ToD; 4050261991Sdim 4051261991Sdim // We may already have a template of the same name; try to find and match it. 4052261991Sdim assert(!DC->isFunctionOrMethod() && 4053261991Sdim "Variable templates cannot be declared at function scope"); 4054261991Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 4055261991Sdim SmallVector<NamedDecl *, 2> FoundDecls; 4056280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 4057261991Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 4058261991Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4059261991Sdim continue; 4060261991Sdim 4061261991Sdim Decl *Found = FoundDecls[I]; 4062261991Sdim if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) { 4063261991Sdim if (IsStructuralMatch(D, FoundTemplate)) { 4064261991Sdim // The variable templates structurally match; call it the same template. 4065261991Sdim Importer.Imported(D->getTemplatedDecl(), 4066261991Sdim FoundTemplate->getTemplatedDecl()); 4067261991Sdim return Importer.Imported(D, FoundTemplate); 4068261991Sdim } 4069261991Sdim } 4070261991Sdim 4071261991Sdim ConflictingDecls.push_back(FoundDecls[I]); 4072261991Sdim } 4073261991Sdim 4074261991Sdim if (!ConflictingDecls.empty()) { 4075261991Sdim Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 4076261991Sdim ConflictingDecls.data(), 4077261991Sdim ConflictingDecls.size()); 4078261991Sdim } 4079261991Sdim 4080261991Sdim if (!Name) 4081276479Sdim return nullptr; 4082261991Sdim 4083261991Sdim VarDecl *DTemplated = D->getTemplatedDecl(); 4084261991Sdim 4085261991Sdim // Import the type. 4086261991Sdim QualType T = Importer.Import(DTemplated->getType()); 4087261991Sdim if (T.isNull()) 4088276479Sdim return nullptr; 4089261991Sdim 4090261991Sdim // Create the declaration that is being templated. 4091261991Sdim SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart()); 4092261991Sdim SourceLocation IdLoc = Importer.Import(DTemplated->getLocation()); 4093261991Sdim TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo()); 4094261991Sdim VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc, 4095261991Sdim IdLoc, Name.getAsIdentifierInfo(), T, 4096261991Sdim TInfo, DTemplated->getStorageClass()); 4097261991Sdim D2Templated->setAccess(DTemplated->getAccess()); 4098261991Sdim D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc())); 4099261991Sdim D2Templated->setLexicalDeclContext(LexicalDC); 4100261991Sdim 4101261991Sdim // Importer.Imported(DTemplated, D2Templated); 4102261991Sdim // LexicalDC->addDeclInternal(D2Templated); 4103261991Sdim 4104261991Sdim // Merge the initializer. 4105261991Sdim if (ImportDefinition(DTemplated, D2Templated)) 4106276479Sdim return nullptr; 4107261991Sdim 4108261991Sdim // Create the variable template declaration itself. 4109261991Sdim TemplateParameterList *TemplateParams = 4110261991Sdim ImportTemplateParameterList(D->getTemplateParameters()); 4111261991Sdim if (!TemplateParams) 4112276479Sdim return nullptr; 4113261991Sdim 4114261991Sdim VarTemplateDecl *D2 = VarTemplateDecl::Create( 4115276479Sdim Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated); 4116261991Sdim D2Templated->setDescribedVarTemplate(D2); 4117261991Sdim 4118261991Sdim D2->setAccess(D->getAccess()); 4119261991Sdim D2->setLexicalDeclContext(LexicalDC); 4120261991Sdim LexicalDC->addDeclInternal(D2); 4121261991Sdim 4122261991Sdim // Note the relationship between the variable templates. 4123261991Sdim Importer.Imported(D, D2); 4124261991Sdim Importer.Imported(DTemplated, D2Templated); 4125261991Sdim 4126261991Sdim if (DTemplated->isThisDeclarationADefinition() && 4127261991Sdim !D2Templated->isThisDeclarationADefinition()) { 4128261991Sdim // FIXME: Import definition! 4129261991Sdim } 4130261991Sdim 4131261991Sdim return D2; 4132261991Sdim} 4133261991Sdim 4134261991SdimDecl *ASTNodeImporter::VisitVarTemplateSpecializationDecl( 4135261991Sdim VarTemplateSpecializationDecl *D) { 4136261991Sdim // If this record has a definition in the translation unit we're coming from, 4137261991Sdim // but this particular declaration is not that definition, import the 4138261991Sdim // definition and map to that. 4139261991Sdim VarDecl *Definition = D->getDefinition(); 4140261991Sdim if (Definition && Definition != D) { 4141261991Sdim Decl *ImportedDef = Importer.Import(Definition); 4142261991Sdim if (!ImportedDef) 4143276479Sdim return nullptr; 4144261991Sdim 4145261991Sdim return Importer.Imported(D, ImportedDef); 4146261991Sdim } 4147261991Sdim 4148261991Sdim VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>( 4149261991Sdim Importer.Import(D->getSpecializedTemplate())); 4150261991Sdim if (!VarTemplate) 4151276479Sdim return nullptr; 4152261991Sdim 4153261991Sdim // Import the context of this declaration. 4154261991Sdim DeclContext *DC = VarTemplate->getDeclContext(); 4155261991Sdim if (!DC) 4156276479Sdim return nullptr; 4157261991Sdim 4158261991Sdim DeclContext *LexicalDC = DC; 4159261991Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 4160261991Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 4161261991Sdim if (!LexicalDC) 4162276479Sdim return nullptr; 4163261991Sdim } 4164261991Sdim 4165261991Sdim // Import the location of this declaration. 4166261991Sdim SourceLocation StartLoc = Importer.Import(D->getLocStart()); 4167261991Sdim SourceLocation IdLoc = Importer.Import(D->getLocation()); 4168261991Sdim 4169261991Sdim // Import template arguments. 4170261991Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 4171261991Sdim if (ImportTemplateArguments(D->getTemplateArgs().data(), 4172261991Sdim D->getTemplateArgs().size(), TemplateArgs)) 4173276479Sdim return nullptr; 4174261991Sdim 4175261991Sdim // Try to find an existing specialization with these template arguments. 4176276479Sdim void *InsertPos = nullptr; 4177261991Sdim VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization( 4178276479Sdim TemplateArgs, InsertPos); 4179261991Sdim if (D2) { 4180261991Sdim // We already have a variable template specialization with these template 4181261991Sdim // arguments. 4182261991Sdim 4183261991Sdim // FIXME: Check for specialization vs. instantiation errors. 4184261991Sdim 4185261991Sdim if (VarDecl *FoundDef = D2->getDefinition()) { 4186261991Sdim if (!D->isThisDeclarationADefinition() || 4187261991Sdim IsStructuralMatch(D, FoundDef)) { 4188261991Sdim // The record types structurally match, or the "from" translation 4189261991Sdim // unit only had a forward declaration anyway; call it the same 4190261991Sdim // variable. 4191261991Sdim return Importer.Imported(D, FoundDef); 4192261991Sdim } 4193261991Sdim } 4194261991Sdim } else { 4195261991Sdim 4196261991Sdim // Import the type. 4197261991Sdim QualType T = Importer.Import(D->getType()); 4198261991Sdim if (T.isNull()) 4199276479Sdim return nullptr; 4200261991Sdim TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 4201261991Sdim 4202261991Sdim // Create a new specialization. 4203261991Sdim D2 = VarTemplateSpecializationDecl::Create( 4204261991Sdim Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo, 4205309124Sdim D->getStorageClass(), TemplateArgs); 4206261991Sdim D2->setSpecializationKind(D->getSpecializationKind()); 4207261991Sdim D2->setTemplateArgsInfo(D->getTemplateArgsInfo()); 4208261991Sdim 4209261991Sdim // Add this specialization to the class template. 4210261991Sdim VarTemplate->AddSpecialization(D2, InsertPos); 4211261991Sdim 4212261991Sdim // Import the qualifier, if any. 4213261991Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 4214261991Sdim 4215261991Sdim // Add the specialization to this context. 4216261991Sdim D2->setLexicalDeclContext(LexicalDC); 4217261991Sdim LexicalDC->addDeclInternal(D2); 4218261991Sdim } 4219261991Sdim Importer.Imported(D, D2); 4220261991Sdim 4221261991Sdim if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2)) 4222276479Sdim return nullptr; 4223261991Sdim 4224261991Sdim return D2; 4225261991Sdim} 4226261991Sdim 4227327952SdimDecl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 4228327952Sdim DeclContext *DC, *LexicalDC; 4229327952Sdim DeclarationName Name; 4230327952Sdim SourceLocation Loc; 4231327952Sdim NamedDecl *ToD; 4232327952Sdim 4233327952Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4234327952Sdim return nullptr; 4235327952Sdim 4236327952Sdim if (ToD) 4237327952Sdim return ToD; 4238327952Sdim 4239327952Sdim // Try to find a function in our own ("to") context with the same name, same 4240327952Sdim // type, and in the same context as the function we're importing. 4241327952Sdim if (!LexicalDC->isFunctionOrMethod()) { 4242327952Sdim unsigned IDNS = Decl::IDNS_Ordinary; 4243327952Sdim SmallVector<NamedDecl *, 2> FoundDecls; 4244327952Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 4245327952Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 4246327952Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 4247327952Sdim continue; 4248327952Sdim 4249327952Sdim if (FunctionTemplateDecl *FoundFunction = 4250327952Sdim dyn_cast<FunctionTemplateDecl>(FoundDecls[I])) { 4251327952Sdim if (FoundFunction->hasExternalFormalLinkage() && 4252327952Sdim D->hasExternalFormalLinkage()) { 4253327952Sdim if (IsStructuralMatch(D, FoundFunction)) { 4254327952Sdim Importer.Imported(D, FoundFunction); 4255327952Sdim // FIXME: Actually try to merge the body and other attributes. 4256327952Sdim return FoundFunction; 4257327952Sdim } 4258327952Sdim } 4259327952Sdim } 4260327952Sdim } 4261327952Sdim } 4262327952Sdim 4263327952Sdim TemplateParameterList *Params = 4264327952Sdim ImportTemplateParameterList(D->getTemplateParameters()); 4265327952Sdim if (!Params) 4266327952Sdim return nullptr; 4267327952Sdim 4268327952Sdim FunctionDecl *TemplatedFD = 4269327952Sdim cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl())); 4270327952Sdim if (!TemplatedFD) 4271327952Sdim return nullptr; 4272327952Sdim 4273327952Sdim FunctionTemplateDecl *ToFunc = FunctionTemplateDecl::Create( 4274327952Sdim Importer.getToContext(), DC, Loc, Name, Params, TemplatedFD); 4275327952Sdim 4276327952Sdim TemplatedFD->setDescribedFunctionTemplate(ToFunc); 4277327952Sdim ToFunc->setAccess(D->getAccess()); 4278327952Sdim ToFunc->setLexicalDeclContext(LexicalDC); 4279327952Sdim Importer.Imported(D, ToFunc); 4280327952Sdim 4281327952Sdim LexicalDC->addDeclInternal(ToFunc); 4282327952Sdim return ToFunc; 4283327952Sdim} 4284327952Sdim 4285203955Srdivacky//---------------------------------------------------------------------------- 4286203955Srdivacky// Import Statements 4287203955Srdivacky//---------------------------------------------------------------------------- 4288203955Srdivacky 4289288943SdimDeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) { 4290288943Sdim if (DG.isNull()) 4291288943Sdim return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0); 4292288943Sdim size_t NumDecls = DG.end() - DG.begin(); 4293288943Sdim SmallVector<Decl *, 1> ToDecls(NumDecls); 4294288943Sdim auto &_Importer = this->Importer; 4295288943Sdim std::transform(DG.begin(), DG.end(), ToDecls.begin(), 4296288943Sdim [&_Importer](Decl *D) -> Decl * { 4297288943Sdim return _Importer.Import(D); 4298288943Sdim }); 4299288943Sdim return DeclGroupRef::Create(Importer.getToContext(), 4300288943Sdim ToDecls.begin(), 4301288943Sdim NumDecls); 4302203955Srdivacky} 4303203955Srdivacky 4304288943Sdim Stmt *ASTNodeImporter::VisitStmt(Stmt *S) { 4305288943Sdim Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node) 4306288943Sdim << S->getStmtClassName(); 4307288943Sdim return nullptr; 4308288943Sdim } 4309309124Sdim 4310309124Sdim 4311309124SdimStmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) { 4312309124Sdim SmallVector<IdentifierInfo *, 4> Names; 4313309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 4314309124Sdim IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I)); 4315321369Sdim // ToII is nullptr when no symbolic name is given for output operand 4316321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 4317321369Sdim if (!ToII && S->getOutputIdentifier(I)) 4318309124Sdim return nullptr; 4319309124Sdim Names.push_back(ToII); 4320309124Sdim } 4321309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 4322309124Sdim IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I)); 4323321369Sdim // ToII is nullptr when no symbolic name is given for input operand 4324321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 4325321369Sdim if (!ToII && S->getInputIdentifier(I)) 4326309124Sdim return nullptr; 4327309124Sdim Names.push_back(ToII); 4328309124Sdim } 4329309124Sdim 4330309124Sdim SmallVector<StringLiteral *, 4> Clobbers; 4331309124Sdim for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) { 4332309124Sdim StringLiteral *Clobber = cast_or_null<StringLiteral>( 4333309124Sdim Importer.Import(S->getClobberStringLiteral(I))); 4334309124Sdim if (!Clobber) 4335309124Sdim return nullptr; 4336309124Sdim Clobbers.push_back(Clobber); 4337309124Sdim } 4338309124Sdim 4339309124Sdim SmallVector<StringLiteral *, 4> Constraints; 4340309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 4341309124Sdim StringLiteral *Output = cast_or_null<StringLiteral>( 4342309124Sdim Importer.Import(S->getOutputConstraintLiteral(I))); 4343309124Sdim if (!Output) 4344309124Sdim return nullptr; 4345309124Sdim Constraints.push_back(Output); 4346309124Sdim } 4347309124Sdim 4348309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 4349309124Sdim StringLiteral *Input = cast_or_null<StringLiteral>( 4350309124Sdim Importer.Import(S->getInputConstraintLiteral(I))); 4351309124Sdim if (!Input) 4352309124Sdim return nullptr; 4353309124Sdim Constraints.push_back(Input); 4354309124Sdim } 4355309124Sdim 4356309124Sdim SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs()); 4357314564Sdim if (ImportContainerChecked(S->outputs(), Exprs)) 4358309124Sdim return nullptr; 4359309124Sdim 4360314564Sdim if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs())) 4361309124Sdim return nullptr; 4362309124Sdim 4363309124Sdim StringLiteral *AsmStr = cast_or_null<StringLiteral>( 4364309124Sdim Importer.Import(S->getAsmString())); 4365309124Sdim if (!AsmStr) 4366309124Sdim return nullptr; 4367309124Sdim 4368309124Sdim return new (Importer.getToContext()) GCCAsmStmt( 4369309124Sdim Importer.getToContext(), 4370309124Sdim Importer.Import(S->getAsmLoc()), 4371309124Sdim S->isSimple(), 4372309124Sdim S->isVolatile(), 4373309124Sdim S->getNumOutputs(), 4374309124Sdim S->getNumInputs(), 4375309124Sdim Names.data(), 4376309124Sdim Constraints.data(), 4377309124Sdim Exprs.data(), 4378309124Sdim AsmStr, 4379309124Sdim S->getNumClobbers(), 4380309124Sdim Clobbers.data(), 4381309124Sdim Importer.Import(S->getRParenLoc())); 4382309124Sdim} 4383309124Sdim 4384288943SdimStmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) { 4385288943Sdim DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup()); 4386288943Sdim for (Decl *ToD : ToDG) { 4387288943Sdim if (!ToD) 4388288943Sdim return nullptr; 4389288943Sdim } 4390288943Sdim SourceLocation ToStartLoc = Importer.Import(S->getStartLoc()); 4391288943Sdim SourceLocation ToEndLoc = Importer.Import(S->getEndLoc()); 4392288943Sdim return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc); 4393288943Sdim} 4394288943Sdim 4395288943SdimStmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) { 4396288943Sdim SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc()); 4397288943Sdim return new (Importer.getToContext()) NullStmt(ToSemiLoc, 4398288943Sdim S->hasLeadingEmptyMacro()); 4399288943Sdim} 4400288943Sdim 4401288943SdimStmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) { 4402309124Sdim llvm::SmallVector<Stmt *, 8> ToStmts(S->size()); 4403314564Sdim 4404314564Sdim if (ImportContainerChecked(S->body(), ToStmts)) 4405309124Sdim return nullptr; 4406309124Sdim 4407288943Sdim SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc()); 4408288943Sdim SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc()); 4409327952Sdim return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc, 4410327952Sdim ToRBraceLoc); 4411288943Sdim} 4412288943Sdim 4413288943SdimStmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) { 4414288943Sdim Expr *ToLHS = Importer.Import(S->getLHS()); 4415288943Sdim if (!ToLHS) 4416288943Sdim return nullptr; 4417288943Sdim Expr *ToRHS = Importer.Import(S->getRHS()); 4418288943Sdim if (!ToRHS && S->getRHS()) 4419288943Sdim return nullptr; 4420327952Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4421327952Sdim if (!ToSubStmt && S->getSubStmt()) 4422327952Sdim return nullptr; 4423288943Sdim SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc()); 4424288943Sdim SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc()); 4425288943Sdim SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4426327952Sdim CaseStmt *ToStmt = new (Importer.getToContext()) 4427327952Sdim CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc); 4428327952Sdim ToStmt->setSubStmt(ToSubStmt); 4429327952Sdim return ToStmt; 4430288943Sdim} 4431288943Sdim 4432288943SdimStmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) { 4433288943Sdim SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc()); 4434288943Sdim SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4435288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4436288943Sdim if (!ToSubStmt && S->getSubStmt()) 4437288943Sdim return nullptr; 4438288943Sdim return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc, 4439288943Sdim ToSubStmt); 4440288943Sdim} 4441288943Sdim 4442288943SdimStmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) { 4443288943Sdim SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc()); 4444288943Sdim LabelDecl *ToLabelDecl = 4445288943Sdim cast_or_null<LabelDecl>(Importer.Import(S->getDecl())); 4446288943Sdim if (!ToLabelDecl && S->getDecl()) 4447288943Sdim return nullptr; 4448288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4449288943Sdim if (!ToSubStmt && S->getSubStmt()) 4450288943Sdim return nullptr; 4451288943Sdim return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl, 4452288943Sdim ToSubStmt); 4453288943Sdim} 4454288943Sdim 4455288943SdimStmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) { 4456288943Sdim SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc()); 4457288943Sdim ArrayRef<const Attr*> FromAttrs(S->getAttrs()); 4458288943Sdim SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size()); 4459288943Sdim ASTContext &_ToContext = Importer.getToContext(); 4460288943Sdim std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(), 4461288943Sdim [&_ToContext](const Attr *A) -> const Attr * { 4462288943Sdim return A->clone(_ToContext); 4463288943Sdim }); 4464288943Sdim for (const Attr *ToA : ToAttrs) { 4465288943Sdim if (!ToA) 4466288943Sdim return nullptr; 4467288943Sdim } 4468288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4469288943Sdim if (!ToSubStmt && S->getSubStmt()) 4470288943Sdim return nullptr; 4471288943Sdim return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc, 4472288943Sdim ToAttrs, ToSubStmt); 4473288943Sdim} 4474288943Sdim 4475288943SdimStmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) { 4476288943Sdim SourceLocation ToIfLoc = Importer.Import(S->getIfLoc()); 4477309124Sdim Stmt *ToInit = Importer.Import(S->getInit()); 4478309124Sdim if (!ToInit && S->getInit()) 4479309124Sdim return nullptr; 4480288943Sdim VarDecl *ToConditionVariable = nullptr; 4481288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4482288943Sdim ToConditionVariable = 4483288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4484288943Sdim if (!ToConditionVariable) 4485288943Sdim return nullptr; 4486288943Sdim } 4487288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4488288943Sdim if (!ToCondition && S->getCond()) 4489288943Sdim return nullptr; 4490288943Sdim Stmt *ToThenStmt = Importer.Import(S->getThen()); 4491288943Sdim if (!ToThenStmt && S->getThen()) 4492288943Sdim return nullptr; 4493288943Sdim SourceLocation ToElseLoc = Importer.Import(S->getElseLoc()); 4494288943Sdim Stmt *ToElseStmt = Importer.Import(S->getElse()); 4495288943Sdim if (!ToElseStmt && S->getElse()) 4496288943Sdim return nullptr; 4497288943Sdim return new (Importer.getToContext()) IfStmt(Importer.getToContext(), 4498309124Sdim ToIfLoc, S->isConstexpr(), 4499309124Sdim ToInit, 4500309124Sdim ToConditionVariable, 4501288943Sdim ToCondition, ToThenStmt, 4502288943Sdim ToElseLoc, ToElseStmt); 4503288943Sdim} 4504288943Sdim 4505288943SdimStmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) { 4506309124Sdim Stmt *ToInit = Importer.Import(S->getInit()); 4507309124Sdim if (!ToInit && S->getInit()) 4508309124Sdim return nullptr; 4509288943Sdim VarDecl *ToConditionVariable = nullptr; 4510288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4511288943Sdim ToConditionVariable = 4512288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4513288943Sdim if (!ToConditionVariable) 4514288943Sdim return nullptr; 4515288943Sdim } 4516288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4517288943Sdim if (!ToCondition && S->getCond()) 4518288943Sdim return nullptr; 4519288943Sdim SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt( 4520309124Sdim Importer.getToContext(), ToInit, 4521309124Sdim ToConditionVariable, ToCondition); 4522288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4523288943Sdim if (!ToBody && S->getBody()) 4524288943Sdim return nullptr; 4525288943Sdim ToStmt->setBody(ToBody); 4526288943Sdim ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc())); 4527288943Sdim // Now we have to re-chain the cases. 4528288943Sdim SwitchCase *LastChainedSwitchCase = nullptr; 4529288943Sdim for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr; 4530288943Sdim SC = SC->getNextSwitchCase()) { 4531288943Sdim SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC)); 4532288943Sdim if (!ToSC) 4533288943Sdim return nullptr; 4534288943Sdim if (LastChainedSwitchCase) 4535288943Sdim LastChainedSwitchCase->setNextSwitchCase(ToSC); 4536288943Sdim else 4537288943Sdim ToStmt->setSwitchCaseList(ToSC); 4538288943Sdim LastChainedSwitchCase = ToSC; 4539288943Sdim } 4540288943Sdim return ToStmt; 4541288943Sdim} 4542288943Sdim 4543288943SdimStmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) { 4544288943Sdim VarDecl *ToConditionVariable = nullptr; 4545288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4546288943Sdim ToConditionVariable = 4547288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4548288943Sdim if (!ToConditionVariable) 4549288943Sdim return nullptr; 4550288943Sdim } 4551288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4552288943Sdim if (!ToCondition && S->getCond()) 4553288943Sdim return nullptr; 4554288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4555288943Sdim if (!ToBody && S->getBody()) 4556288943Sdim return nullptr; 4557288943Sdim SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4558288943Sdim return new (Importer.getToContext()) WhileStmt(Importer.getToContext(), 4559288943Sdim ToConditionVariable, 4560288943Sdim ToCondition, ToBody, 4561288943Sdim ToWhileLoc); 4562288943Sdim} 4563288943Sdim 4564288943SdimStmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) { 4565288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4566288943Sdim if (!ToBody && S->getBody()) 4567288943Sdim return nullptr; 4568288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4569288943Sdim if (!ToCondition && S->getCond()) 4570288943Sdim return nullptr; 4571288943Sdim SourceLocation ToDoLoc = Importer.Import(S->getDoLoc()); 4572288943Sdim SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4573288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4574288943Sdim return new (Importer.getToContext()) DoStmt(ToBody, ToCondition, 4575288943Sdim ToDoLoc, ToWhileLoc, 4576288943Sdim ToRParenLoc); 4577288943Sdim} 4578288943Sdim 4579288943SdimStmt *ASTNodeImporter::VisitForStmt(ForStmt *S) { 4580288943Sdim Stmt *ToInit = Importer.Import(S->getInit()); 4581288943Sdim if (!ToInit && S->getInit()) 4582288943Sdim return nullptr; 4583288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4584288943Sdim if (!ToCondition && S->getCond()) 4585288943Sdim return nullptr; 4586288943Sdim VarDecl *ToConditionVariable = nullptr; 4587288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4588288943Sdim ToConditionVariable = 4589288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4590288943Sdim if (!ToConditionVariable) 4591288943Sdim return nullptr; 4592288943Sdim } 4593288943Sdim Expr *ToInc = Importer.Import(S->getInc()); 4594288943Sdim if (!ToInc && S->getInc()) 4595288943Sdim return nullptr; 4596288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4597288943Sdim if (!ToBody && S->getBody()) 4598288943Sdim return nullptr; 4599288943Sdim SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4600288943Sdim SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc()); 4601288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4602288943Sdim return new (Importer.getToContext()) ForStmt(Importer.getToContext(), 4603288943Sdim ToInit, ToCondition, 4604288943Sdim ToConditionVariable, 4605288943Sdim ToInc, ToBody, 4606288943Sdim ToForLoc, ToLParenLoc, 4607288943Sdim ToRParenLoc); 4608288943Sdim} 4609288943Sdim 4610288943SdimStmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) { 4611288943Sdim LabelDecl *ToLabel = nullptr; 4612288943Sdim if (LabelDecl *FromLabel = S->getLabel()) { 4613288943Sdim ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel)); 4614288943Sdim if (!ToLabel) 4615288943Sdim return nullptr; 4616288943Sdim } 4617288943Sdim SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4618288943Sdim SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc()); 4619288943Sdim return new (Importer.getToContext()) GotoStmt(ToLabel, 4620288943Sdim ToGotoLoc, ToLabelLoc); 4621288943Sdim} 4622288943Sdim 4623288943SdimStmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 4624288943Sdim SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4625288943Sdim SourceLocation ToStarLoc = Importer.Import(S->getStarLoc()); 4626288943Sdim Expr *ToTarget = Importer.Import(S->getTarget()); 4627288943Sdim if (!ToTarget && S->getTarget()) 4628288943Sdim return nullptr; 4629288943Sdim return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc, 4630288943Sdim ToTarget); 4631288943Sdim} 4632288943Sdim 4633288943SdimStmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) { 4634288943Sdim SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc()); 4635288943Sdim return new (Importer.getToContext()) ContinueStmt(ToContinueLoc); 4636288943Sdim} 4637288943Sdim 4638288943SdimStmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) { 4639288943Sdim SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc()); 4640288943Sdim return new (Importer.getToContext()) BreakStmt(ToBreakLoc); 4641288943Sdim} 4642288943Sdim 4643288943SdimStmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) { 4644288943Sdim SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc()); 4645288943Sdim Expr *ToRetExpr = Importer.Import(S->getRetValue()); 4646288943Sdim if (!ToRetExpr && S->getRetValue()) 4647288943Sdim return nullptr; 4648288943Sdim VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate()); 4649288943Sdim VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate)); 4650288943Sdim if (!ToNRVOCandidate && NRVOCandidate) 4651288943Sdim return nullptr; 4652288943Sdim return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr, 4653288943Sdim ToNRVOCandidate); 4654288943Sdim} 4655288943Sdim 4656288943SdimStmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) { 4657288943Sdim SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc()); 4658288943Sdim VarDecl *ToExceptionDecl = nullptr; 4659288943Sdim if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) { 4660288943Sdim ToExceptionDecl = 4661288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 4662288943Sdim if (!ToExceptionDecl) 4663288943Sdim return nullptr; 4664288943Sdim } 4665288943Sdim Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock()); 4666288943Sdim if (!ToHandlerBlock && S->getHandlerBlock()) 4667288943Sdim return nullptr; 4668288943Sdim return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc, 4669288943Sdim ToExceptionDecl, 4670288943Sdim ToHandlerBlock); 4671288943Sdim} 4672288943Sdim 4673288943SdimStmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) { 4674288943Sdim SourceLocation ToTryLoc = Importer.Import(S->getTryLoc()); 4675288943Sdim Stmt *ToTryBlock = Importer.Import(S->getTryBlock()); 4676288943Sdim if (!ToTryBlock && S->getTryBlock()) 4677288943Sdim return nullptr; 4678288943Sdim SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers()); 4679288943Sdim for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) { 4680288943Sdim CXXCatchStmt *FromHandler = S->getHandler(HI); 4681288943Sdim if (Stmt *ToHandler = Importer.Import(FromHandler)) 4682288943Sdim ToHandlers[HI] = ToHandler; 4683288943Sdim else 4684288943Sdim return nullptr; 4685288943Sdim } 4686288943Sdim return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock, 4687288943Sdim ToHandlers); 4688288943Sdim} 4689288943Sdim 4690288943SdimStmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 4691288943Sdim DeclStmt *ToRange = 4692288943Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt())); 4693288943Sdim if (!ToRange && S->getRangeStmt()) 4694288943Sdim return nullptr; 4695309124Sdim DeclStmt *ToBegin = 4696309124Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt())); 4697309124Sdim if (!ToBegin && S->getBeginStmt()) 4698288943Sdim return nullptr; 4699309124Sdim DeclStmt *ToEnd = 4700309124Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt())); 4701309124Sdim if (!ToEnd && S->getEndStmt()) 4702309124Sdim return nullptr; 4703288943Sdim Expr *ToCond = Importer.Import(S->getCond()); 4704288943Sdim if (!ToCond && S->getCond()) 4705288943Sdim return nullptr; 4706288943Sdim Expr *ToInc = Importer.Import(S->getInc()); 4707288943Sdim if (!ToInc && S->getInc()) 4708288943Sdim return nullptr; 4709288943Sdim DeclStmt *ToLoopVar = 4710288943Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt())); 4711288943Sdim if (!ToLoopVar && S->getLoopVarStmt()) 4712288943Sdim return nullptr; 4713288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4714288943Sdim if (!ToBody && S->getBody()) 4715288943Sdim return nullptr; 4716288943Sdim SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4717296417Sdim SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc()); 4718288943Sdim SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4719288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4720309124Sdim return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd, 4721288943Sdim ToCond, ToInc, 4722288943Sdim ToLoopVar, ToBody, 4723296417Sdim ToForLoc, ToCoawaitLoc, 4724296417Sdim ToColonLoc, ToRParenLoc); 4725288943Sdim} 4726288943Sdim 4727288943SdimStmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 4728288943Sdim Stmt *ToElem = Importer.Import(S->getElement()); 4729288943Sdim if (!ToElem && S->getElement()) 4730288943Sdim return nullptr; 4731288943Sdim Expr *ToCollect = Importer.Import(S->getCollection()); 4732288943Sdim if (!ToCollect && S->getCollection()) 4733288943Sdim return nullptr; 4734288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4735288943Sdim if (!ToBody && S->getBody()) 4736288943Sdim return nullptr; 4737288943Sdim SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4738288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4739288943Sdim return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem, 4740288943Sdim ToCollect, 4741288943Sdim ToBody, ToForLoc, 4742288943Sdim ToRParenLoc); 4743288943Sdim} 4744288943Sdim 4745288943SdimStmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 4746288943Sdim SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc()); 4747288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4748288943Sdim VarDecl *ToExceptionDecl = nullptr; 4749288943Sdim if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) { 4750288943Sdim ToExceptionDecl = 4751288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 4752288943Sdim if (!ToExceptionDecl) 4753288943Sdim return nullptr; 4754288943Sdim } 4755288943Sdim Stmt *ToBody = Importer.Import(S->getCatchBody()); 4756288943Sdim if (!ToBody && S->getCatchBody()) 4757288943Sdim return nullptr; 4758288943Sdim return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc, 4759288943Sdim ToRParenLoc, 4760288943Sdim ToExceptionDecl, 4761288943Sdim ToBody); 4762288943Sdim} 4763288943Sdim 4764288943SdimStmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 4765288943Sdim SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc()); 4766288943Sdim Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody()); 4767288943Sdim if (!ToAtFinallyStmt && S->getFinallyBody()) 4768288943Sdim return nullptr; 4769288943Sdim return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc, 4770288943Sdim ToAtFinallyStmt); 4771288943Sdim} 4772288943Sdim 4773288943SdimStmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 4774288943Sdim SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc()); 4775288943Sdim Stmt *ToAtTryStmt = Importer.Import(S->getTryBody()); 4776288943Sdim if (!ToAtTryStmt && S->getTryBody()) 4777288943Sdim return nullptr; 4778288943Sdim SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts()); 4779288943Sdim for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) { 4780288943Sdim ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI); 4781288943Sdim if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt)) 4782288943Sdim ToCatchStmts[CI] = ToCatchStmt; 4783288943Sdim else 4784288943Sdim return nullptr; 4785288943Sdim } 4786288943Sdim Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt()); 4787288943Sdim if (!ToAtFinallyStmt && S->getFinallyStmt()) 4788288943Sdim return nullptr; 4789288943Sdim return ObjCAtTryStmt::Create(Importer.getToContext(), 4790288943Sdim ToAtTryLoc, ToAtTryStmt, 4791288943Sdim ToCatchStmts.begin(), ToCatchStmts.size(), 4792288943Sdim ToAtFinallyStmt); 4793288943Sdim} 4794288943Sdim 4795288943SdimStmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt 4796288943Sdim (ObjCAtSynchronizedStmt *S) { 4797288943Sdim SourceLocation ToAtSynchronizedLoc = 4798288943Sdim Importer.Import(S->getAtSynchronizedLoc()); 4799288943Sdim Expr *ToSynchExpr = Importer.Import(S->getSynchExpr()); 4800288943Sdim if (!ToSynchExpr && S->getSynchExpr()) 4801288943Sdim return nullptr; 4802288943Sdim Stmt *ToSynchBody = Importer.Import(S->getSynchBody()); 4803288943Sdim if (!ToSynchBody && S->getSynchBody()) 4804288943Sdim return nullptr; 4805288943Sdim return new (Importer.getToContext()) ObjCAtSynchronizedStmt( 4806288943Sdim ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody); 4807288943Sdim} 4808288943Sdim 4809288943SdimStmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 4810288943Sdim SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc()); 4811288943Sdim Expr *ToThrow = Importer.Import(S->getThrowExpr()); 4812288943Sdim if (!ToThrow && S->getThrowExpr()) 4813288943Sdim return nullptr; 4814288943Sdim return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow); 4815288943Sdim} 4816288943Sdim 4817288943SdimStmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt 4818288943Sdim (ObjCAutoreleasePoolStmt *S) { 4819288943Sdim SourceLocation ToAtLoc = Importer.Import(S->getAtLoc()); 4820288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4821288943Sdim if (!ToSubStmt && S->getSubStmt()) 4822288943Sdim return nullptr; 4823288943Sdim return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc, 4824288943Sdim ToSubStmt); 4825288943Sdim} 4826288943Sdim 4827203955Srdivacky//---------------------------------------------------------------------------- 4828203955Srdivacky// Import Expressions 4829203955Srdivacky//---------------------------------------------------------------------------- 4830203955SrdivackyExpr *ASTNodeImporter::VisitExpr(Expr *E) { 4831203955Srdivacky Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node) 4832203955Srdivacky << E->getStmtClassName(); 4833276479Sdim return nullptr; 4834203955Srdivacky} 4835203955Srdivacky 4836309124SdimExpr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) { 4837309124Sdim QualType T = Importer.Import(E->getType()); 4838309124Sdim if (T.isNull()) 4839309124Sdim return nullptr; 4840309124Sdim 4841309124Sdim Expr *SubExpr = Importer.Import(E->getSubExpr()); 4842309124Sdim if (!SubExpr && E->getSubExpr()) 4843309124Sdim return nullptr; 4844309124Sdim 4845309124Sdim TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo()); 4846309124Sdim if (!TInfo) 4847309124Sdim return nullptr; 4848309124Sdim 4849309124Sdim return new (Importer.getToContext()) VAArgExpr( 4850309124Sdim Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo, 4851309124Sdim Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI()); 4852309124Sdim} 4853309124Sdim 4854309124Sdim 4855309124SdimExpr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) { 4856309124Sdim QualType T = Importer.Import(E->getType()); 4857309124Sdim if (T.isNull()) 4858309124Sdim return nullptr; 4859309124Sdim 4860309124Sdim return new (Importer.getToContext()) GNUNullExpr( 4861314564Sdim T, Importer.Import(E->getLocStart())); 4862309124Sdim} 4863309124Sdim 4864309124SdimExpr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) { 4865309124Sdim QualType T = Importer.Import(E->getType()); 4866309124Sdim if (T.isNull()) 4867309124Sdim return nullptr; 4868309124Sdim 4869309124Sdim StringLiteral *SL = cast_or_null<StringLiteral>( 4870309124Sdim Importer.Import(E->getFunctionName())); 4871309124Sdim if (!SL && E->getFunctionName()) 4872309124Sdim return nullptr; 4873309124Sdim 4874309124Sdim return new (Importer.getToContext()) PredefinedExpr( 4875314564Sdim Importer.Import(E->getLocStart()), T, E->getIdentType(), SL); 4876309124Sdim} 4877309124Sdim 4878204643SrdivackyExpr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) { 4879204643Srdivacky ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl())); 4880204643Srdivacky if (!ToD) 4881276479Sdim return nullptr; 4882221345Sdim 4883276479Sdim NamedDecl *FoundD = nullptr; 4884221345Sdim if (E->getDecl() != E->getFoundDecl()) { 4885221345Sdim FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl())); 4886221345Sdim if (!FoundD) 4887276479Sdim return nullptr; 4888221345Sdim } 4889204643Srdivacky 4890204643Srdivacky QualType T = Importer.Import(E->getType()); 4891204643Srdivacky if (T.isNull()) 4892276479Sdim return nullptr; 4893226633Sdim 4894314564Sdim 4895314564Sdim TemplateArgumentListInfo ToTAInfo; 4896314564Sdim TemplateArgumentListInfo *ResInfo = nullptr; 4897314564Sdim if (E->hasExplicitTemplateArgs()) { 4898314564Sdim for (const auto &FromLoc : E->template_arguments()) { 4899327952Sdim if (auto ToTALoc = ImportTemplateArgumentLoc(FromLoc)) 4900327952Sdim ToTAInfo.addArgument(*ToTALoc); 4901327952Sdim else 4902314564Sdim return nullptr; 4903314564Sdim } 4904314564Sdim ResInfo = &ToTAInfo; 4905314564Sdim } 4906314564Sdim 4907226633Sdim DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(), 4908226633Sdim Importer.Import(E->getQualifierLoc()), 4909234353Sdim Importer.Import(E->getTemplateKeywordLoc()), 4910226633Sdim ToD, 4911280031Sdim E->refersToEnclosingVariableOrCapture(), 4912226633Sdim Importer.Import(E->getLocation()), 4913226633Sdim T, E->getValueKind(), 4914314564Sdim FoundD, ResInfo); 4915226633Sdim if (E->hadMultipleCandidates()) 4916226633Sdim DRE->setHadMultipleCandidates(true); 4917226633Sdim return DRE; 4918204643Srdivacky} 4919204643Srdivacky 4920309124SdimExpr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 4921309124Sdim QualType T = Importer.Import(E->getType()); 4922309124Sdim if (T.isNull()) 4923314564Sdim return nullptr; 4924309124Sdim 4925309124Sdim return new (Importer.getToContext()) ImplicitValueInitExpr(T); 4926309124Sdim} 4927309124Sdim 4928309124SdimASTNodeImporter::Designator 4929309124SdimASTNodeImporter::ImportDesignator(const Designator &D) { 4930309124Sdim if (D.isFieldDesignator()) { 4931309124Sdim IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName()); 4932309124Sdim // Caller checks for import error 4933309124Sdim return Designator(ToFieldName, Importer.Import(D.getDotLoc()), 4934309124Sdim Importer.Import(D.getFieldLoc())); 4935309124Sdim } 4936309124Sdim if (D.isArrayDesignator()) 4937309124Sdim return Designator(D.getFirstExprIndex(), 4938309124Sdim Importer.Import(D.getLBracketLoc()), 4939309124Sdim Importer.Import(D.getRBracketLoc())); 4940309124Sdim 4941309124Sdim assert(D.isArrayRangeDesignator()); 4942309124Sdim return Designator(D.getFirstExprIndex(), 4943309124Sdim Importer.Import(D.getLBracketLoc()), 4944309124Sdim Importer.Import(D.getEllipsisLoc()), 4945309124Sdim Importer.Import(D.getRBracketLoc())); 4946309124Sdim} 4947309124Sdim 4948309124Sdim 4949309124SdimExpr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) { 4950309124Sdim Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit())); 4951309124Sdim if (!Init) 4952309124Sdim return nullptr; 4953309124Sdim 4954309124Sdim SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1); 4955309124Sdim // List elements from the second, the first is Init itself 4956309124Sdim for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) { 4957309124Sdim if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I)))) 4958309124Sdim IndexExprs[I - 1] = Arg; 4959309124Sdim else 4960309124Sdim return nullptr; 4961309124Sdim } 4962309124Sdim 4963309124Sdim SmallVector<Designator, 4> Designators(DIE->size()); 4964309124Sdim llvm::transform(DIE->designators(), Designators.begin(), 4965309124Sdim [this](const Designator &D) -> Designator { 4966309124Sdim return ImportDesignator(D); 4967309124Sdim }); 4968309124Sdim 4969309124Sdim for (const Designator &D : DIE->designators()) 4970309124Sdim if (D.isFieldDesignator() && !D.getFieldName()) 4971309124Sdim return nullptr; 4972309124Sdim 4973309124Sdim return DesignatedInitExpr::Create( 4974309124Sdim Importer.getToContext(), Designators, 4975309124Sdim IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()), 4976309124Sdim DIE->usesGNUSyntax(), Init); 4977309124Sdim} 4978309124Sdim 4979309124SdimExpr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 4980309124Sdim QualType T = Importer.Import(E->getType()); 4981309124Sdim if (T.isNull()) 4982309124Sdim return nullptr; 4983309124Sdim 4984309124Sdim return new (Importer.getToContext()) 4985309124Sdim CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation())); 4986309124Sdim} 4987309124Sdim 4988203955SrdivackyExpr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) { 4989203955Srdivacky QualType T = Importer.Import(E->getType()); 4990203955Srdivacky if (T.isNull()) 4991276479Sdim return nullptr; 4992203955Srdivacky 4993212904Sdim return IntegerLiteral::Create(Importer.getToContext(), 4994212904Sdim E->getValue(), T, 4995212904Sdim Importer.Import(E->getLocation())); 4996203955Srdivacky} 4997203955Srdivacky 4998309124SdimExpr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) { 4999309124Sdim QualType T = Importer.Import(E->getType()); 5000309124Sdim if (T.isNull()) 5001309124Sdim return nullptr; 5002309124Sdim 5003309124Sdim return FloatingLiteral::Create(Importer.getToContext(), 5004309124Sdim E->getValue(), E->isExact(), T, 5005309124Sdim Importer.Import(E->getLocation())); 5006309124Sdim} 5007309124Sdim 5008204643SrdivackyExpr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) { 5009204643Srdivacky QualType T = Importer.Import(E->getType()); 5010204643Srdivacky if (T.isNull()) 5011276479Sdim return nullptr; 5012276479Sdim 5013226633Sdim return new (Importer.getToContext()) CharacterLiteral(E->getValue(), 5014226633Sdim E->getKind(), T, 5015204643Srdivacky Importer.Import(E->getLocation())); 5016204643Srdivacky} 5017204643Srdivacky 5018309124SdimExpr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) { 5019309124Sdim QualType T = Importer.Import(E->getType()); 5020309124Sdim if (T.isNull()) 5021309124Sdim return nullptr; 5022309124Sdim 5023309124Sdim SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated()); 5024309124Sdim ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin()); 5025309124Sdim 5026309124Sdim return StringLiteral::Create(Importer.getToContext(), E->getBytes(), 5027309124Sdim E->getKind(), E->isPascal(), T, 5028309124Sdim Locations.data(), Locations.size()); 5029309124Sdim} 5030309124Sdim 5031309124SdimExpr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 5032309124Sdim QualType T = Importer.Import(E->getType()); 5033309124Sdim if (T.isNull()) 5034309124Sdim return nullptr; 5035309124Sdim 5036309124Sdim TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo()); 5037309124Sdim if (!TInfo) 5038309124Sdim return nullptr; 5039309124Sdim 5040309124Sdim Expr *Init = Importer.Import(E->getInitializer()); 5041309124Sdim if (!Init) 5042309124Sdim return nullptr; 5043309124Sdim 5044309124Sdim return new (Importer.getToContext()) CompoundLiteralExpr( 5045309124Sdim Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(), 5046309124Sdim Init, E->isFileScope()); 5047309124Sdim} 5048309124Sdim 5049309124SdimExpr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) { 5050309124Sdim QualType T = Importer.Import(E->getType()); 5051309124Sdim if (T.isNull()) 5052309124Sdim return nullptr; 5053309124Sdim 5054309124Sdim SmallVector<Expr *, 6> Exprs(E->getNumSubExprs()); 5055309124Sdim if (ImportArrayChecked( 5056309124Sdim E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(), 5057309124Sdim Exprs.begin())) 5058309124Sdim return nullptr; 5059309124Sdim 5060309124Sdim return new (Importer.getToContext()) AtomicExpr( 5061309124Sdim Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(), 5062309124Sdim Importer.Import(E->getRParenLoc())); 5063309124Sdim} 5064309124Sdim 5065309124SdimExpr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) { 5066309124Sdim QualType T = Importer.Import(E->getType()); 5067309124Sdim if (T.isNull()) 5068309124Sdim return nullptr; 5069309124Sdim 5070309124Sdim LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel())); 5071309124Sdim if (!ToLabel) 5072309124Sdim return nullptr; 5073309124Sdim 5074309124Sdim return new (Importer.getToContext()) AddrLabelExpr( 5075309124Sdim Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()), 5076309124Sdim ToLabel, T); 5077309124Sdim} 5078309124Sdim 5079204643SrdivackyExpr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) { 5080204643Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 5081204643Srdivacky if (!SubExpr) 5082276479Sdim return nullptr; 5083276479Sdim 5084204643Srdivacky return new (Importer.getToContext()) 5085204643Srdivacky ParenExpr(Importer.Import(E->getLParen()), 5086204643Srdivacky Importer.Import(E->getRParen()), 5087204643Srdivacky SubExpr); 5088204643Srdivacky} 5089204643Srdivacky 5090309124SdimExpr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) { 5091309124Sdim SmallVector<Expr *, 4> Exprs(E->getNumExprs()); 5092314564Sdim if (ImportContainerChecked(E->exprs(), Exprs)) 5093309124Sdim return nullptr; 5094309124Sdim 5095309124Sdim return new (Importer.getToContext()) ParenListExpr( 5096309124Sdim Importer.getToContext(), Importer.Import(E->getLParenLoc()), 5097309124Sdim Exprs, Importer.Import(E->getLParenLoc())); 5098309124Sdim} 5099309124Sdim 5100309124SdimExpr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) { 5101309124Sdim QualType T = Importer.Import(E->getType()); 5102309124Sdim if (T.isNull()) 5103309124Sdim return nullptr; 5104309124Sdim 5105309124Sdim CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>( 5106309124Sdim Importer.Import(E->getSubStmt())); 5107309124Sdim if (!ToSubStmt && E->getSubStmt()) 5108309124Sdim return nullptr; 5109309124Sdim 5110309124Sdim return new (Importer.getToContext()) StmtExpr(ToSubStmt, T, 5111309124Sdim Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc())); 5112309124Sdim} 5113309124Sdim 5114204643SrdivackyExpr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) { 5115204643Srdivacky QualType T = Importer.Import(E->getType()); 5116204643Srdivacky if (T.isNull()) 5117276479Sdim return nullptr; 5118204643Srdivacky 5119204643Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 5120204643Srdivacky if (!SubExpr) 5121276479Sdim return nullptr; 5122276479Sdim 5123204643Srdivacky return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(), 5124218893Sdim T, E->getValueKind(), 5125218893Sdim E->getObjectKind(), 5126204643Srdivacky Importer.Import(E->getOperatorLoc())); 5127204643Srdivacky} 5128204643Srdivacky 5129221345SdimExpr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr( 5130221345Sdim UnaryExprOrTypeTraitExpr *E) { 5131204643Srdivacky QualType ResultType = Importer.Import(E->getType()); 5132204643Srdivacky 5133204643Srdivacky if (E->isArgumentType()) { 5134204643Srdivacky TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo()); 5135204643Srdivacky if (!TInfo) 5136276479Sdim return nullptr; 5137276479Sdim 5138221345Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 5139221345Sdim TInfo, ResultType, 5140204643Srdivacky Importer.Import(E->getOperatorLoc()), 5141204643Srdivacky Importer.Import(E->getRParenLoc())); 5142204643Srdivacky } 5143204643Srdivacky 5144204643Srdivacky Expr *SubExpr = Importer.Import(E->getArgumentExpr()); 5145204643Srdivacky if (!SubExpr) 5146276479Sdim return nullptr; 5147276479Sdim 5148221345Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 5149221345Sdim SubExpr, ResultType, 5150204643Srdivacky Importer.Import(E->getOperatorLoc()), 5151204643Srdivacky Importer.Import(E->getRParenLoc())); 5152204643Srdivacky} 5153204643Srdivacky 5154204643SrdivackyExpr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) { 5155204643Srdivacky QualType T = Importer.Import(E->getType()); 5156204643Srdivacky if (T.isNull()) 5157276479Sdim return nullptr; 5158204643Srdivacky 5159204643Srdivacky Expr *LHS = Importer.Import(E->getLHS()); 5160204643Srdivacky if (!LHS) 5161276479Sdim return nullptr; 5162276479Sdim 5163204643Srdivacky Expr *RHS = Importer.Import(E->getRHS()); 5164204643Srdivacky if (!RHS) 5165276479Sdim return nullptr; 5166276479Sdim 5167204643Srdivacky return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(), 5168218893Sdim T, E->getValueKind(), 5169218893Sdim E->getObjectKind(), 5170243830Sdim Importer.Import(E->getOperatorLoc()), 5171321369Sdim E->getFPFeatures()); 5172204643Srdivacky} 5173204643Srdivacky 5174309124SdimExpr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) { 5175309124Sdim QualType T = Importer.Import(E->getType()); 5176309124Sdim if (T.isNull()) 5177309124Sdim return nullptr; 5178309124Sdim 5179309124Sdim Expr *ToLHS = Importer.Import(E->getLHS()); 5180309124Sdim if (!ToLHS) 5181309124Sdim return nullptr; 5182309124Sdim 5183309124Sdim Expr *ToRHS = Importer.Import(E->getRHS()); 5184309124Sdim if (!ToRHS) 5185309124Sdim return nullptr; 5186309124Sdim 5187309124Sdim Expr *ToCond = Importer.Import(E->getCond()); 5188309124Sdim if (!ToCond) 5189309124Sdim return nullptr; 5190309124Sdim 5191309124Sdim return new (Importer.getToContext()) ConditionalOperator( 5192309124Sdim ToCond, Importer.Import(E->getQuestionLoc()), 5193309124Sdim ToLHS, Importer.Import(E->getColonLoc()), 5194309124Sdim ToRHS, T, E->getValueKind(), E->getObjectKind()); 5195309124Sdim} 5196309124Sdim 5197309124SdimExpr *ASTNodeImporter::VisitBinaryConditionalOperator( 5198309124Sdim BinaryConditionalOperator *E) { 5199309124Sdim QualType T = Importer.Import(E->getType()); 5200309124Sdim if (T.isNull()) 5201309124Sdim return nullptr; 5202309124Sdim 5203309124Sdim Expr *Common = Importer.Import(E->getCommon()); 5204309124Sdim if (!Common) 5205309124Sdim return nullptr; 5206309124Sdim 5207309124Sdim Expr *Cond = Importer.Import(E->getCond()); 5208309124Sdim if (!Cond) 5209309124Sdim return nullptr; 5210309124Sdim 5211309124Sdim OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>( 5212309124Sdim Importer.Import(E->getOpaqueValue())); 5213309124Sdim if (!OpaqueValue) 5214309124Sdim return nullptr; 5215309124Sdim 5216309124Sdim Expr *TrueExpr = Importer.Import(E->getTrueExpr()); 5217309124Sdim if (!TrueExpr) 5218309124Sdim return nullptr; 5219309124Sdim 5220309124Sdim Expr *FalseExpr = Importer.Import(E->getFalseExpr()); 5221309124Sdim if (!FalseExpr) 5222309124Sdim return nullptr; 5223309124Sdim 5224309124Sdim return new (Importer.getToContext()) BinaryConditionalOperator( 5225309124Sdim Common, OpaqueValue, Cond, TrueExpr, FalseExpr, 5226309124Sdim Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()), 5227309124Sdim T, E->getValueKind(), E->getObjectKind()); 5228309124Sdim} 5229309124Sdim 5230314564SdimExpr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 5231314564Sdim QualType T = Importer.Import(E->getType()); 5232314564Sdim if (T.isNull()) 5233314564Sdim return nullptr; 5234314564Sdim 5235314564Sdim TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo()); 5236314564Sdim if (!ToQueried) 5237314564Sdim return nullptr; 5238314564Sdim 5239314564Sdim Expr *Dim = Importer.Import(E->getDimensionExpression()); 5240314564Sdim if (!Dim && E->getDimensionExpression()) 5241314564Sdim return nullptr; 5242314564Sdim 5243314564Sdim return new (Importer.getToContext()) ArrayTypeTraitExpr( 5244314564Sdim Importer.Import(E->getLocStart()), E->getTrait(), ToQueried, 5245314564Sdim E->getValue(), Dim, Importer.Import(E->getLocEnd()), T); 5246314564Sdim} 5247314564Sdim 5248314564SdimExpr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 5249314564Sdim QualType T = Importer.Import(E->getType()); 5250314564Sdim if (T.isNull()) 5251314564Sdim return nullptr; 5252314564Sdim 5253314564Sdim Expr *ToQueried = Importer.Import(E->getQueriedExpression()); 5254314564Sdim if (!ToQueried) 5255314564Sdim return nullptr; 5256314564Sdim 5257314564Sdim return new (Importer.getToContext()) ExpressionTraitExpr( 5258314564Sdim Importer.Import(E->getLocStart()), E->getTrait(), ToQueried, 5259314564Sdim E->getValue(), Importer.Import(E->getLocEnd()), T); 5260314564Sdim} 5261314564Sdim 5262309124SdimExpr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 5263309124Sdim QualType T = Importer.Import(E->getType()); 5264309124Sdim if (T.isNull()) 5265309124Sdim return nullptr; 5266309124Sdim 5267309124Sdim Expr *SourceExpr = Importer.Import(E->getSourceExpr()); 5268309124Sdim if (!SourceExpr && E->getSourceExpr()) 5269309124Sdim return nullptr; 5270309124Sdim 5271309124Sdim return new (Importer.getToContext()) OpaqueValueExpr( 5272314564Sdim Importer.Import(E->getLocation()), T, E->getValueKind(), 5273309124Sdim E->getObjectKind(), SourceExpr); 5274309124Sdim} 5275309124Sdim 5276314564SdimExpr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 5277314564Sdim QualType T = Importer.Import(E->getType()); 5278314564Sdim if (T.isNull()) 5279314564Sdim return nullptr; 5280314564Sdim 5281314564Sdim Expr *ToLHS = Importer.Import(E->getLHS()); 5282314564Sdim if (!ToLHS) 5283314564Sdim return nullptr; 5284314564Sdim 5285314564Sdim Expr *ToRHS = Importer.Import(E->getRHS()); 5286314564Sdim if (!ToRHS) 5287314564Sdim return nullptr; 5288314564Sdim 5289314564Sdim return new (Importer.getToContext()) ArraySubscriptExpr( 5290314564Sdim ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(), 5291314564Sdim Importer.Import(E->getRBracketLoc())); 5292314564Sdim} 5293314564Sdim 5294204643SrdivackyExpr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 5295204643Srdivacky QualType T = Importer.Import(E->getType()); 5296204643Srdivacky if (T.isNull()) 5297276479Sdim return nullptr; 5298276479Sdim 5299204643Srdivacky QualType CompLHSType = Importer.Import(E->getComputationLHSType()); 5300204643Srdivacky if (CompLHSType.isNull()) 5301276479Sdim return nullptr; 5302276479Sdim 5303204643Srdivacky QualType CompResultType = Importer.Import(E->getComputationResultType()); 5304204643Srdivacky if (CompResultType.isNull()) 5305276479Sdim return nullptr; 5306276479Sdim 5307204643Srdivacky Expr *LHS = Importer.Import(E->getLHS()); 5308204643Srdivacky if (!LHS) 5309276479Sdim return nullptr; 5310276479Sdim 5311204643Srdivacky Expr *RHS = Importer.Import(E->getRHS()); 5312204643Srdivacky if (!RHS) 5313276479Sdim return nullptr; 5314276479Sdim 5315204643Srdivacky return new (Importer.getToContext()) 5316204643Srdivacky CompoundAssignOperator(LHS, RHS, E->getOpcode(), 5317218893Sdim T, E->getValueKind(), 5318218893Sdim E->getObjectKind(), 5319218893Sdim CompLHSType, CompResultType, 5320243830Sdim Importer.Import(E->getOperatorLoc()), 5321321369Sdim E->getFPFeatures()); 5322204643Srdivacky} 5323204643Srdivacky 5324314564Sdimbool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) { 5325314564Sdim for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) { 5326314564Sdim if (CXXBaseSpecifier *Spec = Importer.Import(*I)) 5327314564Sdim Path.push_back(Spec); 5328314564Sdim else 5329314564Sdim return true; 5330314564Sdim } 5331314564Sdim return false; 5332212904Sdim} 5333212904Sdim 5334203955SrdivackyExpr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) { 5335203955Srdivacky QualType T = Importer.Import(E->getType()); 5336203955Srdivacky if (T.isNull()) 5337276479Sdim return nullptr; 5338203955Srdivacky 5339203955Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 5340203955Srdivacky if (!SubExpr) 5341276479Sdim return nullptr; 5342212904Sdim 5343212904Sdim CXXCastPath BasePath; 5344212904Sdim if (ImportCastPath(E, BasePath)) 5345276479Sdim return nullptr; 5346212904Sdim 5347212904Sdim return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(), 5348212904Sdim SubExpr, &BasePath, E->getValueKind()); 5349203955Srdivacky} 5350203955Srdivacky 5351314564SdimExpr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) { 5352204643Srdivacky QualType T = Importer.Import(E->getType()); 5353204643Srdivacky if (T.isNull()) 5354276479Sdim return nullptr; 5355276479Sdim 5356204643Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 5357204643Srdivacky if (!SubExpr) 5358276479Sdim return nullptr; 5359204643Srdivacky 5360204643Srdivacky TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten()); 5361204643Srdivacky if (!TInfo && E->getTypeInfoAsWritten()) 5362276479Sdim return nullptr; 5363276479Sdim 5364212904Sdim CXXCastPath BasePath; 5365212904Sdim if (ImportCastPath(E, BasePath)) 5366276479Sdim return nullptr; 5367212904Sdim 5368314564Sdim switch (E->getStmtClass()) { 5369314564Sdim case Stmt::CStyleCastExprClass: { 5370314564Sdim CStyleCastExpr *CCE = cast<CStyleCastExpr>(E); 5371314564Sdim return CStyleCastExpr::Create(Importer.getToContext(), T, 5372314564Sdim E->getValueKind(), E->getCastKind(), 5373314564Sdim SubExpr, &BasePath, TInfo, 5374314564Sdim Importer.Import(CCE->getLParenLoc()), 5375314564Sdim Importer.Import(CCE->getRParenLoc())); 5376314564Sdim } 5377314564Sdim 5378314564Sdim case Stmt::CXXFunctionalCastExprClass: { 5379314564Sdim CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E); 5380314564Sdim return CXXFunctionalCastExpr::Create(Importer.getToContext(), T, 5381314564Sdim E->getValueKind(), TInfo, 5382314564Sdim E->getCastKind(), SubExpr, &BasePath, 5383314564Sdim Importer.Import(FCE->getLParenLoc()), 5384314564Sdim Importer.Import(FCE->getRParenLoc())); 5385314564Sdim } 5386314564Sdim 5387314564Sdim case Stmt::ObjCBridgedCastExprClass: { 5388314564Sdim ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E); 5389314564Sdim return new (Importer.getToContext()) ObjCBridgedCastExpr( 5390314564Sdim Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(), 5391314564Sdim E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()), 5392314564Sdim TInfo, SubExpr); 5393314564Sdim } 5394314564Sdim default: 5395314564Sdim break; // just fall through 5396314564Sdim } 5397314564Sdim 5398314564Sdim CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E); 5399314564Sdim SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()), 5400314564Sdim RParenLoc = Importer.Import(Named->getRParenLoc()); 5401314564Sdim SourceRange Brackets = Importer.Import(Named->getAngleBrackets()); 5402314564Sdim 5403314564Sdim switch (E->getStmtClass()) { 5404314564Sdim case Stmt::CXXStaticCastExprClass: 5405314564Sdim return CXXStaticCastExpr::Create(Importer.getToContext(), T, 5406314564Sdim E->getValueKind(), E->getCastKind(), 5407314564Sdim SubExpr, &BasePath, TInfo, 5408314564Sdim ExprLoc, RParenLoc, Brackets); 5409314564Sdim 5410314564Sdim case Stmt::CXXDynamicCastExprClass: 5411314564Sdim return CXXDynamicCastExpr::Create(Importer.getToContext(), T, 5412314564Sdim E->getValueKind(), E->getCastKind(), 5413314564Sdim SubExpr, &BasePath, TInfo, 5414314564Sdim ExprLoc, RParenLoc, Brackets); 5415314564Sdim 5416314564Sdim case Stmt::CXXReinterpretCastExprClass: 5417314564Sdim return CXXReinterpretCastExpr::Create(Importer.getToContext(), T, 5418314564Sdim E->getValueKind(), E->getCastKind(), 5419314564Sdim SubExpr, &BasePath, TInfo, 5420314564Sdim ExprLoc, RParenLoc, Brackets); 5421314564Sdim 5422314564Sdim case Stmt::CXXConstCastExprClass: 5423314564Sdim return CXXConstCastExpr::Create(Importer.getToContext(), T, 5424314564Sdim E->getValueKind(), SubExpr, TInfo, ExprLoc, 5425314564Sdim RParenLoc, Brackets); 5426314564Sdim default: 5427314564Sdim llvm_unreachable("Cast expression of unsupported type!"); 5428314564Sdim return nullptr; 5429314564Sdim } 5430204643Srdivacky} 5431204643Srdivacky 5432314564SdimExpr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) { 5433314564Sdim QualType T = Importer.Import(OE->getType()); 5434314564Sdim if (T.isNull()) 5435314564Sdim return nullptr; 5436314564Sdim 5437314564Sdim SmallVector<OffsetOfNode, 4> Nodes; 5438314564Sdim for (int I = 0, E = OE->getNumComponents(); I < E; ++I) { 5439314564Sdim const OffsetOfNode &Node = OE->getComponent(I); 5440314564Sdim 5441314564Sdim switch (Node.getKind()) { 5442314564Sdim case OffsetOfNode::Array: 5443314564Sdim Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), 5444314564Sdim Node.getArrayExprIndex(), 5445314564Sdim Importer.Import(Node.getLocEnd()))); 5446314564Sdim break; 5447314564Sdim 5448314564Sdim case OffsetOfNode::Base: { 5449314564Sdim CXXBaseSpecifier *BS = Importer.Import(Node.getBase()); 5450314564Sdim if (!BS && Node.getBase()) 5451314564Sdim return nullptr; 5452314564Sdim Nodes.push_back(OffsetOfNode(BS)); 5453314564Sdim break; 5454314564Sdim } 5455314564Sdim case OffsetOfNode::Field: { 5456314564Sdim FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField())); 5457314564Sdim if (!FD) 5458314564Sdim return nullptr; 5459314564Sdim Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD, 5460314564Sdim Importer.Import(Node.getLocEnd()))); 5461314564Sdim break; 5462314564Sdim } 5463314564Sdim case OffsetOfNode::Identifier: { 5464314564Sdim IdentifierInfo *ToII = Importer.Import(Node.getFieldName()); 5465314564Sdim if (!ToII) 5466314564Sdim return nullptr; 5467314564Sdim Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII, 5468314564Sdim Importer.Import(Node.getLocEnd()))); 5469314564Sdim break; 5470314564Sdim } 5471314564Sdim } 5472314564Sdim } 5473314564Sdim 5474314564Sdim SmallVector<Expr *, 4> Exprs(OE->getNumExpressions()); 5475314564Sdim for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) { 5476314564Sdim Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I)); 5477314564Sdim if (!ToIndexExpr) 5478314564Sdim return nullptr; 5479314564Sdim Exprs[I] = ToIndexExpr; 5480314564Sdim } 5481314564Sdim 5482314564Sdim TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo()); 5483314564Sdim if (!TInfo && OE->getTypeSourceInfo()) 5484314564Sdim return nullptr; 5485314564Sdim 5486314564Sdim return OffsetOfExpr::Create(Importer.getToContext(), T, 5487314564Sdim Importer.Import(OE->getOperatorLoc()), 5488314564Sdim TInfo, Nodes, Exprs, 5489314564Sdim Importer.Import(OE->getRParenLoc())); 5490314564Sdim} 5491314564Sdim 5492314564SdimExpr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 5493314564Sdim QualType T = Importer.Import(E->getType()); 5494314564Sdim if (T.isNull()) 5495314564Sdim return nullptr; 5496314564Sdim 5497314564Sdim Expr *Operand = Importer.Import(E->getOperand()); 5498314564Sdim if (!Operand) 5499314564Sdim return nullptr; 5500314564Sdim 5501314564Sdim CanThrowResult CanThrow; 5502314564Sdim if (E->isValueDependent()) 5503314564Sdim CanThrow = CT_Dependent; 5504314564Sdim else 5505314564Sdim CanThrow = E->getValue() ? CT_Can : CT_Cannot; 5506314564Sdim 5507314564Sdim return new (Importer.getToContext()) CXXNoexceptExpr( 5508314564Sdim T, Operand, CanThrow, 5509314564Sdim Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd())); 5510314564Sdim} 5511314564Sdim 5512314564SdimExpr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) { 5513314564Sdim QualType T = Importer.Import(E->getType()); 5514314564Sdim if (T.isNull()) 5515314564Sdim return nullptr; 5516314564Sdim 5517314564Sdim Expr *SubExpr = Importer.Import(E->getSubExpr()); 5518314564Sdim if (!SubExpr && E->getSubExpr()) 5519314564Sdim return nullptr; 5520314564Sdim 5521314564Sdim return new (Importer.getToContext()) CXXThrowExpr( 5522314564Sdim SubExpr, T, Importer.Import(E->getThrowLoc()), 5523314564Sdim E->isThrownVariableInScope()); 5524314564Sdim} 5525314564Sdim 5526314564SdimExpr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 5527314564Sdim ParmVarDecl *Param = cast_or_null<ParmVarDecl>( 5528314564Sdim Importer.Import(E->getParam())); 5529314564Sdim if (!Param) 5530314564Sdim return nullptr; 5531314564Sdim 5532314564Sdim return CXXDefaultArgExpr::Create( 5533314564Sdim Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param); 5534314564Sdim} 5535314564Sdim 5536314564SdimExpr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 5537314564Sdim QualType T = Importer.Import(E->getType()); 5538314564Sdim if (T.isNull()) 5539314564Sdim return nullptr; 5540314564Sdim 5541314564Sdim TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo()); 5542314564Sdim if (!TypeInfo) 5543314564Sdim return nullptr; 5544314564Sdim 5545314564Sdim return new (Importer.getToContext()) CXXScalarValueInitExpr( 5546314564Sdim T, TypeInfo, Importer.Import(E->getRParenLoc())); 5547314564Sdim} 5548314564Sdim 5549314564SdimExpr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 5550314564Sdim Expr *SubExpr = Importer.Import(E->getSubExpr()); 5551314564Sdim if (!SubExpr) 5552314564Sdim return nullptr; 5553314564Sdim 5554314564Sdim auto *Dtor = cast_or_null<CXXDestructorDecl>( 5555314564Sdim Importer.Import(const_cast<CXXDestructorDecl *>( 5556314564Sdim E->getTemporary()->getDestructor()))); 5557314564Sdim if (!Dtor) 5558314564Sdim return nullptr; 5559314564Sdim 5560314564Sdim ASTContext &ToCtx = Importer.getToContext(); 5561314564Sdim CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor); 5562314564Sdim return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr); 5563314564Sdim} 5564314564Sdim 5565314564SdimExpr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) { 5566314564Sdim QualType T = Importer.Import(CE->getType()); 5567314564Sdim if (T.isNull()) 5568314564Sdim return nullptr; 5569314564Sdim 5570314564Sdim SmallVector<Expr *, 8> Args(CE->getNumArgs()); 5571314564Sdim if (ImportContainerChecked(CE->arguments(), Args)) 5572314564Sdim return nullptr; 5573314564Sdim 5574314564Sdim auto *Ctor = cast_or_null<CXXConstructorDecl>( 5575314564Sdim Importer.Import(CE->getConstructor())); 5576314564Sdim if (!Ctor) 5577314564Sdim return nullptr; 5578314564Sdim 5579314564Sdim return CXXTemporaryObjectExpr::Create( 5580314564Sdim Importer.getToContext(), T, 5581314564Sdim Importer.Import(CE->getLocStart()), 5582314564Sdim Ctor, 5583314564Sdim CE->isElidable(), 5584314564Sdim Args, 5585314564Sdim CE->hadMultipleCandidates(), 5586314564Sdim CE->isListInitialization(), 5587314564Sdim CE->isStdInitListInitialization(), 5588314564Sdim CE->requiresZeroInitialization(), 5589314564Sdim CE->getConstructionKind(), 5590314564Sdim Importer.Import(CE->getParenOrBraceRange())); 5591314564Sdim} 5592314564Sdim 5593314564SdimExpr * 5594314564SdimASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 5595314564Sdim QualType T = Importer.Import(E->getType()); 5596314564Sdim if (T.isNull()) 5597314564Sdim return nullptr; 5598314564Sdim 5599314564Sdim Expr *TempE = Importer.Import(E->GetTemporaryExpr()); 5600314564Sdim if (!TempE) 5601314564Sdim return nullptr; 5602314564Sdim 5603314564Sdim ValueDecl *ExtendedBy = cast_or_null<ValueDecl>( 5604314564Sdim Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl()))); 5605314564Sdim if (!ExtendedBy && E->getExtendingDecl()) 5606314564Sdim return nullptr; 5607314564Sdim 5608314564Sdim auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr( 5609314564Sdim T, TempE, E->isBoundToLvalueReference()); 5610314564Sdim 5611314564Sdim // FIXME: Should ManglingNumber get numbers associated with 'to' context? 5612314564Sdim ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber()); 5613314564Sdim return ToMTE; 5614314564Sdim} 5615314564Sdim 5616327952SdimExpr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) { 5617327952Sdim QualType T = Importer.Import(E->getType()); 5618327952Sdim if (T.isNull()) 5619327952Sdim return nullptr; 5620327952Sdim 5621327952Sdim Expr *Pattern = Importer.Import(E->getPattern()); 5622327952Sdim if (!Pattern) 5623327952Sdim return nullptr; 5624327952Sdim 5625327952Sdim return new (Importer.getToContext()) PackExpansionExpr( 5626327952Sdim T, Pattern, Importer.Import(E->getEllipsisLoc()), 5627327952Sdim E->getNumExpansions()); 5628327952Sdim} 5629327952Sdim 5630314564SdimExpr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) { 5631314564Sdim QualType T = Importer.Import(CE->getType()); 5632314564Sdim if (T.isNull()) 5633314564Sdim return nullptr; 5634314564Sdim 5635314564Sdim SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs()); 5636314564Sdim if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs)) 5637314564Sdim return nullptr; 5638314564Sdim 5639314564Sdim FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>( 5640314564Sdim Importer.Import(CE->getOperatorNew())); 5641314564Sdim if (!OperatorNewDecl && CE->getOperatorNew()) 5642314564Sdim return nullptr; 5643314564Sdim 5644314564Sdim FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>( 5645314564Sdim Importer.Import(CE->getOperatorDelete())); 5646314564Sdim if (!OperatorDeleteDecl && CE->getOperatorDelete()) 5647314564Sdim return nullptr; 5648314564Sdim 5649314564Sdim Expr *ToInit = Importer.Import(CE->getInitializer()); 5650314564Sdim if (!ToInit && CE->getInitializer()) 5651314564Sdim return nullptr; 5652314564Sdim 5653314564Sdim TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo()); 5654314564Sdim if (!TInfo) 5655314564Sdim return nullptr; 5656314564Sdim 5657314564Sdim Expr *ToArrSize = Importer.Import(CE->getArraySize()); 5658314564Sdim if (!ToArrSize && CE->getArraySize()) 5659314564Sdim return nullptr; 5660314564Sdim 5661314564Sdim return new (Importer.getToContext()) CXXNewExpr( 5662314564Sdim Importer.getToContext(), 5663314564Sdim CE->isGlobalNew(), 5664314564Sdim OperatorNewDecl, OperatorDeleteDecl, 5665314564Sdim CE->passAlignment(), 5666314564Sdim CE->doesUsualArrayDeleteWantSize(), 5667314564Sdim PlacementArgs, 5668314564Sdim Importer.Import(CE->getTypeIdParens()), 5669314564Sdim ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo, 5670314564Sdim Importer.Import(CE->getSourceRange()), 5671314564Sdim Importer.Import(CE->getDirectInitRange())); 5672314564Sdim} 5673314564Sdim 5674314564SdimExpr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 5675314564Sdim QualType T = Importer.Import(E->getType()); 5676314564Sdim if (T.isNull()) 5677314564Sdim return nullptr; 5678314564Sdim 5679314564Sdim FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>( 5680314564Sdim Importer.Import(E->getOperatorDelete())); 5681314564Sdim if (!OperatorDeleteDecl && E->getOperatorDelete()) 5682314564Sdim return nullptr; 5683314564Sdim 5684314564Sdim Expr *ToArg = Importer.Import(E->getArgument()); 5685314564Sdim if (!ToArg && E->getArgument()) 5686314564Sdim return nullptr; 5687314564Sdim 5688314564Sdim return new (Importer.getToContext()) CXXDeleteExpr( 5689314564Sdim T, E->isGlobalDelete(), 5690314564Sdim E->isArrayForm(), 5691314564Sdim E->isArrayFormAsWritten(), 5692314564Sdim E->doesUsualArrayDeleteWantSize(), 5693314564Sdim OperatorDeleteDecl, 5694314564Sdim ToArg, 5695314564Sdim Importer.Import(E->getLocStart())); 5696314564Sdim} 5697314564Sdim 5698288943SdimExpr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) { 5699288943Sdim QualType T = Importer.Import(E->getType()); 5700288943Sdim if (T.isNull()) 5701288943Sdim return nullptr; 5702288943Sdim 5703288943Sdim CXXConstructorDecl *ToCCD = 5704309124Sdim dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor())); 5705309124Sdim if (!ToCCD) 5706288943Sdim return nullptr; 5707288943Sdim 5708309124Sdim SmallVector<Expr *, 6> ToArgs(E->getNumArgs()); 5709314564Sdim if (ImportContainerChecked(E->arguments(), ToArgs)) 5710309124Sdim return nullptr; 5711288943Sdim 5712288943Sdim return CXXConstructExpr::Create(Importer.getToContext(), T, 5713288943Sdim Importer.Import(E->getLocation()), 5714288943Sdim ToCCD, E->isElidable(), 5715288943Sdim ToArgs, E->hadMultipleCandidates(), 5716288943Sdim E->isListInitialization(), 5717288943Sdim E->isStdInitListInitialization(), 5718288943Sdim E->requiresZeroInitialization(), 5719288943Sdim E->getConstructionKind(), 5720288943Sdim Importer.Import(E->getParenOrBraceRange())); 5721288943Sdim} 5722288943Sdim 5723314564SdimExpr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) { 5724314564Sdim Expr *SubExpr = Importer.Import(EWC->getSubExpr()); 5725314564Sdim if (!SubExpr && EWC->getSubExpr()) 5726314564Sdim return nullptr; 5727314564Sdim 5728314564Sdim SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects()); 5729314564Sdim for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++) 5730314564Sdim if (ExprWithCleanups::CleanupObject Obj = 5731314564Sdim cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I)))) 5732314564Sdim Objs[I] = Obj; 5733314564Sdim else 5734314564Sdim return nullptr; 5735314564Sdim 5736314564Sdim return ExprWithCleanups::Create(Importer.getToContext(), 5737314564Sdim SubExpr, EWC->cleanupsHaveSideEffects(), 5738314564Sdim Objs); 5739314564Sdim} 5740314564Sdim 5741309124SdimExpr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 5742309124Sdim QualType T = Importer.Import(E->getType()); 5743309124Sdim if (T.isNull()) 5744309124Sdim return nullptr; 5745309124Sdim 5746309124Sdim Expr *ToFn = Importer.Import(E->getCallee()); 5747309124Sdim if (!ToFn) 5748309124Sdim return nullptr; 5749309124Sdim 5750309124Sdim SmallVector<Expr *, 4> ToArgs(E->getNumArgs()); 5751314564Sdim if (ImportContainerChecked(E->arguments(), ToArgs)) 5752309124Sdim return nullptr; 5753309124Sdim 5754309124Sdim return new (Importer.getToContext()) CXXMemberCallExpr( 5755309124Sdim Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(), 5756309124Sdim Importer.Import(E->getRParenLoc())); 5757309124Sdim} 5758309124Sdim 5759309124SdimExpr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) { 5760309124Sdim QualType T = Importer.Import(E->getType()); 5761309124Sdim if (T.isNull()) 5762309124Sdim return nullptr; 5763309124Sdim 5764309124Sdim return new (Importer.getToContext()) 5765309124Sdim CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit()); 5766309124Sdim} 5767309124Sdim 5768309124SdimExpr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 5769309124Sdim QualType T = Importer.Import(E->getType()); 5770309124Sdim if (T.isNull()) 5771309124Sdim return nullptr; 5772309124Sdim 5773309124Sdim return new (Importer.getToContext()) 5774309124Sdim CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation())); 5775309124Sdim} 5776309124Sdim 5777309124Sdim 5778288943SdimExpr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) { 5779288943Sdim QualType T = Importer.Import(E->getType()); 5780288943Sdim if (T.isNull()) 5781288943Sdim return nullptr; 5782288943Sdim 5783288943Sdim Expr *ToBase = Importer.Import(E->getBase()); 5784288943Sdim if (!ToBase && E->getBase()) 5785288943Sdim return nullptr; 5786288943Sdim 5787288943Sdim ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl())); 5788288943Sdim if (!ToMember && E->getMemberDecl()) 5789288943Sdim return nullptr; 5790288943Sdim 5791288943Sdim DeclAccessPair ToFoundDecl = DeclAccessPair::make( 5792288943Sdim dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())), 5793288943Sdim E->getFoundDecl().getAccess()); 5794288943Sdim 5795288943Sdim DeclarationNameInfo ToMemberNameInfo( 5796288943Sdim Importer.Import(E->getMemberNameInfo().getName()), 5797288943Sdim Importer.Import(E->getMemberNameInfo().getLoc())); 5798288943Sdim 5799288943Sdim if (E->hasExplicitTemplateArgs()) { 5800288943Sdim return nullptr; // FIXME: handle template arguments 5801288943Sdim } 5802288943Sdim 5803288943Sdim return MemberExpr::Create(Importer.getToContext(), ToBase, 5804288943Sdim E->isArrow(), 5805288943Sdim Importer.Import(E->getOperatorLoc()), 5806288943Sdim Importer.Import(E->getQualifierLoc()), 5807288943Sdim Importer.Import(E->getTemplateKeywordLoc()), 5808288943Sdim ToMember, ToFoundDecl, ToMemberNameInfo, 5809288943Sdim nullptr, T, E->getValueKind(), 5810288943Sdim E->getObjectKind()); 5811288943Sdim} 5812288943Sdim 5813327952SdimExpr *ASTNodeImporter::VisitCXXPseudoDestructorExpr( 5814327952Sdim CXXPseudoDestructorExpr *E) { 5815327952Sdim 5816327952Sdim Expr *BaseE = Importer.Import(E->getBase()); 5817327952Sdim if (!BaseE) 5818327952Sdim return nullptr; 5819327952Sdim 5820327952Sdim TypeSourceInfo *ScopeInfo = Importer.Import(E->getScopeTypeInfo()); 5821327952Sdim if (!ScopeInfo && E->getScopeTypeInfo()) 5822327952Sdim return nullptr; 5823327952Sdim 5824327952Sdim PseudoDestructorTypeStorage Storage; 5825327952Sdim if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) { 5826327952Sdim IdentifierInfo *ToII = Importer.Import(FromII); 5827327952Sdim if (!ToII) 5828327952Sdim return nullptr; 5829327952Sdim Storage = PseudoDestructorTypeStorage( 5830327952Sdim ToII, Importer.Import(E->getDestroyedTypeLoc())); 5831327952Sdim } else { 5832327952Sdim TypeSourceInfo *TI = Importer.Import(E->getDestroyedTypeInfo()); 5833327952Sdim if (!TI) 5834327952Sdim return nullptr; 5835327952Sdim Storage = PseudoDestructorTypeStorage(TI); 5836327952Sdim } 5837327952Sdim 5838327952Sdim return new (Importer.getToContext()) CXXPseudoDestructorExpr( 5839327952Sdim Importer.getToContext(), BaseE, E->isArrow(), 5840327952Sdim Importer.Import(E->getOperatorLoc()), 5841327952Sdim Importer.Import(E->getQualifierLoc()), 5842327952Sdim ScopeInfo, Importer.Import(E->getColonColonLoc()), 5843327952Sdim Importer.Import(E->getTildeLoc()), Storage); 5844327952Sdim} 5845327952Sdim 5846327952SdimExpr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr( 5847327952Sdim CXXDependentScopeMemberExpr *E) { 5848327952Sdim Expr *Base = nullptr; 5849327952Sdim if (!E->isImplicitAccess()) { 5850327952Sdim Base = Importer.Import(E->getBase()); 5851327952Sdim if (!Base) 5852327952Sdim return nullptr; 5853327952Sdim } 5854327952Sdim 5855327952Sdim QualType BaseType = Importer.Import(E->getBaseType()); 5856327952Sdim if (BaseType.isNull()) 5857327952Sdim return nullptr; 5858327952Sdim 5859327952Sdim TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()), 5860327952Sdim Importer.Import(E->getRAngleLoc())); 5861327952Sdim TemplateArgumentListInfo *ResInfo = nullptr; 5862327952Sdim if (E->hasExplicitTemplateArgs()) { 5863327952Sdim if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 5864327952Sdim return nullptr; 5865327952Sdim ResInfo = &ToTAInfo; 5866327952Sdim } 5867327952Sdim 5868327952Sdim DeclarationName Name = Importer.Import(E->getMember()); 5869327952Sdim if (!E->getMember().isEmpty() && Name.isEmpty()) 5870327952Sdim return nullptr; 5871327952Sdim 5872327952Sdim DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc())); 5873327952Sdim // Import additional name location/type info. 5874327952Sdim ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo); 5875327952Sdim auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope()); 5876327952Sdim if (!ToFQ && E->getFirstQualifierFoundInScope()) 5877327952Sdim return nullptr; 5878327952Sdim 5879327952Sdim return CXXDependentScopeMemberExpr::Create( 5880327952Sdim Importer.getToContext(), Base, BaseType, E->isArrow(), 5881327952Sdim Importer.Import(E->getOperatorLoc()), 5882327952Sdim Importer.Import(E->getQualifierLoc()), 5883327952Sdim Importer.Import(E->getTemplateKeywordLoc()), 5884327952Sdim cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo); 5885327952Sdim} 5886327952Sdim 5887288943SdimExpr *ASTNodeImporter::VisitCallExpr(CallExpr *E) { 5888288943Sdim QualType T = Importer.Import(E->getType()); 5889288943Sdim if (T.isNull()) 5890288943Sdim return nullptr; 5891288943Sdim 5892288943Sdim Expr *ToCallee = Importer.Import(E->getCallee()); 5893288943Sdim if (!ToCallee && E->getCallee()) 5894288943Sdim return nullptr; 5895288943Sdim 5896288943Sdim unsigned NumArgs = E->getNumArgs(); 5897288943Sdim 5898288943Sdim llvm::SmallVector<Expr *, 2> ToArgs(NumArgs); 5899288943Sdim 5900288943Sdim for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) { 5901288943Sdim Expr *FromArg = E->getArg(ai); 5902288943Sdim Expr *ToArg = Importer.Import(FromArg); 5903288943Sdim if (!ToArg) 5904288943Sdim return nullptr; 5905288943Sdim ToArgs[ai] = ToArg; 5906288943Sdim } 5907288943Sdim 5908288943Sdim Expr **ToArgs_Copied = new (Importer.getToContext()) 5909288943Sdim Expr*[NumArgs]; 5910288943Sdim 5911288943Sdim for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) 5912288943Sdim ToArgs_Copied[ai] = ToArgs[ai]; 5913288943Sdim 5914288943Sdim return new (Importer.getToContext()) 5915288943Sdim CallExpr(Importer.getToContext(), ToCallee, 5916296417Sdim llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(), 5917288943Sdim Importer.Import(E->getRParenLoc())); 5918288943Sdim} 5919288943Sdim 5920309124SdimExpr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) { 5921309124Sdim QualType T = Importer.Import(ILE->getType()); 5922309124Sdim if (T.isNull()) 5923309124Sdim return nullptr; 5924309124Sdim 5925309124Sdim llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits()); 5926314564Sdim if (ImportContainerChecked(ILE->inits(), Exprs)) 5927309124Sdim return nullptr; 5928309124Sdim 5929309124Sdim ASTContext &ToCtx = Importer.getToContext(); 5930309124Sdim InitListExpr *To = new (ToCtx) InitListExpr( 5931309124Sdim ToCtx, Importer.Import(ILE->getLBraceLoc()), 5932309124Sdim Exprs, Importer.Import(ILE->getLBraceLoc())); 5933309124Sdim To->setType(T); 5934309124Sdim 5935309124Sdim if (ILE->hasArrayFiller()) { 5936309124Sdim Expr *Filler = Importer.Import(ILE->getArrayFiller()); 5937309124Sdim if (!Filler) 5938309124Sdim return nullptr; 5939309124Sdim To->setArrayFiller(Filler); 5940309124Sdim } 5941309124Sdim 5942309124Sdim if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) { 5943309124Sdim FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD)); 5944309124Sdim if (!ToFD) 5945309124Sdim return nullptr; 5946309124Sdim To->setInitializedFieldInUnion(ToFD); 5947309124Sdim } 5948309124Sdim 5949309124Sdim if (InitListExpr *SyntForm = ILE->getSyntacticForm()) { 5950309124Sdim InitListExpr *ToSyntForm = cast_or_null<InitListExpr>( 5951309124Sdim Importer.Import(SyntForm)); 5952309124Sdim if (!ToSyntForm) 5953309124Sdim return nullptr; 5954309124Sdim To->setSyntacticForm(ToSyntForm); 5955309124Sdim } 5956309124Sdim 5957309124Sdim To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator()); 5958309124Sdim To->setValueDependent(ILE->isValueDependent()); 5959309124Sdim To->setInstantiationDependent(ILE->isInstantiationDependent()); 5960309124Sdim 5961309124Sdim return To; 5962309124Sdim} 5963309124Sdim 5964314564SdimExpr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 5965314564Sdim QualType ToType = Importer.Import(E->getType()); 5966314564Sdim if (ToType.isNull()) 5967314564Sdim return nullptr; 5968314564Sdim 5969314564Sdim Expr *ToCommon = Importer.Import(E->getCommonExpr()); 5970314564Sdim if (!ToCommon && E->getCommonExpr()) 5971314564Sdim return nullptr; 5972314564Sdim 5973314564Sdim Expr *ToSubExpr = Importer.Import(E->getSubExpr()); 5974314564Sdim if (!ToSubExpr && E->getSubExpr()) 5975314564Sdim return nullptr; 5976314564Sdim 5977314564Sdim return new (Importer.getToContext()) 5978314564Sdim ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr); 5979314564Sdim} 5980314564Sdim 5981314564SdimExpr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 5982314564Sdim QualType ToType = Importer.Import(E->getType()); 5983314564Sdim if (ToType.isNull()) 5984314564Sdim return nullptr; 5985314564Sdim return new (Importer.getToContext()) ArrayInitIndexExpr(ToType); 5986314564Sdim} 5987314564Sdim 5988309124SdimExpr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 5989309124Sdim FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>( 5990309124Sdim Importer.Import(DIE->getField())); 5991309124Sdim if (!ToField && DIE->getField()) 5992309124Sdim return nullptr; 5993309124Sdim 5994309124Sdim return CXXDefaultInitExpr::Create( 5995309124Sdim Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField); 5996309124Sdim} 5997309124Sdim 5998309124SdimExpr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 5999309124Sdim QualType ToType = Importer.Import(E->getType()); 6000309124Sdim if (ToType.isNull() && !E->getType().isNull()) 6001309124Sdim return nullptr; 6002309124Sdim ExprValueKind VK = E->getValueKind(); 6003309124Sdim CastKind CK = E->getCastKind(); 6004309124Sdim Expr *ToOp = Importer.Import(E->getSubExpr()); 6005309124Sdim if (!ToOp && E->getSubExpr()) 6006309124Sdim return nullptr; 6007309124Sdim CXXCastPath BasePath; 6008309124Sdim if (ImportCastPath(E, BasePath)) 6009309124Sdim return nullptr; 6010309124Sdim TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten()); 6011309124Sdim SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc()); 6012309124Sdim SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc()); 6013309124Sdim SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets()); 6014309124Sdim 6015309124Sdim if (isa<CXXStaticCastExpr>(E)) { 6016309124Sdim return CXXStaticCastExpr::Create( 6017309124Sdim Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 6018309124Sdim ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 6019309124Sdim } else if (isa<CXXDynamicCastExpr>(E)) { 6020309124Sdim return CXXDynamicCastExpr::Create( 6021309124Sdim Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 6022309124Sdim ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 6023309124Sdim } else if (isa<CXXReinterpretCastExpr>(E)) { 6024309124Sdim return CXXReinterpretCastExpr::Create( 6025309124Sdim Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 6026309124Sdim ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 6027309124Sdim } else { 6028309124Sdim return nullptr; 6029309124Sdim } 6030309124Sdim} 6031309124Sdim 6032321369Sdim 6033321369SdimExpr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr( 6034321369Sdim SubstNonTypeTemplateParmExpr *E) { 6035321369Sdim QualType T = Importer.Import(E->getType()); 6036321369Sdim if (T.isNull()) 6037321369Sdim return nullptr; 6038321369Sdim 6039321369Sdim NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>( 6040321369Sdim Importer.Import(E->getParameter())); 6041321369Sdim if (!Param) 6042321369Sdim return nullptr; 6043321369Sdim 6044321369Sdim Expr *Replacement = Importer.Import(E->getReplacement()); 6045321369Sdim if (!Replacement) 6046321369Sdim return nullptr; 6047321369Sdim 6048321369Sdim return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr( 6049321369Sdim T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param, 6050321369Sdim Replacement); 6051321369Sdim} 6052321369Sdim 6053327952SdimExpr *ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) { 6054327952Sdim QualType ToType = Importer.Import(E->getType()); 6055327952Sdim if (ToType.isNull()) 6056327952Sdim return nullptr; 6057327952Sdim 6058327952Sdim SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs()); 6059327952Sdim if (ImportContainerChecked(E->getArgs(), ToArgs)) 6060327952Sdim return nullptr; 6061327952Sdim 6062327952Sdim // According to Sema::BuildTypeTrait(), if E is value-dependent, 6063327952Sdim // Value is always false. 6064327952Sdim bool ToValue = false; 6065327952Sdim if (!E->isValueDependent()) 6066327952Sdim ToValue = E->getValue(); 6067327952Sdim 6068327952Sdim return TypeTraitExpr::Create( 6069327952Sdim Importer.getToContext(), ToType, Importer.Import(E->getLocStart()), 6070327952Sdim E->getTrait(), ToArgs, Importer.Import(E->getLocEnd()), ToValue); 6071327952Sdim} 6072327952Sdim 6073321369Sdimvoid ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod, 6074321369Sdim CXXMethodDecl *FromMethod) { 6075321369Sdim for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) 6076321369Sdim ToMethod->addOverriddenMethod( 6077321369Sdim cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>( 6078321369Sdim FromOverriddenMethod)))); 6079321369Sdim} 6080321369Sdim 6081218893SdimASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, 6082218893Sdim ASTContext &FromContext, FileManager &FromFileManager, 6083218893Sdim bool MinimalImport) 6084203955Srdivacky : ToContext(ToContext), FromContext(FromContext), 6085203955Srdivacky ToFileManager(ToFileManager), FromFileManager(FromFileManager), 6086249423Sdim Minimal(MinimalImport), LastDiagFromFrom(false) 6087218893Sdim{ 6088203955Srdivacky ImportedDecls[FromContext.getTranslationUnitDecl()] 6089203955Srdivacky = ToContext.getTranslationUnitDecl(); 6090203955Srdivacky} 6091203955Srdivacky 6092203955SrdivackyASTImporter::~ASTImporter() { } 6093203955Srdivacky 6094203955SrdivackyQualType ASTImporter::Import(QualType FromT) { 6095203955Srdivacky if (FromT.isNull()) 6096203955Srdivacky return QualType(); 6097218893Sdim 6098218893Sdim const Type *fromTy = FromT.getTypePtr(); 6099203955Srdivacky 6100203955Srdivacky // Check whether we've already imported this type. 6101218893Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos 6102218893Sdim = ImportedTypes.find(fromTy); 6103203955Srdivacky if (Pos != ImportedTypes.end()) 6104218893Sdim return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers()); 6105203955Srdivacky 6106203955Srdivacky // Import the type 6107203955Srdivacky ASTNodeImporter Importer(*this); 6108218893Sdim QualType ToT = Importer.Visit(fromTy); 6109203955Srdivacky if (ToT.isNull()) 6110203955Srdivacky return ToT; 6111203955Srdivacky 6112203955Srdivacky // Record the imported type. 6113218893Sdim ImportedTypes[fromTy] = ToT.getTypePtr(); 6114203955Srdivacky 6115218893Sdim return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers()); 6116203955Srdivacky} 6117203955Srdivacky 6118203955SrdivackyTypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) { 6119203955Srdivacky if (!FromTSI) 6120203955Srdivacky return FromTSI; 6121203955Srdivacky 6122203955Srdivacky // FIXME: For now we just create a "trivial" type source info based 6123212904Sdim // on the type and a single location. Implement a real version of this. 6124203955Srdivacky QualType T = Import(FromTSI->getType()); 6125203955Srdivacky if (T.isNull()) 6126276479Sdim return nullptr; 6127203955Srdivacky 6128203955Srdivacky return ToContext.getTrivialTypeSourceInfo(T, 6129288943Sdim Import(FromTSI->getTypeLoc().getLocStart())); 6130203955Srdivacky} 6131203955Srdivacky 6132288943SdimDecl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) { 6133288943Sdim llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 6134288943Sdim if (Pos != ImportedDecls.end()) { 6135288943Sdim Decl *ToD = Pos->second; 6136288943Sdim ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD); 6137288943Sdim return ToD; 6138288943Sdim } else { 6139288943Sdim return nullptr; 6140288943Sdim } 6141288943Sdim} 6142288943Sdim 6143203955SrdivackyDecl *ASTImporter::Import(Decl *FromD) { 6144203955Srdivacky if (!FromD) 6145276479Sdim return nullptr; 6146203955Srdivacky 6147226633Sdim ASTNodeImporter Importer(*this); 6148226633Sdim 6149203955Srdivacky // Check whether we've already imported this declaration. 6150203955Srdivacky llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 6151226633Sdim if (Pos != ImportedDecls.end()) { 6152226633Sdim Decl *ToD = Pos->second; 6153226633Sdim Importer.ImportDefinitionIfNeeded(FromD, ToD); 6154226633Sdim return ToD; 6155226633Sdim } 6156203955Srdivacky 6157203955Srdivacky // Import the type 6158203955Srdivacky Decl *ToD = Importer.Visit(FromD); 6159203955Srdivacky if (!ToD) 6160276479Sdim return nullptr; 6161276479Sdim 6162203955Srdivacky // Record the imported declaration. 6163203955Srdivacky ImportedDecls[FromD] = ToD; 6164203955Srdivacky 6165203955Srdivacky if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) { 6166203955Srdivacky // Keep track of anonymous tags that have an associated typedef. 6167221345Sdim if (FromTag->getTypedefNameForAnonDecl()) 6168203955Srdivacky AnonTagsWithPendingTypedefs.push_back(FromTag); 6169221345Sdim } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) { 6170203955Srdivacky // When we've finished transforming a typedef, see whether it was the 6171203955Srdivacky // typedef for an anonymous tag. 6172261991Sdim for (SmallVectorImpl<TagDecl *>::iterator 6173203955Srdivacky FromTag = AnonTagsWithPendingTypedefs.begin(), 6174203955Srdivacky FromTagEnd = AnonTagsWithPendingTypedefs.end(); 6175203955Srdivacky FromTag != FromTagEnd; ++FromTag) { 6176221345Sdim if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) { 6177203955Srdivacky if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) { 6178203955Srdivacky // We found the typedef for an anonymous tag; link them. 6179221345Sdim ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD)); 6180203955Srdivacky AnonTagsWithPendingTypedefs.erase(FromTag); 6181203955Srdivacky break; 6182203955Srdivacky } 6183203955Srdivacky } 6184203955Srdivacky } 6185203955Srdivacky } 6186203955Srdivacky 6187203955Srdivacky return ToD; 6188203955Srdivacky} 6189203955Srdivacky 6190203955SrdivackyDeclContext *ASTImporter::ImportContext(DeclContext *FromDC) { 6191203955Srdivacky if (!FromDC) 6192203955Srdivacky return FromDC; 6193203955Srdivacky 6194234353Sdim DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC))); 6195234353Sdim if (!ToDC) 6196276479Sdim return nullptr; 6197276479Sdim 6198234353Sdim // When we're using a record/enum/Objective-C class/protocol as a context, we 6199234353Sdim // need it to have a definition. 6200234353Sdim if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) { 6201234353Sdim RecordDecl *FromRecord = cast<RecordDecl>(FromDC); 6202234353Sdim if (ToRecord->isCompleteDefinition()) { 6203234353Sdim // Do nothing. 6204234353Sdim } else if (FromRecord->isCompleteDefinition()) { 6205234353Sdim ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord, 6206234353Sdim ASTNodeImporter::IDK_Basic); 6207234353Sdim } else { 6208234353Sdim CompleteDecl(ToRecord); 6209234353Sdim } 6210234353Sdim } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) { 6211234353Sdim EnumDecl *FromEnum = cast<EnumDecl>(FromDC); 6212234353Sdim if (ToEnum->isCompleteDefinition()) { 6213234353Sdim // Do nothing. 6214234353Sdim } else if (FromEnum->isCompleteDefinition()) { 6215234353Sdim ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum, 6216234353Sdim ASTNodeImporter::IDK_Basic); 6217234353Sdim } else { 6218234353Sdim CompleteDecl(ToEnum); 6219234353Sdim } 6220234353Sdim } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) { 6221234353Sdim ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC); 6222234353Sdim if (ToClass->getDefinition()) { 6223234353Sdim // Do nothing. 6224234353Sdim } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) { 6225234353Sdim ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass, 6226234353Sdim ASTNodeImporter::IDK_Basic); 6227234353Sdim } else { 6228234353Sdim CompleteDecl(ToClass); 6229234353Sdim } 6230234353Sdim } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) { 6231234353Sdim ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC); 6232234353Sdim if (ToProto->getDefinition()) { 6233234353Sdim // Do nothing. 6234234353Sdim } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) { 6235234353Sdim ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto, 6236234353Sdim ASTNodeImporter::IDK_Basic); 6237234353Sdim } else { 6238234353Sdim CompleteDecl(ToProto); 6239234353Sdim } 6240234353Sdim } 6241234353Sdim 6242234353Sdim return ToDC; 6243203955Srdivacky} 6244203955Srdivacky 6245203955SrdivackyExpr *ASTImporter::Import(Expr *FromE) { 6246203955Srdivacky if (!FromE) 6247276479Sdim return nullptr; 6248203955Srdivacky 6249203955Srdivacky return cast_or_null<Expr>(Import(cast<Stmt>(FromE))); 6250203955Srdivacky} 6251203955Srdivacky 6252203955SrdivackyStmt *ASTImporter::Import(Stmt *FromS) { 6253203955Srdivacky if (!FromS) 6254276479Sdim return nullptr; 6255203955Srdivacky 6256203955Srdivacky // Check whether we've already imported this declaration. 6257203955Srdivacky llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS); 6258203955Srdivacky if (Pos != ImportedStmts.end()) 6259203955Srdivacky return Pos->second; 6260203955Srdivacky 6261203955Srdivacky // Import the type 6262203955Srdivacky ASTNodeImporter Importer(*this); 6263203955Srdivacky Stmt *ToS = Importer.Visit(FromS); 6264203955Srdivacky if (!ToS) 6265276479Sdim return nullptr; 6266276479Sdim 6267203955Srdivacky // Record the imported declaration. 6268203955Srdivacky ImportedStmts[FromS] = ToS; 6269203955Srdivacky return ToS; 6270203955Srdivacky} 6271203955Srdivacky 6272203955SrdivackyNestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) { 6273203955Srdivacky if (!FromNNS) 6274276479Sdim return nullptr; 6275203955Srdivacky 6276221345Sdim NestedNameSpecifier *prefix = Import(FromNNS->getPrefix()); 6277221345Sdim 6278221345Sdim switch (FromNNS->getKind()) { 6279221345Sdim case NestedNameSpecifier::Identifier: 6280221345Sdim if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) { 6281221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, II); 6282221345Sdim } 6283276479Sdim return nullptr; 6284221345Sdim 6285221345Sdim case NestedNameSpecifier::Namespace: 6286221345Sdim if (NamespaceDecl *NS = 6287321369Sdim cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) { 6288221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, NS); 6289221345Sdim } 6290276479Sdim return nullptr; 6291221345Sdim 6292221345Sdim case NestedNameSpecifier::NamespaceAlias: 6293221345Sdim if (NamespaceAliasDecl *NSAD = 6294321369Sdim cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) { 6295221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, NSAD); 6296221345Sdim } 6297276479Sdim return nullptr; 6298221345Sdim 6299221345Sdim case NestedNameSpecifier::Global: 6300221345Sdim return NestedNameSpecifier::GlobalSpecifier(ToContext); 6301221345Sdim 6302280031Sdim case NestedNameSpecifier::Super: 6303280031Sdim if (CXXRecordDecl *RD = 6304321369Sdim cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) { 6305280031Sdim return NestedNameSpecifier::SuperSpecifier(ToContext, RD); 6306280031Sdim } 6307280031Sdim return nullptr; 6308280031Sdim 6309221345Sdim case NestedNameSpecifier::TypeSpec: 6310221345Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 6311221345Sdim QualType T = Import(QualType(FromNNS->getAsType(), 0u)); 6312221345Sdim if (!T.isNull()) { 6313221345Sdim bool bTemplate = FromNNS->getKind() == 6314221345Sdim NestedNameSpecifier::TypeSpecWithTemplate; 6315221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, 6316221345Sdim bTemplate, T.getTypePtr()); 6317221345Sdim } 6318221345Sdim } 6319276479Sdim return nullptr; 6320221345Sdim } 6321221345Sdim 6322221345Sdim llvm_unreachable("Invalid nested name specifier kind"); 6323203955Srdivacky} 6324203955Srdivacky 6325219077SdimNestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) { 6326321369Sdim // Copied from NestedNameSpecifier mostly. 6327321369Sdim SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 6328321369Sdim NestedNameSpecifierLoc NNS = FromNNS; 6329321369Sdim 6330321369Sdim // Push each of the nested-name-specifiers's onto a stack for 6331321369Sdim // serialization in reverse order. 6332321369Sdim while (NNS) { 6333321369Sdim NestedNames.push_back(NNS); 6334321369Sdim NNS = NNS.getPrefix(); 6335321369Sdim } 6336321369Sdim 6337321369Sdim NestedNameSpecifierLocBuilder Builder; 6338321369Sdim 6339321369Sdim while (!NestedNames.empty()) { 6340321369Sdim NNS = NestedNames.pop_back_val(); 6341321369Sdim NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier()); 6342321369Sdim if (!Spec) 6343321369Sdim return NestedNameSpecifierLoc(); 6344321369Sdim 6345321369Sdim NestedNameSpecifier::SpecifierKind Kind = Spec->getKind(); 6346321369Sdim switch (Kind) { 6347321369Sdim case NestedNameSpecifier::Identifier: 6348321369Sdim Builder.Extend(getToContext(), 6349321369Sdim Spec->getAsIdentifier(), 6350321369Sdim Import(NNS.getLocalBeginLoc()), 6351321369Sdim Import(NNS.getLocalEndLoc())); 6352321369Sdim break; 6353321369Sdim 6354321369Sdim case NestedNameSpecifier::Namespace: 6355321369Sdim Builder.Extend(getToContext(), 6356321369Sdim Spec->getAsNamespace(), 6357321369Sdim Import(NNS.getLocalBeginLoc()), 6358321369Sdim Import(NNS.getLocalEndLoc())); 6359321369Sdim break; 6360321369Sdim 6361321369Sdim case NestedNameSpecifier::NamespaceAlias: 6362321369Sdim Builder.Extend(getToContext(), 6363321369Sdim Spec->getAsNamespaceAlias(), 6364321369Sdim Import(NNS.getLocalBeginLoc()), 6365321369Sdim Import(NNS.getLocalEndLoc())); 6366321369Sdim break; 6367321369Sdim 6368321369Sdim case NestedNameSpecifier::TypeSpec: 6369321369Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 6370321369Sdim TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo( 6371321369Sdim QualType(Spec->getAsType(), 0)); 6372321369Sdim Builder.Extend(getToContext(), 6373321369Sdim Import(NNS.getLocalBeginLoc()), 6374321369Sdim TSI->getTypeLoc(), 6375321369Sdim Import(NNS.getLocalEndLoc())); 6376321369Sdim break; 6377321369Sdim } 6378321369Sdim 6379321369Sdim case NestedNameSpecifier::Global: 6380321369Sdim Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc())); 6381321369Sdim break; 6382321369Sdim 6383321369Sdim case NestedNameSpecifier::Super: { 6384321369Sdim SourceRange ToRange = Import(NNS.getSourceRange()); 6385321369Sdim Builder.MakeSuper(getToContext(), 6386321369Sdim Spec->getAsRecordDecl(), 6387321369Sdim ToRange.getBegin(), 6388321369Sdim ToRange.getEnd()); 6389321369Sdim } 6390321369Sdim } 6391321369Sdim } 6392321369Sdim 6393321369Sdim return Builder.getWithLocInContext(getToContext()); 6394219077Sdim} 6395219077Sdim 6396218893SdimTemplateName ASTImporter::Import(TemplateName From) { 6397218893Sdim switch (From.getKind()) { 6398218893Sdim case TemplateName::Template: 6399218893Sdim if (TemplateDecl *ToTemplate 6400218893Sdim = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 6401218893Sdim return TemplateName(ToTemplate); 6402218893Sdim 6403218893Sdim return TemplateName(); 6404218893Sdim 6405218893Sdim case TemplateName::OverloadedTemplate: { 6406218893Sdim OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate(); 6407218893Sdim UnresolvedSet<2> ToTemplates; 6408218893Sdim for (OverloadedTemplateStorage::iterator I = FromStorage->begin(), 6409218893Sdim E = FromStorage->end(); 6410218893Sdim I != E; ++I) { 6411218893Sdim if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I))) 6412218893Sdim ToTemplates.addDecl(To); 6413218893Sdim else 6414218893Sdim return TemplateName(); 6415218893Sdim } 6416218893Sdim return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 6417218893Sdim ToTemplates.end()); 6418218893Sdim } 6419218893Sdim 6420218893Sdim case TemplateName::QualifiedTemplate: { 6421218893Sdim QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName(); 6422218893Sdim NestedNameSpecifier *Qualifier = Import(QTN->getQualifier()); 6423218893Sdim if (!Qualifier) 6424218893Sdim return TemplateName(); 6425218893Sdim 6426218893Sdim if (TemplateDecl *ToTemplate 6427218893Sdim = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 6428218893Sdim return ToContext.getQualifiedTemplateName(Qualifier, 6429218893Sdim QTN->hasTemplateKeyword(), 6430218893Sdim ToTemplate); 6431218893Sdim 6432218893Sdim return TemplateName(); 6433218893Sdim } 6434218893Sdim 6435218893Sdim case TemplateName::DependentTemplate: { 6436218893Sdim DependentTemplateName *DTN = From.getAsDependentTemplateName(); 6437218893Sdim NestedNameSpecifier *Qualifier = Import(DTN->getQualifier()); 6438218893Sdim if (!Qualifier) 6439218893Sdim return TemplateName(); 6440218893Sdim 6441218893Sdim if (DTN->isIdentifier()) { 6442218893Sdim return ToContext.getDependentTemplateName(Qualifier, 6443218893Sdim Import(DTN->getIdentifier())); 6444218893Sdim } 6445218893Sdim 6446218893Sdim return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator()); 6447218893Sdim } 6448224145Sdim 6449224145Sdim case TemplateName::SubstTemplateTemplateParm: { 6450224145Sdim SubstTemplateTemplateParmStorage *subst 6451224145Sdim = From.getAsSubstTemplateTemplateParm(); 6452224145Sdim TemplateTemplateParmDecl *param 6453224145Sdim = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter())); 6454224145Sdim if (!param) 6455224145Sdim return TemplateName(); 6456224145Sdim 6457224145Sdim TemplateName replacement = Import(subst->getReplacement()); 6458224145Sdim if (replacement.isNull()) return TemplateName(); 6459224145Sdim 6460224145Sdim return ToContext.getSubstTemplateTemplateParm(param, replacement); 6461224145Sdim } 6462218893Sdim 6463218893Sdim case TemplateName::SubstTemplateTemplateParmPack: { 6464218893Sdim SubstTemplateTemplateParmPackStorage *SubstPack 6465218893Sdim = From.getAsSubstTemplateTemplateParmPack(); 6466218893Sdim TemplateTemplateParmDecl *Param 6467218893Sdim = cast_or_null<TemplateTemplateParmDecl>( 6468218893Sdim Import(SubstPack->getParameterPack())); 6469218893Sdim if (!Param) 6470218893Sdim return TemplateName(); 6471218893Sdim 6472218893Sdim ASTNodeImporter Importer(*this); 6473218893Sdim TemplateArgument ArgPack 6474218893Sdim = Importer.ImportTemplateArgument(SubstPack->getArgumentPack()); 6475218893Sdim if (ArgPack.isNull()) 6476218893Sdim return TemplateName(); 6477218893Sdim 6478218893Sdim return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack); 6479218893Sdim } 6480218893Sdim } 6481218893Sdim 6482218893Sdim llvm_unreachable("Invalid template name kind"); 6483218893Sdim} 6484218893Sdim 6485203955SrdivackySourceLocation ASTImporter::Import(SourceLocation FromLoc) { 6486203955Srdivacky if (FromLoc.isInvalid()) 6487203955Srdivacky return SourceLocation(); 6488203955Srdivacky 6489203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 6490203955Srdivacky 6491314564Sdim // For now, map everything down to its file location, so that we 6492224145Sdim // don't have to import macro expansions. 6493224145Sdim // FIXME: Import macro expansions! 6494314564Sdim FromLoc = FromSM.getFileLoc(FromLoc); 6495203955Srdivacky std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc); 6496203955Srdivacky SourceManager &ToSM = ToContext.getSourceManager(); 6497280031Sdim FileID ToFileID = Import(Decomposed.first); 6498280031Sdim if (ToFileID.isInvalid()) 6499280031Sdim return SourceLocation(); 6500288943Sdim SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID) 6501288943Sdim .getLocWithOffset(Decomposed.second); 6502288943Sdim return ret; 6503203955Srdivacky} 6504203955Srdivacky 6505203955SrdivackySourceRange ASTImporter::Import(SourceRange FromRange) { 6506203955Srdivacky return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd())); 6507203955Srdivacky} 6508203955Srdivacky 6509203955SrdivackyFileID ASTImporter::Import(FileID FromID) { 6510218893Sdim llvm::DenseMap<FileID, FileID>::iterator Pos 6511218893Sdim = ImportedFileIDs.find(FromID); 6512203955Srdivacky if (Pos != ImportedFileIDs.end()) 6513203955Srdivacky return Pos->second; 6514203955Srdivacky 6515203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 6516203955Srdivacky SourceManager &ToSM = ToContext.getSourceManager(); 6517203955Srdivacky const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID); 6518224145Sdim assert(FromSLoc.isFile() && "Cannot handle macro expansions yet"); 6519203955Srdivacky 6520203955Srdivacky // Include location of this file. 6521203955Srdivacky SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc()); 6522203955Srdivacky 6523203955Srdivacky // Map the FileID for to the "to" source manager. 6524203955Srdivacky FileID ToID; 6525203955Srdivacky const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache(); 6526288943Sdim if (Cache->OrigEntry && Cache->OrigEntry->getDir()) { 6527203955Srdivacky // FIXME: We probably want to use getVirtualFile(), so we don't hit the 6528203955Srdivacky // disk again 6529203955Srdivacky // FIXME: We definitely want to re-use the existing MemoryBuffer, rather 6530203955Srdivacky // than mmap the files several times. 6531221345Sdim const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName()); 6532280031Sdim if (!Entry) 6533280031Sdim return FileID(); 6534203955Srdivacky ToID = ToSM.createFileID(Entry, ToIncludeLoc, 6535203955Srdivacky FromSLoc.getFile().getFileCharacteristic()); 6536203955Srdivacky } else { 6537203955Srdivacky // FIXME: We want to re-use the existing MemoryBuffer! 6538218893Sdim const llvm::MemoryBuffer * 6539218893Sdim FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM); 6540280031Sdim std::unique_ptr<llvm::MemoryBuffer> ToBuf 6541206275Srdivacky = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(), 6542203955Srdivacky FromBuf->getBufferIdentifier()); 6543280031Sdim ToID = ToSM.createFileID(std::move(ToBuf), 6544280031Sdim FromSLoc.getFile().getFileCharacteristic()); 6545203955Srdivacky } 6546203955Srdivacky 6547203955Srdivacky 6548218893Sdim ImportedFileIDs[FromID] = ToID; 6549203955Srdivacky return ToID; 6550203955Srdivacky} 6551203955Srdivacky 6552309124SdimCXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) { 6553309124Sdim Expr *ToExpr = Import(From->getInit()); 6554309124Sdim if (!ToExpr && From->getInit()) 6555309124Sdim return nullptr; 6556309124Sdim 6557309124Sdim if (From->isBaseInitializer()) { 6558309124Sdim TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo()); 6559309124Sdim if (!ToTInfo && From->getTypeSourceInfo()) 6560309124Sdim return nullptr; 6561309124Sdim 6562309124Sdim return new (ToContext) CXXCtorInitializer( 6563309124Sdim ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()), 6564309124Sdim ToExpr, Import(From->getRParenLoc()), 6565309124Sdim From->isPackExpansion() ? Import(From->getEllipsisLoc()) 6566309124Sdim : SourceLocation()); 6567309124Sdim } else if (From->isMemberInitializer()) { 6568309124Sdim FieldDecl *ToField = 6569309124Sdim llvm::cast_or_null<FieldDecl>(Import(From->getMember())); 6570309124Sdim if (!ToField && From->getMember()) 6571309124Sdim return nullptr; 6572309124Sdim 6573309124Sdim return new (ToContext) CXXCtorInitializer( 6574309124Sdim ToContext, ToField, Import(From->getMemberLocation()), 6575309124Sdim Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc())); 6576309124Sdim } else if (From->isIndirectMemberInitializer()) { 6577309124Sdim IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>( 6578309124Sdim Import(From->getIndirectMember())); 6579309124Sdim if (!ToIField && From->getIndirectMember()) 6580309124Sdim return nullptr; 6581309124Sdim 6582309124Sdim return new (ToContext) CXXCtorInitializer( 6583309124Sdim ToContext, ToIField, Import(From->getMemberLocation()), 6584309124Sdim Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc())); 6585309124Sdim } else if (From->isDelegatingInitializer()) { 6586309124Sdim TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo()); 6587309124Sdim if (!ToTInfo && From->getTypeSourceInfo()) 6588309124Sdim return nullptr; 6589309124Sdim 6590309124Sdim return new (ToContext) 6591309124Sdim CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()), 6592309124Sdim ToExpr, Import(From->getRParenLoc())); 6593309124Sdim } else { 6594309124Sdim return nullptr; 6595309124Sdim } 6596309124Sdim} 6597309124Sdim 6598309124Sdim 6599314564SdimCXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) { 6600314564Sdim auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec); 6601314564Sdim if (Pos != ImportedCXXBaseSpecifiers.end()) 6602314564Sdim return Pos->second; 6603314564Sdim 6604314564Sdim CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier( 6605314564Sdim Import(BaseSpec->getSourceRange()), 6606314564Sdim BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(), 6607314564Sdim BaseSpec->getAccessSpecifierAsWritten(), 6608314564Sdim Import(BaseSpec->getTypeSourceInfo()), 6609314564Sdim Import(BaseSpec->getEllipsisLoc())); 6610314564Sdim ImportedCXXBaseSpecifiers[BaseSpec] = Imported; 6611314564Sdim return Imported; 6612314564Sdim} 6613314564Sdim 6614218893Sdimvoid ASTImporter::ImportDefinition(Decl *From) { 6615218893Sdim Decl *To = Import(From); 6616218893Sdim if (!To) 6617218893Sdim return; 6618218893Sdim 6619218893Sdim if (DeclContext *FromDC = cast<DeclContext>(From)) { 6620218893Sdim ASTNodeImporter Importer(*this); 6621226633Sdim 6622226633Sdim if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) { 6623226633Sdim if (!ToRecord->getDefinition()) { 6624226633Sdim Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord, 6625234353Sdim ASTNodeImporter::IDK_Everything); 6626226633Sdim return; 6627226633Sdim } 6628226633Sdim } 6629226633Sdim 6630226633Sdim if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) { 6631226633Sdim if (!ToEnum->getDefinition()) { 6632226633Sdim Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum, 6633234353Sdim ASTNodeImporter::IDK_Everything); 6634226633Sdim return; 6635226633Sdim } 6636226633Sdim } 6637234353Sdim 6638234353Sdim if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) { 6639234353Sdim if (!ToIFace->getDefinition()) { 6640234353Sdim Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace, 6641234353Sdim ASTNodeImporter::IDK_Everything); 6642234353Sdim return; 6643234353Sdim } 6644234353Sdim } 6645226633Sdim 6646234353Sdim if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) { 6647234353Sdim if (!ToProto->getDefinition()) { 6648234353Sdim Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto, 6649234353Sdim ASTNodeImporter::IDK_Everything); 6650234353Sdim return; 6651234353Sdim } 6652234353Sdim } 6653234353Sdim 6654218893Sdim Importer.ImportDeclContext(FromDC, true); 6655218893Sdim } 6656218893Sdim} 6657218893Sdim 6658203955SrdivackyDeclarationName ASTImporter::Import(DeclarationName FromName) { 6659203955Srdivacky if (!FromName) 6660203955Srdivacky return DeclarationName(); 6661203955Srdivacky 6662203955Srdivacky switch (FromName.getNameKind()) { 6663203955Srdivacky case DeclarationName::Identifier: 6664203955Srdivacky return Import(FromName.getAsIdentifierInfo()); 6665203955Srdivacky 6666203955Srdivacky case DeclarationName::ObjCZeroArgSelector: 6667203955Srdivacky case DeclarationName::ObjCOneArgSelector: 6668203955Srdivacky case DeclarationName::ObjCMultiArgSelector: 6669203955Srdivacky return Import(FromName.getObjCSelector()); 6670203955Srdivacky 6671203955Srdivacky case DeclarationName::CXXConstructorName: { 6672203955Srdivacky QualType T = Import(FromName.getCXXNameType()); 6673203955Srdivacky if (T.isNull()) 6674203955Srdivacky return DeclarationName(); 6675203955Srdivacky 6676203955Srdivacky return ToContext.DeclarationNames.getCXXConstructorName( 6677203955Srdivacky ToContext.getCanonicalType(T)); 6678203955Srdivacky } 6679203955Srdivacky 6680203955Srdivacky case DeclarationName::CXXDestructorName: { 6681203955Srdivacky QualType T = Import(FromName.getCXXNameType()); 6682203955Srdivacky if (T.isNull()) 6683203955Srdivacky return DeclarationName(); 6684203955Srdivacky 6685203955Srdivacky return ToContext.DeclarationNames.getCXXDestructorName( 6686203955Srdivacky ToContext.getCanonicalType(T)); 6687203955Srdivacky } 6688203955Srdivacky 6689321369Sdim case DeclarationName::CXXDeductionGuideName: { 6690321369Sdim TemplateDecl *Template = cast_or_null<TemplateDecl>( 6691321369Sdim Import(FromName.getCXXDeductionGuideTemplate())); 6692321369Sdim if (!Template) 6693321369Sdim return DeclarationName(); 6694321369Sdim return ToContext.DeclarationNames.getCXXDeductionGuideName(Template); 6695321369Sdim } 6696321369Sdim 6697203955Srdivacky case DeclarationName::CXXConversionFunctionName: { 6698203955Srdivacky QualType T = Import(FromName.getCXXNameType()); 6699203955Srdivacky if (T.isNull()) 6700203955Srdivacky return DeclarationName(); 6701203955Srdivacky 6702203955Srdivacky return ToContext.DeclarationNames.getCXXConversionFunctionName( 6703203955Srdivacky ToContext.getCanonicalType(T)); 6704203955Srdivacky } 6705203955Srdivacky 6706203955Srdivacky case DeclarationName::CXXOperatorName: 6707203955Srdivacky return ToContext.DeclarationNames.getCXXOperatorName( 6708203955Srdivacky FromName.getCXXOverloadedOperator()); 6709203955Srdivacky 6710203955Srdivacky case DeclarationName::CXXLiteralOperatorName: 6711203955Srdivacky return ToContext.DeclarationNames.getCXXLiteralOperatorName( 6712203955Srdivacky Import(FromName.getCXXLiteralIdentifier())); 6713203955Srdivacky 6714203955Srdivacky case DeclarationName::CXXUsingDirective: 6715203955Srdivacky // FIXME: STATICS! 6716203955Srdivacky return DeclarationName::getUsingDirectiveName(); 6717203955Srdivacky } 6718203955Srdivacky 6719234353Sdim llvm_unreachable("Invalid DeclarationName Kind!"); 6720203955Srdivacky} 6721203955Srdivacky 6722218893SdimIdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) { 6723203955Srdivacky if (!FromId) 6724276479Sdim return nullptr; 6725203955Srdivacky 6726309124Sdim IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName()); 6727309124Sdim 6728309124Sdim if (!ToId->getBuiltinID() && FromId->getBuiltinID()) 6729309124Sdim ToId->setBuiltinID(FromId->getBuiltinID()); 6730309124Sdim 6731309124Sdim return ToId; 6732203955Srdivacky} 6733203955Srdivacky 6734204643SrdivackySelector ASTImporter::Import(Selector FromSel) { 6735204643Srdivacky if (FromSel.isNull()) 6736204643Srdivacky return Selector(); 6737204643Srdivacky 6738226633Sdim SmallVector<IdentifierInfo *, 4> Idents; 6739204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0))); 6740204643Srdivacky for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I) 6741204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I))); 6742204643Srdivacky return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data()); 6743204643Srdivacky} 6744204643Srdivacky 6745203955SrdivackyDeclarationName ASTImporter::HandleNameConflict(DeclarationName Name, 6746203955Srdivacky DeclContext *DC, 6747203955Srdivacky unsigned IDNS, 6748203955Srdivacky NamedDecl **Decls, 6749203955Srdivacky unsigned NumDecls) { 6750203955Srdivacky return Name; 6751203955Srdivacky} 6752203955Srdivacky 6753203955SrdivackyDiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) { 6754249423Sdim if (LastDiagFromFrom) 6755249423Sdim ToContext.getDiagnostics().notePriorDiagnosticFrom( 6756249423Sdim FromContext.getDiagnostics()); 6757249423Sdim LastDiagFromFrom = false; 6758218893Sdim return ToContext.getDiagnostics().Report(Loc, DiagID); 6759203955Srdivacky} 6760203955Srdivacky 6761203955SrdivackyDiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) { 6762249423Sdim if (!LastDiagFromFrom) 6763249423Sdim FromContext.getDiagnostics().notePriorDiagnosticFrom( 6764249423Sdim ToContext.getDiagnostics()); 6765249423Sdim LastDiagFromFrom = true; 6766218893Sdim return FromContext.getDiagnostics().Report(Loc, DiagID); 6767203955Srdivacky} 6768203955Srdivacky 6769234353Sdimvoid ASTImporter::CompleteDecl (Decl *D) { 6770234353Sdim if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 6771234353Sdim if (!ID->getDefinition()) 6772234353Sdim ID->startDefinition(); 6773234353Sdim } 6774234353Sdim else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) { 6775234353Sdim if (!PD->getDefinition()) 6776234353Sdim PD->startDefinition(); 6777234353Sdim } 6778234353Sdim else if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 6779234353Sdim if (!TD->getDefinition() && !TD->isBeingDefined()) { 6780234353Sdim TD->startDefinition(); 6781234353Sdim TD->setCompleteDefinition(true); 6782234353Sdim } 6783234353Sdim } 6784234353Sdim else { 6785234353Sdim assert (0 && "CompleteDecl called on a Decl that can't be completed"); 6786234353Sdim } 6787234353Sdim} 6788234353Sdim 6789203955SrdivackyDecl *ASTImporter::Imported(Decl *From, Decl *To) { 6790309124Sdim if (From->hasAttrs()) { 6791309124Sdim for (Attr *FromAttr : From->getAttrs()) 6792309124Sdim To->addAttr(FromAttr->clone(To->getASTContext())); 6793309124Sdim } 6794309124Sdim if (From->isUsed()) { 6795309124Sdim To->setIsUsed(); 6796309124Sdim } 6797309124Sdim if (From->isImplicit()) { 6798309124Sdim To->setImplicit(); 6799309124Sdim } 6800203955Srdivacky ImportedDecls[From] = To; 6801203955Srdivacky return To; 6802203955Srdivacky} 6803203955Srdivacky 6804239462Sdimbool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To, 6805239462Sdim bool Complain) { 6806218893Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos 6807203955Srdivacky = ImportedTypes.find(From.getTypePtr()); 6808203955Srdivacky if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To)) 6809203955Srdivacky return true; 6810321369Sdim 6811239462Sdim StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls, 6812239462Sdim false, Complain); 6813204643Srdivacky return Ctx.IsStructurallyEquivalent(From, To); 6814203955Srdivacky} 6815