ASTImporter.cpp revision 321369
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); 61203955Srdivacky // FIXME: UnresolvedUsingType 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 80210299Sed // FIXME: DependentTemplateSpecializationType 81218893Sdim QualType VisitObjCInterfaceType(const ObjCInterfaceType *T); 82218893Sdim QualType VisitObjCObjectType(const ObjCObjectType *T); 83218893Sdim QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T); 84203955Srdivacky 85234353Sdim // Importing declarations 86203955Srdivacky bool ImportDeclParts(NamedDecl *D, DeclContext *&DC, 87203955Srdivacky DeclContext *&LexicalDC, DeclarationName &Name, 88288943Sdim NamedDecl *&ToD, SourceLocation &Loc); 89276479Sdim void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr); 90212904Sdim void ImportDeclarationNameLoc(const DeclarationNameInfo &From, 91212904Sdim DeclarationNameInfo& To); 92218893Sdim void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false); 93309124Sdim 94314564Sdim bool ImportCastPath(CastExpr *E, CXXCastPath &Path); 95314564Sdim 96309124Sdim typedef DesignatedInitExpr::Designator Designator; 97309124Sdim Designator ImportDesignator(const Designator &D); 98309124Sdim 99234353Sdim 100234353Sdim /// \brief What we should import from the definition. 101234353Sdim enum ImportDefinitionKind { 102234353Sdim /// \brief Import the default subset of the definition, which might be 103234353Sdim /// nothing (if minimal import is set) or might be everything (if minimal 104234353Sdim /// import is not set). 105234353Sdim IDK_Default, 106234353Sdim /// \brief Import everything. 107234353Sdim IDK_Everything, 108234353Sdim /// \brief Import only the bare bones needed to establish a valid 109234353Sdim /// DeclContext. 110234353Sdim IDK_Basic 111234353Sdim }; 112234353Sdim 113234353Sdim bool shouldForceImportDeclContext(ImportDefinitionKind IDK) { 114234353Sdim return IDK == IDK_Everything || 115234353Sdim (IDK == IDK_Default && !Importer.isMinimalImport()); 116234353Sdim } 117234353Sdim 118226633Sdim bool ImportDefinition(RecordDecl *From, RecordDecl *To, 119234353Sdim ImportDefinitionKind Kind = IDK_Default); 120261991Sdim bool ImportDefinition(VarDecl *From, VarDecl *To, 121261991Sdim ImportDefinitionKind Kind = IDK_Default); 122226633Sdim bool ImportDefinition(EnumDecl *From, EnumDecl *To, 123234353Sdim ImportDefinitionKind Kind = IDK_Default); 124234353Sdim bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, 125234353Sdim ImportDefinitionKind Kind = IDK_Default); 126234353Sdim bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To, 127234353Sdim ImportDefinitionKind Kind = IDK_Default); 128218893Sdim TemplateParameterList *ImportTemplateParameterList( 129218893Sdim TemplateParameterList *Params); 130218893Sdim TemplateArgument ImportTemplateArgument(const TemplateArgument &From); 131314564Sdim TemplateArgumentLoc ImportTemplateArgumentLoc( 132314564Sdim const TemplateArgumentLoc &TALoc, bool &Error); 133218893Sdim bool ImportTemplateArguments(const TemplateArgument *FromArgs, 134218893Sdim unsigned NumFromArgs, 135226633Sdim SmallVectorImpl<TemplateArgument> &ToArgs); 136239462Sdim bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord, 137239462Sdim bool Complain = true); 138261991Sdim bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 139261991Sdim bool Complain = true); 140203955Srdivacky bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord); 141249423Sdim bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC); 142218893Sdim bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To); 143261991Sdim bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To); 144203955Srdivacky Decl *VisitDecl(Decl *D); 145309124Sdim Decl *VisitAccessSpecDecl(AccessSpecDecl *D); 146314564Sdim Decl *VisitStaticAssertDecl(StaticAssertDecl *D); 147234353Sdim Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 148204643Srdivacky Decl *VisitNamespaceDecl(NamespaceDecl *D); 149221345Sdim Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias); 150203955Srdivacky Decl *VisitTypedefDecl(TypedefDecl *D); 151221345Sdim Decl *VisitTypeAliasDecl(TypeAliasDecl *D); 152309124Sdim Decl *VisitLabelDecl(LabelDecl *D); 153203955Srdivacky Decl *VisitEnumDecl(EnumDecl *D); 154203955Srdivacky Decl *VisitRecordDecl(RecordDecl *D); 155203955Srdivacky Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 156203955Srdivacky Decl *VisitFunctionDecl(FunctionDecl *D); 157204643Srdivacky Decl *VisitCXXMethodDecl(CXXMethodDecl *D); 158204643Srdivacky Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 159204643Srdivacky Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 160204643Srdivacky Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 161203955Srdivacky Decl *VisitFieldDecl(FieldDecl *D); 162218893Sdim Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D); 163314564Sdim Decl *VisitFriendDecl(FriendDecl *D); 164204643Srdivacky Decl *VisitObjCIvarDecl(ObjCIvarDecl *D); 165203955Srdivacky Decl *VisitVarDecl(VarDecl *D); 166204643Srdivacky Decl *VisitImplicitParamDecl(ImplicitParamDecl *D); 167203955Srdivacky Decl *VisitParmVarDecl(ParmVarDecl *D); 168204643Srdivacky Decl *VisitObjCMethodDecl(ObjCMethodDecl *D); 169288943Sdim Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D); 170204643Srdivacky Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D); 171204643Srdivacky Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D); 172280031Sdim Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D); 173288943Sdim 174288943Sdim ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list); 175203955Srdivacky Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 176218893Sdim Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 177218893Sdim Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D); 178204643Srdivacky Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D); 179218893Sdim Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 180218893Sdim Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 181218893Sdim Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 182218893Sdim Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 183218893Sdim Decl *VisitClassTemplateDecl(ClassTemplateDecl *D); 184218893Sdim Decl *VisitClassTemplateSpecializationDecl( 185218893Sdim ClassTemplateSpecializationDecl *D); 186261991Sdim Decl *VisitVarTemplateDecl(VarTemplateDecl *D); 187261991Sdim Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); 188261991Sdim 189203955Srdivacky // Importing statements 190288943Sdim DeclGroupRef ImportDeclGroup(DeclGroupRef DG); 191288943Sdim 192203955Srdivacky Stmt *VisitStmt(Stmt *S); 193309124Sdim Stmt *VisitGCCAsmStmt(GCCAsmStmt *S); 194288943Sdim Stmt *VisitDeclStmt(DeclStmt *S); 195288943Sdim Stmt *VisitNullStmt(NullStmt *S); 196288943Sdim Stmt *VisitCompoundStmt(CompoundStmt *S); 197288943Sdim Stmt *VisitCaseStmt(CaseStmt *S); 198288943Sdim Stmt *VisitDefaultStmt(DefaultStmt *S); 199288943Sdim Stmt *VisitLabelStmt(LabelStmt *S); 200288943Sdim Stmt *VisitAttributedStmt(AttributedStmt *S); 201288943Sdim Stmt *VisitIfStmt(IfStmt *S); 202288943Sdim Stmt *VisitSwitchStmt(SwitchStmt *S); 203288943Sdim Stmt *VisitWhileStmt(WhileStmt *S); 204288943Sdim Stmt *VisitDoStmt(DoStmt *S); 205288943Sdim Stmt *VisitForStmt(ForStmt *S); 206288943Sdim Stmt *VisitGotoStmt(GotoStmt *S); 207288943Sdim Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S); 208288943Sdim Stmt *VisitContinueStmt(ContinueStmt *S); 209288943Sdim Stmt *VisitBreakStmt(BreakStmt *S); 210288943Sdim Stmt *VisitReturnStmt(ReturnStmt *S); 211288943Sdim // FIXME: MSAsmStmt 212288943Sdim // FIXME: SEHExceptStmt 213288943Sdim // FIXME: SEHFinallyStmt 214288943Sdim // FIXME: SEHTryStmt 215288943Sdim // FIXME: SEHLeaveStmt 216288943Sdim // FIXME: CapturedStmt 217288943Sdim Stmt *VisitCXXCatchStmt(CXXCatchStmt *S); 218288943Sdim Stmt *VisitCXXTryStmt(CXXTryStmt *S); 219288943Sdim Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S); 220288943Sdim // FIXME: MSDependentExistsStmt 221288943Sdim Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S); 222288943Sdim Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S); 223288943Sdim Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S); 224288943Sdim Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S); 225288943Sdim Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S); 226288943Sdim Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S); 227288943Sdim Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S); 228203955Srdivacky 229203955Srdivacky // Importing expressions 230203955Srdivacky Expr *VisitExpr(Expr *E); 231309124Sdim Expr *VisitVAArgExpr(VAArgExpr *E); 232309124Sdim Expr *VisitGNUNullExpr(GNUNullExpr *E); 233309124Sdim Expr *VisitPredefinedExpr(PredefinedExpr *E); 234204643Srdivacky Expr *VisitDeclRefExpr(DeclRefExpr *E); 235309124Sdim Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE); 236309124Sdim Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E); 237309124Sdim Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); 238203955Srdivacky Expr *VisitIntegerLiteral(IntegerLiteral *E); 239309124Sdim Expr *VisitFloatingLiteral(FloatingLiteral *E); 240204643Srdivacky Expr *VisitCharacterLiteral(CharacterLiteral *E); 241309124Sdim Expr *VisitStringLiteral(StringLiteral *E); 242309124Sdim Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 243309124Sdim Expr *VisitAtomicExpr(AtomicExpr *E); 244309124Sdim Expr *VisitAddrLabelExpr(AddrLabelExpr *E); 245204643Srdivacky Expr *VisitParenExpr(ParenExpr *E); 246309124Sdim Expr *VisitParenListExpr(ParenListExpr *E); 247309124Sdim Expr *VisitStmtExpr(StmtExpr *E); 248204643Srdivacky Expr *VisitUnaryOperator(UnaryOperator *E); 249221345Sdim Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 250204643Srdivacky Expr *VisitBinaryOperator(BinaryOperator *E); 251309124Sdim Expr *VisitConditionalOperator(ConditionalOperator *E); 252309124Sdim Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E); 253309124Sdim Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E); 254314564Sdim Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 255314564Sdim Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E); 256314564Sdim Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 257204643Srdivacky Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E); 258203955Srdivacky Expr *VisitImplicitCastExpr(ImplicitCastExpr *E); 259314564Sdim Expr *VisitExplicitCastExpr(ExplicitCastExpr *E); 260314564Sdim Expr *VisitOffsetOfExpr(OffsetOfExpr *OE); 261314564Sdim Expr *VisitCXXThrowExpr(CXXThrowExpr *E); 262314564Sdim Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E); 263314564Sdim Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E); 264314564Sdim Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 265314564Sdim Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 266314564Sdim Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE); 267314564Sdim Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 268314564Sdim Expr *VisitCXXNewExpr(CXXNewExpr *CE); 269314564Sdim Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E); 270288943Sdim Expr *VisitCXXConstructExpr(CXXConstructExpr *E); 271309124Sdim Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E); 272314564Sdim Expr *VisitExprWithCleanups(ExprWithCleanups *EWC); 273309124Sdim Expr *VisitCXXThisExpr(CXXThisExpr *E); 274309124Sdim Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); 275288943Sdim Expr *VisitMemberExpr(MemberExpr *E); 276288943Sdim Expr *VisitCallExpr(CallExpr *E); 277309124Sdim Expr *VisitInitListExpr(InitListExpr *E); 278314564Sdim Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E); 279314564Sdim Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E); 280309124Sdim Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E); 281309124Sdim Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E); 282321369Sdim Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E); 283309124Sdim 284321369Sdim 285309124Sdim template<typename IIter, typename OIter> 286309124Sdim void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) { 287309124Sdim typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT; 288309124Sdim ASTImporter &ImporterRef = Importer; 289309124Sdim std::transform(Ibegin, Iend, Obegin, 290309124Sdim [&ImporterRef](ItemT From) -> ItemT { 291309124Sdim return ImporterRef.Import(From); 292309124Sdim }); 293309124Sdim } 294309124Sdim 295309124Sdim template<typename IIter, typename OIter> 296309124Sdim bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) { 297309124Sdim typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT; 298309124Sdim ASTImporter &ImporterRef = Importer; 299309124Sdim bool Failed = false; 300309124Sdim std::transform(Ibegin, Iend, Obegin, 301309124Sdim [&ImporterRef, &Failed](ItemT *From) -> ItemT * { 302314564Sdim ItemT *To = cast_or_null<ItemT>( 303314564Sdim ImporterRef.Import(From)); 304309124Sdim if (!To && From) 305309124Sdim Failed = true; 306309124Sdim return To; 307309124Sdim }); 308309124Sdim return Failed; 309309124Sdim } 310314564Sdim 311314564Sdim template<typename InContainerTy, typename OutContainerTy> 312314564Sdim bool ImportContainerChecked(const InContainerTy &InContainer, 313314564Sdim OutContainerTy &OutContainer) { 314314564Sdim return ImportArrayChecked(InContainer.begin(), InContainer.end(), 315314564Sdim OutContainer.begin()); 316314564Sdim } 317314564Sdim 318314564Sdim template<typename InContainerTy, typename OIter> 319314564Sdim bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) { 320314564Sdim return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin); 321314564Sdim } 322309124Sdim 323321369Sdim // Importing overrides. 324321369Sdim void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod); 325203955Srdivacky }; 326203955Srdivacky} 327203955Srdivacky 328203955Srdivacky//---------------------------------------------------------------------------- 329203955Srdivacky// Import Types 330203955Srdivacky//---------------------------------------------------------------------------- 331203955Srdivacky 332321369Sdimusing namespace clang; 333321369Sdim 334218893SdimQualType ASTNodeImporter::VisitType(const Type *T) { 335203955Srdivacky Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node) 336203955Srdivacky << T->getTypeClassName(); 337203955Srdivacky return QualType(); 338203955Srdivacky} 339203955Srdivacky 340314564SdimQualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){ 341314564Sdim QualType UnderlyingType = Importer.Import(T->getValueType()); 342314564Sdim if(UnderlyingType.isNull()) 343314564Sdim return QualType(); 344314564Sdim 345314564Sdim return Importer.getToContext().getAtomicType(UnderlyingType); 346314564Sdim} 347314564Sdim 348218893SdimQualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) { 349203955Srdivacky switch (T->getKind()) { 350309124Sdim#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 351309124Sdim case BuiltinType::Id: \ 352309124Sdim return Importer.getToContext().SingletonId; 353309124Sdim#include "clang/Basic/OpenCLImageTypes.def" 354234353Sdim#define SHARED_SINGLETON_TYPE(Expansion) 355234353Sdim#define BUILTIN_TYPE(Id, SingletonId) \ 356234353Sdim case BuiltinType::Id: return Importer.getToContext().SingletonId; 357234353Sdim#include "clang/AST/BuiltinTypes.def" 358234353Sdim 359234353Sdim // FIXME: for Char16, Char32, and NullPtr, make sure that the "to" 360234353Sdim // context supports C++. 361234353Sdim 362234353Sdim // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to" 363234353Sdim // context supports ObjC. 364234353Sdim 365203955Srdivacky case BuiltinType::Char_U: 366203955Srdivacky // The context we're importing from has an unsigned 'char'. If we're 367203955Srdivacky // importing into a context with a signed 'char', translate to 368203955Srdivacky // 'unsigned char' instead. 369234353Sdim if (Importer.getToContext().getLangOpts().CharIsSigned) 370203955Srdivacky return Importer.getToContext().UnsignedCharTy; 371203955Srdivacky 372203955Srdivacky return Importer.getToContext().CharTy; 373203955Srdivacky 374203955Srdivacky case BuiltinType::Char_S: 375203955Srdivacky // The context we're importing from has an unsigned 'char'. If we're 376203955Srdivacky // importing into a context with a signed 'char', translate to 377203955Srdivacky // 'unsigned char' instead. 378234353Sdim if (!Importer.getToContext().getLangOpts().CharIsSigned) 379203955Srdivacky return Importer.getToContext().SignedCharTy; 380203955Srdivacky 381203955Srdivacky return Importer.getToContext().CharTy; 382203955Srdivacky 383218893Sdim case BuiltinType::WChar_S: 384218893Sdim case BuiltinType::WChar_U: 385203955Srdivacky // FIXME: If not in C++, shall we translate to the C equivalent of 386203955Srdivacky // wchar_t? 387203955Srdivacky return Importer.getToContext().WCharTy; 388234353Sdim } 389203955Srdivacky 390234353Sdim llvm_unreachable("Invalid BuiltinType Kind!"); 391203955Srdivacky} 392203955Srdivacky 393314564SdimQualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) { 394314564Sdim QualType OrigT = Importer.Import(T->getOriginalType()); 395314564Sdim if (OrigT.isNull()) 396314564Sdim return QualType(); 397314564Sdim 398314564Sdim return Importer.getToContext().getDecayedType(OrigT); 399314564Sdim} 400314564Sdim 401218893SdimQualType ASTNodeImporter::VisitComplexType(const ComplexType *T) { 402203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 403203955Srdivacky if (ToElementType.isNull()) 404203955Srdivacky return QualType(); 405203955Srdivacky 406203955Srdivacky return Importer.getToContext().getComplexType(ToElementType); 407203955Srdivacky} 408203955Srdivacky 409218893SdimQualType ASTNodeImporter::VisitPointerType(const PointerType *T) { 410203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 411203955Srdivacky if (ToPointeeType.isNull()) 412203955Srdivacky return QualType(); 413203955Srdivacky 414203955Srdivacky return Importer.getToContext().getPointerType(ToPointeeType); 415203955Srdivacky} 416203955Srdivacky 417218893SdimQualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) { 418203955Srdivacky // FIXME: Check for blocks support in "to" context. 419203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 420203955Srdivacky if (ToPointeeType.isNull()) 421203955Srdivacky return QualType(); 422203955Srdivacky 423203955Srdivacky return Importer.getToContext().getBlockPointerType(ToPointeeType); 424203955Srdivacky} 425203955Srdivacky 426218893SdimQualType 427218893SdimASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) { 428203955Srdivacky // FIXME: Check for C++ support in "to" context. 429203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 430203955Srdivacky if (ToPointeeType.isNull()) 431203955Srdivacky return QualType(); 432203955Srdivacky 433203955Srdivacky return Importer.getToContext().getLValueReferenceType(ToPointeeType); 434203955Srdivacky} 435203955Srdivacky 436218893SdimQualType 437218893SdimASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) { 438203955Srdivacky // FIXME: Check for C++0x support in "to" context. 439203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 440203955Srdivacky if (ToPointeeType.isNull()) 441203955Srdivacky return QualType(); 442203955Srdivacky 443203955Srdivacky return Importer.getToContext().getRValueReferenceType(ToPointeeType); 444203955Srdivacky} 445203955Srdivacky 446218893SdimQualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) { 447203955Srdivacky // FIXME: Check for C++ support in "to" context. 448203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 449203955Srdivacky if (ToPointeeType.isNull()) 450203955Srdivacky return QualType(); 451203955Srdivacky 452203955Srdivacky QualType ClassType = Importer.Import(QualType(T->getClass(), 0)); 453203955Srdivacky return Importer.getToContext().getMemberPointerType(ToPointeeType, 454203955Srdivacky ClassType.getTypePtr()); 455203955Srdivacky} 456203955Srdivacky 457218893SdimQualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) { 458203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 459203955Srdivacky if (ToElementType.isNull()) 460203955Srdivacky return QualType(); 461203955Srdivacky 462203955Srdivacky return Importer.getToContext().getConstantArrayType(ToElementType, 463203955Srdivacky T->getSize(), 464203955Srdivacky T->getSizeModifier(), 465203955Srdivacky T->getIndexTypeCVRQualifiers()); 466203955Srdivacky} 467203955Srdivacky 468218893SdimQualType 469218893SdimASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 470203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 471203955Srdivacky if (ToElementType.isNull()) 472203955Srdivacky return QualType(); 473203955Srdivacky 474203955Srdivacky return Importer.getToContext().getIncompleteArrayType(ToElementType, 475203955Srdivacky T->getSizeModifier(), 476203955Srdivacky T->getIndexTypeCVRQualifiers()); 477203955Srdivacky} 478203955Srdivacky 479218893SdimQualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) { 480203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 481203955Srdivacky if (ToElementType.isNull()) 482203955Srdivacky return QualType(); 483203955Srdivacky 484203955Srdivacky Expr *Size = Importer.Import(T->getSizeExpr()); 485203955Srdivacky if (!Size) 486203955Srdivacky return QualType(); 487203955Srdivacky 488203955Srdivacky SourceRange Brackets = Importer.Import(T->getBracketsRange()); 489203955Srdivacky return Importer.getToContext().getVariableArrayType(ToElementType, Size, 490203955Srdivacky T->getSizeModifier(), 491203955Srdivacky T->getIndexTypeCVRQualifiers(), 492203955Srdivacky Brackets); 493203955Srdivacky} 494203955Srdivacky 495218893SdimQualType ASTNodeImporter::VisitVectorType(const VectorType *T) { 496203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 497203955Srdivacky if (ToElementType.isNull()) 498203955Srdivacky return QualType(); 499203955Srdivacky 500203955Srdivacky return Importer.getToContext().getVectorType(ToElementType, 501203955Srdivacky T->getNumElements(), 502218893Sdim T->getVectorKind()); 503203955Srdivacky} 504203955Srdivacky 505218893SdimQualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) { 506203955Srdivacky QualType ToElementType = Importer.Import(T->getElementType()); 507203955Srdivacky if (ToElementType.isNull()) 508203955Srdivacky return QualType(); 509203955Srdivacky 510203955Srdivacky return Importer.getToContext().getExtVectorType(ToElementType, 511203955Srdivacky T->getNumElements()); 512203955Srdivacky} 513203955Srdivacky 514218893SdimQualType 515218893SdimASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 516203955Srdivacky // FIXME: What happens if we're importing a function without a prototype 517203955Srdivacky // into C++? Should we make it variadic? 518276479Sdim QualType ToResultType = Importer.Import(T->getReturnType()); 519203955Srdivacky if (ToResultType.isNull()) 520203955Srdivacky return QualType(); 521206084Srdivacky 522203955Srdivacky return Importer.getToContext().getFunctionNoProtoType(ToResultType, 523206084Srdivacky T->getExtInfo()); 524203955Srdivacky} 525203955Srdivacky 526218893SdimQualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) { 527276479Sdim QualType ToResultType = Importer.Import(T->getReturnType()); 528203955Srdivacky if (ToResultType.isNull()) 529203955Srdivacky return QualType(); 530203955Srdivacky 531203955Srdivacky // Import argument types 532226633Sdim SmallVector<QualType, 4> ArgTypes; 533276479Sdim for (const auto &A : T->param_types()) { 534276479Sdim QualType ArgType = Importer.Import(A); 535203955Srdivacky if (ArgType.isNull()) 536203955Srdivacky return QualType(); 537203955Srdivacky ArgTypes.push_back(ArgType); 538203955Srdivacky } 539203955Srdivacky 540203955Srdivacky // Import exception types 541226633Sdim SmallVector<QualType, 4> ExceptionTypes; 542276479Sdim for (const auto &E : T->exceptions()) { 543276479Sdim QualType ExceptionType = Importer.Import(E); 544203955Srdivacky if (ExceptionType.isNull()) 545203955Srdivacky return QualType(); 546203955Srdivacky ExceptionTypes.push_back(ExceptionType); 547203955Srdivacky } 548218893Sdim 549243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo(); 550243830Sdim FunctionProtoType::ExtProtoInfo ToEPI; 551243830Sdim 552243830Sdim ToEPI.ExtInfo = FromEPI.ExtInfo; 553243830Sdim ToEPI.Variadic = FromEPI.Variadic; 554243830Sdim ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn; 555243830Sdim ToEPI.TypeQuals = FromEPI.TypeQuals; 556243830Sdim ToEPI.RefQualifier = FromEPI.RefQualifier; 557280031Sdim ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type; 558280031Sdim ToEPI.ExceptionSpec.Exceptions = ExceptionTypes; 559280031Sdim ToEPI.ExceptionSpec.NoexceptExpr = 560280031Sdim Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr); 561280031Sdim ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>( 562280031Sdim Importer.Import(FromEPI.ExceptionSpec.SourceDecl)); 563280031Sdim ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>( 564280031Sdim Importer.Import(FromEPI.ExceptionSpec.SourceTemplate)); 565243830Sdim 566249423Sdim return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI); 567203955Srdivacky} 568203955Srdivacky 569226633SdimQualType ASTNodeImporter::VisitParenType(const ParenType *T) { 570226633Sdim QualType ToInnerType = Importer.Import(T->getInnerType()); 571226633Sdim if (ToInnerType.isNull()) 572226633Sdim return QualType(); 573226633Sdim 574226633Sdim return Importer.getToContext().getParenType(ToInnerType); 575226633Sdim} 576226633Sdim 577218893SdimQualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) { 578221345Sdim TypedefNameDecl *ToDecl 579221345Sdim = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl())); 580203955Srdivacky if (!ToDecl) 581203955Srdivacky return QualType(); 582203955Srdivacky 583203955Srdivacky return Importer.getToContext().getTypeDeclType(ToDecl); 584203955Srdivacky} 585203955Srdivacky 586218893SdimQualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) { 587203955Srdivacky Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 588203955Srdivacky if (!ToExpr) 589203955Srdivacky return QualType(); 590203955Srdivacky 591203955Srdivacky return Importer.getToContext().getTypeOfExprType(ToExpr); 592203955Srdivacky} 593203955Srdivacky 594218893SdimQualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) { 595203955Srdivacky QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 596203955Srdivacky if (ToUnderlyingType.isNull()) 597203955Srdivacky return QualType(); 598203955Srdivacky 599203955Srdivacky return Importer.getToContext().getTypeOfType(ToUnderlyingType); 600203955Srdivacky} 601203955Srdivacky 602218893SdimQualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) { 603218893Sdim // FIXME: Make sure that the "to" context supports C++0x! 604203955Srdivacky Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 605203955Srdivacky if (!ToExpr) 606203955Srdivacky return QualType(); 607203955Srdivacky 608234353Sdim QualType UnderlyingType = Importer.Import(T->getUnderlyingType()); 609234353Sdim if (UnderlyingType.isNull()) 610234353Sdim return QualType(); 611234353Sdim 612234353Sdim return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType); 613203955Srdivacky} 614203955Srdivacky 615223017SdimQualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) { 616223017Sdim QualType ToBaseType = Importer.Import(T->getBaseType()); 617223017Sdim QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 618223017Sdim if (ToBaseType.isNull() || ToUnderlyingType.isNull()) 619223017Sdim return QualType(); 620223017Sdim 621223017Sdim return Importer.getToContext().getUnaryTransformType(ToBaseType, 622223017Sdim ToUnderlyingType, 623223017Sdim T->getUTTKind()); 624223017Sdim} 625223017Sdim 626218893SdimQualType ASTNodeImporter::VisitAutoType(const AutoType *T) { 627251662Sdim // FIXME: Make sure that the "to" context supports C++11! 628218893Sdim QualType FromDeduced = T->getDeducedType(); 629218893Sdim QualType ToDeduced; 630218893Sdim if (!FromDeduced.isNull()) { 631218893Sdim ToDeduced = Importer.Import(FromDeduced); 632218893Sdim if (ToDeduced.isNull()) 633218893Sdim return QualType(); 634218893Sdim } 635218893Sdim 636296417Sdim return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(), 637261991Sdim /*IsDependent*/false); 638218893Sdim} 639218893Sdim 640309124SdimQualType ASTNodeImporter::VisitInjectedClassNameType( 641309124Sdim const InjectedClassNameType *T) { 642309124Sdim CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl())); 643309124Sdim if (!D) 644309124Sdim return QualType(); 645309124Sdim 646309124Sdim QualType InjType = Importer.Import(T->getInjectedSpecializationType()); 647309124Sdim if (InjType.isNull()) 648309124Sdim return QualType(); 649309124Sdim 650309124Sdim // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading 651309124Sdim // See comments in InjectedClassNameType definition for details 652309124Sdim // return Importer.getToContext().getInjectedClassNameType(D, InjType); 653309124Sdim enum { 654309124Sdim TypeAlignmentInBits = 4, 655309124Sdim TypeAlignment = 1 << TypeAlignmentInBits 656309124Sdim }; 657309124Sdim 658309124Sdim return QualType(new (Importer.getToContext(), TypeAlignment) 659309124Sdim InjectedClassNameType(D, InjType), 0); 660309124Sdim} 661309124Sdim 662218893SdimQualType ASTNodeImporter::VisitRecordType(const RecordType *T) { 663203955Srdivacky RecordDecl *ToDecl 664203955Srdivacky = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl())); 665203955Srdivacky if (!ToDecl) 666203955Srdivacky return QualType(); 667203955Srdivacky 668203955Srdivacky return Importer.getToContext().getTagDeclType(ToDecl); 669203955Srdivacky} 670203955Srdivacky 671218893SdimQualType ASTNodeImporter::VisitEnumType(const EnumType *T) { 672203955Srdivacky EnumDecl *ToDecl 673203955Srdivacky = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl())); 674203955Srdivacky if (!ToDecl) 675203955Srdivacky return QualType(); 676203955Srdivacky 677203955Srdivacky return Importer.getToContext().getTagDeclType(ToDecl); 678203955Srdivacky} 679203955Srdivacky 680288943SdimQualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) { 681288943Sdim QualType FromModifiedType = T->getModifiedType(); 682288943Sdim QualType FromEquivalentType = T->getEquivalentType(); 683288943Sdim QualType ToModifiedType; 684288943Sdim QualType ToEquivalentType; 685288943Sdim 686288943Sdim if (!FromModifiedType.isNull()) { 687288943Sdim ToModifiedType = Importer.Import(FromModifiedType); 688288943Sdim if (ToModifiedType.isNull()) 689288943Sdim return QualType(); 690288943Sdim } 691288943Sdim if (!FromEquivalentType.isNull()) { 692288943Sdim ToEquivalentType = Importer.Import(FromEquivalentType); 693288943Sdim if (ToEquivalentType.isNull()) 694288943Sdim return QualType(); 695288943Sdim } 696288943Sdim 697288943Sdim return Importer.getToContext().getAttributedType(T->getAttrKind(), 698288943Sdim ToModifiedType, ToEquivalentType); 699288943Sdim} 700288943Sdim 701309124Sdim 702309124SdimQualType ASTNodeImporter::VisitTemplateTypeParmType( 703309124Sdim const TemplateTypeParmType *T) { 704309124Sdim TemplateTypeParmDecl *ParmDecl = 705309124Sdim cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl())); 706309124Sdim if (!ParmDecl && T->getDecl()) 707309124Sdim return QualType(); 708309124Sdim 709309124Sdim return Importer.getToContext().getTemplateTypeParmType( 710309124Sdim T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl); 711309124Sdim} 712309124Sdim 713321369SdimQualType ASTNodeImporter::VisitSubstTemplateTypeParmType( 714321369Sdim const SubstTemplateTypeParmType *T) { 715321369Sdim const TemplateTypeParmType *Replaced = 716321369Sdim cast_or_null<TemplateTypeParmType>(Importer.Import( 717321369Sdim QualType(T->getReplacedParameter(), 0)).getTypePtr()); 718321369Sdim if (!Replaced) 719321369Sdim return QualType(); 720321369Sdim 721321369Sdim QualType Replacement = Importer.Import(T->getReplacementType()); 722321369Sdim if (Replacement.isNull()) 723321369Sdim return QualType(); 724321369Sdim Replacement = Replacement.getCanonicalType(); 725321369Sdim 726321369Sdim return Importer.getToContext().getSubstTemplateTypeParmType( 727321369Sdim Replaced, Replacement); 728321369Sdim} 729321369Sdim 730218893SdimQualType ASTNodeImporter::VisitTemplateSpecializationType( 731218893Sdim const TemplateSpecializationType *T) { 732218893Sdim TemplateName ToTemplate = Importer.Import(T->getTemplateName()); 733218893Sdim if (ToTemplate.isNull()) 734218893Sdim return QualType(); 735218893Sdim 736226633Sdim SmallVector<TemplateArgument, 2> ToTemplateArgs; 737218893Sdim if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs)) 738218893Sdim return QualType(); 739218893Sdim 740218893Sdim QualType ToCanonType; 741218893Sdim if (!QualType(T, 0).isCanonical()) { 742218893Sdim QualType FromCanonType 743218893Sdim = Importer.getFromContext().getCanonicalType(QualType(T, 0)); 744218893Sdim ToCanonType =Importer.Import(FromCanonType); 745218893Sdim if (ToCanonType.isNull()) 746218893Sdim return QualType(); 747218893Sdim } 748218893Sdim return Importer.getToContext().getTemplateSpecializationType(ToTemplate, 749309124Sdim ToTemplateArgs, 750218893Sdim ToCanonType); 751218893Sdim} 752218893Sdim 753218893SdimQualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) { 754276479Sdim NestedNameSpecifier *ToQualifier = nullptr; 755208600Srdivacky // Note: the qualifier in an ElaboratedType is optional. 756208600Srdivacky if (T->getQualifier()) { 757208600Srdivacky ToQualifier = Importer.Import(T->getQualifier()); 758208600Srdivacky if (!ToQualifier) 759208600Srdivacky return QualType(); 760208600Srdivacky } 761203955Srdivacky 762203955Srdivacky QualType ToNamedType = Importer.Import(T->getNamedType()); 763203955Srdivacky if (ToNamedType.isNull()) 764203955Srdivacky return QualType(); 765203955Srdivacky 766208600Srdivacky return Importer.getToContext().getElaboratedType(T->getKeyword(), 767208600Srdivacky ToQualifier, ToNamedType); 768203955Srdivacky} 769203955Srdivacky 770218893SdimQualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 771203955Srdivacky ObjCInterfaceDecl *Class 772203955Srdivacky = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl())); 773203955Srdivacky if (!Class) 774203955Srdivacky return QualType(); 775203955Srdivacky 776208600Srdivacky return Importer.getToContext().getObjCInterfaceType(Class); 777208600Srdivacky} 778208600Srdivacky 779218893SdimQualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) { 780208600Srdivacky QualType ToBaseType = Importer.Import(T->getBaseType()); 781208600Srdivacky if (ToBaseType.isNull()) 782208600Srdivacky return QualType(); 783208600Srdivacky 784288943Sdim SmallVector<QualType, 4> TypeArgs; 785288943Sdim for (auto TypeArg : T->getTypeArgsAsWritten()) { 786288943Sdim QualType ImportedTypeArg = Importer.Import(TypeArg); 787288943Sdim if (ImportedTypeArg.isNull()) 788288943Sdim return QualType(); 789288943Sdim 790288943Sdim TypeArgs.push_back(ImportedTypeArg); 791288943Sdim } 792288943Sdim 793226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 794276479Sdim for (auto *P : T->quals()) { 795203955Srdivacky ObjCProtocolDecl *Protocol 796276479Sdim = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P)); 797203955Srdivacky if (!Protocol) 798203955Srdivacky return QualType(); 799203955Srdivacky Protocols.push_back(Protocol); 800203955Srdivacky } 801203955Srdivacky 802288943Sdim return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs, 803288943Sdim Protocols, 804288943Sdim T->isKindOfTypeAsWritten()); 805203955Srdivacky} 806203955Srdivacky 807218893SdimQualType 808218893SdimASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 809203955Srdivacky QualType ToPointeeType = Importer.Import(T->getPointeeType()); 810203955Srdivacky if (ToPointeeType.isNull()) 811203955Srdivacky return QualType(); 812203955Srdivacky 813208600Srdivacky return Importer.getToContext().getObjCObjectPointerType(ToPointeeType); 814203955Srdivacky} 815203955Srdivacky 816203955Srdivacky//---------------------------------------------------------------------------- 817203955Srdivacky// Import Declarations 818203955Srdivacky//---------------------------------------------------------------------------- 819203955Srdivackybool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC, 820203955Srdivacky DeclContext *&LexicalDC, 821203955Srdivacky DeclarationName &Name, 822288943Sdim NamedDecl *&ToD, 823203955Srdivacky SourceLocation &Loc) { 824203955Srdivacky // Import the context of this declaration. 825203955Srdivacky DC = Importer.ImportContext(D->getDeclContext()); 826203955Srdivacky if (!DC) 827203955Srdivacky return true; 828203955Srdivacky 829203955Srdivacky LexicalDC = DC; 830203955Srdivacky if (D->getDeclContext() != D->getLexicalDeclContext()) { 831203955Srdivacky LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 832203955Srdivacky if (!LexicalDC) 833203955Srdivacky return true; 834203955Srdivacky } 835203955Srdivacky 836203955Srdivacky // Import the name of this declaration. 837203955Srdivacky Name = Importer.Import(D->getDeclName()); 838203955Srdivacky if (D->getDeclName() && !Name) 839203955Srdivacky return true; 840203955Srdivacky 841203955Srdivacky // Import the location of this declaration. 842203955Srdivacky Loc = Importer.Import(D->getLocation()); 843288943Sdim ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D)); 844203955Srdivacky return false; 845203955Srdivacky} 846203955Srdivacky 847226633Sdimvoid ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) { 848226633Sdim if (!FromD) 849226633Sdim return; 850226633Sdim 851226633Sdim if (!ToD) { 852226633Sdim ToD = Importer.Import(FromD); 853226633Sdim if (!ToD) 854226633Sdim return; 855226633Sdim } 856226633Sdim 857226633Sdim if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) { 858226633Sdim if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) { 859249423Sdim if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) { 860226633Sdim ImportDefinition(FromRecord, ToRecord); 861226633Sdim } 862226633Sdim } 863226633Sdim return; 864226633Sdim } 865226633Sdim 866226633Sdim if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) { 867226633Sdim if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) { 868226633Sdim if (FromEnum->getDefinition() && !ToEnum->getDefinition()) { 869226633Sdim ImportDefinition(FromEnum, ToEnum); 870226633Sdim } 871226633Sdim } 872226633Sdim return; 873226633Sdim } 874226633Sdim} 875226633Sdim 876212904Sdimvoid 877212904SdimASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From, 878212904Sdim DeclarationNameInfo& To) { 879212904Sdim // NOTE: To.Name and To.Loc are already imported. 880212904Sdim // We only have to import To.LocInfo. 881212904Sdim switch (To.getName().getNameKind()) { 882212904Sdim case DeclarationName::Identifier: 883212904Sdim case DeclarationName::ObjCZeroArgSelector: 884212904Sdim case DeclarationName::ObjCOneArgSelector: 885212904Sdim case DeclarationName::ObjCMultiArgSelector: 886212904Sdim case DeclarationName::CXXUsingDirective: 887321369Sdim case DeclarationName::CXXDeductionGuideName: 888212904Sdim return; 889212904Sdim 890212904Sdim case DeclarationName::CXXOperatorName: { 891212904Sdim SourceRange Range = From.getCXXOperatorNameRange(); 892212904Sdim To.setCXXOperatorNameRange(Importer.Import(Range)); 893212904Sdim return; 894212904Sdim } 895212904Sdim case DeclarationName::CXXLiteralOperatorName: { 896212904Sdim SourceLocation Loc = From.getCXXLiteralOperatorNameLoc(); 897212904Sdim To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc)); 898212904Sdim return; 899212904Sdim } 900212904Sdim case DeclarationName::CXXConstructorName: 901212904Sdim case DeclarationName::CXXDestructorName: 902212904Sdim case DeclarationName::CXXConversionFunctionName: { 903212904Sdim TypeSourceInfo *FromTInfo = From.getNamedTypeInfo(); 904212904Sdim To.setNamedTypeInfo(Importer.Import(FromTInfo)); 905212904Sdim return; 906212904Sdim } 907212904Sdim } 908234353Sdim llvm_unreachable("Unknown name kind."); 909212904Sdim} 910212904Sdim 911234353Sdimvoid ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) { 912218893Sdim if (Importer.isMinimalImport() && !ForceImport) { 913226633Sdim Importer.ImportContext(FromDC); 914218893Sdim return; 915218893Sdim } 916218893Sdim 917276479Sdim for (auto *From : FromDC->decls()) 918276479Sdim Importer.Import(From); 919204643Srdivacky} 920204643Srdivacky 921226633Sdimbool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To, 922234353Sdim ImportDefinitionKind Kind) { 923234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 924234353Sdim if (Kind == IDK_Everything) 925234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 926234353Sdim 927218893Sdim return false; 928234353Sdim } 929218893Sdim 930218893Sdim To->startDefinition(); 931218893Sdim 932218893Sdim // Add base classes. 933218893Sdim if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) { 934218893Sdim CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From); 935234353Sdim 936234353Sdim struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data(); 937234353Sdim struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data(); 938234353Sdim ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor; 939249423Sdim ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers; 940234353Sdim ToData.Aggregate = FromData.Aggregate; 941234353Sdim ToData.PlainOldData = FromData.PlainOldData; 942234353Sdim ToData.Empty = FromData.Empty; 943234353Sdim ToData.Polymorphic = FromData.Polymorphic; 944234353Sdim ToData.Abstract = FromData.Abstract; 945234353Sdim ToData.IsStandardLayout = FromData.IsStandardLayout; 946234353Sdim ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases; 947234353Sdim ToData.HasPrivateFields = FromData.HasPrivateFields; 948234353Sdim ToData.HasProtectedFields = FromData.HasProtectedFields; 949234353Sdim ToData.HasPublicFields = FromData.HasPublicFields; 950234353Sdim ToData.HasMutableFields = FromData.HasMutableFields; 951276479Sdim ToData.HasVariantMembers = FromData.HasVariantMembers; 952234353Sdim ToData.HasOnlyCMembers = FromData.HasOnlyCMembers; 953239462Sdim ToData.HasInClassInitializer = FromData.HasInClassInitializer; 954249423Sdim ToData.HasUninitializedReferenceMember 955249423Sdim = FromData.HasUninitializedReferenceMember; 956309124Sdim ToData.HasUninitializedFields = FromData.HasUninitializedFields; 957309124Sdim ToData.HasInheritedConstructor = FromData.HasInheritedConstructor; 958309124Sdim ToData.HasInheritedAssignment = FromData.HasInheritedAssignment; 959249423Sdim ToData.NeedOverloadResolutionForMoveConstructor 960249423Sdim = FromData.NeedOverloadResolutionForMoveConstructor; 961249423Sdim ToData.NeedOverloadResolutionForMoveAssignment 962249423Sdim = FromData.NeedOverloadResolutionForMoveAssignment; 963249423Sdim ToData.NeedOverloadResolutionForDestructor 964249423Sdim = FromData.NeedOverloadResolutionForDestructor; 965249423Sdim ToData.DefaultedMoveConstructorIsDeleted 966249423Sdim = FromData.DefaultedMoveConstructorIsDeleted; 967249423Sdim ToData.DefaultedMoveAssignmentIsDeleted 968249423Sdim = FromData.DefaultedMoveAssignmentIsDeleted; 969249423Sdim ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted; 970249423Sdim ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers; 971249423Sdim ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor; 972234353Sdim ToData.HasConstexprNonCopyMoveConstructor 973234353Sdim = FromData.HasConstexprNonCopyMoveConstructor; 974309124Sdim ToData.HasDefaultedDefaultConstructor 975309124Sdim = FromData.HasDefaultedDefaultConstructor; 976234353Sdim ToData.DefaultedDefaultConstructorIsConstexpr 977234353Sdim = FromData.DefaultedDefaultConstructorIsConstexpr; 978234353Sdim ToData.HasConstexprDefaultConstructor 979234353Sdim = FromData.HasConstexprDefaultConstructor; 980234353Sdim ToData.HasNonLiteralTypeFieldsOrBases 981234353Sdim = FromData.HasNonLiteralTypeFieldsOrBases; 982234353Sdim // ComputedVisibleConversions not imported. 983234353Sdim ToData.UserProvidedDefaultConstructor 984234353Sdim = FromData.UserProvidedDefaultConstructor; 985249423Sdim ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers; 986321369Sdim ToData.ImplicitCopyConstructorCanHaveConstParamForVBase 987321369Sdim = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase; 988321369Sdim ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase 989321369Sdim = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase; 990249423Sdim ToData.ImplicitCopyAssignmentHasConstParam 991249423Sdim = FromData.ImplicitCopyAssignmentHasConstParam; 992249423Sdim ToData.HasDeclaredCopyConstructorWithConstParam 993249423Sdim = FromData.HasDeclaredCopyConstructorWithConstParam; 994249423Sdim ToData.HasDeclaredCopyAssignmentWithConstParam 995249423Sdim = FromData.HasDeclaredCopyAssignmentWithConstParam; 996234353Sdim ToData.IsLambda = FromData.IsLambda; 997234353Sdim 998226633Sdim SmallVector<CXXBaseSpecifier *, 4> Bases; 999276479Sdim for (const auto &Base1 : FromCXX->bases()) { 1000276479Sdim QualType T = Importer.Import(Base1.getType()); 1001218893Sdim if (T.isNull()) 1002218893Sdim return true; 1003218893Sdim 1004218893Sdim SourceLocation EllipsisLoc; 1005276479Sdim if (Base1.isPackExpansion()) 1006276479Sdim EllipsisLoc = Importer.Import(Base1.getEllipsisLoc()); 1007226633Sdim 1008226633Sdim // Ensure that we have a definition for the base. 1009276479Sdim ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()); 1010226633Sdim 1011218893Sdim Bases.push_back( 1012218893Sdim new (Importer.getToContext()) 1013276479Sdim CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()), 1014276479Sdim Base1.isVirtual(), 1015276479Sdim Base1.isBaseOfClass(), 1016276479Sdim Base1.getAccessSpecifierAsWritten(), 1017276479Sdim Importer.Import(Base1.getTypeSourceInfo()), 1018218893Sdim EllipsisLoc)); 1019218893Sdim } 1020218893Sdim if (!Bases.empty()) 1021218893Sdim ToCXX->setBases(Bases.data(), Bases.size()); 1022218893Sdim } 1023218893Sdim 1024234353Sdim if (shouldForceImportDeclContext(Kind)) 1025234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 1026234353Sdim 1027218893Sdim To->completeDefinition(); 1028218893Sdim return false; 1029218893Sdim} 1030218893Sdim 1031261991Sdimbool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To, 1032261991Sdim ImportDefinitionKind Kind) { 1033288943Sdim if (To->getAnyInitializer()) 1034261991Sdim return false; 1035261991Sdim 1036261991Sdim // FIXME: Can we really import any initializer? Alternatively, we could force 1037261991Sdim // ourselves to import every declaration of a variable and then only use 1038261991Sdim // getInit() here. 1039261991Sdim To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer()))); 1040261991Sdim 1041261991Sdim // FIXME: Other bits to merge? 1042261991Sdim 1043261991Sdim return false; 1044261991Sdim} 1045261991Sdim 1046226633Sdimbool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To, 1047234353Sdim ImportDefinitionKind Kind) { 1048234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 1049234353Sdim if (Kind == IDK_Everything) 1050234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 1051226633Sdim return false; 1052234353Sdim } 1053226633Sdim 1054226633Sdim To->startDefinition(); 1055226633Sdim 1056226633Sdim QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From)); 1057226633Sdim if (T.isNull()) 1058226633Sdim return true; 1059226633Sdim 1060226633Sdim QualType ToPromotionType = Importer.Import(From->getPromotionType()); 1061226633Sdim if (ToPromotionType.isNull()) 1062226633Sdim return true; 1063234353Sdim 1064234353Sdim if (shouldForceImportDeclContext(Kind)) 1065234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 1066226633Sdim 1067226633Sdim // FIXME: we might need to merge the number of positive or negative bits 1068226633Sdim // if the enumerator lists don't match. 1069226633Sdim To->completeDefinition(T, ToPromotionType, 1070226633Sdim From->getNumPositiveBits(), 1071226633Sdim From->getNumNegativeBits()); 1072226633Sdim return false; 1073226633Sdim} 1074226633Sdim 1075218893SdimTemplateParameterList *ASTNodeImporter::ImportTemplateParameterList( 1076218893Sdim TemplateParameterList *Params) { 1077314564Sdim SmallVector<NamedDecl *, 4> ToParams(Params->size()); 1078314564Sdim if (ImportContainerChecked(*Params, ToParams)) 1079314564Sdim return nullptr; 1080314564Sdim 1081314564Sdim Expr *ToRequiresClause; 1082314564Sdim if (Expr *const R = Params->getRequiresClause()) { 1083314564Sdim ToRequiresClause = Importer.Import(R); 1084314564Sdim if (!ToRequiresClause) 1085276479Sdim return nullptr; 1086314564Sdim } else { 1087314564Sdim ToRequiresClause = nullptr; 1088314564Sdim } 1089276479Sdim 1090218893Sdim return TemplateParameterList::Create(Importer.getToContext(), 1091218893Sdim Importer.Import(Params->getTemplateLoc()), 1092218893Sdim Importer.Import(Params->getLAngleLoc()), 1093296417Sdim ToParams, 1094314564Sdim Importer.Import(Params->getRAngleLoc()), 1095314564Sdim ToRequiresClause); 1096218893Sdim} 1097218893Sdim 1098218893SdimTemplateArgument 1099218893SdimASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) { 1100218893Sdim switch (From.getKind()) { 1101218893Sdim case TemplateArgument::Null: 1102218893Sdim return TemplateArgument(); 1103218893Sdim 1104218893Sdim case TemplateArgument::Type: { 1105218893Sdim QualType ToType = Importer.Import(From.getAsType()); 1106218893Sdim if (ToType.isNull()) 1107218893Sdim return TemplateArgument(); 1108218893Sdim return TemplateArgument(ToType); 1109218893Sdim } 1110218893Sdim 1111218893Sdim case TemplateArgument::Integral: { 1112218893Sdim QualType ToType = Importer.Import(From.getIntegralType()); 1113218893Sdim if (ToType.isNull()) 1114218893Sdim return TemplateArgument(); 1115239462Sdim return TemplateArgument(From, ToType); 1116218893Sdim } 1117218893Sdim 1118243830Sdim case TemplateArgument::Declaration: { 1119280031Sdim ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl())); 1120280031Sdim QualType ToType = Importer.Import(From.getParamTypeForDecl()); 1121280031Sdim if (!To || ToType.isNull()) 1122280031Sdim return TemplateArgument(); 1123280031Sdim return TemplateArgument(To, ToType); 1124243830Sdim } 1125243830Sdim 1126243830Sdim case TemplateArgument::NullPtr: { 1127243830Sdim QualType ToType = Importer.Import(From.getNullPtrType()); 1128243830Sdim if (ToType.isNull()) 1129243830Sdim return TemplateArgument(); 1130243830Sdim return TemplateArgument(ToType, /*isNullPtr*/true); 1131243830Sdim } 1132243830Sdim 1133218893Sdim case TemplateArgument::Template: { 1134218893Sdim TemplateName ToTemplate = Importer.Import(From.getAsTemplate()); 1135218893Sdim if (ToTemplate.isNull()) 1136218893Sdim return TemplateArgument(); 1137218893Sdim 1138218893Sdim return TemplateArgument(ToTemplate); 1139218893Sdim } 1140218893Sdim 1141218893Sdim case TemplateArgument::TemplateExpansion: { 1142218893Sdim TemplateName ToTemplate 1143218893Sdim = Importer.Import(From.getAsTemplateOrTemplatePattern()); 1144218893Sdim if (ToTemplate.isNull()) 1145218893Sdim return TemplateArgument(); 1146218893Sdim 1147218893Sdim return TemplateArgument(ToTemplate, From.getNumTemplateExpansions()); 1148218893Sdim } 1149218893Sdim 1150218893Sdim case TemplateArgument::Expression: 1151218893Sdim if (Expr *ToExpr = Importer.Import(From.getAsExpr())) 1152218893Sdim return TemplateArgument(ToExpr); 1153218893Sdim return TemplateArgument(); 1154218893Sdim 1155218893Sdim case TemplateArgument::Pack: { 1156226633Sdim SmallVector<TemplateArgument, 2> ToPack; 1157218893Sdim ToPack.reserve(From.pack_size()); 1158218893Sdim if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack)) 1159218893Sdim return TemplateArgument(); 1160296417Sdim 1161296417Sdim return TemplateArgument( 1162296417Sdim llvm::makeArrayRef(ToPack).copy(Importer.getToContext())); 1163218893Sdim } 1164218893Sdim } 1165218893Sdim 1166218893Sdim llvm_unreachable("Invalid template argument kind"); 1167218893Sdim} 1168218893Sdim 1169314564SdimTemplateArgumentLoc ASTNodeImporter::ImportTemplateArgumentLoc( 1170314564Sdim const TemplateArgumentLoc &TALoc, bool &Error) { 1171314564Sdim Error = false; 1172314564Sdim TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument()); 1173314564Sdim TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo(); 1174314564Sdim TemplateArgumentLocInfo ToInfo; 1175314564Sdim if (Arg.getKind() == TemplateArgument::Expression) { 1176314564Sdim Expr *E = Importer.Import(FromInfo.getAsExpr()); 1177314564Sdim ToInfo = TemplateArgumentLocInfo(E); 1178314564Sdim if (!E) 1179314564Sdim Error = true; 1180314564Sdim } else if (Arg.getKind() == TemplateArgument::Type) { 1181314564Sdim if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo())) 1182314564Sdim ToInfo = TemplateArgumentLocInfo(TSI); 1183314564Sdim else 1184314564Sdim Error = true; 1185314564Sdim } else { 1186314564Sdim ToInfo = TemplateArgumentLocInfo( 1187314564Sdim Importer.Import(FromInfo.getTemplateQualifierLoc()), 1188314564Sdim Importer.Import(FromInfo.getTemplateNameLoc()), 1189314564Sdim Importer.Import(FromInfo.getTemplateEllipsisLoc())); 1190314564Sdim } 1191314564Sdim return TemplateArgumentLoc(Arg, ToInfo); 1192314564Sdim} 1193314564Sdim 1194218893Sdimbool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs, 1195218893Sdim unsigned NumFromArgs, 1196226633Sdim SmallVectorImpl<TemplateArgument> &ToArgs) { 1197218893Sdim for (unsigned I = 0; I != NumFromArgs; ++I) { 1198218893Sdim TemplateArgument To = ImportTemplateArgument(FromArgs[I]); 1199218893Sdim if (To.isNull() && !FromArgs[I].isNull()) 1200218893Sdim return true; 1201218893Sdim 1202218893Sdim ToArgs.push_back(To); 1203218893Sdim } 1204218893Sdim 1205218893Sdim return false; 1206218893Sdim} 1207218893Sdim 1208203955Srdivackybool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord, 1209239462Sdim RecordDecl *ToRecord, bool Complain) { 1210261991Sdim // Eliminate a potential failure point where we attempt to re-import 1211261991Sdim // something we're trying to import while completing ToRecord. 1212261991Sdim Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord); 1213261991Sdim if (ToOrigin) { 1214261991Sdim RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin); 1215261991Sdim if (ToOriginRecord) 1216261991Sdim ToRecord = ToOriginRecord; 1217261991Sdim } 1218261991Sdim 1219204643Srdivacky StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1220261991Sdim ToRecord->getASTContext(), 1221239462Sdim Importer.getNonEquivalentDecls(), 1222239462Sdim false, Complain); 1223204643Srdivacky return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord); 1224203955Srdivacky} 1225203955Srdivacky 1226261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 1227261991Sdim bool Complain) { 1228261991Sdim StructuralEquivalenceContext Ctx( 1229261991Sdim Importer.getFromContext(), Importer.getToContext(), 1230261991Sdim Importer.getNonEquivalentDecls(), false, Complain); 1231261991Sdim return Ctx.IsStructurallyEquivalent(FromVar, ToVar); 1232261991Sdim} 1233261991Sdim 1234203955Srdivackybool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) { 1235204643Srdivacky StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1236203955Srdivacky Importer.getToContext(), 1237203955Srdivacky Importer.getNonEquivalentDecls()); 1238204643Srdivacky return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum); 1239203955Srdivacky} 1240203955Srdivacky 1241249423Sdimbool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC, 1242249423Sdim EnumConstantDecl *ToEC) 1243249423Sdim{ 1244249423Sdim const llvm::APSInt &FromVal = FromEC->getInitVal(); 1245249423Sdim const llvm::APSInt &ToVal = ToEC->getInitVal(); 1246249423Sdim 1247249423Sdim return FromVal.isSigned() == ToVal.isSigned() && 1248249423Sdim FromVal.getBitWidth() == ToVal.getBitWidth() && 1249249423Sdim FromVal == ToVal; 1250249423Sdim} 1251249423Sdim 1252249423Sdimbool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From, 1253218893Sdim ClassTemplateDecl *To) { 1254218893Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1255218893Sdim Importer.getToContext(), 1256218893Sdim Importer.getNonEquivalentDecls()); 1257321369Sdim return Ctx.IsStructurallyEquivalent(From, To); 1258218893Sdim} 1259218893Sdim 1260261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From, 1261261991Sdim VarTemplateDecl *To) { 1262261991Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1263261991Sdim Importer.getToContext(), 1264261991Sdim Importer.getNonEquivalentDecls()); 1265261991Sdim return Ctx.IsStructurallyEquivalent(From, To); 1266261991Sdim} 1267261991Sdim 1268203955SrdivackyDecl *ASTNodeImporter::VisitDecl(Decl *D) { 1269203955Srdivacky Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 1270203955Srdivacky << D->getDeclKindName(); 1271276479Sdim return nullptr; 1272203955Srdivacky} 1273203955Srdivacky 1274234353SdimDecl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 1275234353Sdim TranslationUnitDecl *ToD = 1276234353Sdim Importer.getToContext().getTranslationUnitDecl(); 1277234353Sdim 1278234353Sdim Importer.Imported(D, ToD); 1279234353Sdim 1280234353Sdim return ToD; 1281234353Sdim} 1282234353Sdim 1283309124SdimDecl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) { 1284309124Sdim 1285309124Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 1286309124Sdim SourceLocation ColonLoc = Importer.Import(D->getColonLoc()); 1287309124Sdim 1288309124Sdim // Import the context of this declaration. 1289309124Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1290309124Sdim if (!DC) 1291309124Sdim return nullptr; 1292309124Sdim 1293309124Sdim AccessSpecDecl *accessSpecDecl 1294309124Sdim = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(), 1295309124Sdim DC, Loc, ColonLoc); 1296309124Sdim 1297309124Sdim if (!accessSpecDecl) 1298309124Sdim return nullptr; 1299309124Sdim 1300309124Sdim // Lexical DeclContext and Semantic DeclContext 1301309124Sdim // is always the same for the accessSpec. 1302309124Sdim accessSpecDecl->setLexicalDeclContext(DC); 1303309124Sdim DC->addDeclInternal(accessSpecDecl); 1304309124Sdim 1305309124Sdim return accessSpecDecl; 1306309124Sdim} 1307309124Sdim 1308314564SdimDecl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) { 1309314564Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1310314564Sdim if (!DC) 1311314564Sdim return nullptr; 1312314564Sdim 1313314564Sdim DeclContext *LexicalDC = DC; 1314314564Sdim 1315314564Sdim // Import the location of this declaration. 1316314564Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 1317314564Sdim 1318314564Sdim Expr *AssertExpr = Importer.Import(D->getAssertExpr()); 1319314564Sdim if (!AssertExpr) 1320314564Sdim return nullptr; 1321314564Sdim 1322314564Sdim StringLiteral *FromMsg = D->getMessage(); 1323314564Sdim StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg)); 1324314564Sdim if (!ToMsg && FromMsg) 1325314564Sdim return nullptr; 1326314564Sdim 1327314564Sdim StaticAssertDecl *ToD = StaticAssertDecl::Create( 1328314564Sdim Importer.getToContext(), DC, Loc, AssertExpr, ToMsg, 1329314564Sdim Importer.Import(D->getRParenLoc()), D->isFailed()); 1330314564Sdim 1331314564Sdim ToD->setLexicalDeclContext(LexicalDC); 1332314564Sdim LexicalDC->addDeclInternal(ToD); 1333314564Sdim Importer.Imported(D, ToD); 1334314564Sdim return ToD; 1335314564Sdim} 1336314564Sdim 1337204643SrdivackyDecl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) { 1338204643Srdivacky // Import the major distinguishing characteristics of this namespace. 1339204643Srdivacky DeclContext *DC, *LexicalDC; 1340204643Srdivacky DeclarationName Name; 1341204643Srdivacky SourceLocation Loc; 1342288943Sdim NamedDecl *ToD; 1343288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1344276479Sdim return nullptr; 1345288943Sdim if (ToD) 1346288943Sdim return ToD; 1347276479Sdim 1348276479Sdim NamespaceDecl *MergeWithNamespace = nullptr; 1349204643Srdivacky if (!Name) { 1350204643Srdivacky // This is an anonymous namespace. Adopt an existing anonymous 1351204643Srdivacky // namespace if we can. 1352204643Srdivacky // FIXME: Not testable. 1353204643Srdivacky if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC)) 1354204643Srdivacky MergeWithNamespace = TU->getAnonymousNamespace(); 1355204643Srdivacky else 1356204643Srdivacky MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace(); 1357204643Srdivacky } else { 1358226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1359249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1360280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1361226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1362226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace)) 1363204643Srdivacky continue; 1364204643Srdivacky 1365226633Sdim if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) { 1366204643Srdivacky MergeWithNamespace = FoundNS; 1367204643Srdivacky ConflictingDecls.clear(); 1368204643Srdivacky break; 1369204643Srdivacky } 1370204643Srdivacky 1371226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1372204643Srdivacky } 1373204643Srdivacky 1374204643Srdivacky if (!ConflictingDecls.empty()) { 1375207619Srdivacky Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace, 1376204643Srdivacky ConflictingDecls.data(), 1377204643Srdivacky ConflictingDecls.size()); 1378204643Srdivacky } 1379204643Srdivacky } 1380204643Srdivacky 1381204643Srdivacky // Create the "to" namespace, if needed. 1382204643Srdivacky NamespaceDecl *ToNamespace = MergeWithNamespace; 1383204643Srdivacky if (!ToNamespace) { 1384221345Sdim ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC, 1385234353Sdim D->isInline(), 1386221345Sdim Importer.Import(D->getLocStart()), 1387234353Sdim Loc, Name.getAsIdentifierInfo(), 1388276479Sdim /*PrevDecl=*/nullptr); 1389204643Srdivacky ToNamespace->setLexicalDeclContext(LexicalDC); 1390234353Sdim LexicalDC->addDeclInternal(ToNamespace); 1391204643Srdivacky 1392204643Srdivacky // If this is an anonymous namespace, register it as the anonymous 1393204643Srdivacky // namespace within its context. 1394204643Srdivacky if (!Name) { 1395204643Srdivacky if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC)) 1396204643Srdivacky TU->setAnonymousNamespace(ToNamespace); 1397204643Srdivacky else 1398204643Srdivacky cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace); 1399204643Srdivacky } 1400204643Srdivacky } 1401204643Srdivacky Importer.Imported(D, ToNamespace); 1402204643Srdivacky 1403204643Srdivacky ImportDeclContext(D); 1404204643Srdivacky 1405204643Srdivacky return ToNamespace; 1406204643Srdivacky} 1407204643Srdivacky 1408221345SdimDecl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) { 1409203955Srdivacky // Import the major distinguishing characteristics of this typedef. 1410203955Srdivacky DeclContext *DC, *LexicalDC; 1411203955Srdivacky DeclarationName Name; 1412203955Srdivacky SourceLocation Loc; 1413288943Sdim NamedDecl *ToD; 1414288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1415276479Sdim return nullptr; 1416288943Sdim if (ToD) 1417288943Sdim return ToD; 1418276479Sdim 1419203955Srdivacky // If this typedef is not in block scope, determine whether we've 1420203955Srdivacky // seen a typedef with the same name (that we can merge with) or any 1421203955Srdivacky // other entity by that name (which name lookup could conflict with). 1422203955Srdivacky if (!DC->isFunctionOrMethod()) { 1423226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1424203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 1425249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1426280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1427226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1428226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1429203955Srdivacky continue; 1430221345Sdim if (TypedefNameDecl *FoundTypedef = 1431226633Sdim dyn_cast<TypedefNameDecl>(FoundDecls[I])) { 1432203955Srdivacky if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(), 1433203955Srdivacky FoundTypedef->getUnderlyingType())) 1434203955Srdivacky return Importer.Imported(D, FoundTypedef); 1435203955Srdivacky } 1436321369Sdim 1437226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1438203955Srdivacky } 1439321369Sdim 1440203955Srdivacky if (!ConflictingDecls.empty()) { 1441203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1442203955Srdivacky ConflictingDecls.data(), 1443203955Srdivacky ConflictingDecls.size()); 1444203955Srdivacky if (!Name) 1445276479Sdim return nullptr; 1446203955Srdivacky } 1447203955Srdivacky } 1448321369Sdim 1449203955Srdivacky // Import the underlying type of this typedef; 1450203955Srdivacky QualType T = Importer.Import(D->getUnderlyingType()); 1451203955Srdivacky if (T.isNull()) 1452276479Sdim return nullptr; 1453276479Sdim 1454203955Srdivacky // Create the new typedef node. 1455203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 1456221345Sdim SourceLocation StartL = Importer.Import(D->getLocStart()); 1457221345Sdim TypedefNameDecl *ToTypedef; 1458221345Sdim if (IsAlias) 1459226633Sdim ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC, 1460226633Sdim StartL, Loc, 1461226633Sdim Name.getAsIdentifierInfo(), 1462226633Sdim TInfo); 1463226633Sdim else 1464221345Sdim ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC, 1465221345Sdim StartL, Loc, 1466221345Sdim Name.getAsIdentifierInfo(), 1467221345Sdim TInfo); 1468321369Sdim 1469204643Srdivacky ToTypedef->setAccess(D->getAccess()); 1470203955Srdivacky ToTypedef->setLexicalDeclContext(LexicalDC); 1471203955Srdivacky Importer.Imported(D, ToTypedef); 1472234353Sdim LexicalDC->addDeclInternal(ToTypedef); 1473321369Sdim 1474203955Srdivacky return ToTypedef; 1475203955Srdivacky} 1476203955Srdivacky 1477221345SdimDecl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) { 1478221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/false); 1479221345Sdim} 1480221345Sdim 1481221345SdimDecl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) { 1482221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/true); 1483221345Sdim} 1484221345Sdim 1485309124SdimDecl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) { 1486309124Sdim // Import the major distinguishing characteristics of this label. 1487309124Sdim DeclContext *DC, *LexicalDC; 1488309124Sdim DeclarationName Name; 1489309124Sdim SourceLocation Loc; 1490309124Sdim NamedDecl *ToD; 1491309124Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1492309124Sdim return nullptr; 1493309124Sdim if (ToD) 1494309124Sdim return ToD; 1495309124Sdim 1496309124Sdim assert(LexicalDC->isFunctionOrMethod()); 1497309124Sdim 1498309124Sdim LabelDecl *ToLabel = D->isGnuLocal() 1499309124Sdim ? LabelDecl::Create(Importer.getToContext(), 1500309124Sdim DC, Importer.Import(D->getLocation()), 1501309124Sdim Name.getAsIdentifierInfo(), 1502309124Sdim Importer.Import(D->getLocStart())) 1503309124Sdim : LabelDecl::Create(Importer.getToContext(), 1504309124Sdim DC, Importer.Import(D->getLocation()), 1505309124Sdim Name.getAsIdentifierInfo()); 1506309124Sdim Importer.Imported(D, ToLabel); 1507309124Sdim 1508309124Sdim LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt())); 1509309124Sdim if (!Label) 1510309124Sdim return nullptr; 1511309124Sdim 1512309124Sdim ToLabel->setStmt(Label); 1513309124Sdim ToLabel->setLexicalDeclContext(LexicalDC); 1514309124Sdim LexicalDC->addDeclInternal(ToLabel); 1515309124Sdim return ToLabel; 1516309124Sdim} 1517309124Sdim 1518203955SrdivackyDecl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) { 1519203955Srdivacky // Import the major distinguishing characteristics of this enum. 1520203955Srdivacky DeclContext *DC, *LexicalDC; 1521203955Srdivacky DeclarationName Name; 1522203955Srdivacky SourceLocation Loc; 1523288943Sdim NamedDecl *ToD; 1524288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1525276479Sdim return nullptr; 1526288943Sdim if (ToD) 1527288943Sdim return ToD; 1528276479Sdim 1529203955Srdivacky // Figure out what enum name we're looking for. 1530203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 1531203955Srdivacky DeclarationName SearchName = Name; 1532221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 1533221345Sdim SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 1534203955Srdivacky IDNS = Decl::IDNS_Ordinary; 1535234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 1536203955Srdivacky IDNS |= Decl::IDNS_Ordinary; 1537203955Srdivacky 1538203955Srdivacky // We may already have an enum of the same name; try to find and match it. 1539203955Srdivacky if (!DC->isFunctionOrMethod() && SearchName) { 1540226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1541249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1542321369Sdim DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls); 1543226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1544226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1545203955Srdivacky continue; 1546203955Srdivacky 1547226633Sdim Decl *Found = FoundDecls[I]; 1548221345Sdim if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 1549203955Srdivacky if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 1550203955Srdivacky Found = Tag->getDecl(); 1551203955Srdivacky } 1552203955Srdivacky 1553203955Srdivacky if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) { 1554203955Srdivacky if (IsStructuralMatch(D, FoundEnum)) 1555203955Srdivacky return Importer.Imported(D, FoundEnum); 1556203955Srdivacky } 1557203955Srdivacky 1558226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1559203955Srdivacky } 1560203955Srdivacky 1561203955Srdivacky if (!ConflictingDecls.empty()) { 1562203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1563203955Srdivacky ConflictingDecls.data(), 1564203955Srdivacky ConflictingDecls.size()); 1565203955Srdivacky } 1566203955Srdivacky } 1567203955Srdivacky 1568203955Srdivacky // Create the enum declaration. 1569221345Sdim EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC, 1570221345Sdim Importer.Import(D->getLocStart()), 1571276479Sdim Loc, Name.getAsIdentifierInfo(), nullptr, 1572218893Sdim D->isScoped(), D->isScopedUsingClassTag(), 1573218893Sdim D->isFixed()); 1574205219Srdivacky // Import the qualifier, if any. 1575219077Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 1576204643Srdivacky D2->setAccess(D->getAccess()); 1577203955Srdivacky D2->setLexicalDeclContext(LexicalDC); 1578203955Srdivacky Importer.Imported(D, D2); 1579234353Sdim LexicalDC->addDeclInternal(D2); 1580203955Srdivacky 1581203955Srdivacky // Import the integer type. 1582203955Srdivacky QualType ToIntegerType = Importer.Import(D->getIntegerType()); 1583203955Srdivacky if (ToIntegerType.isNull()) 1584276479Sdim return nullptr; 1585203955Srdivacky D2->setIntegerType(ToIntegerType); 1586203955Srdivacky 1587203955Srdivacky // Import the definition 1588226633Sdim if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 1589276479Sdim return nullptr; 1590203955Srdivacky 1591203955Srdivacky return D2; 1592203955Srdivacky} 1593203955Srdivacky 1594203955SrdivackyDecl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) { 1595203955Srdivacky // If this record has a definition in the translation unit we're coming from, 1596203955Srdivacky // but this particular declaration is not that definition, import the 1597203955Srdivacky // definition and map to that. 1598203955Srdivacky TagDecl *Definition = D->getDefinition(); 1599203955Srdivacky if (Definition && Definition != D) { 1600203955Srdivacky Decl *ImportedDef = Importer.Import(Definition); 1601203955Srdivacky if (!ImportedDef) 1602276479Sdim return nullptr; 1603276479Sdim 1604203955Srdivacky return Importer.Imported(D, ImportedDef); 1605203955Srdivacky } 1606203955Srdivacky 1607203955Srdivacky // Import the major distinguishing characteristics of this record. 1608203955Srdivacky DeclContext *DC, *LexicalDC; 1609203955Srdivacky DeclarationName Name; 1610203955Srdivacky SourceLocation Loc; 1611288943Sdim NamedDecl *ToD; 1612288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1613276479Sdim return nullptr; 1614288943Sdim if (ToD) 1615288943Sdim return ToD; 1616276479Sdim 1617203955Srdivacky // Figure out what structure name we're looking for. 1618203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 1619203955Srdivacky DeclarationName SearchName = Name; 1620221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 1621221345Sdim SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 1622203955Srdivacky IDNS = Decl::IDNS_Ordinary; 1623234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 1624203955Srdivacky IDNS |= Decl::IDNS_Ordinary; 1625203955Srdivacky 1626203955Srdivacky // We may already have a record of the same name; try to find and match it. 1627276479Sdim RecordDecl *AdoptDecl = nullptr; 1628321369Sdim RecordDecl *PrevDecl = nullptr; 1629239462Sdim if (!DC->isFunctionOrMethod()) { 1630226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1631249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1632321369Sdim DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls); 1633321369Sdim 1634321369Sdim if (!FoundDecls.empty()) { 1635321369Sdim // We're going to have to compare D against potentially conflicting Decls, so complete it. 1636321369Sdim if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition()) 1637321369Sdim D->getASTContext().getExternalSource()->CompleteType(D); 1638321369Sdim } 1639321369Sdim 1640226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1641226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1642203955Srdivacky continue; 1643203955Srdivacky 1644226633Sdim Decl *Found = FoundDecls[I]; 1645221345Sdim if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 1646203955Srdivacky if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 1647203955Srdivacky Found = Tag->getDecl(); 1648203955Srdivacky } 1649203955Srdivacky 1650203955Srdivacky if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) { 1651243830Sdim if (D->isAnonymousStructOrUnion() && 1652243830Sdim FoundRecord->isAnonymousStructOrUnion()) { 1653243830Sdim // If both anonymous structs/unions are in a record context, make sure 1654243830Sdim // they occur in the same location in the context records. 1655321369Sdim if (Optional<unsigned> Index1 = 1656321369Sdim StructuralEquivalenceContext::findUntaggedStructOrUnionIndex( 1657321369Sdim D)) { 1658321369Sdim if (Optional<unsigned> Index2 = StructuralEquivalenceContext:: 1659309124Sdim findUntaggedStructOrUnionIndex(FoundRecord)) { 1660243830Sdim if (*Index1 != *Index2) 1661243830Sdim continue; 1662243830Sdim } 1663243830Sdim } 1664243830Sdim } 1665243830Sdim 1666321369Sdim PrevDecl = FoundRecord; 1667321369Sdim 1668203955Srdivacky if (RecordDecl *FoundDef = FoundRecord->getDefinition()) { 1669239462Sdim if ((SearchName && !D->isCompleteDefinition()) 1670239462Sdim || (D->isCompleteDefinition() && 1671239462Sdim D->isAnonymousStructOrUnion() 1672239462Sdim == FoundDef->isAnonymousStructOrUnion() && 1673239462Sdim IsStructuralMatch(D, FoundDef))) { 1674203955Srdivacky // The record types structurally match, or the "from" translation 1675203955Srdivacky // unit only had a forward declaration anyway; call it the same 1676203955Srdivacky // function. 1677203955Srdivacky // FIXME: For C++, we should also merge methods here. 1678203955Srdivacky return Importer.Imported(D, FoundDef); 1679203955Srdivacky } 1680239462Sdim } else if (!D->isCompleteDefinition()) { 1681203955Srdivacky // We have a forward declaration of this type, so adopt that forward 1682203955Srdivacky // declaration rather than building a new one. 1683276479Sdim 1684276479Sdim // If one or both can be completed from external storage then try one 1685276479Sdim // last time to complete and compare them before doing this. 1686276479Sdim 1687276479Sdim if (FoundRecord->hasExternalLexicalStorage() && 1688276479Sdim !FoundRecord->isCompleteDefinition()) 1689276479Sdim FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord); 1690276479Sdim if (D->hasExternalLexicalStorage()) 1691276479Sdim D->getASTContext().getExternalSource()->CompleteType(D); 1692276479Sdim 1693276479Sdim if (FoundRecord->isCompleteDefinition() && 1694276479Sdim D->isCompleteDefinition() && 1695276479Sdim !IsStructuralMatch(D, FoundRecord)) 1696276479Sdim continue; 1697276479Sdim 1698203955Srdivacky AdoptDecl = FoundRecord; 1699203955Srdivacky continue; 1700239462Sdim } else if (!SearchName) { 1701239462Sdim continue; 1702239462Sdim } 1703203955Srdivacky } 1704203955Srdivacky 1705226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1706203955Srdivacky } 1707203955Srdivacky 1708239462Sdim if (!ConflictingDecls.empty() && SearchName) { 1709203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1710203955Srdivacky ConflictingDecls.data(), 1711203955Srdivacky ConflictingDecls.size()); 1712203955Srdivacky } 1713203955Srdivacky } 1714203955Srdivacky 1715203955Srdivacky // Create the record declaration. 1716203955Srdivacky RecordDecl *D2 = AdoptDecl; 1717221345Sdim SourceLocation StartLoc = Importer.Import(D->getLocStart()); 1718203955Srdivacky if (!D2) { 1719309124Sdim CXXRecordDecl *D2CXX = nullptr; 1720309124Sdim if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) { 1721309124Sdim if (DCXX->isLambda()) { 1722309124Sdim TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo()); 1723309124Sdim D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(), 1724309124Sdim DC, TInfo, Loc, 1725309124Sdim DCXX->isDependentLambda(), 1726309124Sdim DCXX->isGenericLambda(), 1727309124Sdim DCXX->getLambdaCaptureDefault()); 1728309124Sdim Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl()); 1729309124Sdim if (DCXX->getLambdaContextDecl() && !CDecl) 1730309124Sdim return nullptr; 1731309124Sdim D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl); 1732309124Sdim } else if (DCXX->isInjectedClassName()) { 1733309124Sdim // We have to be careful to do a similar dance to the one in 1734309124Sdim // Sema::ActOnStartCXXMemberDeclarations 1735309124Sdim CXXRecordDecl *const PrevDecl = nullptr; 1736309124Sdim const bool DelayTypeCreation = true; 1737309124Sdim D2CXX = CXXRecordDecl::Create( 1738309124Sdim Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc, 1739309124Sdim Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation); 1740309124Sdim Importer.getToContext().getTypeDeclType( 1741309124Sdim D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC)); 1742309124Sdim } else { 1743309124Sdim D2CXX = CXXRecordDecl::Create(Importer.getToContext(), 1744309124Sdim D->getTagKind(), 1745309124Sdim DC, StartLoc, Loc, 1746309124Sdim Name.getAsIdentifierInfo()); 1747309124Sdim } 1748203955Srdivacky D2 = D2CXX; 1749204643Srdivacky D2->setAccess(D->getAccess()); 1750203955Srdivacky } else { 1751203955Srdivacky D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(), 1752221345Sdim DC, StartLoc, Loc, Name.getAsIdentifierInfo()); 1753203955Srdivacky } 1754219077Sdim 1755219077Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 1756203955Srdivacky D2->setLexicalDeclContext(LexicalDC); 1757234353Sdim LexicalDC->addDeclInternal(D2); 1758239462Sdim if (D->isAnonymousStructOrUnion()) 1759239462Sdim D2->setAnonymousStructOrUnion(true); 1760321369Sdim if (PrevDecl) { 1761321369Sdim // FIXME: do this for all Redeclarables, not just RecordDecls. 1762321369Sdim D2->setPreviousDecl(PrevDecl); 1763321369Sdim } 1764203955Srdivacky } 1765203955Srdivacky 1766203955Srdivacky Importer.Imported(D, D2); 1767203955Srdivacky 1768234353Sdim if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default)) 1769276479Sdim return nullptr; 1770276479Sdim 1771203955Srdivacky return D2; 1772203955Srdivacky} 1773203955Srdivacky 1774203955SrdivackyDecl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) { 1775203955Srdivacky // Import the major distinguishing characteristics of this enumerator. 1776203955Srdivacky DeclContext *DC, *LexicalDC; 1777203955Srdivacky DeclarationName Name; 1778203955Srdivacky SourceLocation Loc; 1779288943Sdim NamedDecl *ToD; 1780288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1781276479Sdim return nullptr; 1782288943Sdim if (ToD) 1783288943Sdim return ToD; 1784203955Srdivacky 1785203955Srdivacky QualType T = Importer.Import(D->getType()); 1786203955Srdivacky if (T.isNull()) 1787276479Sdim return nullptr; 1788203955Srdivacky 1789203955Srdivacky // Determine whether there are any other declarations with the same name and 1790203955Srdivacky // in the same context. 1791203955Srdivacky if (!LexicalDC->isFunctionOrMethod()) { 1792226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1793203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 1794249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1795280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1796226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1797226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1798203955Srdivacky continue; 1799249423Sdim 1800249423Sdim if (EnumConstantDecl *FoundEnumConstant 1801249423Sdim = dyn_cast<EnumConstantDecl>(FoundDecls[I])) { 1802249423Sdim if (IsStructuralMatch(D, FoundEnumConstant)) 1803249423Sdim return Importer.Imported(D, FoundEnumConstant); 1804249423Sdim } 1805249423Sdim 1806226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1807203955Srdivacky } 1808203955Srdivacky 1809203955Srdivacky if (!ConflictingDecls.empty()) { 1810203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1811203955Srdivacky ConflictingDecls.data(), 1812203955Srdivacky ConflictingDecls.size()); 1813203955Srdivacky if (!Name) 1814276479Sdim return nullptr; 1815203955Srdivacky } 1816203955Srdivacky } 1817203955Srdivacky 1818203955Srdivacky Expr *Init = Importer.Import(D->getInitExpr()); 1819203955Srdivacky if (D->getInitExpr() && !Init) 1820276479Sdim return nullptr; 1821276479Sdim 1822203955Srdivacky EnumConstantDecl *ToEnumerator 1823203955Srdivacky = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc, 1824203955Srdivacky Name.getAsIdentifierInfo(), T, 1825203955Srdivacky Init, D->getInitVal()); 1826204643Srdivacky ToEnumerator->setAccess(D->getAccess()); 1827203955Srdivacky ToEnumerator->setLexicalDeclContext(LexicalDC); 1828203955Srdivacky Importer.Imported(D, ToEnumerator); 1829234353Sdim LexicalDC->addDeclInternal(ToEnumerator); 1830203955Srdivacky return ToEnumerator; 1831203955Srdivacky} 1832203955Srdivacky 1833203955SrdivackyDecl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) { 1834203955Srdivacky // Import the major distinguishing characteristics of this function. 1835203955Srdivacky DeclContext *DC, *LexicalDC; 1836203955Srdivacky DeclarationName Name; 1837203955Srdivacky SourceLocation Loc; 1838288943Sdim NamedDecl *ToD; 1839288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1840276479Sdim return nullptr; 1841288943Sdim if (ToD) 1842288943Sdim return ToD; 1843212904Sdim 1844203955Srdivacky // Try to find a function in our own ("to") context with the same name, same 1845203955Srdivacky // type, and in the same context as the function we're importing. 1846203955Srdivacky if (!LexicalDC->isFunctionOrMethod()) { 1847226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 1848203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 1849249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 1850280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1851226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 1852226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 1853203955Srdivacky continue; 1854321369Sdim 1855226633Sdim if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) { 1856261991Sdim if (FoundFunction->hasExternalFormalLinkage() && 1857261991Sdim D->hasExternalFormalLinkage()) { 1858203955Srdivacky if (Importer.IsStructurallyEquivalent(D->getType(), 1859203955Srdivacky FoundFunction->getType())) { 1860203955Srdivacky // FIXME: Actually try to merge the body and other attributes. 1861203955Srdivacky return Importer.Imported(D, FoundFunction); 1862203955Srdivacky } 1863321369Sdim 1864203955Srdivacky // FIXME: Check for overloading more carefully, e.g., by boosting 1865203955Srdivacky // Sema::IsOverload out to the AST library. 1866321369Sdim 1867203955Srdivacky // Function overloading is okay in C++. 1868234353Sdim if (Importer.getToContext().getLangOpts().CPlusPlus) 1869203955Srdivacky continue; 1870321369Sdim 1871203955Srdivacky // Complain about inconsistent function types. 1872203955Srdivacky Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent) 1873203955Srdivacky << Name << D->getType() << FoundFunction->getType(); 1874203955Srdivacky Importer.ToDiag(FoundFunction->getLocation(), 1875203955Srdivacky diag::note_odr_value_here) 1876203955Srdivacky << FoundFunction->getType(); 1877203955Srdivacky } 1878203955Srdivacky } 1879321369Sdim 1880226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 1881203955Srdivacky } 1882321369Sdim 1883203955Srdivacky if (!ConflictingDecls.empty()) { 1884203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 1885203955Srdivacky ConflictingDecls.data(), 1886203955Srdivacky ConflictingDecls.size()); 1887203955Srdivacky if (!Name) 1888276479Sdim return nullptr; 1889203955Srdivacky } 1890203955Srdivacky } 1891203955Srdivacky 1892212904Sdim DeclarationNameInfo NameInfo(Name, Loc); 1893212904Sdim // Import additional name location/type info. 1894212904Sdim ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 1895212904Sdim 1896243830Sdim QualType FromTy = D->getType(); 1897243830Sdim bool usedDifferentExceptionSpec = false; 1898243830Sdim 1899243830Sdim if (const FunctionProtoType * 1900243830Sdim FromFPT = D->getType()->getAs<FunctionProtoType>()) { 1901243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo(); 1902243830Sdim // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the 1903243830Sdim // FunctionDecl that we are importing the FunctionProtoType for. 1904243830Sdim // To avoid an infinite recursion when importing, create the FunctionDecl 1905243830Sdim // with a simplified function type and update it afterwards. 1906280031Sdim if (FromEPI.ExceptionSpec.SourceDecl || 1907280031Sdim FromEPI.ExceptionSpec.SourceTemplate || 1908280031Sdim FromEPI.ExceptionSpec.NoexceptExpr) { 1909243830Sdim FunctionProtoType::ExtProtoInfo DefaultEPI; 1910243830Sdim FromTy = Importer.getFromContext().getFunctionType( 1911276479Sdim FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI); 1912243830Sdim usedDifferentExceptionSpec = true; 1913243830Sdim } 1914243830Sdim } 1915243830Sdim 1916203955Srdivacky // Import the type. 1917243830Sdim QualType T = Importer.Import(FromTy); 1918203955Srdivacky if (T.isNull()) 1919276479Sdim return nullptr; 1920276479Sdim 1921203955Srdivacky // Import the function parameters. 1922226633Sdim SmallVector<ParmVarDecl *, 8> Parameters; 1923309124Sdim for (auto P : D->parameters()) { 1924276479Sdim ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P)); 1925203955Srdivacky if (!ToP) 1926276479Sdim return nullptr; 1927276479Sdim 1928203955Srdivacky Parameters.push_back(ToP); 1929203955Srdivacky } 1930203955Srdivacky 1931203955Srdivacky // Create the imported function. 1932203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 1933276479Sdim FunctionDecl *ToFunction = nullptr; 1934288943Sdim SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart()); 1935204643Srdivacky if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 1936204643Srdivacky ToFunction = CXXConstructorDecl::Create(Importer.getToContext(), 1937204643Srdivacky cast<CXXRecordDecl>(DC), 1938288943Sdim InnerLocStart, 1939212904Sdim NameInfo, T, TInfo, 1940204643Srdivacky FromConstructor->isExplicit(), 1941204643Srdivacky D->isInlineSpecified(), 1942226633Sdim D->isImplicit(), 1943226633Sdim D->isConstexpr()); 1944309124Sdim if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) { 1945309124Sdim SmallVector<CXXCtorInitializer *, 4> CtorInitializers; 1946309124Sdim for (CXXCtorInitializer *I : FromConstructor->inits()) { 1947309124Sdim CXXCtorInitializer *ToI = 1948309124Sdim cast_or_null<CXXCtorInitializer>(Importer.Import(I)); 1949309124Sdim if (!ToI && I) 1950309124Sdim return nullptr; 1951309124Sdim CtorInitializers.push_back(ToI); 1952309124Sdim } 1953309124Sdim CXXCtorInitializer **Memory = 1954309124Sdim new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers]; 1955309124Sdim std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory); 1956309124Sdim CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction); 1957309124Sdim ToCtor->setCtorInitializers(Memory); 1958309124Sdim ToCtor->setNumCtorInitializers(NumInitializers); 1959309124Sdim } 1960204643Srdivacky } else if (isa<CXXDestructorDecl>(D)) { 1961204643Srdivacky ToFunction = CXXDestructorDecl::Create(Importer.getToContext(), 1962204643Srdivacky cast<CXXRecordDecl>(DC), 1963288943Sdim InnerLocStart, 1964218893Sdim NameInfo, T, TInfo, 1965204643Srdivacky D->isInlineSpecified(), 1966204643Srdivacky D->isImplicit()); 1967204643Srdivacky } else if (CXXConversionDecl *FromConversion 1968204643Srdivacky = dyn_cast<CXXConversionDecl>(D)) { 1969204643Srdivacky ToFunction = CXXConversionDecl::Create(Importer.getToContext(), 1970204643Srdivacky cast<CXXRecordDecl>(DC), 1971288943Sdim InnerLocStart, 1972212904Sdim NameInfo, T, TInfo, 1973204643Srdivacky D->isInlineSpecified(), 1974221345Sdim FromConversion->isExplicit(), 1975226633Sdim D->isConstexpr(), 1976221345Sdim Importer.Import(D->getLocEnd())); 1977218893Sdim } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 1978218893Sdim ToFunction = CXXMethodDecl::Create(Importer.getToContext(), 1979218893Sdim cast<CXXRecordDecl>(DC), 1980288943Sdim InnerLocStart, 1981218893Sdim NameInfo, T, TInfo, 1982249423Sdim Method->getStorageClass(), 1983221345Sdim Method->isInlineSpecified(), 1984226633Sdim D->isConstexpr(), 1985221345Sdim Importer.Import(D->getLocEnd())); 1986204643Srdivacky } else { 1987212904Sdim ToFunction = FunctionDecl::Create(Importer.getToContext(), DC, 1988288943Sdim InnerLocStart, 1989212904Sdim NameInfo, T, TInfo, D->getStorageClass(), 1990204643Srdivacky D->isInlineSpecified(), 1991226633Sdim D->hasWrittenPrototype(), 1992226633Sdim D->isConstexpr()); 1993204643Srdivacky } 1994205219Srdivacky 1995205219Srdivacky // Import the qualifier, if any. 1996219077Sdim ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 1997204643Srdivacky ToFunction->setAccess(D->getAccess()); 1998204643Srdivacky ToFunction->setLexicalDeclContext(LexicalDC); 1999218893Sdim ToFunction->setVirtualAsWritten(D->isVirtualAsWritten()); 2000218893Sdim ToFunction->setTrivial(D->isTrivial()); 2001218893Sdim ToFunction->setPure(D->isPure()); 2002204643Srdivacky Importer.Imported(D, ToFunction); 2003203955Srdivacky 2004203955Srdivacky // Set the parameters. 2005203955Srdivacky for (unsigned I = 0, N = Parameters.size(); I != N; ++I) { 2006204643Srdivacky Parameters[I]->setOwningFunction(ToFunction); 2007234353Sdim ToFunction->addDeclInternal(Parameters[I]); 2008203955Srdivacky } 2009226633Sdim ToFunction->setParams(Parameters); 2010203955Srdivacky 2011243830Sdim if (usedDifferentExceptionSpec) { 2012243830Sdim // Update FunctionProtoType::ExtProtoInfo. 2013243830Sdim QualType T = Importer.Import(D->getType()); 2014243830Sdim if (T.isNull()) 2015276479Sdim return nullptr; 2016243830Sdim ToFunction->setType(T); 2017243830Sdim } 2018243830Sdim 2019288943Sdim // Import the body, if any. 2020288943Sdim if (Stmt *FromBody = D->getBody()) { 2021288943Sdim if (Stmt *ToBody = Importer.Import(FromBody)) { 2022288943Sdim ToFunction->setBody(ToBody); 2023288943Sdim } 2024288943Sdim } 2025288943Sdim 2026203955Srdivacky // FIXME: Other bits to merge? 2027218893Sdim 2028218893Sdim // Add this function to the lexical context. 2029234353Sdim LexicalDC->addDeclInternal(ToFunction); 2030218893Sdim 2031321369Sdim if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D)) 2032321369Sdim ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod); 2033321369Sdim 2034204643Srdivacky return ToFunction; 2035203955Srdivacky} 2036203955Srdivacky 2037204643SrdivackyDecl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) { 2038204643Srdivacky return VisitFunctionDecl(D); 2039204643Srdivacky} 2040204643Srdivacky 2041204643SrdivackyDecl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 2042204643Srdivacky return VisitCXXMethodDecl(D); 2043204643Srdivacky} 2044204643Srdivacky 2045204643SrdivackyDecl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 2046204643Srdivacky return VisitCXXMethodDecl(D); 2047204643Srdivacky} 2048204643Srdivacky 2049204643SrdivackyDecl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) { 2050204643Srdivacky return VisitCXXMethodDecl(D); 2051204643Srdivacky} 2052204643Srdivacky 2053243830Sdimstatic unsigned getFieldIndex(Decl *F) { 2054243830Sdim RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext()); 2055243830Sdim if (!Owner) 2056243830Sdim return 0; 2057243830Sdim 2058243830Sdim unsigned Index = 1; 2059276479Sdim for (const auto *D : Owner->noload_decls()) { 2060276479Sdim if (D == F) 2061243830Sdim return Index; 2062243830Sdim 2063243830Sdim if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) 2064243830Sdim ++Index; 2065243830Sdim } 2066243830Sdim 2067243830Sdim return Index; 2068243830Sdim} 2069243830Sdim 2070203955SrdivackyDecl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) { 2071203955Srdivacky // Import the major distinguishing characteristics of a variable. 2072203955Srdivacky DeclContext *DC, *LexicalDC; 2073203955Srdivacky DeclarationName Name; 2074203955Srdivacky SourceLocation Loc; 2075288943Sdim NamedDecl *ToD; 2076288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2077276479Sdim return nullptr; 2078288943Sdim if (ToD) 2079288943Sdim return ToD; 2080276479Sdim 2081226633Sdim // Determine whether we've already imported this field. 2082249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2083280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2084226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2085226633Sdim if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) { 2086243830Sdim // For anonymous fields, match up by index. 2087243830Sdim if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 2088243830Sdim continue; 2089243830Sdim 2090321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2091226633Sdim FoundField->getType())) { 2092226633Sdim Importer.Imported(D, FoundField); 2093226633Sdim return FoundField; 2094226633Sdim } 2095321369Sdim 2096226633Sdim Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 2097226633Sdim << Name << D->getType() << FoundField->getType(); 2098226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 2099226633Sdim << FoundField->getType(); 2100276479Sdim return nullptr; 2101226633Sdim } 2102226633Sdim } 2103226633Sdim 2104203955Srdivacky // Import the type. 2105203955Srdivacky QualType T = Importer.Import(D->getType()); 2106203955Srdivacky if (T.isNull()) 2107276479Sdim return nullptr; 2108276479Sdim 2109203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2110203955Srdivacky Expr *BitWidth = Importer.Import(D->getBitWidth()); 2111203955Srdivacky if (!BitWidth && D->getBitWidth()) 2112276479Sdim return nullptr; 2113276479Sdim 2114221345Sdim FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC, 2115221345Sdim Importer.Import(D->getInnerLocStart()), 2116203955Srdivacky Loc, Name.getAsIdentifierInfo(), 2117223017Sdim T, TInfo, BitWidth, D->isMutable(), 2118239462Sdim D->getInClassInitStyle()); 2119204643Srdivacky ToField->setAccess(D->getAccess()); 2120203955Srdivacky ToField->setLexicalDeclContext(LexicalDC); 2121309124Sdim if (Expr *FromInitializer = D->getInClassInitializer()) { 2122309124Sdim Expr *ToInitializer = Importer.Import(FromInitializer); 2123309124Sdim if (ToInitializer) 2124309124Sdim ToField->setInClassInitializer(ToInitializer); 2125309124Sdim else 2126309124Sdim return nullptr; 2127309124Sdim } 2128243830Sdim ToField->setImplicit(D->isImplicit()); 2129203955Srdivacky Importer.Imported(D, ToField); 2130234353Sdim LexicalDC->addDeclInternal(ToField); 2131203955Srdivacky return ToField; 2132203955Srdivacky} 2133203955Srdivacky 2134218893SdimDecl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 2135218893Sdim // Import the major distinguishing characteristics of a variable. 2136218893Sdim DeclContext *DC, *LexicalDC; 2137218893Sdim DeclarationName Name; 2138218893Sdim SourceLocation Loc; 2139288943Sdim NamedDecl *ToD; 2140288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2141276479Sdim return nullptr; 2142288943Sdim if (ToD) 2143288943Sdim return ToD; 2144218893Sdim 2145226633Sdim // Determine whether we've already imported this field. 2146249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2147280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2148226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2149226633Sdim if (IndirectFieldDecl *FoundField 2150226633Sdim = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) { 2151243830Sdim // For anonymous indirect fields, match up by index. 2152243830Sdim if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 2153243830Sdim continue; 2154243830Sdim 2155321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2156239462Sdim FoundField->getType(), 2157261991Sdim !Name.isEmpty())) { 2158226633Sdim Importer.Imported(D, FoundField); 2159226633Sdim return FoundField; 2160226633Sdim } 2161239462Sdim 2162239462Sdim // If there are more anonymous fields to check, continue. 2163239462Sdim if (!Name && I < N-1) 2164239462Sdim continue; 2165239462Sdim 2166226633Sdim Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 2167226633Sdim << Name << D->getType() << FoundField->getType(); 2168226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 2169226633Sdim << FoundField->getType(); 2170276479Sdim return nullptr; 2171226633Sdim } 2172226633Sdim } 2173226633Sdim 2174218893Sdim // Import the type. 2175218893Sdim QualType T = Importer.Import(D->getType()); 2176218893Sdim if (T.isNull()) 2177276479Sdim return nullptr; 2178218893Sdim 2179218893Sdim NamedDecl **NamedChain = 2180218893Sdim new (Importer.getToContext())NamedDecl*[D->getChainingSize()]; 2181218893Sdim 2182218893Sdim unsigned i = 0; 2183276479Sdim for (auto *PI : D->chain()) { 2184276479Sdim Decl *D = Importer.Import(PI); 2185218893Sdim if (!D) 2186276479Sdim return nullptr; 2187218893Sdim NamedChain[i++] = cast<NamedDecl>(D); 2188218893Sdim } 2189218893Sdim 2190218893Sdim IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create( 2191280031Sdim Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T, 2192309124Sdim {NamedChain, D->getChainingSize()}); 2193280031Sdim 2194280031Sdim for (const auto *Attr : D->attrs()) 2195280031Sdim ToIndirectField->addAttr(Attr->clone(Importer.getToContext())); 2196280031Sdim 2197218893Sdim ToIndirectField->setAccess(D->getAccess()); 2198218893Sdim ToIndirectField->setLexicalDeclContext(LexicalDC); 2199218893Sdim Importer.Imported(D, ToIndirectField); 2200234353Sdim LexicalDC->addDeclInternal(ToIndirectField); 2201218893Sdim return ToIndirectField; 2202218893Sdim} 2203218893Sdim 2204314564SdimDecl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) { 2205314564Sdim // Import the major distinguishing characteristics of a declaration. 2206314564Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 2207314564Sdim DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext() 2208314564Sdim ? DC : Importer.ImportContext(D->getLexicalDeclContext()); 2209314564Sdim if (!DC || !LexicalDC) 2210314564Sdim return nullptr; 2211314564Sdim 2212314564Sdim // Determine whether we've already imported this decl. 2213314564Sdim // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup. 2214314564Sdim auto *RD = cast<CXXRecordDecl>(DC); 2215314564Sdim FriendDecl *ImportedFriend = RD->getFirstFriend(); 2216314564Sdim StructuralEquivalenceContext Context( 2217314564Sdim Importer.getFromContext(), Importer.getToContext(), 2218314564Sdim Importer.getNonEquivalentDecls(), false, false); 2219314564Sdim 2220314564Sdim while (ImportedFriend) { 2221314564Sdim if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) { 2222314564Sdim if (Context.IsStructurallyEquivalent(D->getFriendDecl(), 2223314564Sdim ImportedFriend->getFriendDecl())) 2224314564Sdim return Importer.Imported(D, ImportedFriend); 2225314564Sdim 2226314564Sdim } else if (D->getFriendType() && ImportedFriend->getFriendType()) { 2227314564Sdim if (Importer.IsStructurallyEquivalent( 2228314564Sdim D->getFriendType()->getType(), 2229314564Sdim ImportedFriend->getFriendType()->getType(), true)) 2230314564Sdim return Importer.Imported(D, ImportedFriend); 2231314564Sdim } 2232314564Sdim ImportedFriend = ImportedFriend->getNextFriend(); 2233314564Sdim } 2234314564Sdim 2235314564Sdim // Not found. Create it. 2236314564Sdim FriendDecl::FriendUnion ToFU; 2237314564Sdim if (NamedDecl *FriendD = D->getFriendDecl()) 2238314564Sdim ToFU = cast_or_null<NamedDecl>(Importer.Import(FriendD)); 2239314564Sdim else 2240314564Sdim ToFU = Importer.Import(D->getFriendType()); 2241314564Sdim if (!ToFU) 2242314564Sdim return nullptr; 2243314564Sdim 2244314564Sdim SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists); 2245314564Sdim TemplateParameterList **FromTPLists = 2246314564Sdim D->getTrailingObjects<TemplateParameterList *>(); 2247314564Sdim for (unsigned I = 0; I < D->NumTPLists; I++) { 2248314564Sdim TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]); 2249314564Sdim if (!List) 2250314564Sdim return nullptr; 2251314564Sdim ToTPLists[I] = List; 2252314564Sdim } 2253314564Sdim 2254314564Sdim FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC, 2255314564Sdim Importer.Import(D->getLocation()), 2256314564Sdim ToFU, Importer.Import(D->getFriendLoc()), 2257314564Sdim ToTPLists); 2258314564Sdim 2259314564Sdim Importer.Imported(D, FrD); 2260314564Sdim RD->pushFriendDecl(FrD); 2261314564Sdim 2262314564Sdim FrD->setAccess(D->getAccess()); 2263314564Sdim FrD->setLexicalDeclContext(LexicalDC); 2264314564Sdim LexicalDC->addDeclInternal(FrD); 2265314564Sdim return FrD; 2266314564Sdim} 2267314564Sdim 2268204643SrdivackyDecl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 2269204643Srdivacky // Import the major distinguishing characteristics of an ivar. 2270204643Srdivacky DeclContext *DC, *LexicalDC; 2271204643Srdivacky DeclarationName Name; 2272204643Srdivacky SourceLocation Loc; 2273288943Sdim NamedDecl *ToD; 2274288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2275276479Sdim return nullptr; 2276288943Sdim if (ToD) 2277288943Sdim return ToD; 2278276479Sdim 2279321369Sdim // Determine whether we've already imported this ivar 2280249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2281280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2282226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2283226633Sdim if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) { 2284321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2285204643Srdivacky FoundIvar->getType())) { 2286204643Srdivacky Importer.Imported(D, FoundIvar); 2287204643Srdivacky return FoundIvar; 2288204643Srdivacky } 2289204643Srdivacky 2290204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent) 2291204643Srdivacky << Name << D->getType() << FoundIvar->getType(); 2292204643Srdivacky Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here) 2293204643Srdivacky << FoundIvar->getType(); 2294276479Sdim return nullptr; 2295204643Srdivacky } 2296204643Srdivacky } 2297204643Srdivacky 2298204643Srdivacky // Import the type. 2299204643Srdivacky QualType T = Importer.Import(D->getType()); 2300204643Srdivacky if (T.isNull()) 2301276479Sdim return nullptr; 2302276479Sdim 2303204643Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2304204643Srdivacky Expr *BitWidth = Importer.Import(D->getBitWidth()); 2305204643Srdivacky if (!BitWidth && D->getBitWidth()) 2306276479Sdim return nullptr; 2307276479Sdim 2308206125Srdivacky ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(), 2309206125Srdivacky cast<ObjCContainerDecl>(DC), 2310221345Sdim Importer.Import(D->getInnerLocStart()), 2311204643Srdivacky Loc, Name.getAsIdentifierInfo(), 2312204643Srdivacky T, TInfo, D->getAccessControl(), 2313276479Sdim BitWidth, D->getSynthesize()); 2314204643Srdivacky ToIvar->setLexicalDeclContext(LexicalDC); 2315204643Srdivacky Importer.Imported(D, ToIvar); 2316234353Sdim LexicalDC->addDeclInternal(ToIvar); 2317204643Srdivacky return ToIvar; 2318204643Srdivacky 2319204643Srdivacky} 2320204643Srdivacky 2321203955SrdivackyDecl *ASTNodeImporter::VisitVarDecl(VarDecl *D) { 2322203955Srdivacky // Import the major distinguishing characteristics of a variable. 2323203955Srdivacky DeclContext *DC, *LexicalDC; 2324203955Srdivacky DeclarationName Name; 2325203955Srdivacky SourceLocation Loc; 2326288943Sdim NamedDecl *ToD; 2327288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2328276479Sdim return nullptr; 2329288943Sdim if (ToD) 2330288943Sdim return ToD; 2331276479Sdim 2332203955Srdivacky // Try to find a variable in our own ("to") context with the same name and 2333203955Srdivacky // in the same context as the variable we're importing. 2334203955Srdivacky if (D->isFileVarDecl()) { 2335276479Sdim VarDecl *MergeWithVar = nullptr; 2336226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2337203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2338249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2339280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2340226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2341226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2342203955Srdivacky continue; 2343321369Sdim 2344226633Sdim if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) { 2345203955Srdivacky // We have found a variable that we may need to merge with. Check it. 2346261991Sdim if (FoundVar->hasExternalFormalLinkage() && 2347261991Sdim D->hasExternalFormalLinkage()) { 2348321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 2349203955Srdivacky FoundVar->getType())) { 2350203955Srdivacky MergeWithVar = FoundVar; 2351203955Srdivacky break; 2352203955Srdivacky } 2353203955Srdivacky 2354203955Srdivacky const ArrayType *FoundArray 2355203955Srdivacky = Importer.getToContext().getAsArrayType(FoundVar->getType()); 2356203955Srdivacky const ArrayType *TArray 2357203955Srdivacky = Importer.getToContext().getAsArrayType(D->getType()); 2358203955Srdivacky if (FoundArray && TArray) { 2359203955Srdivacky if (isa<IncompleteArrayType>(FoundArray) && 2360203955Srdivacky isa<ConstantArrayType>(TArray)) { 2361203955Srdivacky // Import the type. 2362203955Srdivacky QualType T = Importer.Import(D->getType()); 2363203955Srdivacky if (T.isNull()) 2364276479Sdim return nullptr; 2365276479Sdim 2366203955Srdivacky FoundVar->setType(T); 2367203955Srdivacky MergeWithVar = FoundVar; 2368203955Srdivacky break; 2369203955Srdivacky } else if (isa<IncompleteArrayType>(TArray) && 2370203955Srdivacky isa<ConstantArrayType>(FoundArray)) { 2371203955Srdivacky MergeWithVar = FoundVar; 2372203955Srdivacky break; 2373203955Srdivacky } 2374203955Srdivacky } 2375203955Srdivacky 2376203955Srdivacky Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent) 2377203955Srdivacky << Name << D->getType() << FoundVar->getType(); 2378203955Srdivacky Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here) 2379203955Srdivacky << FoundVar->getType(); 2380203955Srdivacky } 2381203955Srdivacky } 2382203955Srdivacky 2383226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 2384203955Srdivacky } 2385203955Srdivacky 2386203955Srdivacky if (MergeWithVar) { 2387203955Srdivacky // An equivalent variable with external linkage has been found. Link 2388203955Srdivacky // the two declarations, then merge them. 2389203955Srdivacky Importer.Imported(D, MergeWithVar); 2390203955Srdivacky 2391203955Srdivacky if (VarDecl *DDef = D->getDefinition()) { 2392203955Srdivacky if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) { 2393203955Srdivacky Importer.ToDiag(ExistingDef->getLocation(), 2394203955Srdivacky diag::err_odr_variable_multiple_def) 2395203955Srdivacky << Name; 2396203955Srdivacky Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here); 2397203955Srdivacky } else { 2398203955Srdivacky Expr *Init = Importer.Import(DDef->getInit()); 2399203955Srdivacky MergeWithVar->setInit(Init); 2400234353Sdim if (DDef->isInitKnownICE()) { 2401234353Sdim EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt(); 2402234353Sdim Eval->CheckedICE = true; 2403234353Sdim Eval->IsICE = DDef->isInitICE(); 2404234353Sdim } 2405203955Srdivacky } 2406203955Srdivacky } 2407203955Srdivacky 2408203955Srdivacky return MergeWithVar; 2409203955Srdivacky } 2410203955Srdivacky 2411203955Srdivacky if (!ConflictingDecls.empty()) { 2412203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 2413203955Srdivacky ConflictingDecls.data(), 2414203955Srdivacky ConflictingDecls.size()); 2415203955Srdivacky if (!Name) 2416276479Sdim return nullptr; 2417203955Srdivacky } 2418203955Srdivacky } 2419203955Srdivacky 2420203955Srdivacky // Import the type. 2421203955Srdivacky QualType T = Importer.Import(D->getType()); 2422203955Srdivacky if (T.isNull()) 2423276479Sdim return nullptr; 2424276479Sdim 2425203955Srdivacky // Create the imported variable. 2426203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2427221345Sdim VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC, 2428221345Sdim Importer.Import(D->getInnerLocStart()), 2429221345Sdim Loc, Name.getAsIdentifierInfo(), 2430221345Sdim T, TInfo, 2431249423Sdim D->getStorageClass()); 2432219077Sdim ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2433204643Srdivacky ToVar->setAccess(D->getAccess()); 2434203955Srdivacky ToVar->setLexicalDeclContext(LexicalDC); 2435203955Srdivacky Importer.Imported(D, ToVar); 2436234353Sdim LexicalDC->addDeclInternal(ToVar); 2437203955Srdivacky 2438288943Sdim if (!D->isFileVarDecl() && 2439288943Sdim D->isUsed()) 2440288943Sdim ToVar->setIsUsed(); 2441288943Sdim 2442203955Srdivacky // Merge the initializer. 2443261991Sdim if (ImportDefinition(D, ToVar)) 2444276479Sdim return nullptr; 2445203955Srdivacky 2446321369Sdim if (D->isConstexpr()) 2447321369Sdim ToVar->setConstexpr(true); 2448321369Sdim 2449203955Srdivacky return ToVar; 2450203955Srdivacky} 2451203955Srdivacky 2452204643SrdivackyDecl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 2453204643Srdivacky // Parameters are created in the translation unit's context, then moved 2454204643Srdivacky // into the function declaration's context afterward. 2455204643Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 2456204643Srdivacky 2457204643Srdivacky // Import the name of this declaration. 2458204643Srdivacky DeclarationName Name = Importer.Import(D->getDeclName()); 2459204643Srdivacky if (D->getDeclName() && !Name) 2460276479Sdim return nullptr; 2461276479Sdim 2462204643Srdivacky // Import the location of this declaration. 2463204643Srdivacky SourceLocation Loc = Importer.Import(D->getLocation()); 2464204643Srdivacky 2465204643Srdivacky // Import the parameter's type. 2466204643Srdivacky QualType T = Importer.Import(D->getType()); 2467204643Srdivacky if (T.isNull()) 2468276479Sdim return nullptr; 2469276479Sdim 2470204643Srdivacky // Create the imported parameter. 2471321369Sdim auto *ToParm = ImplicitParamDecl::Create(Importer.getToContext(), DC, Loc, 2472321369Sdim Name.getAsIdentifierInfo(), T, 2473321369Sdim D->getParameterKind()); 2474204643Srdivacky return Importer.Imported(D, ToParm); 2475204643Srdivacky} 2476204643Srdivacky 2477203955SrdivackyDecl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) { 2478203955Srdivacky // Parameters are created in the translation unit's context, then moved 2479203955Srdivacky // into the function declaration's context afterward. 2480203955Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 2481203955Srdivacky 2482203955Srdivacky // Import the name of this declaration. 2483203955Srdivacky DeclarationName Name = Importer.Import(D->getDeclName()); 2484203955Srdivacky if (D->getDeclName() && !Name) 2485276479Sdim return nullptr; 2486276479Sdim 2487203955Srdivacky // Import the location of this declaration. 2488203955Srdivacky SourceLocation Loc = Importer.Import(D->getLocation()); 2489203955Srdivacky 2490203955Srdivacky // Import the parameter's type. 2491203955Srdivacky QualType T = Importer.Import(D->getType()); 2492203955Srdivacky if (T.isNull()) 2493276479Sdim return nullptr; 2494276479Sdim 2495203955Srdivacky // Create the imported parameter. 2496203955Srdivacky TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2497203955Srdivacky ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC, 2498221345Sdim Importer.Import(D->getInnerLocStart()), 2499203955Srdivacky Loc, Name.getAsIdentifierInfo(), 2500203955Srdivacky T, TInfo, D->getStorageClass(), 2501321369Sdim /*DefaultArg*/ nullptr); 2502321369Sdim 2503321369Sdim // Set the default argument. 2504205219Srdivacky ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg()); 2505321369Sdim ToParm->setKNRPromoted(D->isKNRPromoted()); 2506288943Sdim 2507321369Sdim Expr *ToDefArg = nullptr; 2508321369Sdim Expr *FromDefArg = nullptr; 2509321369Sdim if (D->hasUninstantiatedDefaultArg()) { 2510321369Sdim FromDefArg = D->getUninstantiatedDefaultArg(); 2511321369Sdim ToDefArg = Importer.Import(FromDefArg); 2512321369Sdim ToParm->setUninstantiatedDefaultArg(ToDefArg); 2513321369Sdim } else if (D->hasUnparsedDefaultArg()) { 2514321369Sdim ToParm->setUnparsedDefaultArg(); 2515321369Sdim } else if (D->hasDefaultArg()) { 2516321369Sdim FromDefArg = D->getDefaultArg(); 2517321369Sdim ToDefArg = Importer.Import(FromDefArg); 2518321369Sdim ToParm->setDefaultArg(ToDefArg); 2519321369Sdim } 2520321369Sdim if (FromDefArg && !ToDefArg) 2521321369Sdim return nullptr; 2522321369Sdim 2523288943Sdim if (D->isUsed()) 2524288943Sdim ToParm->setIsUsed(); 2525288943Sdim 2526203955Srdivacky return Importer.Imported(D, ToParm); 2527203955Srdivacky} 2528203955Srdivacky 2529204643SrdivackyDecl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 2530204643Srdivacky // Import the major distinguishing characteristics of a method. 2531204643Srdivacky DeclContext *DC, *LexicalDC; 2532204643Srdivacky DeclarationName Name; 2533204643Srdivacky SourceLocation Loc; 2534288943Sdim NamedDecl *ToD; 2535288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2536276479Sdim return nullptr; 2537288943Sdim if (ToD) 2538288943Sdim return ToD; 2539276479Sdim 2540249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2541280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2542226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2543226633Sdim if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) { 2544204643Srdivacky if (FoundMethod->isInstanceMethod() != D->isInstanceMethod()) 2545204643Srdivacky continue; 2546204643Srdivacky 2547204643Srdivacky // Check return types. 2548276479Sdim if (!Importer.IsStructurallyEquivalent(D->getReturnType(), 2549276479Sdim FoundMethod->getReturnType())) { 2550204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent) 2551276479Sdim << D->isInstanceMethod() << Name << D->getReturnType() 2552276479Sdim << FoundMethod->getReturnType(); 2553204643Srdivacky Importer.ToDiag(FoundMethod->getLocation(), 2554204643Srdivacky diag::note_odr_objc_method_here) 2555204643Srdivacky << D->isInstanceMethod() << Name; 2556276479Sdim return nullptr; 2557204643Srdivacky } 2558204643Srdivacky 2559204643Srdivacky // Check the number of parameters. 2560204643Srdivacky if (D->param_size() != FoundMethod->param_size()) { 2561204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent) 2562204643Srdivacky << D->isInstanceMethod() << Name 2563204643Srdivacky << D->param_size() << FoundMethod->param_size(); 2564204643Srdivacky Importer.ToDiag(FoundMethod->getLocation(), 2565204643Srdivacky diag::note_odr_objc_method_here) 2566204643Srdivacky << D->isInstanceMethod() << Name; 2567276479Sdim return nullptr; 2568204643Srdivacky } 2569204643Srdivacky 2570204643Srdivacky // Check parameter types. 2571321369Sdim for (ObjCMethodDecl::param_iterator P = D->param_begin(), 2572204643Srdivacky PEnd = D->param_end(), FoundP = FoundMethod->param_begin(); 2573204643Srdivacky P != PEnd; ++P, ++FoundP) { 2574321369Sdim if (!Importer.IsStructurallyEquivalent((*P)->getType(), 2575204643Srdivacky (*FoundP)->getType())) { 2576321369Sdim Importer.FromDiag((*P)->getLocation(), 2577204643Srdivacky diag::err_odr_objc_method_param_type_inconsistent) 2578204643Srdivacky << D->isInstanceMethod() << Name 2579204643Srdivacky << (*P)->getType() << (*FoundP)->getType(); 2580204643Srdivacky Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here) 2581204643Srdivacky << (*FoundP)->getType(); 2582276479Sdim return nullptr; 2583204643Srdivacky } 2584204643Srdivacky } 2585204643Srdivacky 2586204643Srdivacky // Check variadic/non-variadic. 2587204643Srdivacky // Check the number of parameters. 2588204643Srdivacky if (D->isVariadic() != FoundMethod->isVariadic()) { 2589204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent) 2590204643Srdivacky << D->isInstanceMethod() << Name; 2591204643Srdivacky Importer.ToDiag(FoundMethod->getLocation(), 2592204643Srdivacky diag::note_odr_objc_method_here) 2593204643Srdivacky << D->isInstanceMethod() << Name; 2594276479Sdim return nullptr; 2595204643Srdivacky } 2596204643Srdivacky 2597204643Srdivacky // FIXME: Any other bits we need to merge? 2598204643Srdivacky return Importer.Imported(D, FoundMethod); 2599204643Srdivacky } 2600204643Srdivacky } 2601204643Srdivacky 2602204643Srdivacky // Import the result type. 2603276479Sdim QualType ResultTy = Importer.Import(D->getReturnType()); 2604204643Srdivacky if (ResultTy.isNull()) 2605276479Sdim return nullptr; 2606204643Srdivacky 2607276479Sdim TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo()); 2608204962Srdivacky 2609276479Sdim ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create( 2610276479Sdim Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()), 2611276479Sdim Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(), 2612276479Sdim D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(), 2613276479Sdim D->getImplementationControl(), D->hasRelatedResultType()); 2614204643Srdivacky 2615204643Srdivacky // FIXME: When we decide to merge method definitions, we'll need to 2616204643Srdivacky // deal with implicit parameters. 2617204643Srdivacky 2618204643Srdivacky // Import the parameters 2619226633Sdim SmallVector<ParmVarDecl *, 5> ToParams; 2620309124Sdim for (auto *FromP : D->parameters()) { 2621276479Sdim ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP)); 2622204643Srdivacky if (!ToP) 2623276479Sdim return nullptr; 2624276479Sdim 2625204643Srdivacky ToParams.push_back(ToP); 2626204643Srdivacky } 2627204643Srdivacky 2628204643Srdivacky // Set the parameters. 2629204643Srdivacky for (unsigned I = 0, N = ToParams.size(); I != N; ++I) { 2630204643Srdivacky ToParams[I]->setOwningFunction(ToMethod); 2631234353Sdim ToMethod->addDeclInternal(ToParams[I]); 2632204643Srdivacky } 2633226633Sdim SmallVector<SourceLocation, 12> SelLocs; 2634226633Sdim D->getSelectorLocs(SelLocs); 2635226633Sdim ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs); 2636204643Srdivacky 2637204643Srdivacky ToMethod->setLexicalDeclContext(LexicalDC); 2638204643Srdivacky Importer.Imported(D, ToMethod); 2639234353Sdim LexicalDC->addDeclInternal(ToMethod); 2640204643Srdivacky return ToMethod; 2641204643Srdivacky} 2642204643Srdivacky 2643288943SdimDecl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 2644288943Sdim // Import the major distinguishing characteristics of a category. 2645288943Sdim DeclContext *DC, *LexicalDC; 2646288943Sdim DeclarationName Name; 2647288943Sdim SourceLocation Loc; 2648288943Sdim NamedDecl *ToD; 2649288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2650288943Sdim return nullptr; 2651288943Sdim if (ToD) 2652288943Sdim return ToD; 2653288943Sdim 2654288943Sdim TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo()); 2655288943Sdim if (!BoundInfo) 2656288943Sdim return nullptr; 2657288943Sdim 2658288943Sdim ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create( 2659288943Sdim Importer.getToContext(), DC, 2660288943Sdim D->getVariance(), 2661288943Sdim Importer.Import(D->getVarianceLoc()), 2662288943Sdim D->getIndex(), 2663288943Sdim Importer.Import(D->getLocation()), 2664288943Sdim Name.getAsIdentifierInfo(), 2665288943Sdim Importer.Import(D->getColonLoc()), 2666288943Sdim BoundInfo); 2667288943Sdim Importer.Imported(D, Result); 2668288943Sdim Result->setLexicalDeclContext(LexicalDC); 2669288943Sdim return Result; 2670288943Sdim} 2671288943Sdim 2672204643SrdivackyDecl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 2673204643Srdivacky // Import the major distinguishing characteristics of a category. 2674204643Srdivacky DeclContext *DC, *LexicalDC; 2675204643Srdivacky DeclarationName Name; 2676204643Srdivacky SourceLocation Loc; 2677288943Sdim NamedDecl *ToD; 2678288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2679276479Sdim return nullptr; 2680288943Sdim if (ToD) 2681288943Sdim return ToD; 2682276479Sdim 2683204643Srdivacky ObjCInterfaceDecl *ToInterface 2684204643Srdivacky = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface())); 2685204643Srdivacky if (!ToInterface) 2686276479Sdim return nullptr; 2687276479Sdim 2688204643Srdivacky // Determine if we've already encountered this category. 2689204643Srdivacky ObjCCategoryDecl *MergeWithCategory 2690204643Srdivacky = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo()); 2691204643Srdivacky ObjCCategoryDecl *ToCategory = MergeWithCategory; 2692204643Srdivacky if (!ToCategory) { 2693204643Srdivacky ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC, 2694226633Sdim Importer.Import(D->getAtStartLoc()), 2695204643Srdivacky Loc, 2696204643Srdivacky Importer.Import(D->getCategoryNameLoc()), 2697226633Sdim Name.getAsIdentifierInfo(), 2698234353Sdim ToInterface, 2699288943Sdim /*TypeParamList=*/nullptr, 2700234353Sdim Importer.Import(D->getIvarLBraceLoc()), 2701234353Sdim Importer.Import(D->getIvarRBraceLoc())); 2702204643Srdivacky ToCategory->setLexicalDeclContext(LexicalDC); 2703234353Sdim LexicalDC->addDeclInternal(ToCategory); 2704204643Srdivacky Importer.Imported(D, ToCategory); 2705288943Sdim // Import the type parameter list after calling Imported, to avoid 2706288943Sdim // loops when bringing in their DeclContext. 2707288943Sdim ToCategory->setTypeParamList(ImportObjCTypeParamList( 2708288943Sdim D->getTypeParamList())); 2709204643Srdivacky 2710204643Srdivacky // Import protocols 2711226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 2712226633Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 2713204643Srdivacky ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc 2714204643Srdivacky = D->protocol_loc_begin(); 2715204643Srdivacky for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(), 2716204643Srdivacky FromProtoEnd = D->protocol_end(); 2717204643Srdivacky FromProto != FromProtoEnd; 2718204643Srdivacky ++FromProto, ++FromProtoLoc) { 2719204643Srdivacky ObjCProtocolDecl *ToProto 2720204643Srdivacky = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 2721204643Srdivacky if (!ToProto) 2722276479Sdim return nullptr; 2723204643Srdivacky Protocols.push_back(ToProto); 2724204643Srdivacky ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 2725204643Srdivacky } 2726204643Srdivacky 2727204643Srdivacky // FIXME: If we're merging, make sure that the protocol list is the same. 2728204643Srdivacky ToCategory->setProtocolList(Protocols.data(), Protocols.size(), 2729204643Srdivacky ProtocolLocs.data(), Importer.getToContext()); 2730204643Srdivacky 2731204643Srdivacky } else { 2732204643Srdivacky Importer.Imported(D, ToCategory); 2733204643Srdivacky } 2734204643Srdivacky 2735204643Srdivacky // Import all of the members of this category. 2736204643Srdivacky ImportDeclContext(D); 2737204643Srdivacky 2738204643Srdivacky // If we have an implementation, import it as well. 2739204643Srdivacky if (D->getImplementation()) { 2740204643Srdivacky ObjCCategoryImplDecl *Impl 2741218893Sdim = cast_or_null<ObjCCategoryImplDecl>( 2742218893Sdim Importer.Import(D->getImplementation())); 2743204643Srdivacky if (!Impl) 2744276479Sdim return nullptr; 2745276479Sdim 2746204643Srdivacky ToCategory->setImplementation(Impl); 2747204643Srdivacky } 2748204643Srdivacky 2749204643Srdivacky return ToCategory; 2750204643Srdivacky} 2751204643Srdivacky 2752234353Sdimbool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From, 2753234353Sdim ObjCProtocolDecl *To, 2754234353Sdim ImportDefinitionKind Kind) { 2755234353Sdim if (To->getDefinition()) { 2756234353Sdim if (shouldForceImportDeclContext(Kind)) 2757234353Sdim ImportDeclContext(From); 2758234353Sdim return false; 2759234353Sdim } 2760234353Sdim 2761234353Sdim // Start the protocol definition 2762234353Sdim To->startDefinition(); 2763234353Sdim 2764234353Sdim // Import protocols 2765234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 2766234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 2767234353Sdim ObjCProtocolDecl::protocol_loc_iterator 2768234353Sdim FromProtoLoc = From->protocol_loc_begin(); 2769234353Sdim for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(), 2770234353Sdim FromProtoEnd = From->protocol_end(); 2771234353Sdim FromProto != FromProtoEnd; 2772234353Sdim ++FromProto, ++FromProtoLoc) { 2773234353Sdim ObjCProtocolDecl *ToProto 2774234353Sdim = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 2775234353Sdim if (!ToProto) 2776234353Sdim return true; 2777234353Sdim Protocols.push_back(ToProto); 2778234353Sdim ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 2779234353Sdim } 2780234353Sdim 2781234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 2782234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 2783234353Sdim ProtocolLocs.data(), Importer.getToContext()); 2784234353Sdim 2785234353Sdim if (shouldForceImportDeclContext(Kind)) { 2786234353Sdim // Import all of the members of this protocol. 2787234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 2788234353Sdim } 2789234353Sdim return false; 2790234353Sdim} 2791234353Sdim 2792204643SrdivackyDecl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 2793234353Sdim // If this protocol has a definition in the translation unit we're coming 2794234353Sdim // from, but this particular declaration is not that definition, import the 2795234353Sdim // definition and map to that. 2796234353Sdim ObjCProtocolDecl *Definition = D->getDefinition(); 2797234353Sdim if (Definition && Definition != D) { 2798234353Sdim Decl *ImportedDef = Importer.Import(Definition); 2799234353Sdim if (!ImportedDef) 2800276479Sdim return nullptr; 2801276479Sdim 2802234353Sdim return Importer.Imported(D, ImportedDef); 2803234353Sdim } 2804234353Sdim 2805204643Srdivacky // Import the major distinguishing characteristics of a protocol. 2806204643Srdivacky DeclContext *DC, *LexicalDC; 2807204643Srdivacky DeclarationName Name; 2808204643Srdivacky SourceLocation Loc; 2809288943Sdim NamedDecl *ToD; 2810288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2811276479Sdim return nullptr; 2812288943Sdim if (ToD) 2813288943Sdim return ToD; 2814204643Srdivacky 2815276479Sdim ObjCProtocolDecl *MergeWithProtocol = nullptr; 2816249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 2817280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2818226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2819226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol)) 2820204643Srdivacky continue; 2821204643Srdivacky 2822226633Sdim if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I]))) 2823204643Srdivacky break; 2824204643Srdivacky } 2825204643Srdivacky 2826204643Srdivacky ObjCProtocolDecl *ToProto = MergeWithProtocol; 2827234353Sdim if (!ToProto) { 2828234353Sdim ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC, 2829234353Sdim Name.getAsIdentifierInfo(), Loc, 2830234353Sdim Importer.Import(D->getAtStartLoc()), 2831276479Sdim /*PrevDecl=*/nullptr); 2832234353Sdim ToProto->setLexicalDeclContext(LexicalDC); 2833234353Sdim LexicalDC->addDeclInternal(ToProto); 2834234353Sdim } 2835234353Sdim 2836234353Sdim Importer.Imported(D, ToProto); 2837234353Sdim 2838234353Sdim if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto)) 2839276479Sdim return nullptr; 2840276479Sdim 2841234353Sdim return ToProto; 2842234353Sdim} 2843234353Sdim 2844280031SdimDecl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 2845280031Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 2846280031Sdim DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 2847280031Sdim 2848280031Sdim SourceLocation ExternLoc = Importer.Import(D->getExternLoc()); 2849280031Sdim SourceLocation LangLoc = Importer.Import(D->getLocation()); 2850280031Sdim 2851280031Sdim bool HasBraces = D->hasBraces(); 2852280031Sdim 2853280031Sdim LinkageSpecDecl *ToLinkageSpec = 2854280031Sdim LinkageSpecDecl::Create(Importer.getToContext(), 2855280031Sdim DC, 2856280031Sdim ExternLoc, 2857280031Sdim LangLoc, 2858280031Sdim D->getLanguage(), 2859280031Sdim HasBraces); 2860280031Sdim 2861280031Sdim if (HasBraces) { 2862280031Sdim SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc()); 2863280031Sdim ToLinkageSpec->setRBraceLoc(RBraceLoc); 2864280031Sdim } 2865280031Sdim 2866280031Sdim ToLinkageSpec->setLexicalDeclContext(LexicalDC); 2867280031Sdim LexicalDC->addDeclInternal(ToLinkageSpec); 2868280031Sdim 2869280031Sdim Importer.Imported(D, ToLinkageSpec); 2870280031Sdim 2871280031Sdim return ToLinkageSpec; 2872280031Sdim} 2873280031Sdim 2874234353Sdimbool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, 2875234353Sdim ObjCInterfaceDecl *To, 2876234353Sdim ImportDefinitionKind Kind) { 2877234353Sdim if (To->getDefinition()) { 2878234353Sdim // Check consistency of superclass. 2879234353Sdim ObjCInterfaceDecl *FromSuper = From->getSuperClass(); 2880234353Sdim if (FromSuper) { 2881234353Sdim FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper)); 2882234353Sdim if (!FromSuper) 2883234353Sdim return true; 2884204643Srdivacky } 2885234353Sdim 2886234353Sdim ObjCInterfaceDecl *ToSuper = To->getSuperClass(); 2887234353Sdim if ((bool)FromSuper != (bool)ToSuper || 2888234353Sdim (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) { 2889234353Sdim Importer.ToDiag(To->getLocation(), 2890234353Sdim diag::err_odr_objc_superclass_inconsistent) 2891234353Sdim << To->getDeclName(); 2892234353Sdim if (ToSuper) 2893234353Sdim Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass) 2894234353Sdim << To->getSuperClass()->getDeclName(); 2895234353Sdim else 2896234353Sdim Importer.ToDiag(To->getLocation(), 2897234353Sdim diag::note_odr_objc_missing_superclass); 2898234353Sdim if (From->getSuperClass()) 2899234353Sdim Importer.FromDiag(From->getSuperClassLoc(), 2900234353Sdim diag::note_odr_objc_superclass) 2901234353Sdim << From->getSuperClass()->getDeclName(); 2902234353Sdim else 2903234353Sdim Importer.FromDiag(From->getLocation(), 2904234353Sdim diag::note_odr_objc_missing_superclass); 2905234353Sdim } 2906234353Sdim 2907234353Sdim if (shouldForceImportDeclContext(Kind)) 2908234353Sdim ImportDeclContext(From); 2909234353Sdim return false; 2910234353Sdim } 2911234353Sdim 2912234353Sdim // Start the definition. 2913234353Sdim To->startDefinition(); 2914234353Sdim 2915234353Sdim // If this class has a superclass, import it. 2916234353Sdim if (From->getSuperClass()) { 2917288943Sdim TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo()); 2918288943Sdim if (!SuperTInfo) 2919234353Sdim return true; 2920288943Sdim 2921288943Sdim To->setSuperClass(SuperTInfo); 2922234353Sdim } 2923234353Sdim 2924234353Sdim // Import protocols 2925234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 2926234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 2927234353Sdim ObjCInterfaceDecl::protocol_loc_iterator 2928234353Sdim FromProtoLoc = From->protocol_loc_begin(); 2929234353Sdim 2930234353Sdim for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(), 2931234353Sdim FromProtoEnd = From->protocol_end(); 2932204643Srdivacky FromProto != FromProtoEnd; 2933204643Srdivacky ++FromProto, ++FromProtoLoc) { 2934234353Sdim ObjCProtocolDecl *ToProto 2935234353Sdim = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 2936234353Sdim if (!ToProto) 2937234353Sdim return true; 2938234353Sdim Protocols.push_back(ToProto); 2939234353Sdim ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 2940234353Sdim } 2941234353Sdim 2942234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 2943234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 2944234353Sdim ProtocolLocs.data(), Importer.getToContext()); 2945234353Sdim 2946234353Sdim // Import categories. When the categories themselves are imported, they'll 2947234353Sdim // hook themselves into this interface. 2948276479Sdim for (auto *Cat : From->known_categories()) 2949276479Sdim Importer.Import(Cat); 2950249423Sdim 2951234353Sdim // If we have an @implementation, import it as well. 2952234353Sdim if (From->getImplementation()) { 2953234353Sdim ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>( 2954234353Sdim Importer.Import(From->getImplementation())); 2955234353Sdim if (!Impl) 2956234353Sdim return true; 2957204643Srdivacky 2958234353Sdim To->setImplementation(Impl); 2959204643Srdivacky } 2960204643Srdivacky 2961234353Sdim if (shouldForceImportDeclContext(Kind)) { 2962234353Sdim // Import all of the members of this class. 2963234353Sdim ImportDeclContext(From, /*ForceImport=*/true); 2964234353Sdim } 2965234353Sdim return false; 2966204643Srdivacky} 2967204643Srdivacky 2968288943SdimObjCTypeParamList * 2969288943SdimASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) { 2970288943Sdim if (!list) 2971288943Sdim return nullptr; 2972288943Sdim 2973288943Sdim SmallVector<ObjCTypeParamDecl *, 4> toTypeParams; 2974288943Sdim for (auto fromTypeParam : *list) { 2975288943Sdim auto toTypeParam = cast_or_null<ObjCTypeParamDecl>( 2976288943Sdim Importer.Import(fromTypeParam)); 2977288943Sdim if (!toTypeParam) 2978288943Sdim return nullptr; 2979288943Sdim 2980288943Sdim toTypeParams.push_back(toTypeParam); 2981288943Sdim } 2982288943Sdim 2983288943Sdim return ObjCTypeParamList::create(Importer.getToContext(), 2984288943Sdim Importer.Import(list->getLAngleLoc()), 2985288943Sdim toTypeParams, 2986288943Sdim Importer.Import(list->getRAngleLoc())); 2987288943Sdim} 2988288943Sdim 2989203955SrdivackyDecl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 2990234353Sdim // If this class has a definition in the translation unit we're coming from, 2991234353Sdim // but this particular declaration is not that definition, import the 2992234353Sdim // definition and map to that. 2993234353Sdim ObjCInterfaceDecl *Definition = D->getDefinition(); 2994234353Sdim if (Definition && Definition != D) { 2995234353Sdim Decl *ImportedDef = Importer.Import(Definition); 2996234353Sdim if (!ImportedDef) 2997276479Sdim return nullptr; 2998276479Sdim 2999234353Sdim return Importer.Imported(D, ImportedDef); 3000234353Sdim } 3001234353Sdim 3002203955Srdivacky // Import the major distinguishing characteristics of an @interface. 3003203955Srdivacky DeclContext *DC, *LexicalDC; 3004203955Srdivacky DeclarationName Name; 3005203955Srdivacky SourceLocation Loc; 3006288943Sdim NamedDecl *ToD; 3007288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3008276479Sdim return nullptr; 3009288943Sdim if (ToD) 3010288943Sdim return ToD; 3011203955Srdivacky 3012234353Sdim // Look for an existing interface with the same name. 3013276479Sdim ObjCInterfaceDecl *MergeWithIface = nullptr; 3014249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3015280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3016226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3017226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 3018203955Srdivacky continue; 3019203955Srdivacky 3020226633Sdim if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I]))) 3021203955Srdivacky break; 3022203955Srdivacky } 3023203955Srdivacky 3024234353Sdim // Create an interface declaration, if one does not already exist. 3025203955Srdivacky ObjCInterfaceDecl *ToIface = MergeWithIface; 3026234353Sdim if (!ToIface) { 3027234353Sdim ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC, 3028234353Sdim Importer.Import(D->getAtStartLoc()), 3029288943Sdim Name.getAsIdentifierInfo(), 3030288943Sdim /*TypeParamList=*/nullptr, 3031276479Sdim /*PrevDecl=*/nullptr, Loc, 3032234353Sdim D->isImplicitInterfaceDecl()); 3033234353Sdim ToIface->setLexicalDeclContext(LexicalDC); 3034234353Sdim LexicalDC->addDeclInternal(ToIface); 3035203955Srdivacky } 3036234353Sdim Importer.Imported(D, ToIface); 3037288943Sdim // Import the type parameter list after calling Imported, to avoid 3038288943Sdim // loops when bringing in their DeclContext. 3039288943Sdim ToIface->setTypeParamList(ImportObjCTypeParamList( 3040288943Sdim D->getTypeParamListAsWritten())); 3041203955Srdivacky 3042234353Sdim if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface)) 3043276479Sdim return nullptr; 3044276479Sdim 3045204643Srdivacky return ToIface; 3046203955Srdivacky} 3047203955Srdivacky 3048218893SdimDecl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 3049218893Sdim ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>( 3050218893Sdim Importer.Import(D->getCategoryDecl())); 3051218893Sdim if (!Category) 3052276479Sdim return nullptr; 3053276479Sdim 3054218893Sdim ObjCCategoryImplDecl *ToImpl = Category->getImplementation(); 3055218893Sdim if (!ToImpl) { 3056218893Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3057218893Sdim if (!DC) 3058276479Sdim return nullptr; 3059276479Sdim 3060234353Sdim SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc()); 3061218893Sdim ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC, 3062226633Sdim Importer.Import(D->getIdentifier()), 3063226633Sdim Category->getClassInterface(), 3064218893Sdim Importer.Import(D->getLocation()), 3065234353Sdim Importer.Import(D->getAtStartLoc()), 3066234353Sdim CategoryNameLoc); 3067218893Sdim 3068218893Sdim DeclContext *LexicalDC = DC; 3069218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3070218893Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3071218893Sdim if (!LexicalDC) 3072276479Sdim return nullptr; 3073276479Sdim 3074218893Sdim ToImpl->setLexicalDeclContext(LexicalDC); 3075218893Sdim } 3076218893Sdim 3077234353Sdim LexicalDC->addDeclInternal(ToImpl); 3078218893Sdim Category->setImplementation(ToImpl); 3079218893Sdim } 3080218893Sdim 3081218893Sdim Importer.Imported(D, ToImpl); 3082218893Sdim ImportDeclContext(D); 3083218893Sdim return ToImpl; 3084218893Sdim} 3085218893Sdim 3086218893SdimDecl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 3087218893Sdim // Find the corresponding interface. 3088218893Sdim ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>( 3089218893Sdim Importer.Import(D->getClassInterface())); 3090218893Sdim if (!Iface) 3091276479Sdim return nullptr; 3092218893Sdim 3093218893Sdim // Import the superclass, if any. 3094276479Sdim ObjCInterfaceDecl *Super = nullptr; 3095218893Sdim if (D->getSuperClass()) { 3096218893Sdim Super = cast_or_null<ObjCInterfaceDecl>( 3097218893Sdim Importer.Import(D->getSuperClass())); 3098218893Sdim if (!Super) 3099276479Sdim return nullptr; 3100218893Sdim } 3101218893Sdim 3102218893Sdim ObjCImplementationDecl *Impl = Iface->getImplementation(); 3103218893Sdim if (!Impl) { 3104218893Sdim // We haven't imported an implementation yet. Create a new @implementation 3105218893Sdim // now. 3106218893Sdim Impl = ObjCImplementationDecl::Create(Importer.getToContext(), 3107218893Sdim Importer.ImportContext(D->getDeclContext()), 3108226633Sdim Iface, Super, 3109218893Sdim Importer.Import(D->getLocation()), 3110234353Sdim Importer.Import(D->getAtStartLoc()), 3111251662Sdim Importer.Import(D->getSuperClassLoc()), 3112234353Sdim Importer.Import(D->getIvarLBraceLoc()), 3113234353Sdim Importer.Import(D->getIvarRBraceLoc())); 3114218893Sdim 3115218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3116218893Sdim DeclContext *LexicalDC 3117218893Sdim = Importer.ImportContext(D->getLexicalDeclContext()); 3118218893Sdim if (!LexicalDC) 3119276479Sdim return nullptr; 3120218893Sdim Impl->setLexicalDeclContext(LexicalDC); 3121218893Sdim } 3122218893Sdim 3123218893Sdim // Associate the implementation with the class it implements. 3124218893Sdim Iface->setImplementation(Impl); 3125218893Sdim Importer.Imported(D, Iface->getImplementation()); 3126218893Sdim } else { 3127218893Sdim Importer.Imported(D, Iface->getImplementation()); 3128218893Sdim 3129218893Sdim // Verify that the existing @implementation has the same superclass. 3130218893Sdim if ((Super && !Impl->getSuperClass()) || 3131218893Sdim (!Super && Impl->getSuperClass()) || 3132276479Sdim (Super && Impl->getSuperClass() && 3133276479Sdim !declaresSameEntity(Super->getCanonicalDecl(), 3134276479Sdim Impl->getSuperClass()))) { 3135276479Sdim Importer.ToDiag(Impl->getLocation(), 3136276479Sdim diag::err_odr_objc_superclass_inconsistent) 3137276479Sdim << Iface->getDeclName(); 3138276479Sdim // FIXME: It would be nice to have the location of the superclass 3139276479Sdim // below. 3140276479Sdim if (Impl->getSuperClass()) 3141276479Sdim Importer.ToDiag(Impl->getLocation(), 3142276479Sdim diag::note_odr_objc_superclass) 3143276479Sdim << Impl->getSuperClass()->getDeclName(); 3144276479Sdim else 3145276479Sdim Importer.ToDiag(Impl->getLocation(), 3146276479Sdim diag::note_odr_objc_missing_superclass); 3147276479Sdim if (D->getSuperClass()) 3148276479Sdim Importer.FromDiag(D->getLocation(), 3149218893Sdim diag::note_odr_objc_superclass) 3150276479Sdim << D->getSuperClass()->getDeclName(); 3151276479Sdim else 3152276479Sdim Importer.FromDiag(D->getLocation(), 3153218893Sdim diag::note_odr_objc_missing_superclass); 3154276479Sdim return nullptr; 3155218893Sdim } 3156218893Sdim } 3157218893Sdim 3158218893Sdim // Import all of the members of this @implementation. 3159218893Sdim ImportDeclContext(D); 3160218893Sdim 3161218893Sdim return Impl; 3162218893Sdim} 3163218893Sdim 3164204643SrdivackyDecl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 3165204643Srdivacky // Import the major distinguishing characteristics of an @property. 3166204643Srdivacky DeclContext *DC, *LexicalDC; 3167204643Srdivacky DeclarationName Name; 3168204643Srdivacky SourceLocation Loc; 3169288943Sdim NamedDecl *ToD; 3170288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3171276479Sdim return nullptr; 3172288943Sdim if (ToD) 3173288943Sdim return ToD; 3174204643Srdivacky 3175204643Srdivacky // Check whether we have already imported this property. 3176249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3177280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3178226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3179204643Srdivacky if (ObjCPropertyDecl *FoundProp 3180226633Sdim = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) { 3181204643Srdivacky // Check property types. 3182321369Sdim if (!Importer.IsStructurallyEquivalent(D->getType(), 3183204643Srdivacky FoundProp->getType())) { 3184204643Srdivacky Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent) 3185204643Srdivacky << Name << D->getType() << FoundProp->getType(); 3186204643Srdivacky Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here) 3187204643Srdivacky << FoundProp->getType(); 3188276479Sdim return nullptr; 3189204643Srdivacky } 3190204643Srdivacky 3191204643Srdivacky // FIXME: Check property attributes, getters, setters, etc.? 3192204643Srdivacky 3193204643Srdivacky // Consider these properties to be equivalent. 3194204643Srdivacky Importer.Imported(D, FoundProp); 3195204643Srdivacky return FoundProp; 3196204643Srdivacky } 3197204643Srdivacky } 3198204643Srdivacky 3199204643Srdivacky // Import the type. 3200288943Sdim TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo()); 3201288943Sdim if (!TSI) 3202276479Sdim return nullptr; 3203204643Srdivacky 3204204643Srdivacky // Create the new property. 3205204643Srdivacky ObjCPropertyDecl *ToProperty 3206204643Srdivacky = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc, 3207204643Srdivacky Name.getAsIdentifierInfo(), 3208204643Srdivacky Importer.Import(D->getAtLoc()), 3209234353Sdim Importer.Import(D->getLParenLoc()), 3210288943Sdim Importer.Import(D->getType()), 3211288943Sdim TSI, 3212204643Srdivacky D->getPropertyImplementation()); 3213204643Srdivacky Importer.Imported(D, ToProperty); 3214204643Srdivacky ToProperty->setLexicalDeclContext(LexicalDC); 3215234353Sdim LexicalDC->addDeclInternal(ToProperty); 3216204643Srdivacky 3217204643Srdivacky ToProperty->setPropertyAttributes(D->getPropertyAttributes()); 3218210299Sed ToProperty->setPropertyAttributesAsWritten( 3219210299Sed D->getPropertyAttributesAsWritten()); 3220321369Sdim ToProperty->setGetterName(Importer.Import(D->getGetterName()), 3221321369Sdim Importer.Import(D->getGetterNameLoc())); 3222321369Sdim ToProperty->setSetterName(Importer.Import(D->getSetterName()), 3223321369Sdim Importer.Import(D->getSetterNameLoc())); 3224204643Srdivacky ToProperty->setGetterMethodDecl( 3225204643Srdivacky cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl()))); 3226204643Srdivacky ToProperty->setSetterMethodDecl( 3227204643Srdivacky cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl()))); 3228204643Srdivacky ToProperty->setPropertyIvarDecl( 3229204643Srdivacky cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl()))); 3230204643Srdivacky return ToProperty; 3231204643Srdivacky} 3232204643Srdivacky 3233218893SdimDecl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 3234218893Sdim ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>( 3235218893Sdim Importer.Import(D->getPropertyDecl())); 3236218893Sdim if (!Property) 3237276479Sdim return nullptr; 3238218893Sdim 3239218893Sdim DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3240218893Sdim if (!DC) 3241276479Sdim return nullptr; 3242276479Sdim 3243218893Sdim // Import the lexical declaration context. 3244218893Sdim DeclContext *LexicalDC = DC; 3245218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3246218893Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3247218893Sdim if (!LexicalDC) 3248276479Sdim return nullptr; 3249218893Sdim } 3250218893Sdim 3251218893Sdim ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC); 3252218893Sdim if (!InImpl) 3253276479Sdim return nullptr; 3254218893Sdim 3255218893Sdim // Import the ivar (for an @synthesize). 3256276479Sdim ObjCIvarDecl *Ivar = nullptr; 3257218893Sdim if (D->getPropertyIvarDecl()) { 3258218893Sdim Ivar = cast_or_null<ObjCIvarDecl>( 3259218893Sdim Importer.Import(D->getPropertyIvarDecl())); 3260218893Sdim if (!Ivar) 3261276479Sdim return nullptr; 3262218893Sdim } 3263218893Sdim 3264218893Sdim ObjCPropertyImplDecl *ToImpl 3265309124Sdim = InImpl->FindPropertyImplDecl(Property->getIdentifier(), 3266309124Sdim Property->getQueryKind()); 3267218893Sdim if (!ToImpl) { 3268218893Sdim ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC, 3269218893Sdim Importer.Import(D->getLocStart()), 3270218893Sdim Importer.Import(D->getLocation()), 3271218893Sdim Property, 3272218893Sdim D->getPropertyImplementation(), 3273218893Sdim Ivar, 3274218893Sdim Importer.Import(D->getPropertyIvarDeclLoc())); 3275218893Sdim ToImpl->setLexicalDeclContext(LexicalDC); 3276218893Sdim Importer.Imported(D, ToImpl); 3277234353Sdim LexicalDC->addDeclInternal(ToImpl); 3278218893Sdim } else { 3279218893Sdim // Check that we have the same kind of property implementation (@synthesize 3280218893Sdim // vs. @dynamic). 3281218893Sdim if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) { 3282218893Sdim Importer.ToDiag(ToImpl->getLocation(), 3283218893Sdim diag::err_odr_objc_property_impl_kind_inconsistent) 3284218893Sdim << Property->getDeclName() 3285218893Sdim << (ToImpl->getPropertyImplementation() 3286218893Sdim == ObjCPropertyImplDecl::Dynamic); 3287218893Sdim Importer.FromDiag(D->getLocation(), 3288218893Sdim diag::note_odr_objc_property_impl_kind) 3289218893Sdim << D->getPropertyDecl()->getDeclName() 3290218893Sdim << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic); 3291276479Sdim return nullptr; 3292218893Sdim } 3293218893Sdim 3294218893Sdim // For @synthesize, check that we have the same 3295218893Sdim if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && 3296218893Sdim Ivar != ToImpl->getPropertyIvarDecl()) { 3297218893Sdim Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), 3298218893Sdim diag::err_odr_objc_synthesize_ivar_inconsistent) 3299218893Sdim << Property->getDeclName() 3300218893Sdim << ToImpl->getPropertyIvarDecl()->getDeclName() 3301218893Sdim << Ivar->getDeclName(); 3302218893Sdim Importer.FromDiag(D->getPropertyIvarDeclLoc(), 3303218893Sdim diag::note_odr_objc_synthesize_ivar_here) 3304218893Sdim << D->getPropertyIvarDecl()->getDeclName(); 3305276479Sdim return nullptr; 3306218893Sdim } 3307218893Sdim 3308218893Sdim // Merge the existing implementation with the new implementation. 3309218893Sdim Importer.Imported(D, ToImpl); 3310218893Sdim } 3311218893Sdim 3312218893Sdim return ToImpl; 3313218893Sdim} 3314218893Sdim 3315218893SdimDecl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 3316218893Sdim // For template arguments, we adopt the translation unit as our declaration 3317218893Sdim // context. This context will be fixed when the actual template declaration 3318218893Sdim // is created. 3319218893Sdim 3320218893Sdim // FIXME: Import default argument. 3321218893Sdim return TemplateTypeParmDecl::Create(Importer.getToContext(), 3322218893Sdim Importer.getToContext().getTranslationUnitDecl(), 3323221345Sdim Importer.Import(D->getLocStart()), 3324218893Sdim Importer.Import(D->getLocation()), 3325218893Sdim D->getDepth(), 3326218893Sdim D->getIndex(), 3327218893Sdim Importer.Import(D->getIdentifier()), 3328218893Sdim D->wasDeclaredWithTypename(), 3329218893Sdim D->isParameterPack()); 3330218893Sdim} 3331218893Sdim 3332218893SdimDecl * 3333218893SdimASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 3334218893Sdim // Import the name of this declaration. 3335218893Sdim DeclarationName Name = Importer.Import(D->getDeclName()); 3336218893Sdim if (D->getDeclName() && !Name) 3337276479Sdim return nullptr; 3338276479Sdim 3339218893Sdim // Import the location of this declaration. 3340218893Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 3341218893Sdim 3342218893Sdim // Import the type of this declaration. 3343218893Sdim QualType T = Importer.Import(D->getType()); 3344218893Sdim if (T.isNull()) 3345276479Sdim return nullptr; 3346276479Sdim 3347218893Sdim // Import type-source information. 3348218893Sdim TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 3349218893Sdim if (D->getTypeSourceInfo() && !TInfo) 3350276479Sdim return nullptr; 3351276479Sdim 3352218893Sdim // FIXME: Import default argument. 3353218893Sdim 3354218893Sdim return NonTypeTemplateParmDecl::Create(Importer.getToContext(), 3355218893Sdim Importer.getToContext().getTranslationUnitDecl(), 3356221345Sdim Importer.Import(D->getInnerLocStart()), 3357218893Sdim Loc, D->getDepth(), D->getPosition(), 3358218893Sdim Name.getAsIdentifierInfo(), 3359218893Sdim T, D->isParameterPack(), TInfo); 3360218893Sdim} 3361218893Sdim 3362218893SdimDecl * 3363218893SdimASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 3364218893Sdim // Import the name of this declaration. 3365218893Sdim DeclarationName Name = Importer.Import(D->getDeclName()); 3366218893Sdim if (D->getDeclName() && !Name) 3367276479Sdim return nullptr; 3368276479Sdim 3369218893Sdim // Import the location of this declaration. 3370218893Sdim SourceLocation Loc = Importer.Import(D->getLocation()); 3371218893Sdim 3372218893Sdim // Import template parameters. 3373218893Sdim TemplateParameterList *TemplateParams 3374218893Sdim = ImportTemplateParameterList(D->getTemplateParameters()); 3375218893Sdim if (!TemplateParams) 3376276479Sdim return nullptr; 3377276479Sdim 3378218893Sdim // FIXME: Import default argument. 3379218893Sdim 3380218893Sdim return TemplateTemplateParmDecl::Create(Importer.getToContext(), 3381218893Sdim Importer.getToContext().getTranslationUnitDecl(), 3382218893Sdim Loc, D->getDepth(), D->getPosition(), 3383218893Sdim D->isParameterPack(), 3384218893Sdim Name.getAsIdentifierInfo(), 3385218893Sdim TemplateParams); 3386218893Sdim} 3387218893Sdim 3388218893SdimDecl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 3389218893Sdim // If this record has a definition in the translation unit we're coming from, 3390218893Sdim // but this particular declaration is not that definition, import the 3391218893Sdim // definition and map to that. 3392218893Sdim CXXRecordDecl *Definition 3393218893Sdim = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition()); 3394218893Sdim if (Definition && Definition != D->getTemplatedDecl()) { 3395218893Sdim Decl *ImportedDef 3396218893Sdim = Importer.Import(Definition->getDescribedClassTemplate()); 3397218893Sdim if (!ImportedDef) 3398276479Sdim return nullptr; 3399276479Sdim 3400218893Sdim return Importer.Imported(D, ImportedDef); 3401218893Sdim } 3402218893Sdim 3403218893Sdim // Import the major distinguishing characteristics of this class template. 3404218893Sdim DeclContext *DC, *LexicalDC; 3405218893Sdim DeclarationName Name; 3406218893Sdim SourceLocation Loc; 3407288943Sdim NamedDecl *ToD; 3408288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3409276479Sdim return nullptr; 3410288943Sdim if (ToD) 3411288943Sdim return ToD; 3412276479Sdim 3413218893Sdim // We may already have a template of the same name; try to find and match it. 3414218893Sdim if (!DC->isFunctionOrMethod()) { 3415226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 3416249423Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3417280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3418226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3419226633Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 3420218893Sdim continue; 3421218893Sdim 3422226633Sdim Decl *Found = FoundDecls[I]; 3423218893Sdim if (ClassTemplateDecl *FoundTemplate 3424218893Sdim = dyn_cast<ClassTemplateDecl>(Found)) { 3425218893Sdim if (IsStructuralMatch(D, FoundTemplate)) { 3426218893Sdim // The class templates structurally match; call it the same template. 3427218893Sdim // FIXME: We may be filling in a forward declaration here. Handle 3428218893Sdim // this case! 3429218893Sdim Importer.Imported(D->getTemplatedDecl(), 3430218893Sdim FoundTemplate->getTemplatedDecl()); 3431218893Sdim return Importer.Imported(D, FoundTemplate); 3432218893Sdim } 3433218893Sdim } 3434218893Sdim 3435226633Sdim ConflictingDecls.push_back(FoundDecls[I]); 3436218893Sdim } 3437218893Sdim 3438218893Sdim if (!ConflictingDecls.empty()) { 3439218893Sdim Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 3440218893Sdim ConflictingDecls.data(), 3441218893Sdim ConflictingDecls.size()); 3442218893Sdim } 3443218893Sdim 3444218893Sdim if (!Name) 3445276479Sdim return nullptr; 3446218893Sdim } 3447218893Sdim 3448218893Sdim CXXRecordDecl *DTemplated = D->getTemplatedDecl(); 3449218893Sdim 3450218893Sdim // Create the declaration that is being templated. 3451309124Sdim // Create the declaration that is being templated. 3452309124Sdim CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>( 3453309124Sdim Importer.Import(DTemplated)); 3454309124Sdim if (!D2Templated) 3455309124Sdim return nullptr; 3456309124Sdim 3457309124Sdim // Resolve possible cyclic import. 3458309124Sdim if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D)) 3459309124Sdim return AlreadyImported; 3460309124Sdim 3461218893Sdim // Create the class template declaration itself. 3462218893Sdim TemplateParameterList *TemplateParams 3463218893Sdim = ImportTemplateParameterList(D->getTemplateParameters()); 3464218893Sdim if (!TemplateParams) 3465276479Sdim return nullptr; 3466276479Sdim 3467218893Sdim ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC, 3468218893Sdim Loc, Name, TemplateParams, 3469314564Sdim D2Templated); 3470218893Sdim D2Templated->setDescribedClassTemplate(D2); 3471218893Sdim 3472218893Sdim D2->setAccess(D->getAccess()); 3473218893Sdim D2->setLexicalDeclContext(LexicalDC); 3474234353Sdim LexicalDC->addDeclInternal(D2); 3475218893Sdim 3476218893Sdim // Note the relationship between the class templates. 3477218893Sdim Importer.Imported(D, D2); 3478218893Sdim Importer.Imported(DTemplated, D2Templated); 3479218893Sdim 3480226633Sdim if (DTemplated->isCompleteDefinition() && 3481226633Sdim !D2Templated->isCompleteDefinition()) { 3482218893Sdim // FIXME: Import definition! 3483218893Sdim } 3484218893Sdim 3485218893Sdim return D2; 3486218893Sdim} 3487218893Sdim 3488218893SdimDecl *ASTNodeImporter::VisitClassTemplateSpecializationDecl( 3489218893Sdim ClassTemplateSpecializationDecl *D) { 3490218893Sdim // If this record has a definition in the translation unit we're coming from, 3491218893Sdim // but this particular declaration is not that definition, import the 3492218893Sdim // definition and map to that. 3493218893Sdim TagDecl *Definition = D->getDefinition(); 3494218893Sdim if (Definition && Definition != D) { 3495218893Sdim Decl *ImportedDef = Importer.Import(Definition); 3496218893Sdim if (!ImportedDef) 3497276479Sdim return nullptr; 3498276479Sdim 3499218893Sdim return Importer.Imported(D, ImportedDef); 3500218893Sdim } 3501218893Sdim 3502218893Sdim ClassTemplateDecl *ClassTemplate 3503218893Sdim = cast_or_null<ClassTemplateDecl>(Importer.Import( 3504218893Sdim D->getSpecializedTemplate())); 3505218893Sdim if (!ClassTemplate) 3506276479Sdim return nullptr; 3507276479Sdim 3508218893Sdim // Import the context of this declaration. 3509218893Sdim DeclContext *DC = ClassTemplate->getDeclContext(); 3510218893Sdim if (!DC) 3511276479Sdim return nullptr; 3512276479Sdim 3513218893Sdim DeclContext *LexicalDC = DC; 3514218893Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3515218893Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3516218893Sdim if (!LexicalDC) 3517276479Sdim return nullptr; 3518218893Sdim } 3519218893Sdim 3520218893Sdim // Import the location of this declaration. 3521221345Sdim SourceLocation StartLoc = Importer.Import(D->getLocStart()); 3522221345Sdim SourceLocation IdLoc = Importer.Import(D->getLocation()); 3523218893Sdim 3524218893Sdim // Import template arguments. 3525226633Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 3526218893Sdim if (ImportTemplateArguments(D->getTemplateArgs().data(), 3527218893Sdim D->getTemplateArgs().size(), 3528218893Sdim TemplateArgs)) 3529276479Sdim return nullptr; 3530276479Sdim 3531218893Sdim // Try to find an existing specialization with these template arguments. 3532276479Sdim void *InsertPos = nullptr; 3533218893Sdim ClassTemplateSpecializationDecl *D2 3534276479Sdim = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); 3535218893Sdim if (D2) { 3536218893Sdim // We already have a class template specialization with these template 3537218893Sdim // arguments. 3538218893Sdim 3539218893Sdim // FIXME: Check for specialization vs. instantiation errors. 3540218893Sdim 3541218893Sdim if (RecordDecl *FoundDef = D2->getDefinition()) { 3542226633Sdim if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) { 3543218893Sdim // The record types structurally match, or the "from" translation 3544218893Sdim // unit only had a forward declaration anyway; call it the same 3545218893Sdim // function. 3546218893Sdim return Importer.Imported(D, FoundDef); 3547218893Sdim } 3548218893Sdim } 3549218893Sdim } else { 3550218893Sdim // Create a new specialization. 3551321369Sdim if (ClassTemplatePartialSpecializationDecl *PartialSpec = 3552321369Sdim dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) { 3553321369Sdim 3554321369Sdim // Import TemplateArgumentListInfo 3555321369Sdim TemplateArgumentListInfo ToTAInfo; 3556321369Sdim auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten(); 3557321369Sdim for (unsigned I = 0, E = ASTTemplateArgs.NumTemplateArgs; I < E; ++I) { 3558321369Sdim bool Error = false; 3559321369Sdim auto ToLoc = ImportTemplateArgumentLoc(ASTTemplateArgs[I], Error); 3560321369Sdim if (Error) 3561321369Sdim return nullptr; 3562321369Sdim ToTAInfo.addArgument(ToLoc); 3563321369Sdim } 3564321369Sdim 3565321369Sdim QualType CanonInjType = Importer.Import( 3566321369Sdim PartialSpec->getInjectedSpecializationType()); 3567321369Sdim if (CanonInjType.isNull()) 3568321369Sdim return nullptr; 3569321369Sdim CanonInjType = CanonInjType.getCanonicalType(); 3570321369Sdim 3571321369Sdim TemplateParameterList *ToTPList = ImportTemplateParameterList( 3572321369Sdim PartialSpec->getTemplateParameters()); 3573321369Sdim if (!ToTPList && PartialSpec->getTemplateParameters()) 3574321369Sdim return nullptr; 3575321369Sdim 3576321369Sdim D2 = ClassTemplatePartialSpecializationDecl::Create( 3577321369Sdim Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc, 3578321369Sdim ToTPList, ClassTemplate, 3579321369Sdim llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()), 3580321369Sdim ToTAInfo, CanonInjType, nullptr); 3581321369Sdim 3582321369Sdim } else { 3583321369Sdim D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(), 3584321369Sdim D->getTagKind(), DC, 3585321369Sdim StartLoc, IdLoc, 3586321369Sdim ClassTemplate, 3587321369Sdim TemplateArgs, 3588321369Sdim /*PrevDecl=*/nullptr); 3589321369Sdim } 3590321369Sdim 3591218893Sdim D2->setSpecializationKind(D->getSpecializationKind()); 3592218893Sdim 3593218893Sdim // Add this specialization to the class template. 3594218893Sdim ClassTemplate->AddSpecialization(D2, InsertPos); 3595218893Sdim 3596218893Sdim // Import the qualifier, if any. 3597219077Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 3598321369Sdim 3599321369Sdim Importer.Imported(D, D2); 3600321369Sdim 3601321369Sdim if (auto *TSI = D->getTypeAsWritten()) { 3602321369Sdim TypeSourceInfo *TInfo = Importer.Import(TSI); 3603321369Sdim if (!TInfo) 3604321369Sdim return nullptr; 3605321369Sdim D2->setTypeAsWritten(TInfo); 3606321369Sdim D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc())); 3607321369Sdim D2->setExternLoc(Importer.Import(D->getExternLoc())); 3608321369Sdim } 3609321369Sdim 3610321369Sdim SourceLocation POI = Importer.Import(D->getPointOfInstantiation()); 3611321369Sdim if (POI.isValid()) 3612321369Sdim D2->setPointOfInstantiation(POI); 3613321369Sdim else if (D->getPointOfInstantiation().isValid()) 3614321369Sdim return nullptr; 3615321369Sdim 3616321369Sdim D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind()); 3617321369Sdim 3618218893Sdim // Add the specialization to this context. 3619218893Sdim D2->setLexicalDeclContext(LexicalDC); 3620234353Sdim LexicalDC->addDeclInternal(D2); 3621218893Sdim } 3622218893Sdim Importer.Imported(D, D2); 3623226633Sdim if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 3624276479Sdim return nullptr; 3625276479Sdim 3626218893Sdim return D2; 3627218893Sdim} 3628218893Sdim 3629261991SdimDecl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) { 3630261991Sdim // If this variable has a definition in the translation unit we're coming 3631261991Sdim // from, 3632261991Sdim // but this particular declaration is not that definition, import the 3633261991Sdim // definition and map to that. 3634261991Sdim VarDecl *Definition = 3635261991Sdim cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition()); 3636261991Sdim if (Definition && Definition != D->getTemplatedDecl()) { 3637261991Sdim Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate()); 3638261991Sdim if (!ImportedDef) 3639276479Sdim return nullptr; 3640261991Sdim 3641261991Sdim return Importer.Imported(D, ImportedDef); 3642261991Sdim } 3643261991Sdim 3644261991Sdim // Import the major distinguishing characteristics of this variable template. 3645261991Sdim DeclContext *DC, *LexicalDC; 3646261991Sdim DeclarationName Name; 3647261991Sdim SourceLocation Loc; 3648288943Sdim NamedDecl *ToD; 3649288943Sdim if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3650276479Sdim return nullptr; 3651288943Sdim if (ToD) 3652288943Sdim return ToD; 3653261991Sdim 3654261991Sdim // We may already have a template of the same name; try to find and match it. 3655261991Sdim assert(!DC->isFunctionOrMethod() && 3656261991Sdim "Variable templates cannot be declared at function scope"); 3657261991Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 3658261991Sdim SmallVector<NamedDecl *, 2> FoundDecls; 3659280031Sdim DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3660261991Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3661261991Sdim if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 3662261991Sdim continue; 3663261991Sdim 3664261991Sdim Decl *Found = FoundDecls[I]; 3665261991Sdim if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) { 3666261991Sdim if (IsStructuralMatch(D, FoundTemplate)) { 3667261991Sdim // The variable templates structurally match; call it the same template. 3668261991Sdim Importer.Imported(D->getTemplatedDecl(), 3669261991Sdim FoundTemplate->getTemplatedDecl()); 3670261991Sdim return Importer.Imported(D, FoundTemplate); 3671261991Sdim } 3672261991Sdim } 3673261991Sdim 3674261991Sdim ConflictingDecls.push_back(FoundDecls[I]); 3675261991Sdim } 3676261991Sdim 3677261991Sdim if (!ConflictingDecls.empty()) { 3678261991Sdim Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 3679261991Sdim ConflictingDecls.data(), 3680261991Sdim ConflictingDecls.size()); 3681261991Sdim } 3682261991Sdim 3683261991Sdim if (!Name) 3684276479Sdim return nullptr; 3685261991Sdim 3686261991Sdim VarDecl *DTemplated = D->getTemplatedDecl(); 3687261991Sdim 3688261991Sdim // Import the type. 3689261991Sdim QualType T = Importer.Import(DTemplated->getType()); 3690261991Sdim if (T.isNull()) 3691276479Sdim return nullptr; 3692261991Sdim 3693261991Sdim // Create the declaration that is being templated. 3694261991Sdim SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart()); 3695261991Sdim SourceLocation IdLoc = Importer.Import(DTemplated->getLocation()); 3696261991Sdim TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo()); 3697261991Sdim VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc, 3698261991Sdim IdLoc, Name.getAsIdentifierInfo(), T, 3699261991Sdim TInfo, DTemplated->getStorageClass()); 3700261991Sdim D2Templated->setAccess(DTemplated->getAccess()); 3701261991Sdim D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc())); 3702261991Sdim D2Templated->setLexicalDeclContext(LexicalDC); 3703261991Sdim 3704261991Sdim // Importer.Imported(DTemplated, D2Templated); 3705261991Sdim // LexicalDC->addDeclInternal(D2Templated); 3706261991Sdim 3707261991Sdim // Merge the initializer. 3708261991Sdim if (ImportDefinition(DTemplated, D2Templated)) 3709276479Sdim return nullptr; 3710261991Sdim 3711261991Sdim // Create the variable template declaration itself. 3712261991Sdim TemplateParameterList *TemplateParams = 3713261991Sdim ImportTemplateParameterList(D->getTemplateParameters()); 3714261991Sdim if (!TemplateParams) 3715276479Sdim return nullptr; 3716261991Sdim 3717261991Sdim VarTemplateDecl *D2 = VarTemplateDecl::Create( 3718276479Sdim Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated); 3719261991Sdim D2Templated->setDescribedVarTemplate(D2); 3720261991Sdim 3721261991Sdim D2->setAccess(D->getAccess()); 3722261991Sdim D2->setLexicalDeclContext(LexicalDC); 3723261991Sdim LexicalDC->addDeclInternal(D2); 3724261991Sdim 3725261991Sdim // Note the relationship between the variable templates. 3726261991Sdim Importer.Imported(D, D2); 3727261991Sdim Importer.Imported(DTemplated, D2Templated); 3728261991Sdim 3729261991Sdim if (DTemplated->isThisDeclarationADefinition() && 3730261991Sdim !D2Templated->isThisDeclarationADefinition()) { 3731261991Sdim // FIXME: Import definition! 3732261991Sdim } 3733261991Sdim 3734261991Sdim return D2; 3735261991Sdim} 3736261991Sdim 3737261991SdimDecl *ASTNodeImporter::VisitVarTemplateSpecializationDecl( 3738261991Sdim VarTemplateSpecializationDecl *D) { 3739261991Sdim // If this record has a definition in the translation unit we're coming from, 3740261991Sdim // but this particular declaration is not that definition, import the 3741261991Sdim // definition and map to that. 3742261991Sdim VarDecl *Definition = D->getDefinition(); 3743261991Sdim if (Definition && Definition != D) { 3744261991Sdim Decl *ImportedDef = Importer.Import(Definition); 3745261991Sdim if (!ImportedDef) 3746276479Sdim return nullptr; 3747261991Sdim 3748261991Sdim return Importer.Imported(D, ImportedDef); 3749261991Sdim } 3750261991Sdim 3751261991Sdim VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>( 3752261991Sdim Importer.Import(D->getSpecializedTemplate())); 3753261991Sdim if (!VarTemplate) 3754276479Sdim return nullptr; 3755261991Sdim 3756261991Sdim // Import the context of this declaration. 3757261991Sdim DeclContext *DC = VarTemplate->getDeclContext(); 3758261991Sdim if (!DC) 3759276479Sdim return nullptr; 3760261991Sdim 3761261991Sdim DeclContext *LexicalDC = DC; 3762261991Sdim if (D->getDeclContext() != D->getLexicalDeclContext()) { 3763261991Sdim LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3764261991Sdim if (!LexicalDC) 3765276479Sdim return nullptr; 3766261991Sdim } 3767261991Sdim 3768261991Sdim // Import the location of this declaration. 3769261991Sdim SourceLocation StartLoc = Importer.Import(D->getLocStart()); 3770261991Sdim SourceLocation IdLoc = Importer.Import(D->getLocation()); 3771261991Sdim 3772261991Sdim // Import template arguments. 3773261991Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 3774261991Sdim if (ImportTemplateArguments(D->getTemplateArgs().data(), 3775261991Sdim D->getTemplateArgs().size(), TemplateArgs)) 3776276479Sdim return nullptr; 3777261991Sdim 3778261991Sdim // Try to find an existing specialization with these template arguments. 3779276479Sdim void *InsertPos = nullptr; 3780261991Sdim VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization( 3781276479Sdim TemplateArgs, InsertPos); 3782261991Sdim if (D2) { 3783261991Sdim // We already have a variable template specialization with these template 3784261991Sdim // arguments. 3785261991Sdim 3786261991Sdim // FIXME: Check for specialization vs. instantiation errors. 3787261991Sdim 3788261991Sdim if (VarDecl *FoundDef = D2->getDefinition()) { 3789261991Sdim if (!D->isThisDeclarationADefinition() || 3790261991Sdim IsStructuralMatch(D, FoundDef)) { 3791261991Sdim // The record types structurally match, or the "from" translation 3792261991Sdim // unit only had a forward declaration anyway; call it the same 3793261991Sdim // variable. 3794261991Sdim return Importer.Imported(D, FoundDef); 3795261991Sdim } 3796261991Sdim } 3797261991Sdim } else { 3798261991Sdim 3799261991Sdim // Import the type. 3800261991Sdim QualType T = Importer.Import(D->getType()); 3801261991Sdim if (T.isNull()) 3802276479Sdim return nullptr; 3803261991Sdim TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 3804261991Sdim 3805261991Sdim // Create a new specialization. 3806261991Sdim D2 = VarTemplateSpecializationDecl::Create( 3807261991Sdim Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo, 3808309124Sdim D->getStorageClass(), TemplateArgs); 3809261991Sdim D2->setSpecializationKind(D->getSpecializationKind()); 3810261991Sdim D2->setTemplateArgsInfo(D->getTemplateArgsInfo()); 3811261991Sdim 3812261991Sdim // Add this specialization to the class template. 3813261991Sdim VarTemplate->AddSpecialization(D2, InsertPos); 3814261991Sdim 3815261991Sdim // Import the qualifier, if any. 3816261991Sdim D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 3817261991Sdim 3818261991Sdim // Add the specialization to this context. 3819261991Sdim D2->setLexicalDeclContext(LexicalDC); 3820261991Sdim LexicalDC->addDeclInternal(D2); 3821261991Sdim } 3822261991Sdim Importer.Imported(D, D2); 3823261991Sdim 3824261991Sdim if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2)) 3825276479Sdim return nullptr; 3826261991Sdim 3827261991Sdim return D2; 3828261991Sdim} 3829261991Sdim 3830203955Srdivacky//---------------------------------------------------------------------------- 3831203955Srdivacky// Import Statements 3832203955Srdivacky//---------------------------------------------------------------------------- 3833203955Srdivacky 3834288943SdimDeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) { 3835288943Sdim if (DG.isNull()) 3836288943Sdim return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0); 3837288943Sdim size_t NumDecls = DG.end() - DG.begin(); 3838288943Sdim SmallVector<Decl *, 1> ToDecls(NumDecls); 3839288943Sdim auto &_Importer = this->Importer; 3840288943Sdim std::transform(DG.begin(), DG.end(), ToDecls.begin(), 3841288943Sdim [&_Importer](Decl *D) -> Decl * { 3842288943Sdim return _Importer.Import(D); 3843288943Sdim }); 3844288943Sdim return DeclGroupRef::Create(Importer.getToContext(), 3845288943Sdim ToDecls.begin(), 3846288943Sdim NumDecls); 3847203955Srdivacky} 3848203955Srdivacky 3849288943Sdim Stmt *ASTNodeImporter::VisitStmt(Stmt *S) { 3850288943Sdim Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node) 3851288943Sdim << S->getStmtClassName(); 3852288943Sdim return nullptr; 3853288943Sdim } 3854309124Sdim 3855309124Sdim 3856309124SdimStmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) { 3857309124Sdim SmallVector<IdentifierInfo *, 4> Names; 3858309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 3859309124Sdim IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I)); 3860321369Sdim // ToII is nullptr when no symbolic name is given for output operand 3861321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 3862321369Sdim if (!ToII && S->getOutputIdentifier(I)) 3863309124Sdim return nullptr; 3864309124Sdim Names.push_back(ToII); 3865309124Sdim } 3866309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 3867309124Sdim IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I)); 3868321369Sdim // ToII is nullptr when no symbolic name is given for input operand 3869321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 3870321369Sdim if (!ToII && S->getInputIdentifier(I)) 3871309124Sdim return nullptr; 3872309124Sdim Names.push_back(ToII); 3873309124Sdim } 3874309124Sdim 3875309124Sdim SmallVector<StringLiteral *, 4> Clobbers; 3876309124Sdim for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) { 3877309124Sdim StringLiteral *Clobber = cast_or_null<StringLiteral>( 3878309124Sdim Importer.Import(S->getClobberStringLiteral(I))); 3879309124Sdim if (!Clobber) 3880309124Sdim return nullptr; 3881309124Sdim Clobbers.push_back(Clobber); 3882309124Sdim } 3883309124Sdim 3884309124Sdim SmallVector<StringLiteral *, 4> Constraints; 3885309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 3886309124Sdim StringLiteral *Output = cast_or_null<StringLiteral>( 3887309124Sdim Importer.Import(S->getOutputConstraintLiteral(I))); 3888309124Sdim if (!Output) 3889309124Sdim return nullptr; 3890309124Sdim Constraints.push_back(Output); 3891309124Sdim } 3892309124Sdim 3893309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 3894309124Sdim StringLiteral *Input = cast_or_null<StringLiteral>( 3895309124Sdim Importer.Import(S->getInputConstraintLiteral(I))); 3896309124Sdim if (!Input) 3897309124Sdim return nullptr; 3898309124Sdim Constraints.push_back(Input); 3899309124Sdim } 3900309124Sdim 3901309124Sdim SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs()); 3902314564Sdim if (ImportContainerChecked(S->outputs(), Exprs)) 3903309124Sdim return nullptr; 3904309124Sdim 3905314564Sdim if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs())) 3906309124Sdim return nullptr; 3907309124Sdim 3908309124Sdim StringLiteral *AsmStr = cast_or_null<StringLiteral>( 3909309124Sdim Importer.Import(S->getAsmString())); 3910309124Sdim if (!AsmStr) 3911309124Sdim return nullptr; 3912309124Sdim 3913309124Sdim return new (Importer.getToContext()) GCCAsmStmt( 3914309124Sdim Importer.getToContext(), 3915309124Sdim Importer.Import(S->getAsmLoc()), 3916309124Sdim S->isSimple(), 3917309124Sdim S->isVolatile(), 3918309124Sdim S->getNumOutputs(), 3919309124Sdim S->getNumInputs(), 3920309124Sdim Names.data(), 3921309124Sdim Constraints.data(), 3922309124Sdim Exprs.data(), 3923309124Sdim AsmStr, 3924309124Sdim S->getNumClobbers(), 3925309124Sdim Clobbers.data(), 3926309124Sdim Importer.Import(S->getRParenLoc())); 3927309124Sdim} 3928309124Sdim 3929288943SdimStmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) { 3930288943Sdim DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup()); 3931288943Sdim for (Decl *ToD : ToDG) { 3932288943Sdim if (!ToD) 3933288943Sdim return nullptr; 3934288943Sdim } 3935288943Sdim SourceLocation ToStartLoc = Importer.Import(S->getStartLoc()); 3936288943Sdim SourceLocation ToEndLoc = Importer.Import(S->getEndLoc()); 3937288943Sdim return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc); 3938288943Sdim} 3939288943Sdim 3940288943SdimStmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) { 3941288943Sdim SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc()); 3942288943Sdim return new (Importer.getToContext()) NullStmt(ToSemiLoc, 3943288943Sdim S->hasLeadingEmptyMacro()); 3944288943Sdim} 3945288943Sdim 3946288943SdimStmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) { 3947309124Sdim llvm::SmallVector<Stmt *, 8> ToStmts(S->size()); 3948314564Sdim 3949314564Sdim if (ImportContainerChecked(S->body(), ToStmts)) 3950309124Sdim return nullptr; 3951309124Sdim 3952288943Sdim SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc()); 3953288943Sdim SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc()); 3954288943Sdim return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(), 3955288943Sdim ToStmts, 3956288943Sdim ToLBraceLoc, ToRBraceLoc); 3957288943Sdim} 3958288943Sdim 3959288943SdimStmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) { 3960288943Sdim Expr *ToLHS = Importer.Import(S->getLHS()); 3961288943Sdim if (!ToLHS) 3962288943Sdim return nullptr; 3963288943Sdim Expr *ToRHS = Importer.Import(S->getRHS()); 3964288943Sdim if (!ToRHS && S->getRHS()) 3965288943Sdim return nullptr; 3966288943Sdim SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc()); 3967288943Sdim SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc()); 3968288943Sdim SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 3969288943Sdim return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS, 3970288943Sdim ToCaseLoc, ToEllipsisLoc, 3971288943Sdim ToColonLoc); 3972288943Sdim} 3973288943Sdim 3974288943SdimStmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) { 3975288943Sdim SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc()); 3976288943Sdim SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 3977288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 3978288943Sdim if (!ToSubStmt && S->getSubStmt()) 3979288943Sdim return nullptr; 3980288943Sdim return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc, 3981288943Sdim ToSubStmt); 3982288943Sdim} 3983288943Sdim 3984288943SdimStmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) { 3985288943Sdim SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc()); 3986288943Sdim LabelDecl *ToLabelDecl = 3987288943Sdim cast_or_null<LabelDecl>(Importer.Import(S->getDecl())); 3988288943Sdim if (!ToLabelDecl && S->getDecl()) 3989288943Sdim return nullptr; 3990288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 3991288943Sdim if (!ToSubStmt && S->getSubStmt()) 3992288943Sdim return nullptr; 3993288943Sdim return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl, 3994288943Sdim ToSubStmt); 3995288943Sdim} 3996288943Sdim 3997288943SdimStmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) { 3998288943Sdim SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc()); 3999288943Sdim ArrayRef<const Attr*> FromAttrs(S->getAttrs()); 4000288943Sdim SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size()); 4001288943Sdim ASTContext &_ToContext = Importer.getToContext(); 4002288943Sdim std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(), 4003288943Sdim [&_ToContext](const Attr *A) -> const Attr * { 4004288943Sdim return A->clone(_ToContext); 4005288943Sdim }); 4006288943Sdim for (const Attr *ToA : ToAttrs) { 4007288943Sdim if (!ToA) 4008288943Sdim return nullptr; 4009288943Sdim } 4010288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4011288943Sdim if (!ToSubStmt && S->getSubStmt()) 4012288943Sdim return nullptr; 4013288943Sdim return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc, 4014288943Sdim ToAttrs, ToSubStmt); 4015288943Sdim} 4016288943Sdim 4017288943SdimStmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) { 4018288943Sdim SourceLocation ToIfLoc = Importer.Import(S->getIfLoc()); 4019309124Sdim Stmt *ToInit = Importer.Import(S->getInit()); 4020309124Sdim if (!ToInit && S->getInit()) 4021309124Sdim return nullptr; 4022288943Sdim VarDecl *ToConditionVariable = nullptr; 4023288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4024288943Sdim ToConditionVariable = 4025288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4026288943Sdim if (!ToConditionVariable) 4027288943Sdim return nullptr; 4028288943Sdim } 4029288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4030288943Sdim if (!ToCondition && S->getCond()) 4031288943Sdim return nullptr; 4032288943Sdim Stmt *ToThenStmt = Importer.Import(S->getThen()); 4033288943Sdim if (!ToThenStmt && S->getThen()) 4034288943Sdim return nullptr; 4035288943Sdim SourceLocation ToElseLoc = Importer.Import(S->getElseLoc()); 4036288943Sdim Stmt *ToElseStmt = Importer.Import(S->getElse()); 4037288943Sdim if (!ToElseStmt && S->getElse()) 4038288943Sdim return nullptr; 4039288943Sdim return new (Importer.getToContext()) IfStmt(Importer.getToContext(), 4040309124Sdim ToIfLoc, S->isConstexpr(), 4041309124Sdim ToInit, 4042309124Sdim ToConditionVariable, 4043288943Sdim ToCondition, ToThenStmt, 4044288943Sdim ToElseLoc, ToElseStmt); 4045288943Sdim} 4046288943Sdim 4047288943SdimStmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) { 4048309124Sdim Stmt *ToInit = Importer.Import(S->getInit()); 4049309124Sdim if (!ToInit && S->getInit()) 4050309124Sdim return nullptr; 4051288943Sdim VarDecl *ToConditionVariable = nullptr; 4052288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4053288943Sdim ToConditionVariable = 4054288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4055288943Sdim if (!ToConditionVariable) 4056288943Sdim return nullptr; 4057288943Sdim } 4058288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4059288943Sdim if (!ToCondition && S->getCond()) 4060288943Sdim return nullptr; 4061288943Sdim SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt( 4062309124Sdim Importer.getToContext(), ToInit, 4063309124Sdim ToConditionVariable, ToCondition); 4064288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4065288943Sdim if (!ToBody && S->getBody()) 4066288943Sdim return nullptr; 4067288943Sdim ToStmt->setBody(ToBody); 4068288943Sdim ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc())); 4069288943Sdim // Now we have to re-chain the cases. 4070288943Sdim SwitchCase *LastChainedSwitchCase = nullptr; 4071288943Sdim for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr; 4072288943Sdim SC = SC->getNextSwitchCase()) { 4073288943Sdim SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC)); 4074288943Sdim if (!ToSC) 4075288943Sdim return nullptr; 4076288943Sdim if (LastChainedSwitchCase) 4077288943Sdim LastChainedSwitchCase->setNextSwitchCase(ToSC); 4078288943Sdim else 4079288943Sdim ToStmt->setSwitchCaseList(ToSC); 4080288943Sdim LastChainedSwitchCase = ToSC; 4081288943Sdim } 4082288943Sdim return ToStmt; 4083288943Sdim} 4084288943Sdim 4085288943SdimStmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) { 4086288943Sdim VarDecl *ToConditionVariable = nullptr; 4087288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4088288943Sdim ToConditionVariable = 4089288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4090288943Sdim if (!ToConditionVariable) 4091288943Sdim return nullptr; 4092288943Sdim } 4093288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4094288943Sdim if (!ToCondition && S->getCond()) 4095288943Sdim return nullptr; 4096288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4097288943Sdim if (!ToBody && S->getBody()) 4098288943Sdim return nullptr; 4099288943Sdim SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4100288943Sdim return new (Importer.getToContext()) WhileStmt(Importer.getToContext(), 4101288943Sdim ToConditionVariable, 4102288943Sdim ToCondition, ToBody, 4103288943Sdim ToWhileLoc); 4104288943Sdim} 4105288943Sdim 4106288943SdimStmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) { 4107288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4108288943Sdim if (!ToBody && S->getBody()) 4109288943Sdim return nullptr; 4110288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4111288943Sdim if (!ToCondition && S->getCond()) 4112288943Sdim return nullptr; 4113288943Sdim SourceLocation ToDoLoc = Importer.Import(S->getDoLoc()); 4114288943Sdim SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4115288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4116288943Sdim return new (Importer.getToContext()) DoStmt(ToBody, ToCondition, 4117288943Sdim ToDoLoc, ToWhileLoc, 4118288943Sdim ToRParenLoc); 4119288943Sdim} 4120288943Sdim 4121288943SdimStmt *ASTNodeImporter::VisitForStmt(ForStmt *S) { 4122288943Sdim Stmt *ToInit = Importer.Import(S->getInit()); 4123288943Sdim if (!ToInit && S->getInit()) 4124288943Sdim return nullptr; 4125288943Sdim Expr *ToCondition = Importer.Import(S->getCond()); 4126288943Sdim if (!ToCondition && S->getCond()) 4127288943Sdim return nullptr; 4128288943Sdim VarDecl *ToConditionVariable = nullptr; 4129288943Sdim if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4130288943Sdim ToConditionVariable = 4131288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4132288943Sdim if (!ToConditionVariable) 4133288943Sdim return nullptr; 4134288943Sdim } 4135288943Sdim Expr *ToInc = Importer.Import(S->getInc()); 4136288943Sdim if (!ToInc && S->getInc()) 4137288943Sdim return nullptr; 4138288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4139288943Sdim if (!ToBody && S->getBody()) 4140288943Sdim return nullptr; 4141288943Sdim SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4142288943Sdim SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc()); 4143288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4144288943Sdim return new (Importer.getToContext()) ForStmt(Importer.getToContext(), 4145288943Sdim ToInit, ToCondition, 4146288943Sdim ToConditionVariable, 4147288943Sdim ToInc, ToBody, 4148288943Sdim ToForLoc, ToLParenLoc, 4149288943Sdim ToRParenLoc); 4150288943Sdim} 4151288943Sdim 4152288943SdimStmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) { 4153288943Sdim LabelDecl *ToLabel = nullptr; 4154288943Sdim if (LabelDecl *FromLabel = S->getLabel()) { 4155288943Sdim ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel)); 4156288943Sdim if (!ToLabel) 4157288943Sdim return nullptr; 4158288943Sdim } 4159288943Sdim SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4160288943Sdim SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc()); 4161288943Sdim return new (Importer.getToContext()) GotoStmt(ToLabel, 4162288943Sdim ToGotoLoc, ToLabelLoc); 4163288943Sdim} 4164288943Sdim 4165288943SdimStmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 4166288943Sdim SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4167288943Sdim SourceLocation ToStarLoc = Importer.Import(S->getStarLoc()); 4168288943Sdim Expr *ToTarget = Importer.Import(S->getTarget()); 4169288943Sdim if (!ToTarget && S->getTarget()) 4170288943Sdim return nullptr; 4171288943Sdim return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc, 4172288943Sdim ToTarget); 4173288943Sdim} 4174288943Sdim 4175288943SdimStmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) { 4176288943Sdim SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc()); 4177288943Sdim return new (Importer.getToContext()) ContinueStmt(ToContinueLoc); 4178288943Sdim} 4179288943Sdim 4180288943SdimStmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) { 4181288943Sdim SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc()); 4182288943Sdim return new (Importer.getToContext()) BreakStmt(ToBreakLoc); 4183288943Sdim} 4184288943Sdim 4185288943SdimStmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) { 4186288943Sdim SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc()); 4187288943Sdim Expr *ToRetExpr = Importer.Import(S->getRetValue()); 4188288943Sdim if (!ToRetExpr && S->getRetValue()) 4189288943Sdim return nullptr; 4190288943Sdim VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate()); 4191288943Sdim VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate)); 4192288943Sdim if (!ToNRVOCandidate && NRVOCandidate) 4193288943Sdim return nullptr; 4194288943Sdim return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr, 4195288943Sdim ToNRVOCandidate); 4196288943Sdim} 4197288943Sdim 4198288943SdimStmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) { 4199288943Sdim SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc()); 4200288943Sdim VarDecl *ToExceptionDecl = nullptr; 4201288943Sdim if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) { 4202288943Sdim ToExceptionDecl = 4203288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 4204288943Sdim if (!ToExceptionDecl) 4205288943Sdim return nullptr; 4206288943Sdim } 4207288943Sdim Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock()); 4208288943Sdim if (!ToHandlerBlock && S->getHandlerBlock()) 4209288943Sdim return nullptr; 4210288943Sdim return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc, 4211288943Sdim ToExceptionDecl, 4212288943Sdim ToHandlerBlock); 4213288943Sdim} 4214288943Sdim 4215288943SdimStmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) { 4216288943Sdim SourceLocation ToTryLoc = Importer.Import(S->getTryLoc()); 4217288943Sdim Stmt *ToTryBlock = Importer.Import(S->getTryBlock()); 4218288943Sdim if (!ToTryBlock && S->getTryBlock()) 4219288943Sdim return nullptr; 4220288943Sdim SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers()); 4221288943Sdim for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) { 4222288943Sdim CXXCatchStmt *FromHandler = S->getHandler(HI); 4223288943Sdim if (Stmt *ToHandler = Importer.Import(FromHandler)) 4224288943Sdim ToHandlers[HI] = ToHandler; 4225288943Sdim else 4226288943Sdim return nullptr; 4227288943Sdim } 4228288943Sdim return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock, 4229288943Sdim ToHandlers); 4230288943Sdim} 4231288943Sdim 4232288943SdimStmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 4233288943Sdim DeclStmt *ToRange = 4234288943Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt())); 4235288943Sdim if (!ToRange && S->getRangeStmt()) 4236288943Sdim return nullptr; 4237309124Sdim DeclStmt *ToBegin = 4238309124Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt())); 4239309124Sdim if (!ToBegin && S->getBeginStmt()) 4240288943Sdim return nullptr; 4241309124Sdim DeclStmt *ToEnd = 4242309124Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt())); 4243309124Sdim if (!ToEnd && S->getEndStmt()) 4244309124Sdim return nullptr; 4245288943Sdim Expr *ToCond = Importer.Import(S->getCond()); 4246288943Sdim if (!ToCond && S->getCond()) 4247288943Sdim return nullptr; 4248288943Sdim Expr *ToInc = Importer.Import(S->getInc()); 4249288943Sdim if (!ToInc && S->getInc()) 4250288943Sdim return nullptr; 4251288943Sdim DeclStmt *ToLoopVar = 4252288943Sdim dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt())); 4253288943Sdim if (!ToLoopVar && S->getLoopVarStmt()) 4254288943Sdim return nullptr; 4255288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4256288943Sdim if (!ToBody && S->getBody()) 4257288943Sdim return nullptr; 4258288943Sdim SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4259296417Sdim SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc()); 4260288943Sdim SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4261288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4262309124Sdim return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd, 4263288943Sdim ToCond, ToInc, 4264288943Sdim ToLoopVar, ToBody, 4265296417Sdim ToForLoc, ToCoawaitLoc, 4266296417Sdim ToColonLoc, ToRParenLoc); 4267288943Sdim} 4268288943Sdim 4269288943SdimStmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 4270288943Sdim Stmt *ToElem = Importer.Import(S->getElement()); 4271288943Sdim if (!ToElem && S->getElement()) 4272288943Sdim return nullptr; 4273288943Sdim Expr *ToCollect = Importer.Import(S->getCollection()); 4274288943Sdim if (!ToCollect && S->getCollection()) 4275288943Sdim return nullptr; 4276288943Sdim Stmt *ToBody = Importer.Import(S->getBody()); 4277288943Sdim if (!ToBody && S->getBody()) 4278288943Sdim return nullptr; 4279288943Sdim SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4280288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4281288943Sdim return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem, 4282288943Sdim ToCollect, 4283288943Sdim ToBody, ToForLoc, 4284288943Sdim ToRParenLoc); 4285288943Sdim} 4286288943Sdim 4287288943SdimStmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 4288288943Sdim SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc()); 4289288943Sdim SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4290288943Sdim VarDecl *ToExceptionDecl = nullptr; 4291288943Sdim if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) { 4292288943Sdim ToExceptionDecl = 4293288943Sdim dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 4294288943Sdim if (!ToExceptionDecl) 4295288943Sdim return nullptr; 4296288943Sdim } 4297288943Sdim Stmt *ToBody = Importer.Import(S->getCatchBody()); 4298288943Sdim if (!ToBody && S->getCatchBody()) 4299288943Sdim return nullptr; 4300288943Sdim return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc, 4301288943Sdim ToRParenLoc, 4302288943Sdim ToExceptionDecl, 4303288943Sdim ToBody); 4304288943Sdim} 4305288943Sdim 4306288943SdimStmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 4307288943Sdim SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc()); 4308288943Sdim Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody()); 4309288943Sdim if (!ToAtFinallyStmt && S->getFinallyBody()) 4310288943Sdim return nullptr; 4311288943Sdim return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc, 4312288943Sdim ToAtFinallyStmt); 4313288943Sdim} 4314288943Sdim 4315288943SdimStmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 4316288943Sdim SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc()); 4317288943Sdim Stmt *ToAtTryStmt = Importer.Import(S->getTryBody()); 4318288943Sdim if (!ToAtTryStmt && S->getTryBody()) 4319288943Sdim return nullptr; 4320288943Sdim SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts()); 4321288943Sdim for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) { 4322288943Sdim ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI); 4323288943Sdim if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt)) 4324288943Sdim ToCatchStmts[CI] = ToCatchStmt; 4325288943Sdim else 4326288943Sdim return nullptr; 4327288943Sdim } 4328288943Sdim Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt()); 4329288943Sdim if (!ToAtFinallyStmt && S->getFinallyStmt()) 4330288943Sdim return nullptr; 4331288943Sdim return ObjCAtTryStmt::Create(Importer.getToContext(), 4332288943Sdim ToAtTryLoc, ToAtTryStmt, 4333288943Sdim ToCatchStmts.begin(), ToCatchStmts.size(), 4334288943Sdim ToAtFinallyStmt); 4335288943Sdim} 4336288943Sdim 4337288943SdimStmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt 4338288943Sdim (ObjCAtSynchronizedStmt *S) { 4339288943Sdim SourceLocation ToAtSynchronizedLoc = 4340288943Sdim Importer.Import(S->getAtSynchronizedLoc()); 4341288943Sdim Expr *ToSynchExpr = Importer.Import(S->getSynchExpr()); 4342288943Sdim if (!ToSynchExpr && S->getSynchExpr()) 4343288943Sdim return nullptr; 4344288943Sdim Stmt *ToSynchBody = Importer.Import(S->getSynchBody()); 4345288943Sdim if (!ToSynchBody && S->getSynchBody()) 4346288943Sdim return nullptr; 4347288943Sdim return new (Importer.getToContext()) ObjCAtSynchronizedStmt( 4348288943Sdim ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody); 4349288943Sdim} 4350288943Sdim 4351288943SdimStmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 4352288943Sdim SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc()); 4353288943Sdim Expr *ToThrow = Importer.Import(S->getThrowExpr()); 4354288943Sdim if (!ToThrow && S->getThrowExpr()) 4355288943Sdim return nullptr; 4356288943Sdim return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow); 4357288943Sdim} 4358288943Sdim 4359288943SdimStmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt 4360288943Sdim (ObjCAutoreleasePoolStmt *S) { 4361288943Sdim SourceLocation ToAtLoc = Importer.Import(S->getAtLoc()); 4362288943Sdim Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4363288943Sdim if (!ToSubStmt && S->getSubStmt()) 4364288943Sdim return nullptr; 4365288943Sdim return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc, 4366288943Sdim ToSubStmt); 4367288943Sdim} 4368288943Sdim 4369203955Srdivacky//---------------------------------------------------------------------------- 4370203955Srdivacky// Import Expressions 4371203955Srdivacky//---------------------------------------------------------------------------- 4372203955SrdivackyExpr *ASTNodeImporter::VisitExpr(Expr *E) { 4373203955Srdivacky Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node) 4374203955Srdivacky << E->getStmtClassName(); 4375276479Sdim return nullptr; 4376203955Srdivacky} 4377203955Srdivacky 4378309124SdimExpr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) { 4379309124Sdim QualType T = Importer.Import(E->getType()); 4380309124Sdim if (T.isNull()) 4381309124Sdim return nullptr; 4382309124Sdim 4383309124Sdim Expr *SubExpr = Importer.Import(E->getSubExpr()); 4384309124Sdim if (!SubExpr && E->getSubExpr()) 4385309124Sdim return nullptr; 4386309124Sdim 4387309124Sdim TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo()); 4388309124Sdim if (!TInfo) 4389309124Sdim return nullptr; 4390309124Sdim 4391309124Sdim return new (Importer.getToContext()) VAArgExpr( 4392309124Sdim Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo, 4393309124Sdim Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI()); 4394309124Sdim} 4395309124Sdim 4396309124Sdim 4397309124SdimExpr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) { 4398309124Sdim QualType T = Importer.Import(E->getType()); 4399309124Sdim if (T.isNull()) 4400309124Sdim return nullptr; 4401309124Sdim 4402309124Sdim return new (Importer.getToContext()) GNUNullExpr( 4403314564Sdim T, Importer.Import(E->getLocStart())); 4404309124Sdim} 4405309124Sdim 4406309124SdimExpr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) { 4407309124Sdim QualType T = Importer.Import(E->getType()); 4408309124Sdim if (T.isNull()) 4409309124Sdim return nullptr; 4410309124Sdim 4411309124Sdim StringLiteral *SL = cast_or_null<StringLiteral>( 4412309124Sdim Importer.Import(E->getFunctionName())); 4413309124Sdim if (!SL && E->getFunctionName()) 4414309124Sdim return nullptr; 4415309124Sdim 4416309124Sdim return new (Importer.getToContext()) PredefinedExpr( 4417314564Sdim Importer.Import(E->getLocStart()), T, E->getIdentType(), SL); 4418309124Sdim} 4419309124Sdim 4420204643SrdivackyExpr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) { 4421204643Srdivacky ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl())); 4422204643Srdivacky if (!ToD) 4423276479Sdim return nullptr; 4424221345Sdim 4425276479Sdim NamedDecl *FoundD = nullptr; 4426221345Sdim if (E->getDecl() != E->getFoundDecl()) { 4427221345Sdim FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl())); 4428221345Sdim if (!FoundD) 4429276479Sdim return nullptr; 4430221345Sdim } 4431204643Srdivacky 4432204643Srdivacky QualType T = Importer.Import(E->getType()); 4433204643Srdivacky if (T.isNull()) 4434276479Sdim return nullptr; 4435226633Sdim 4436314564Sdim 4437314564Sdim TemplateArgumentListInfo ToTAInfo; 4438314564Sdim TemplateArgumentListInfo *ResInfo = nullptr; 4439314564Sdim if (E->hasExplicitTemplateArgs()) { 4440314564Sdim for (const auto &FromLoc : E->template_arguments()) { 4441314564Sdim bool Error = false; 4442314564Sdim TemplateArgumentLoc ToTALoc = ImportTemplateArgumentLoc(FromLoc, Error); 4443314564Sdim if (Error) 4444314564Sdim return nullptr; 4445314564Sdim ToTAInfo.addArgument(ToTALoc); 4446314564Sdim } 4447314564Sdim ResInfo = &ToTAInfo; 4448314564Sdim } 4449314564Sdim 4450226633Sdim DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(), 4451226633Sdim Importer.Import(E->getQualifierLoc()), 4452234353Sdim Importer.Import(E->getTemplateKeywordLoc()), 4453226633Sdim ToD, 4454280031Sdim E->refersToEnclosingVariableOrCapture(), 4455226633Sdim Importer.Import(E->getLocation()), 4456226633Sdim T, E->getValueKind(), 4457314564Sdim FoundD, ResInfo); 4458226633Sdim if (E->hadMultipleCandidates()) 4459226633Sdim DRE->setHadMultipleCandidates(true); 4460226633Sdim return DRE; 4461204643Srdivacky} 4462204643Srdivacky 4463309124SdimExpr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 4464309124Sdim QualType T = Importer.Import(E->getType()); 4465309124Sdim if (T.isNull()) 4466314564Sdim return nullptr; 4467309124Sdim 4468309124Sdim return new (Importer.getToContext()) ImplicitValueInitExpr(T); 4469309124Sdim} 4470309124Sdim 4471309124SdimASTNodeImporter::Designator 4472309124SdimASTNodeImporter::ImportDesignator(const Designator &D) { 4473309124Sdim if (D.isFieldDesignator()) { 4474309124Sdim IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName()); 4475309124Sdim // Caller checks for import error 4476309124Sdim return Designator(ToFieldName, Importer.Import(D.getDotLoc()), 4477309124Sdim Importer.Import(D.getFieldLoc())); 4478309124Sdim } 4479309124Sdim if (D.isArrayDesignator()) 4480309124Sdim return Designator(D.getFirstExprIndex(), 4481309124Sdim Importer.Import(D.getLBracketLoc()), 4482309124Sdim Importer.Import(D.getRBracketLoc())); 4483309124Sdim 4484309124Sdim assert(D.isArrayRangeDesignator()); 4485309124Sdim return Designator(D.getFirstExprIndex(), 4486309124Sdim Importer.Import(D.getLBracketLoc()), 4487309124Sdim Importer.Import(D.getEllipsisLoc()), 4488309124Sdim Importer.Import(D.getRBracketLoc())); 4489309124Sdim} 4490309124Sdim 4491309124Sdim 4492309124SdimExpr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) { 4493309124Sdim Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit())); 4494309124Sdim if (!Init) 4495309124Sdim return nullptr; 4496309124Sdim 4497309124Sdim SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1); 4498309124Sdim // List elements from the second, the first is Init itself 4499309124Sdim for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) { 4500309124Sdim if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I)))) 4501309124Sdim IndexExprs[I - 1] = Arg; 4502309124Sdim else 4503309124Sdim return nullptr; 4504309124Sdim } 4505309124Sdim 4506309124Sdim SmallVector<Designator, 4> Designators(DIE->size()); 4507309124Sdim llvm::transform(DIE->designators(), Designators.begin(), 4508309124Sdim [this](const Designator &D) -> Designator { 4509309124Sdim return ImportDesignator(D); 4510309124Sdim }); 4511309124Sdim 4512309124Sdim for (const Designator &D : DIE->designators()) 4513309124Sdim if (D.isFieldDesignator() && !D.getFieldName()) 4514309124Sdim return nullptr; 4515309124Sdim 4516309124Sdim return DesignatedInitExpr::Create( 4517309124Sdim Importer.getToContext(), Designators, 4518309124Sdim IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()), 4519309124Sdim DIE->usesGNUSyntax(), Init); 4520309124Sdim} 4521309124Sdim 4522309124SdimExpr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 4523309124Sdim QualType T = Importer.Import(E->getType()); 4524309124Sdim if (T.isNull()) 4525309124Sdim return nullptr; 4526309124Sdim 4527309124Sdim return new (Importer.getToContext()) 4528309124Sdim CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation())); 4529309124Sdim} 4530309124Sdim 4531203955SrdivackyExpr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) { 4532203955Srdivacky QualType T = Importer.Import(E->getType()); 4533203955Srdivacky if (T.isNull()) 4534276479Sdim return nullptr; 4535203955Srdivacky 4536212904Sdim return IntegerLiteral::Create(Importer.getToContext(), 4537212904Sdim E->getValue(), T, 4538212904Sdim Importer.Import(E->getLocation())); 4539203955Srdivacky} 4540203955Srdivacky 4541309124SdimExpr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) { 4542309124Sdim QualType T = Importer.Import(E->getType()); 4543309124Sdim if (T.isNull()) 4544309124Sdim return nullptr; 4545309124Sdim 4546309124Sdim return FloatingLiteral::Create(Importer.getToContext(), 4547309124Sdim E->getValue(), E->isExact(), T, 4548309124Sdim Importer.Import(E->getLocation())); 4549309124Sdim} 4550309124Sdim 4551204643SrdivackyExpr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) { 4552204643Srdivacky QualType T = Importer.Import(E->getType()); 4553204643Srdivacky if (T.isNull()) 4554276479Sdim return nullptr; 4555276479Sdim 4556226633Sdim return new (Importer.getToContext()) CharacterLiteral(E->getValue(), 4557226633Sdim E->getKind(), T, 4558204643Srdivacky Importer.Import(E->getLocation())); 4559204643Srdivacky} 4560204643Srdivacky 4561309124SdimExpr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) { 4562309124Sdim QualType T = Importer.Import(E->getType()); 4563309124Sdim if (T.isNull()) 4564309124Sdim return nullptr; 4565309124Sdim 4566309124Sdim SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated()); 4567309124Sdim ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin()); 4568309124Sdim 4569309124Sdim return StringLiteral::Create(Importer.getToContext(), E->getBytes(), 4570309124Sdim E->getKind(), E->isPascal(), T, 4571309124Sdim Locations.data(), Locations.size()); 4572309124Sdim} 4573309124Sdim 4574309124SdimExpr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 4575309124Sdim QualType T = Importer.Import(E->getType()); 4576309124Sdim if (T.isNull()) 4577309124Sdim return nullptr; 4578309124Sdim 4579309124Sdim TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo()); 4580309124Sdim if (!TInfo) 4581309124Sdim return nullptr; 4582309124Sdim 4583309124Sdim Expr *Init = Importer.Import(E->getInitializer()); 4584309124Sdim if (!Init) 4585309124Sdim return nullptr; 4586309124Sdim 4587309124Sdim return new (Importer.getToContext()) CompoundLiteralExpr( 4588309124Sdim Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(), 4589309124Sdim Init, E->isFileScope()); 4590309124Sdim} 4591309124Sdim 4592309124SdimExpr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) { 4593309124Sdim QualType T = Importer.Import(E->getType()); 4594309124Sdim if (T.isNull()) 4595309124Sdim return nullptr; 4596309124Sdim 4597309124Sdim SmallVector<Expr *, 6> Exprs(E->getNumSubExprs()); 4598309124Sdim if (ImportArrayChecked( 4599309124Sdim E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(), 4600309124Sdim Exprs.begin())) 4601309124Sdim return nullptr; 4602309124Sdim 4603309124Sdim return new (Importer.getToContext()) AtomicExpr( 4604309124Sdim Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(), 4605309124Sdim Importer.Import(E->getRParenLoc())); 4606309124Sdim} 4607309124Sdim 4608309124SdimExpr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) { 4609309124Sdim QualType T = Importer.Import(E->getType()); 4610309124Sdim if (T.isNull()) 4611309124Sdim return nullptr; 4612309124Sdim 4613309124Sdim LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel())); 4614309124Sdim if (!ToLabel) 4615309124Sdim return nullptr; 4616309124Sdim 4617309124Sdim return new (Importer.getToContext()) AddrLabelExpr( 4618309124Sdim Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()), 4619309124Sdim ToLabel, T); 4620309124Sdim} 4621309124Sdim 4622204643SrdivackyExpr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) { 4623204643Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 4624204643Srdivacky if (!SubExpr) 4625276479Sdim return nullptr; 4626276479Sdim 4627204643Srdivacky return new (Importer.getToContext()) 4628204643Srdivacky ParenExpr(Importer.Import(E->getLParen()), 4629204643Srdivacky Importer.Import(E->getRParen()), 4630204643Srdivacky SubExpr); 4631204643Srdivacky} 4632204643Srdivacky 4633309124SdimExpr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) { 4634309124Sdim SmallVector<Expr *, 4> Exprs(E->getNumExprs()); 4635314564Sdim if (ImportContainerChecked(E->exprs(), Exprs)) 4636309124Sdim return nullptr; 4637309124Sdim 4638309124Sdim return new (Importer.getToContext()) ParenListExpr( 4639309124Sdim Importer.getToContext(), Importer.Import(E->getLParenLoc()), 4640309124Sdim Exprs, Importer.Import(E->getLParenLoc())); 4641309124Sdim} 4642309124Sdim 4643309124SdimExpr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) { 4644309124Sdim QualType T = Importer.Import(E->getType()); 4645309124Sdim if (T.isNull()) 4646309124Sdim return nullptr; 4647309124Sdim 4648309124Sdim CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>( 4649309124Sdim Importer.Import(E->getSubStmt())); 4650309124Sdim if (!ToSubStmt && E->getSubStmt()) 4651309124Sdim return nullptr; 4652309124Sdim 4653309124Sdim return new (Importer.getToContext()) StmtExpr(ToSubStmt, T, 4654309124Sdim Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc())); 4655309124Sdim} 4656309124Sdim 4657204643SrdivackyExpr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) { 4658204643Srdivacky QualType T = Importer.Import(E->getType()); 4659204643Srdivacky if (T.isNull()) 4660276479Sdim return nullptr; 4661204643Srdivacky 4662204643Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 4663204643Srdivacky if (!SubExpr) 4664276479Sdim return nullptr; 4665276479Sdim 4666204643Srdivacky return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(), 4667218893Sdim T, E->getValueKind(), 4668218893Sdim E->getObjectKind(), 4669204643Srdivacky Importer.Import(E->getOperatorLoc())); 4670204643Srdivacky} 4671204643Srdivacky 4672221345SdimExpr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr( 4673221345Sdim UnaryExprOrTypeTraitExpr *E) { 4674204643Srdivacky QualType ResultType = Importer.Import(E->getType()); 4675204643Srdivacky 4676204643Srdivacky if (E->isArgumentType()) { 4677204643Srdivacky TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo()); 4678204643Srdivacky if (!TInfo) 4679276479Sdim return nullptr; 4680276479Sdim 4681221345Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 4682221345Sdim TInfo, ResultType, 4683204643Srdivacky Importer.Import(E->getOperatorLoc()), 4684204643Srdivacky Importer.Import(E->getRParenLoc())); 4685204643Srdivacky } 4686204643Srdivacky 4687204643Srdivacky Expr *SubExpr = Importer.Import(E->getArgumentExpr()); 4688204643Srdivacky if (!SubExpr) 4689276479Sdim return nullptr; 4690276479Sdim 4691221345Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 4692221345Sdim SubExpr, ResultType, 4693204643Srdivacky Importer.Import(E->getOperatorLoc()), 4694204643Srdivacky Importer.Import(E->getRParenLoc())); 4695204643Srdivacky} 4696204643Srdivacky 4697204643SrdivackyExpr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) { 4698204643Srdivacky QualType T = Importer.Import(E->getType()); 4699204643Srdivacky if (T.isNull()) 4700276479Sdim return nullptr; 4701204643Srdivacky 4702204643Srdivacky Expr *LHS = Importer.Import(E->getLHS()); 4703204643Srdivacky if (!LHS) 4704276479Sdim return nullptr; 4705276479Sdim 4706204643Srdivacky Expr *RHS = Importer.Import(E->getRHS()); 4707204643Srdivacky if (!RHS) 4708276479Sdim return nullptr; 4709276479Sdim 4710204643Srdivacky return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(), 4711218893Sdim T, E->getValueKind(), 4712218893Sdim E->getObjectKind(), 4713243830Sdim Importer.Import(E->getOperatorLoc()), 4714321369Sdim E->getFPFeatures()); 4715204643Srdivacky} 4716204643Srdivacky 4717309124SdimExpr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) { 4718309124Sdim QualType T = Importer.Import(E->getType()); 4719309124Sdim if (T.isNull()) 4720309124Sdim return nullptr; 4721309124Sdim 4722309124Sdim Expr *ToLHS = Importer.Import(E->getLHS()); 4723309124Sdim if (!ToLHS) 4724309124Sdim return nullptr; 4725309124Sdim 4726309124Sdim Expr *ToRHS = Importer.Import(E->getRHS()); 4727309124Sdim if (!ToRHS) 4728309124Sdim return nullptr; 4729309124Sdim 4730309124Sdim Expr *ToCond = Importer.Import(E->getCond()); 4731309124Sdim if (!ToCond) 4732309124Sdim return nullptr; 4733309124Sdim 4734309124Sdim return new (Importer.getToContext()) ConditionalOperator( 4735309124Sdim ToCond, Importer.Import(E->getQuestionLoc()), 4736309124Sdim ToLHS, Importer.Import(E->getColonLoc()), 4737309124Sdim ToRHS, T, E->getValueKind(), E->getObjectKind()); 4738309124Sdim} 4739309124Sdim 4740309124SdimExpr *ASTNodeImporter::VisitBinaryConditionalOperator( 4741309124Sdim BinaryConditionalOperator *E) { 4742309124Sdim QualType T = Importer.Import(E->getType()); 4743309124Sdim if (T.isNull()) 4744309124Sdim return nullptr; 4745309124Sdim 4746309124Sdim Expr *Common = Importer.Import(E->getCommon()); 4747309124Sdim if (!Common) 4748309124Sdim return nullptr; 4749309124Sdim 4750309124Sdim Expr *Cond = Importer.Import(E->getCond()); 4751309124Sdim if (!Cond) 4752309124Sdim return nullptr; 4753309124Sdim 4754309124Sdim OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>( 4755309124Sdim Importer.Import(E->getOpaqueValue())); 4756309124Sdim if (!OpaqueValue) 4757309124Sdim return nullptr; 4758309124Sdim 4759309124Sdim Expr *TrueExpr = Importer.Import(E->getTrueExpr()); 4760309124Sdim if (!TrueExpr) 4761309124Sdim return nullptr; 4762309124Sdim 4763309124Sdim Expr *FalseExpr = Importer.Import(E->getFalseExpr()); 4764309124Sdim if (!FalseExpr) 4765309124Sdim return nullptr; 4766309124Sdim 4767309124Sdim return new (Importer.getToContext()) BinaryConditionalOperator( 4768309124Sdim Common, OpaqueValue, Cond, TrueExpr, FalseExpr, 4769309124Sdim Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()), 4770309124Sdim T, E->getValueKind(), E->getObjectKind()); 4771309124Sdim} 4772309124Sdim 4773314564SdimExpr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 4774314564Sdim QualType T = Importer.Import(E->getType()); 4775314564Sdim if (T.isNull()) 4776314564Sdim return nullptr; 4777314564Sdim 4778314564Sdim TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo()); 4779314564Sdim if (!ToQueried) 4780314564Sdim return nullptr; 4781314564Sdim 4782314564Sdim Expr *Dim = Importer.Import(E->getDimensionExpression()); 4783314564Sdim if (!Dim && E->getDimensionExpression()) 4784314564Sdim return nullptr; 4785314564Sdim 4786314564Sdim return new (Importer.getToContext()) ArrayTypeTraitExpr( 4787314564Sdim Importer.Import(E->getLocStart()), E->getTrait(), ToQueried, 4788314564Sdim E->getValue(), Dim, Importer.Import(E->getLocEnd()), T); 4789314564Sdim} 4790314564Sdim 4791314564SdimExpr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 4792314564Sdim QualType T = Importer.Import(E->getType()); 4793314564Sdim if (T.isNull()) 4794314564Sdim return nullptr; 4795314564Sdim 4796314564Sdim Expr *ToQueried = Importer.Import(E->getQueriedExpression()); 4797314564Sdim if (!ToQueried) 4798314564Sdim return nullptr; 4799314564Sdim 4800314564Sdim return new (Importer.getToContext()) ExpressionTraitExpr( 4801314564Sdim Importer.Import(E->getLocStart()), E->getTrait(), ToQueried, 4802314564Sdim E->getValue(), Importer.Import(E->getLocEnd()), T); 4803314564Sdim} 4804314564Sdim 4805309124SdimExpr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 4806309124Sdim QualType T = Importer.Import(E->getType()); 4807309124Sdim if (T.isNull()) 4808309124Sdim return nullptr; 4809309124Sdim 4810309124Sdim Expr *SourceExpr = Importer.Import(E->getSourceExpr()); 4811309124Sdim if (!SourceExpr && E->getSourceExpr()) 4812309124Sdim return nullptr; 4813309124Sdim 4814309124Sdim return new (Importer.getToContext()) OpaqueValueExpr( 4815314564Sdim Importer.Import(E->getLocation()), T, E->getValueKind(), 4816309124Sdim E->getObjectKind(), SourceExpr); 4817309124Sdim} 4818309124Sdim 4819314564SdimExpr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 4820314564Sdim QualType T = Importer.Import(E->getType()); 4821314564Sdim if (T.isNull()) 4822314564Sdim return nullptr; 4823314564Sdim 4824314564Sdim Expr *ToLHS = Importer.Import(E->getLHS()); 4825314564Sdim if (!ToLHS) 4826314564Sdim return nullptr; 4827314564Sdim 4828314564Sdim Expr *ToRHS = Importer.Import(E->getRHS()); 4829314564Sdim if (!ToRHS) 4830314564Sdim return nullptr; 4831314564Sdim 4832314564Sdim return new (Importer.getToContext()) ArraySubscriptExpr( 4833314564Sdim ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(), 4834314564Sdim Importer.Import(E->getRBracketLoc())); 4835314564Sdim} 4836314564Sdim 4837204643SrdivackyExpr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 4838204643Srdivacky QualType T = Importer.Import(E->getType()); 4839204643Srdivacky if (T.isNull()) 4840276479Sdim return nullptr; 4841276479Sdim 4842204643Srdivacky QualType CompLHSType = Importer.Import(E->getComputationLHSType()); 4843204643Srdivacky if (CompLHSType.isNull()) 4844276479Sdim return nullptr; 4845276479Sdim 4846204643Srdivacky QualType CompResultType = Importer.Import(E->getComputationResultType()); 4847204643Srdivacky if (CompResultType.isNull()) 4848276479Sdim return nullptr; 4849276479Sdim 4850204643Srdivacky Expr *LHS = Importer.Import(E->getLHS()); 4851204643Srdivacky if (!LHS) 4852276479Sdim return nullptr; 4853276479Sdim 4854204643Srdivacky Expr *RHS = Importer.Import(E->getRHS()); 4855204643Srdivacky if (!RHS) 4856276479Sdim return nullptr; 4857276479Sdim 4858204643Srdivacky return new (Importer.getToContext()) 4859204643Srdivacky CompoundAssignOperator(LHS, RHS, E->getOpcode(), 4860218893Sdim T, E->getValueKind(), 4861218893Sdim E->getObjectKind(), 4862218893Sdim CompLHSType, CompResultType, 4863243830Sdim Importer.Import(E->getOperatorLoc()), 4864321369Sdim E->getFPFeatures()); 4865204643Srdivacky} 4866204643Srdivacky 4867314564Sdimbool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) { 4868314564Sdim for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) { 4869314564Sdim if (CXXBaseSpecifier *Spec = Importer.Import(*I)) 4870314564Sdim Path.push_back(Spec); 4871314564Sdim else 4872314564Sdim return true; 4873314564Sdim } 4874314564Sdim return false; 4875212904Sdim} 4876212904Sdim 4877203955SrdivackyExpr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) { 4878203955Srdivacky QualType T = Importer.Import(E->getType()); 4879203955Srdivacky if (T.isNull()) 4880276479Sdim return nullptr; 4881203955Srdivacky 4882203955Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 4883203955Srdivacky if (!SubExpr) 4884276479Sdim return nullptr; 4885212904Sdim 4886212904Sdim CXXCastPath BasePath; 4887212904Sdim if (ImportCastPath(E, BasePath)) 4888276479Sdim return nullptr; 4889212904Sdim 4890212904Sdim return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(), 4891212904Sdim SubExpr, &BasePath, E->getValueKind()); 4892203955Srdivacky} 4893203955Srdivacky 4894314564SdimExpr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) { 4895204643Srdivacky QualType T = Importer.Import(E->getType()); 4896204643Srdivacky if (T.isNull()) 4897276479Sdim return nullptr; 4898276479Sdim 4899204643Srdivacky Expr *SubExpr = Importer.Import(E->getSubExpr()); 4900204643Srdivacky if (!SubExpr) 4901276479Sdim return nullptr; 4902204643Srdivacky 4903204643Srdivacky TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten()); 4904204643Srdivacky if (!TInfo && E->getTypeInfoAsWritten()) 4905276479Sdim return nullptr; 4906276479Sdim 4907212904Sdim CXXCastPath BasePath; 4908212904Sdim if (ImportCastPath(E, BasePath)) 4909276479Sdim return nullptr; 4910212904Sdim 4911314564Sdim switch (E->getStmtClass()) { 4912314564Sdim case Stmt::CStyleCastExprClass: { 4913314564Sdim CStyleCastExpr *CCE = cast<CStyleCastExpr>(E); 4914314564Sdim return CStyleCastExpr::Create(Importer.getToContext(), T, 4915314564Sdim E->getValueKind(), E->getCastKind(), 4916314564Sdim SubExpr, &BasePath, TInfo, 4917314564Sdim Importer.Import(CCE->getLParenLoc()), 4918314564Sdim Importer.Import(CCE->getRParenLoc())); 4919314564Sdim } 4920314564Sdim 4921314564Sdim case Stmt::CXXFunctionalCastExprClass: { 4922314564Sdim CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E); 4923314564Sdim return CXXFunctionalCastExpr::Create(Importer.getToContext(), T, 4924314564Sdim E->getValueKind(), TInfo, 4925314564Sdim E->getCastKind(), SubExpr, &BasePath, 4926314564Sdim Importer.Import(FCE->getLParenLoc()), 4927314564Sdim Importer.Import(FCE->getRParenLoc())); 4928314564Sdim } 4929314564Sdim 4930314564Sdim case Stmt::ObjCBridgedCastExprClass: { 4931314564Sdim ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E); 4932314564Sdim return new (Importer.getToContext()) ObjCBridgedCastExpr( 4933314564Sdim Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(), 4934314564Sdim E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()), 4935314564Sdim TInfo, SubExpr); 4936314564Sdim } 4937314564Sdim default: 4938314564Sdim break; // just fall through 4939314564Sdim } 4940314564Sdim 4941314564Sdim CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E); 4942314564Sdim SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()), 4943314564Sdim RParenLoc = Importer.Import(Named->getRParenLoc()); 4944314564Sdim SourceRange Brackets = Importer.Import(Named->getAngleBrackets()); 4945314564Sdim 4946314564Sdim switch (E->getStmtClass()) { 4947314564Sdim case Stmt::CXXStaticCastExprClass: 4948314564Sdim return CXXStaticCastExpr::Create(Importer.getToContext(), T, 4949314564Sdim E->getValueKind(), E->getCastKind(), 4950314564Sdim SubExpr, &BasePath, TInfo, 4951314564Sdim ExprLoc, RParenLoc, Brackets); 4952314564Sdim 4953314564Sdim case Stmt::CXXDynamicCastExprClass: 4954314564Sdim return CXXDynamicCastExpr::Create(Importer.getToContext(), T, 4955314564Sdim E->getValueKind(), E->getCastKind(), 4956314564Sdim SubExpr, &BasePath, TInfo, 4957314564Sdim ExprLoc, RParenLoc, Brackets); 4958314564Sdim 4959314564Sdim case Stmt::CXXReinterpretCastExprClass: 4960314564Sdim return CXXReinterpretCastExpr::Create(Importer.getToContext(), T, 4961314564Sdim E->getValueKind(), E->getCastKind(), 4962314564Sdim SubExpr, &BasePath, TInfo, 4963314564Sdim ExprLoc, RParenLoc, Brackets); 4964314564Sdim 4965314564Sdim case Stmt::CXXConstCastExprClass: 4966314564Sdim return CXXConstCastExpr::Create(Importer.getToContext(), T, 4967314564Sdim E->getValueKind(), SubExpr, TInfo, ExprLoc, 4968314564Sdim RParenLoc, Brackets); 4969314564Sdim default: 4970314564Sdim llvm_unreachable("Cast expression of unsupported type!"); 4971314564Sdim return nullptr; 4972314564Sdim } 4973204643Srdivacky} 4974204643Srdivacky 4975314564SdimExpr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) { 4976314564Sdim QualType T = Importer.Import(OE->getType()); 4977314564Sdim if (T.isNull()) 4978314564Sdim return nullptr; 4979314564Sdim 4980314564Sdim SmallVector<OffsetOfNode, 4> Nodes; 4981314564Sdim for (int I = 0, E = OE->getNumComponents(); I < E; ++I) { 4982314564Sdim const OffsetOfNode &Node = OE->getComponent(I); 4983314564Sdim 4984314564Sdim switch (Node.getKind()) { 4985314564Sdim case OffsetOfNode::Array: 4986314564Sdim Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), 4987314564Sdim Node.getArrayExprIndex(), 4988314564Sdim Importer.Import(Node.getLocEnd()))); 4989314564Sdim break; 4990314564Sdim 4991314564Sdim case OffsetOfNode::Base: { 4992314564Sdim CXXBaseSpecifier *BS = Importer.Import(Node.getBase()); 4993314564Sdim if (!BS && Node.getBase()) 4994314564Sdim return nullptr; 4995314564Sdim Nodes.push_back(OffsetOfNode(BS)); 4996314564Sdim break; 4997314564Sdim } 4998314564Sdim case OffsetOfNode::Field: { 4999314564Sdim FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField())); 5000314564Sdim if (!FD) 5001314564Sdim return nullptr; 5002314564Sdim Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD, 5003314564Sdim Importer.Import(Node.getLocEnd()))); 5004314564Sdim break; 5005314564Sdim } 5006314564Sdim case OffsetOfNode::Identifier: { 5007314564Sdim IdentifierInfo *ToII = Importer.Import(Node.getFieldName()); 5008314564Sdim if (!ToII) 5009314564Sdim return nullptr; 5010314564Sdim Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII, 5011314564Sdim Importer.Import(Node.getLocEnd()))); 5012314564Sdim break; 5013314564Sdim } 5014314564Sdim } 5015314564Sdim } 5016314564Sdim 5017314564Sdim SmallVector<Expr *, 4> Exprs(OE->getNumExpressions()); 5018314564Sdim for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) { 5019314564Sdim Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I)); 5020314564Sdim if (!ToIndexExpr) 5021314564Sdim return nullptr; 5022314564Sdim Exprs[I] = ToIndexExpr; 5023314564Sdim } 5024314564Sdim 5025314564Sdim TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo()); 5026314564Sdim if (!TInfo && OE->getTypeSourceInfo()) 5027314564Sdim return nullptr; 5028314564Sdim 5029314564Sdim return OffsetOfExpr::Create(Importer.getToContext(), T, 5030314564Sdim Importer.Import(OE->getOperatorLoc()), 5031314564Sdim TInfo, Nodes, Exprs, 5032314564Sdim Importer.Import(OE->getRParenLoc())); 5033314564Sdim} 5034314564Sdim 5035314564SdimExpr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 5036314564Sdim QualType T = Importer.Import(E->getType()); 5037314564Sdim if (T.isNull()) 5038314564Sdim return nullptr; 5039314564Sdim 5040314564Sdim Expr *Operand = Importer.Import(E->getOperand()); 5041314564Sdim if (!Operand) 5042314564Sdim return nullptr; 5043314564Sdim 5044314564Sdim CanThrowResult CanThrow; 5045314564Sdim if (E->isValueDependent()) 5046314564Sdim CanThrow = CT_Dependent; 5047314564Sdim else 5048314564Sdim CanThrow = E->getValue() ? CT_Can : CT_Cannot; 5049314564Sdim 5050314564Sdim return new (Importer.getToContext()) CXXNoexceptExpr( 5051314564Sdim T, Operand, CanThrow, 5052314564Sdim Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd())); 5053314564Sdim} 5054314564Sdim 5055314564SdimExpr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) { 5056314564Sdim QualType T = Importer.Import(E->getType()); 5057314564Sdim if (T.isNull()) 5058314564Sdim return nullptr; 5059314564Sdim 5060314564Sdim Expr *SubExpr = Importer.Import(E->getSubExpr()); 5061314564Sdim if (!SubExpr && E->getSubExpr()) 5062314564Sdim return nullptr; 5063314564Sdim 5064314564Sdim return new (Importer.getToContext()) CXXThrowExpr( 5065314564Sdim SubExpr, T, Importer.Import(E->getThrowLoc()), 5066314564Sdim E->isThrownVariableInScope()); 5067314564Sdim} 5068314564Sdim 5069314564SdimExpr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 5070314564Sdim ParmVarDecl *Param = cast_or_null<ParmVarDecl>( 5071314564Sdim Importer.Import(E->getParam())); 5072314564Sdim if (!Param) 5073314564Sdim return nullptr; 5074314564Sdim 5075314564Sdim return CXXDefaultArgExpr::Create( 5076314564Sdim Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param); 5077314564Sdim} 5078314564Sdim 5079314564SdimExpr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 5080314564Sdim QualType T = Importer.Import(E->getType()); 5081314564Sdim if (T.isNull()) 5082314564Sdim return nullptr; 5083314564Sdim 5084314564Sdim TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo()); 5085314564Sdim if (!TypeInfo) 5086314564Sdim return nullptr; 5087314564Sdim 5088314564Sdim return new (Importer.getToContext()) CXXScalarValueInitExpr( 5089314564Sdim T, TypeInfo, Importer.Import(E->getRParenLoc())); 5090314564Sdim} 5091314564Sdim 5092314564SdimExpr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 5093314564Sdim Expr *SubExpr = Importer.Import(E->getSubExpr()); 5094314564Sdim if (!SubExpr) 5095314564Sdim return nullptr; 5096314564Sdim 5097314564Sdim auto *Dtor = cast_or_null<CXXDestructorDecl>( 5098314564Sdim Importer.Import(const_cast<CXXDestructorDecl *>( 5099314564Sdim E->getTemporary()->getDestructor()))); 5100314564Sdim if (!Dtor) 5101314564Sdim return nullptr; 5102314564Sdim 5103314564Sdim ASTContext &ToCtx = Importer.getToContext(); 5104314564Sdim CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor); 5105314564Sdim return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr); 5106314564Sdim} 5107314564Sdim 5108314564SdimExpr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) { 5109314564Sdim QualType T = Importer.Import(CE->getType()); 5110314564Sdim if (T.isNull()) 5111314564Sdim return nullptr; 5112314564Sdim 5113314564Sdim SmallVector<Expr *, 8> Args(CE->getNumArgs()); 5114314564Sdim if (ImportContainerChecked(CE->arguments(), Args)) 5115314564Sdim return nullptr; 5116314564Sdim 5117314564Sdim auto *Ctor = cast_or_null<CXXConstructorDecl>( 5118314564Sdim Importer.Import(CE->getConstructor())); 5119314564Sdim if (!Ctor) 5120314564Sdim return nullptr; 5121314564Sdim 5122314564Sdim return CXXTemporaryObjectExpr::Create( 5123314564Sdim Importer.getToContext(), T, 5124314564Sdim Importer.Import(CE->getLocStart()), 5125314564Sdim Ctor, 5126314564Sdim CE->isElidable(), 5127314564Sdim Args, 5128314564Sdim CE->hadMultipleCandidates(), 5129314564Sdim CE->isListInitialization(), 5130314564Sdim CE->isStdInitListInitialization(), 5131314564Sdim CE->requiresZeroInitialization(), 5132314564Sdim CE->getConstructionKind(), 5133314564Sdim Importer.Import(CE->getParenOrBraceRange())); 5134314564Sdim} 5135314564Sdim 5136314564SdimExpr * 5137314564SdimASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 5138314564Sdim QualType T = Importer.Import(E->getType()); 5139314564Sdim if (T.isNull()) 5140314564Sdim return nullptr; 5141314564Sdim 5142314564Sdim Expr *TempE = Importer.Import(E->GetTemporaryExpr()); 5143314564Sdim if (!TempE) 5144314564Sdim return nullptr; 5145314564Sdim 5146314564Sdim ValueDecl *ExtendedBy = cast_or_null<ValueDecl>( 5147314564Sdim Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl()))); 5148314564Sdim if (!ExtendedBy && E->getExtendingDecl()) 5149314564Sdim return nullptr; 5150314564Sdim 5151314564Sdim auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr( 5152314564Sdim T, TempE, E->isBoundToLvalueReference()); 5153314564Sdim 5154314564Sdim // FIXME: Should ManglingNumber get numbers associated with 'to' context? 5155314564Sdim ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber()); 5156314564Sdim return ToMTE; 5157314564Sdim} 5158314564Sdim 5159314564SdimExpr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) { 5160314564Sdim QualType T = Importer.Import(CE->getType()); 5161314564Sdim if (T.isNull()) 5162314564Sdim return nullptr; 5163314564Sdim 5164314564Sdim SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs()); 5165314564Sdim if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs)) 5166314564Sdim return nullptr; 5167314564Sdim 5168314564Sdim FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>( 5169314564Sdim Importer.Import(CE->getOperatorNew())); 5170314564Sdim if (!OperatorNewDecl && CE->getOperatorNew()) 5171314564Sdim return nullptr; 5172314564Sdim 5173314564Sdim FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>( 5174314564Sdim Importer.Import(CE->getOperatorDelete())); 5175314564Sdim if (!OperatorDeleteDecl && CE->getOperatorDelete()) 5176314564Sdim return nullptr; 5177314564Sdim 5178314564Sdim Expr *ToInit = Importer.Import(CE->getInitializer()); 5179314564Sdim if (!ToInit && CE->getInitializer()) 5180314564Sdim return nullptr; 5181314564Sdim 5182314564Sdim TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo()); 5183314564Sdim if (!TInfo) 5184314564Sdim return nullptr; 5185314564Sdim 5186314564Sdim Expr *ToArrSize = Importer.Import(CE->getArraySize()); 5187314564Sdim if (!ToArrSize && CE->getArraySize()) 5188314564Sdim return nullptr; 5189314564Sdim 5190314564Sdim return new (Importer.getToContext()) CXXNewExpr( 5191314564Sdim Importer.getToContext(), 5192314564Sdim CE->isGlobalNew(), 5193314564Sdim OperatorNewDecl, OperatorDeleteDecl, 5194314564Sdim CE->passAlignment(), 5195314564Sdim CE->doesUsualArrayDeleteWantSize(), 5196314564Sdim PlacementArgs, 5197314564Sdim Importer.Import(CE->getTypeIdParens()), 5198314564Sdim ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo, 5199314564Sdim Importer.Import(CE->getSourceRange()), 5200314564Sdim Importer.Import(CE->getDirectInitRange())); 5201314564Sdim} 5202314564Sdim 5203314564SdimExpr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 5204314564Sdim QualType T = Importer.Import(E->getType()); 5205314564Sdim if (T.isNull()) 5206314564Sdim return nullptr; 5207314564Sdim 5208314564Sdim FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>( 5209314564Sdim Importer.Import(E->getOperatorDelete())); 5210314564Sdim if (!OperatorDeleteDecl && E->getOperatorDelete()) 5211314564Sdim return nullptr; 5212314564Sdim 5213314564Sdim Expr *ToArg = Importer.Import(E->getArgument()); 5214314564Sdim if (!ToArg && E->getArgument()) 5215314564Sdim return nullptr; 5216314564Sdim 5217314564Sdim return new (Importer.getToContext()) CXXDeleteExpr( 5218314564Sdim T, E->isGlobalDelete(), 5219314564Sdim E->isArrayForm(), 5220314564Sdim E->isArrayFormAsWritten(), 5221314564Sdim E->doesUsualArrayDeleteWantSize(), 5222314564Sdim OperatorDeleteDecl, 5223314564Sdim ToArg, 5224314564Sdim Importer.Import(E->getLocStart())); 5225314564Sdim} 5226314564Sdim 5227288943SdimExpr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) { 5228288943Sdim QualType T = Importer.Import(E->getType()); 5229288943Sdim if (T.isNull()) 5230288943Sdim return nullptr; 5231288943Sdim 5232288943Sdim CXXConstructorDecl *ToCCD = 5233309124Sdim dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor())); 5234309124Sdim if (!ToCCD) 5235288943Sdim return nullptr; 5236288943Sdim 5237309124Sdim SmallVector<Expr *, 6> ToArgs(E->getNumArgs()); 5238314564Sdim if (ImportContainerChecked(E->arguments(), ToArgs)) 5239309124Sdim return nullptr; 5240288943Sdim 5241288943Sdim return CXXConstructExpr::Create(Importer.getToContext(), T, 5242288943Sdim Importer.Import(E->getLocation()), 5243288943Sdim ToCCD, E->isElidable(), 5244288943Sdim ToArgs, E->hadMultipleCandidates(), 5245288943Sdim E->isListInitialization(), 5246288943Sdim E->isStdInitListInitialization(), 5247288943Sdim E->requiresZeroInitialization(), 5248288943Sdim E->getConstructionKind(), 5249288943Sdim Importer.Import(E->getParenOrBraceRange())); 5250288943Sdim} 5251288943Sdim 5252314564SdimExpr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) { 5253314564Sdim Expr *SubExpr = Importer.Import(EWC->getSubExpr()); 5254314564Sdim if (!SubExpr && EWC->getSubExpr()) 5255314564Sdim return nullptr; 5256314564Sdim 5257314564Sdim SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects()); 5258314564Sdim for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++) 5259314564Sdim if (ExprWithCleanups::CleanupObject Obj = 5260314564Sdim cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I)))) 5261314564Sdim Objs[I] = Obj; 5262314564Sdim else 5263314564Sdim return nullptr; 5264314564Sdim 5265314564Sdim return ExprWithCleanups::Create(Importer.getToContext(), 5266314564Sdim SubExpr, EWC->cleanupsHaveSideEffects(), 5267314564Sdim Objs); 5268314564Sdim} 5269314564Sdim 5270309124SdimExpr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 5271309124Sdim QualType T = Importer.Import(E->getType()); 5272309124Sdim if (T.isNull()) 5273309124Sdim return nullptr; 5274309124Sdim 5275309124Sdim Expr *ToFn = Importer.Import(E->getCallee()); 5276309124Sdim if (!ToFn) 5277309124Sdim return nullptr; 5278309124Sdim 5279309124Sdim SmallVector<Expr *, 4> ToArgs(E->getNumArgs()); 5280314564Sdim if (ImportContainerChecked(E->arguments(), ToArgs)) 5281309124Sdim return nullptr; 5282309124Sdim 5283309124Sdim return new (Importer.getToContext()) CXXMemberCallExpr( 5284309124Sdim Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(), 5285309124Sdim Importer.Import(E->getRParenLoc())); 5286309124Sdim} 5287309124Sdim 5288309124SdimExpr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) { 5289309124Sdim QualType T = Importer.Import(E->getType()); 5290309124Sdim if (T.isNull()) 5291309124Sdim return nullptr; 5292309124Sdim 5293309124Sdim return new (Importer.getToContext()) 5294309124Sdim CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit()); 5295309124Sdim} 5296309124Sdim 5297309124SdimExpr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 5298309124Sdim QualType T = Importer.Import(E->getType()); 5299309124Sdim if (T.isNull()) 5300309124Sdim return nullptr; 5301309124Sdim 5302309124Sdim return new (Importer.getToContext()) 5303309124Sdim CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation())); 5304309124Sdim} 5305309124Sdim 5306309124Sdim 5307288943SdimExpr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) { 5308288943Sdim QualType T = Importer.Import(E->getType()); 5309288943Sdim if (T.isNull()) 5310288943Sdim return nullptr; 5311288943Sdim 5312288943Sdim Expr *ToBase = Importer.Import(E->getBase()); 5313288943Sdim if (!ToBase && E->getBase()) 5314288943Sdim return nullptr; 5315288943Sdim 5316288943Sdim ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl())); 5317288943Sdim if (!ToMember && E->getMemberDecl()) 5318288943Sdim return nullptr; 5319288943Sdim 5320288943Sdim DeclAccessPair ToFoundDecl = DeclAccessPair::make( 5321288943Sdim dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())), 5322288943Sdim E->getFoundDecl().getAccess()); 5323288943Sdim 5324288943Sdim DeclarationNameInfo ToMemberNameInfo( 5325288943Sdim Importer.Import(E->getMemberNameInfo().getName()), 5326288943Sdim Importer.Import(E->getMemberNameInfo().getLoc())); 5327288943Sdim 5328288943Sdim if (E->hasExplicitTemplateArgs()) { 5329288943Sdim return nullptr; // FIXME: handle template arguments 5330288943Sdim } 5331288943Sdim 5332288943Sdim return MemberExpr::Create(Importer.getToContext(), ToBase, 5333288943Sdim E->isArrow(), 5334288943Sdim Importer.Import(E->getOperatorLoc()), 5335288943Sdim Importer.Import(E->getQualifierLoc()), 5336288943Sdim Importer.Import(E->getTemplateKeywordLoc()), 5337288943Sdim ToMember, ToFoundDecl, ToMemberNameInfo, 5338288943Sdim nullptr, T, E->getValueKind(), 5339288943Sdim E->getObjectKind()); 5340288943Sdim} 5341288943Sdim 5342288943SdimExpr *ASTNodeImporter::VisitCallExpr(CallExpr *E) { 5343288943Sdim QualType T = Importer.Import(E->getType()); 5344288943Sdim if (T.isNull()) 5345288943Sdim return nullptr; 5346288943Sdim 5347288943Sdim Expr *ToCallee = Importer.Import(E->getCallee()); 5348288943Sdim if (!ToCallee && E->getCallee()) 5349288943Sdim return nullptr; 5350288943Sdim 5351288943Sdim unsigned NumArgs = E->getNumArgs(); 5352288943Sdim 5353288943Sdim llvm::SmallVector<Expr *, 2> ToArgs(NumArgs); 5354288943Sdim 5355288943Sdim for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) { 5356288943Sdim Expr *FromArg = E->getArg(ai); 5357288943Sdim Expr *ToArg = Importer.Import(FromArg); 5358288943Sdim if (!ToArg) 5359288943Sdim return nullptr; 5360288943Sdim ToArgs[ai] = ToArg; 5361288943Sdim } 5362288943Sdim 5363288943Sdim Expr **ToArgs_Copied = new (Importer.getToContext()) 5364288943Sdim Expr*[NumArgs]; 5365288943Sdim 5366288943Sdim for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) 5367288943Sdim ToArgs_Copied[ai] = ToArgs[ai]; 5368288943Sdim 5369288943Sdim return new (Importer.getToContext()) 5370288943Sdim CallExpr(Importer.getToContext(), ToCallee, 5371296417Sdim llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(), 5372288943Sdim Importer.Import(E->getRParenLoc())); 5373288943Sdim} 5374288943Sdim 5375309124SdimExpr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) { 5376309124Sdim QualType T = Importer.Import(ILE->getType()); 5377309124Sdim if (T.isNull()) 5378309124Sdim return nullptr; 5379309124Sdim 5380309124Sdim llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits()); 5381314564Sdim if (ImportContainerChecked(ILE->inits(), Exprs)) 5382309124Sdim return nullptr; 5383309124Sdim 5384309124Sdim ASTContext &ToCtx = Importer.getToContext(); 5385309124Sdim InitListExpr *To = new (ToCtx) InitListExpr( 5386309124Sdim ToCtx, Importer.Import(ILE->getLBraceLoc()), 5387309124Sdim Exprs, Importer.Import(ILE->getLBraceLoc())); 5388309124Sdim To->setType(T); 5389309124Sdim 5390309124Sdim if (ILE->hasArrayFiller()) { 5391309124Sdim Expr *Filler = Importer.Import(ILE->getArrayFiller()); 5392309124Sdim if (!Filler) 5393309124Sdim return nullptr; 5394309124Sdim To->setArrayFiller(Filler); 5395309124Sdim } 5396309124Sdim 5397309124Sdim if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) { 5398309124Sdim FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD)); 5399309124Sdim if (!ToFD) 5400309124Sdim return nullptr; 5401309124Sdim To->setInitializedFieldInUnion(ToFD); 5402309124Sdim } 5403309124Sdim 5404309124Sdim if (InitListExpr *SyntForm = ILE->getSyntacticForm()) { 5405309124Sdim InitListExpr *ToSyntForm = cast_or_null<InitListExpr>( 5406309124Sdim Importer.Import(SyntForm)); 5407309124Sdim if (!ToSyntForm) 5408309124Sdim return nullptr; 5409309124Sdim To->setSyntacticForm(ToSyntForm); 5410309124Sdim } 5411309124Sdim 5412309124Sdim To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator()); 5413309124Sdim To->setValueDependent(ILE->isValueDependent()); 5414309124Sdim To->setInstantiationDependent(ILE->isInstantiationDependent()); 5415309124Sdim 5416309124Sdim return To; 5417309124Sdim} 5418309124Sdim 5419314564SdimExpr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 5420314564Sdim QualType ToType = Importer.Import(E->getType()); 5421314564Sdim if (ToType.isNull()) 5422314564Sdim return nullptr; 5423314564Sdim 5424314564Sdim Expr *ToCommon = Importer.Import(E->getCommonExpr()); 5425314564Sdim if (!ToCommon && E->getCommonExpr()) 5426314564Sdim return nullptr; 5427314564Sdim 5428314564Sdim Expr *ToSubExpr = Importer.Import(E->getSubExpr()); 5429314564Sdim if (!ToSubExpr && E->getSubExpr()) 5430314564Sdim return nullptr; 5431314564Sdim 5432314564Sdim return new (Importer.getToContext()) 5433314564Sdim ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr); 5434314564Sdim} 5435314564Sdim 5436314564SdimExpr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 5437314564Sdim QualType ToType = Importer.Import(E->getType()); 5438314564Sdim if (ToType.isNull()) 5439314564Sdim return nullptr; 5440314564Sdim return new (Importer.getToContext()) ArrayInitIndexExpr(ToType); 5441314564Sdim} 5442314564Sdim 5443309124SdimExpr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 5444309124Sdim FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>( 5445309124Sdim Importer.Import(DIE->getField())); 5446309124Sdim if (!ToField && DIE->getField()) 5447309124Sdim return nullptr; 5448309124Sdim 5449309124Sdim return CXXDefaultInitExpr::Create( 5450309124Sdim Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField); 5451309124Sdim} 5452309124Sdim 5453309124SdimExpr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 5454309124Sdim QualType ToType = Importer.Import(E->getType()); 5455309124Sdim if (ToType.isNull() && !E->getType().isNull()) 5456309124Sdim return nullptr; 5457309124Sdim ExprValueKind VK = E->getValueKind(); 5458309124Sdim CastKind CK = E->getCastKind(); 5459309124Sdim Expr *ToOp = Importer.Import(E->getSubExpr()); 5460309124Sdim if (!ToOp && E->getSubExpr()) 5461309124Sdim return nullptr; 5462309124Sdim CXXCastPath BasePath; 5463309124Sdim if (ImportCastPath(E, BasePath)) 5464309124Sdim return nullptr; 5465309124Sdim TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten()); 5466309124Sdim SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc()); 5467309124Sdim SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc()); 5468309124Sdim SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets()); 5469309124Sdim 5470309124Sdim if (isa<CXXStaticCastExpr>(E)) { 5471309124Sdim return CXXStaticCastExpr::Create( 5472309124Sdim Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 5473309124Sdim ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 5474309124Sdim } else if (isa<CXXDynamicCastExpr>(E)) { 5475309124Sdim return CXXDynamicCastExpr::Create( 5476309124Sdim Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 5477309124Sdim ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 5478309124Sdim } else if (isa<CXXReinterpretCastExpr>(E)) { 5479309124Sdim return CXXReinterpretCastExpr::Create( 5480309124Sdim Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 5481309124Sdim ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 5482309124Sdim } else { 5483309124Sdim return nullptr; 5484309124Sdim } 5485309124Sdim} 5486309124Sdim 5487321369Sdim 5488321369SdimExpr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr( 5489321369Sdim SubstNonTypeTemplateParmExpr *E) { 5490321369Sdim QualType T = Importer.Import(E->getType()); 5491321369Sdim if (T.isNull()) 5492321369Sdim return nullptr; 5493321369Sdim 5494321369Sdim NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>( 5495321369Sdim Importer.Import(E->getParameter())); 5496321369Sdim if (!Param) 5497321369Sdim return nullptr; 5498321369Sdim 5499321369Sdim Expr *Replacement = Importer.Import(E->getReplacement()); 5500321369Sdim if (!Replacement) 5501321369Sdim return nullptr; 5502321369Sdim 5503321369Sdim return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr( 5504321369Sdim T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param, 5505321369Sdim Replacement); 5506321369Sdim} 5507321369Sdim 5508321369Sdimvoid ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod, 5509321369Sdim CXXMethodDecl *FromMethod) { 5510321369Sdim for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) 5511321369Sdim ToMethod->addOverriddenMethod( 5512321369Sdim cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>( 5513321369Sdim FromOverriddenMethod)))); 5514321369Sdim} 5515321369Sdim 5516218893SdimASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, 5517218893Sdim ASTContext &FromContext, FileManager &FromFileManager, 5518218893Sdim bool MinimalImport) 5519203955Srdivacky : ToContext(ToContext), FromContext(FromContext), 5520203955Srdivacky ToFileManager(ToFileManager), FromFileManager(FromFileManager), 5521249423Sdim Minimal(MinimalImport), LastDiagFromFrom(false) 5522218893Sdim{ 5523203955Srdivacky ImportedDecls[FromContext.getTranslationUnitDecl()] 5524203955Srdivacky = ToContext.getTranslationUnitDecl(); 5525203955Srdivacky} 5526203955Srdivacky 5527203955SrdivackyASTImporter::~ASTImporter() { } 5528203955Srdivacky 5529203955SrdivackyQualType ASTImporter::Import(QualType FromT) { 5530203955Srdivacky if (FromT.isNull()) 5531203955Srdivacky return QualType(); 5532218893Sdim 5533218893Sdim const Type *fromTy = FromT.getTypePtr(); 5534203955Srdivacky 5535203955Srdivacky // Check whether we've already imported this type. 5536218893Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos 5537218893Sdim = ImportedTypes.find(fromTy); 5538203955Srdivacky if (Pos != ImportedTypes.end()) 5539218893Sdim return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers()); 5540203955Srdivacky 5541203955Srdivacky // Import the type 5542203955Srdivacky ASTNodeImporter Importer(*this); 5543218893Sdim QualType ToT = Importer.Visit(fromTy); 5544203955Srdivacky if (ToT.isNull()) 5545203955Srdivacky return ToT; 5546203955Srdivacky 5547203955Srdivacky // Record the imported type. 5548218893Sdim ImportedTypes[fromTy] = ToT.getTypePtr(); 5549203955Srdivacky 5550218893Sdim return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers()); 5551203955Srdivacky} 5552203955Srdivacky 5553203955SrdivackyTypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) { 5554203955Srdivacky if (!FromTSI) 5555203955Srdivacky return FromTSI; 5556203955Srdivacky 5557203955Srdivacky // FIXME: For now we just create a "trivial" type source info based 5558212904Sdim // on the type and a single location. Implement a real version of this. 5559203955Srdivacky QualType T = Import(FromTSI->getType()); 5560203955Srdivacky if (T.isNull()) 5561276479Sdim return nullptr; 5562203955Srdivacky 5563203955Srdivacky return ToContext.getTrivialTypeSourceInfo(T, 5564288943Sdim Import(FromTSI->getTypeLoc().getLocStart())); 5565203955Srdivacky} 5566203955Srdivacky 5567288943SdimDecl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) { 5568288943Sdim llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 5569288943Sdim if (Pos != ImportedDecls.end()) { 5570288943Sdim Decl *ToD = Pos->second; 5571288943Sdim ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD); 5572288943Sdim return ToD; 5573288943Sdim } else { 5574288943Sdim return nullptr; 5575288943Sdim } 5576288943Sdim} 5577288943Sdim 5578203955SrdivackyDecl *ASTImporter::Import(Decl *FromD) { 5579203955Srdivacky if (!FromD) 5580276479Sdim return nullptr; 5581203955Srdivacky 5582226633Sdim ASTNodeImporter Importer(*this); 5583226633Sdim 5584203955Srdivacky // Check whether we've already imported this declaration. 5585203955Srdivacky llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 5586226633Sdim if (Pos != ImportedDecls.end()) { 5587226633Sdim Decl *ToD = Pos->second; 5588226633Sdim Importer.ImportDefinitionIfNeeded(FromD, ToD); 5589226633Sdim return ToD; 5590226633Sdim } 5591203955Srdivacky 5592203955Srdivacky // Import the type 5593203955Srdivacky Decl *ToD = Importer.Visit(FromD); 5594203955Srdivacky if (!ToD) 5595276479Sdim return nullptr; 5596276479Sdim 5597203955Srdivacky // Record the imported declaration. 5598203955Srdivacky ImportedDecls[FromD] = ToD; 5599203955Srdivacky 5600203955Srdivacky if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) { 5601203955Srdivacky // Keep track of anonymous tags that have an associated typedef. 5602221345Sdim if (FromTag->getTypedefNameForAnonDecl()) 5603203955Srdivacky AnonTagsWithPendingTypedefs.push_back(FromTag); 5604221345Sdim } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) { 5605203955Srdivacky // When we've finished transforming a typedef, see whether it was the 5606203955Srdivacky // typedef for an anonymous tag. 5607261991Sdim for (SmallVectorImpl<TagDecl *>::iterator 5608203955Srdivacky FromTag = AnonTagsWithPendingTypedefs.begin(), 5609203955Srdivacky FromTagEnd = AnonTagsWithPendingTypedefs.end(); 5610203955Srdivacky FromTag != FromTagEnd; ++FromTag) { 5611221345Sdim if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) { 5612203955Srdivacky if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) { 5613203955Srdivacky // We found the typedef for an anonymous tag; link them. 5614221345Sdim ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD)); 5615203955Srdivacky AnonTagsWithPendingTypedefs.erase(FromTag); 5616203955Srdivacky break; 5617203955Srdivacky } 5618203955Srdivacky } 5619203955Srdivacky } 5620203955Srdivacky } 5621203955Srdivacky 5622203955Srdivacky return ToD; 5623203955Srdivacky} 5624203955Srdivacky 5625203955SrdivackyDeclContext *ASTImporter::ImportContext(DeclContext *FromDC) { 5626203955Srdivacky if (!FromDC) 5627203955Srdivacky return FromDC; 5628203955Srdivacky 5629234353Sdim DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC))); 5630234353Sdim if (!ToDC) 5631276479Sdim return nullptr; 5632276479Sdim 5633234353Sdim // When we're using a record/enum/Objective-C class/protocol as a context, we 5634234353Sdim // need it to have a definition. 5635234353Sdim if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) { 5636234353Sdim RecordDecl *FromRecord = cast<RecordDecl>(FromDC); 5637234353Sdim if (ToRecord->isCompleteDefinition()) { 5638234353Sdim // Do nothing. 5639234353Sdim } else if (FromRecord->isCompleteDefinition()) { 5640234353Sdim ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord, 5641234353Sdim ASTNodeImporter::IDK_Basic); 5642234353Sdim } else { 5643234353Sdim CompleteDecl(ToRecord); 5644234353Sdim } 5645234353Sdim } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) { 5646234353Sdim EnumDecl *FromEnum = cast<EnumDecl>(FromDC); 5647234353Sdim if (ToEnum->isCompleteDefinition()) { 5648234353Sdim // Do nothing. 5649234353Sdim } else if (FromEnum->isCompleteDefinition()) { 5650234353Sdim ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum, 5651234353Sdim ASTNodeImporter::IDK_Basic); 5652234353Sdim } else { 5653234353Sdim CompleteDecl(ToEnum); 5654234353Sdim } 5655234353Sdim } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) { 5656234353Sdim ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC); 5657234353Sdim if (ToClass->getDefinition()) { 5658234353Sdim // Do nothing. 5659234353Sdim } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) { 5660234353Sdim ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass, 5661234353Sdim ASTNodeImporter::IDK_Basic); 5662234353Sdim } else { 5663234353Sdim CompleteDecl(ToClass); 5664234353Sdim } 5665234353Sdim } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) { 5666234353Sdim ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC); 5667234353Sdim if (ToProto->getDefinition()) { 5668234353Sdim // Do nothing. 5669234353Sdim } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) { 5670234353Sdim ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto, 5671234353Sdim ASTNodeImporter::IDK_Basic); 5672234353Sdim } else { 5673234353Sdim CompleteDecl(ToProto); 5674234353Sdim } 5675234353Sdim } 5676234353Sdim 5677234353Sdim return ToDC; 5678203955Srdivacky} 5679203955Srdivacky 5680203955SrdivackyExpr *ASTImporter::Import(Expr *FromE) { 5681203955Srdivacky if (!FromE) 5682276479Sdim return nullptr; 5683203955Srdivacky 5684203955Srdivacky return cast_or_null<Expr>(Import(cast<Stmt>(FromE))); 5685203955Srdivacky} 5686203955Srdivacky 5687203955SrdivackyStmt *ASTImporter::Import(Stmt *FromS) { 5688203955Srdivacky if (!FromS) 5689276479Sdim return nullptr; 5690203955Srdivacky 5691203955Srdivacky // Check whether we've already imported this declaration. 5692203955Srdivacky llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS); 5693203955Srdivacky if (Pos != ImportedStmts.end()) 5694203955Srdivacky return Pos->second; 5695203955Srdivacky 5696203955Srdivacky // Import the type 5697203955Srdivacky ASTNodeImporter Importer(*this); 5698203955Srdivacky Stmt *ToS = Importer.Visit(FromS); 5699203955Srdivacky if (!ToS) 5700276479Sdim return nullptr; 5701276479Sdim 5702203955Srdivacky // Record the imported declaration. 5703203955Srdivacky ImportedStmts[FromS] = ToS; 5704203955Srdivacky return ToS; 5705203955Srdivacky} 5706203955Srdivacky 5707203955SrdivackyNestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) { 5708203955Srdivacky if (!FromNNS) 5709276479Sdim return nullptr; 5710203955Srdivacky 5711221345Sdim NestedNameSpecifier *prefix = Import(FromNNS->getPrefix()); 5712221345Sdim 5713221345Sdim switch (FromNNS->getKind()) { 5714221345Sdim case NestedNameSpecifier::Identifier: 5715221345Sdim if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) { 5716221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, II); 5717221345Sdim } 5718276479Sdim return nullptr; 5719221345Sdim 5720221345Sdim case NestedNameSpecifier::Namespace: 5721221345Sdim if (NamespaceDecl *NS = 5722321369Sdim cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) { 5723221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, NS); 5724221345Sdim } 5725276479Sdim return nullptr; 5726221345Sdim 5727221345Sdim case NestedNameSpecifier::NamespaceAlias: 5728221345Sdim if (NamespaceAliasDecl *NSAD = 5729321369Sdim cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) { 5730221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, NSAD); 5731221345Sdim } 5732276479Sdim return nullptr; 5733221345Sdim 5734221345Sdim case NestedNameSpecifier::Global: 5735221345Sdim return NestedNameSpecifier::GlobalSpecifier(ToContext); 5736221345Sdim 5737280031Sdim case NestedNameSpecifier::Super: 5738280031Sdim if (CXXRecordDecl *RD = 5739321369Sdim cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) { 5740280031Sdim return NestedNameSpecifier::SuperSpecifier(ToContext, RD); 5741280031Sdim } 5742280031Sdim return nullptr; 5743280031Sdim 5744221345Sdim case NestedNameSpecifier::TypeSpec: 5745221345Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 5746221345Sdim QualType T = Import(QualType(FromNNS->getAsType(), 0u)); 5747221345Sdim if (!T.isNull()) { 5748221345Sdim bool bTemplate = FromNNS->getKind() == 5749221345Sdim NestedNameSpecifier::TypeSpecWithTemplate; 5750221345Sdim return NestedNameSpecifier::Create(ToContext, prefix, 5751221345Sdim bTemplate, T.getTypePtr()); 5752221345Sdim } 5753221345Sdim } 5754276479Sdim return nullptr; 5755221345Sdim } 5756221345Sdim 5757221345Sdim llvm_unreachable("Invalid nested name specifier kind"); 5758203955Srdivacky} 5759203955Srdivacky 5760219077SdimNestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) { 5761321369Sdim // Copied from NestedNameSpecifier mostly. 5762321369Sdim SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 5763321369Sdim NestedNameSpecifierLoc NNS = FromNNS; 5764321369Sdim 5765321369Sdim // Push each of the nested-name-specifiers's onto a stack for 5766321369Sdim // serialization in reverse order. 5767321369Sdim while (NNS) { 5768321369Sdim NestedNames.push_back(NNS); 5769321369Sdim NNS = NNS.getPrefix(); 5770321369Sdim } 5771321369Sdim 5772321369Sdim NestedNameSpecifierLocBuilder Builder; 5773321369Sdim 5774321369Sdim while (!NestedNames.empty()) { 5775321369Sdim NNS = NestedNames.pop_back_val(); 5776321369Sdim NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier()); 5777321369Sdim if (!Spec) 5778321369Sdim return NestedNameSpecifierLoc(); 5779321369Sdim 5780321369Sdim NestedNameSpecifier::SpecifierKind Kind = Spec->getKind(); 5781321369Sdim switch (Kind) { 5782321369Sdim case NestedNameSpecifier::Identifier: 5783321369Sdim Builder.Extend(getToContext(), 5784321369Sdim Spec->getAsIdentifier(), 5785321369Sdim Import(NNS.getLocalBeginLoc()), 5786321369Sdim Import(NNS.getLocalEndLoc())); 5787321369Sdim break; 5788321369Sdim 5789321369Sdim case NestedNameSpecifier::Namespace: 5790321369Sdim Builder.Extend(getToContext(), 5791321369Sdim Spec->getAsNamespace(), 5792321369Sdim Import(NNS.getLocalBeginLoc()), 5793321369Sdim Import(NNS.getLocalEndLoc())); 5794321369Sdim break; 5795321369Sdim 5796321369Sdim case NestedNameSpecifier::NamespaceAlias: 5797321369Sdim Builder.Extend(getToContext(), 5798321369Sdim Spec->getAsNamespaceAlias(), 5799321369Sdim Import(NNS.getLocalBeginLoc()), 5800321369Sdim Import(NNS.getLocalEndLoc())); 5801321369Sdim break; 5802321369Sdim 5803321369Sdim case NestedNameSpecifier::TypeSpec: 5804321369Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 5805321369Sdim TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo( 5806321369Sdim QualType(Spec->getAsType(), 0)); 5807321369Sdim Builder.Extend(getToContext(), 5808321369Sdim Import(NNS.getLocalBeginLoc()), 5809321369Sdim TSI->getTypeLoc(), 5810321369Sdim Import(NNS.getLocalEndLoc())); 5811321369Sdim break; 5812321369Sdim } 5813321369Sdim 5814321369Sdim case NestedNameSpecifier::Global: 5815321369Sdim Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc())); 5816321369Sdim break; 5817321369Sdim 5818321369Sdim case NestedNameSpecifier::Super: { 5819321369Sdim SourceRange ToRange = Import(NNS.getSourceRange()); 5820321369Sdim Builder.MakeSuper(getToContext(), 5821321369Sdim Spec->getAsRecordDecl(), 5822321369Sdim ToRange.getBegin(), 5823321369Sdim ToRange.getEnd()); 5824321369Sdim } 5825321369Sdim } 5826321369Sdim } 5827321369Sdim 5828321369Sdim return Builder.getWithLocInContext(getToContext()); 5829219077Sdim} 5830219077Sdim 5831218893SdimTemplateName ASTImporter::Import(TemplateName From) { 5832218893Sdim switch (From.getKind()) { 5833218893Sdim case TemplateName::Template: 5834218893Sdim if (TemplateDecl *ToTemplate 5835218893Sdim = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 5836218893Sdim return TemplateName(ToTemplate); 5837218893Sdim 5838218893Sdim return TemplateName(); 5839218893Sdim 5840218893Sdim case TemplateName::OverloadedTemplate: { 5841218893Sdim OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate(); 5842218893Sdim UnresolvedSet<2> ToTemplates; 5843218893Sdim for (OverloadedTemplateStorage::iterator I = FromStorage->begin(), 5844218893Sdim E = FromStorage->end(); 5845218893Sdim I != E; ++I) { 5846218893Sdim if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I))) 5847218893Sdim ToTemplates.addDecl(To); 5848218893Sdim else 5849218893Sdim return TemplateName(); 5850218893Sdim } 5851218893Sdim return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 5852218893Sdim ToTemplates.end()); 5853218893Sdim } 5854218893Sdim 5855218893Sdim case TemplateName::QualifiedTemplate: { 5856218893Sdim QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName(); 5857218893Sdim NestedNameSpecifier *Qualifier = Import(QTN->getQualifier()); 5858218893Sdim if (!Qualifier) 5859218893Sdim return TemplateName(); 5860218893Sdim 5861218893Sdim if (TemplateDecl *ToTemplate 5862218893Sdim = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 5863218893Sdim return ToContext.getQualifiedTemplateName(Qualifier, 5864218893Sdim QTN->hasTemplateKeyword(), 5865218893Sdim ToTemplate); 5866218893Sdim 5867218893Sdim return TemplateName(); 5868218893Sdim } 5869218893Sdim 5870218893Sdim case TemplateName::DependentTemplate: { 5871218893Sdim DependentTemplateName *DTN = From.getAsDependentTemplateName(); 5872218893Sdim NestedNameSpecifier *Qualifier = Import(DTN->getQualifier()); 5873218893Sdim if (!Qualifier) 5874218893Sdim return TemplateName(); 5875218893Sdim 5876218893Sdim if (DTN->isIdentifier()) { 5877218893Sdim return ToContext.getDependentTemplateName(Qualifier, 5878218893Sdim Import(DTN->getIdentifier())); 5879218893Sdim } 5880218893Sdim 5881218893Sdim return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator()); 5882218893Sdim } 5883224145Sdim 5884224145Sdim case TemplateName::SubstTemplateTemplateParm: { 5885224145Sdim SubstTemplateTemplateParmStorage *subst 5886224145Sdim = From.getAsSubstTemplateTemplateParm(); 5887224145Sdim TemplateTemplateParmDecl *param 5888224145Sdim = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter())); 5889224145Sdim if (!param) 5890224145Sdim return TemplateName(); 5891224145Sdim 5892224145Sdim TemplateName replacement = Import(subst->getReplacement()); 5893224145Sdim if (replacement.isNull()) return TemplateName(); 5894224145Sdim 5895224145Sdim return ToContext.getSubstTemplateTemplateParm(param, replacement); 5896224145Sdim } 5897218893Sdim 5898218893Sdim case TemplateName::SubstTemplateTemplateParmPack: { 5899218893Sdim SubstTemplateTemplateParmPackStorage *SubstPack 5900218893Sdim = From.getAsSubstTemplateTemplateParmPack(); 5901218893Sdim TemplateTemplateParmDecl *Param 5902218893Sdim = cast_or_null<TemplateTemplateParmDecl>( 5903218893Sdim Import(SubstPack->getParameterPack())); 5904218893Sdim if (!Param) 5905218893Sdim return TemplateName(); 5906218893Sdim 5907218893Sdim ASTNodeImporter Importer(*this); 5908218893Sdim TemplateArgument ArgPack 5909218893Sdim = Importer.ImportTemplateArgument(SubstPack->getArgumentPack()); 5910218893Sdim if (ArgPack.isNull()) 5911218893Sdim return TemplateName(); 5912218893Sdim 5913218893Sdim return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack); 5914218893Sdim } 5915218893Sdim } 5916218893Sdim 5917218893Sdim llvm_unreachable("Invalid template name kind"); 5918218893Sdim} 5919218893Sdim 5920203955SrdivackySourceLocation ASTImporter::Import(SourceLocation FromLoc) { 5921203955Srdivacky if (FromLoc.isInvalid()) 5922203955Srdivacky return SourceLocation(); 5923203955Srdivacky 5924203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 5925203955Srdivacky 5926314564Sdim // For now, map everything down to its file location, so that we 5927224145Sdim // don't have to import macro expansions. 5928224145Sdim // FIXME: Import macro expansions! 5929314564Sdim FromLoc = FromSM.getFileLoc(FromLoc); 5930203955Srdivacky std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc); 5931203955Srdivacky SourceManager &ToSM = ToContext.getSourceManager(); 5932280031Sdim FileID ToFileID = Import(Decomposed.first); 5933280031Sdim if (ToFileID.isInvalid()) 5934280031Sdim return SourceLocation(); 5935288943Sdim SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID) 5936288943Sdim .getLocWithOffset(Decomposed.second); 5937288943Sdim return ret; 5938203955Srdivacky} 5939203955Srdivacky 5940203955SrdivackySourceRange ASTImporter::Import(SourceRange FromRange) { 5941203955Srdivacky return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd())); 5942203955Srdivacky} 5943203955Srdivacky 5944203955SrdivackyFileID ASTImporter::Import(FileID FromID) { 5945218893Sdim llvm::DenseMap<FileID, FileID>::iterator Pos 5946218893Sdim = ImportedFileIDs.find(FromID); 5947203955Srdivacky if (Pos != ImportedFileIDs.end()) 5948203955Srdivacky return Pos->second; 5949203955Srdivacky 5950203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 5951203955Srdivacky SourceManager &ToSM = ToContext.getSourceManager(); 5952203955Srdivacky const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID); 5953224145Sdim assert(FromSLoc.isFile() && "Cannot handle macro expansions yet"); 5954203955Srdivacky 5955203955Srdivacky // Include location of this file. 5956203955Srdivacky SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc()); 5957203955Srdivacky 5958203955Srdivacky // Map the FileID for to the "to" source manager. 5959203955Srdivacky FileID ToID; 5960203955Srdivacky const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache(); 5961288943Sdim if (Cache->OrigEntry && Cache->OrigEntry->getDir()) { 5962203955Srdivacky // FIXME: We probably want to use getVirtualFile(), so we don't hit the 5963203955Srdivacky // disk again 5964203955Srdivacky // FIXME: We definitely want to re-use the existing MemoryBuffer, rather 5965203955Srdivacky // than mmap the files several times. 5966221345Sdim const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName()); 5967280031Sdim if (!Entry) 5968280031Sdim return FileID(); 5969203955Srdivacky ToID = ToSM.createFileID(Entry, ToIncludeLoc, 5970203955Srdivacky FromSLoc.getFile().getFileCharacteristic()); 5971203955Srdivacky } else { 5972203955Srdivacky // FIXME: We want to re-use the existing MemoryBuffer! 5973218893Sdim const llvm::MemoryBuffer * 5974218893Sdim FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM); 5975280031Sdim std::unique_ptr<llvm::MemoryBuffer> ToBuf 5976206275Srdivacky = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(), 5977203955Srdivacky FromBuf->getBufferIdentifier()); 5978280031Sdim ToID = ToSM.createFileID(std::move(ToBuf), 5979280031Sdim FromSLoc.getFile().getFileCharacteristic()); 5980203955Srdivacky } 5981203955Srdivacky 5982203955Srdivacky 5983218893Sdim ImportedFileIDs[FromID] = ToID; 5984203955Srdivacky return ToID; 5985203955Srdivacky} 5986203955Srdivacky 5987309124SdimCXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) { 5988309124Sdim Expr *ToExpr = Import(From->getInit()); 5989309124Sdim if (!ToExpr && From->getInit()) 5990309124Sdim return nullptr; 5991309124Sdim 5992309124Sdim if (From->isBaseInitializer()) { 5993309124Sdim TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo()); 5994309124Sdim if (!ToTInfo && From->getTypeSourceInfo()) 5995309124Sdim return nullptr; 5996309124Sdim 5997309124Sdim return new (ToContext) CXXCtorInitializer( 5998309124Sdim ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()), 5999309124Sdim ToExpr, Import(From->getRParenLoc()), 6000309124Sdim From->isPackExpansion() ? Import(From->getEllipsisLoc()) 6001309124Sdim : SourceLocation()); 6002309124Sdim } else if (From->isMemberInitializer()) { 6003309124Sdim FieldDecl *ToField = 6004309124Sdim llvm::cast_or_null<FieldDecl>(Import(From->getMember())); 6005309124Sdim if (!ToField && From->getMember()) 6006309124Sdim return nullptr; 6007309124Sdim 6008309124Sdim return new (ToContext) CXXCtorInitializer( 6009309124Sdim ToContext, ToField, Import(From->getMemberLocation()), 6010309124Sdim Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc())); 6011309124Sdim } else if (From->isIndirectMemberInitializer()) { 6012309124Sdim IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>( 6013309124Sdim Import(From->getIndirectMember())); 6014309124Sdim if (!ToIField && From->getIndirectMember()) 6015309124Sdim return nullptr; 6016309124Sdim 6017309124Sdim return new (ToContext) CXXCtorInitializer( 6018309124Sdim ToContext, ToIField, Import(From->getMemberLocation()), 6019309124Sdim Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc())); 6020309124Sdim } else if (From->isDelegatingInitializer()) { 6021309124Sdim TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo()); 6022309124Sdim if (!ToTInfo && From->getTypeSourceInfo()) 6023309124Sdim return nullptr; 6024309124Sdim 6025309124Sdim return new (ToContext) 6026309124Sdim CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()), 6027309124Sdim ToExpr, Import(From->getRParenLoc())); 6028309124Sdim } else { 6029309124Sdim return nullptr; 6030309124Sdim } 6031309124Sdim} 6032309124Sdim 6033309124Sdim 6034314564SdimCXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) { 6035314564Sdim auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec); 6036314564Sdim if (Pos != ImportedCXXBaseSpecifiers.end()) 6037314564Sdim return Pos->second; 6038314564Sdim 6039314564Sdim CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier( 6040314564Sdim Import(BaseSpec->getSourceRange()), 6041314564Sdim BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(), 6042314564Sdim BaseSpec->getAccessSpecifierAsWritten(), 6043314564Sdim Import(BaseSpec->getTypeSourceInfo()), 6044314564Sdim Import(BaseSpec->getEllipsisLoc())); 6045314564Sdim ImportedCXXBaseSpecifiers[BaseSpec] = Imported; 6046314564Sdim return Imported; 6047314564Sdim} 6048314564Sdim 6049218893Sdimvoid ASTImporter::ImportDefinition(Decl *From) { 6050218893Sdim Decl *To = Import(From); 6051218893Sdim if (!To) 6052218893Sdim return; 6053218893Sdim 6054218893Sdim if (DeclContext *FromDC = cast<DeclContext>(From)) { 6055218893Sdim ASTNodeImporter Importer(*this); 6056226633Sdim 6057226633Sdim if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) { 6058226633Sdim if (!ToRecord->getDefinition()) { 6059226633Sdim Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord, 6060234353Sdim ASTNodeImporter::IDK_Everything); 6061226633Sdim return; 6062226633Sdim } 6063226633Sdim } 6064226633Sdim 6065226633Sdim if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) { 6066226633Sdim if (!ToEnum->getDefinition()) { 6067226633Sdim Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum, 6068234353Sdim ASTNodeImporter::IDK_Everything); 6069226633Sdim return; 6070226633Sdim } 6071226633Sdim } 6072234353Sdim 6073234353Sdim if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) { 6074234353Sdim if (!ToIFace->getDefinition()) { 6075234353Sdim Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace, 6076234353Sdim ASTNodeImporter::IDK_Everything); 6077234353Sdim return; 6078234353Sdim } 6079234353Sdim } 6080226633Sdim 6081234353Sdim if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) { 6082234353Sdim if (!ToProto->getDefinition()) { 6083234353Sdim Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto, 6084234353Sdim ASTNodeImporter::IDK_Everything); 6085234353Sdim return; 6086234353Sdim } 6087234353Sdim } 6088234353Sdim 6089218893Sdim Importer.ImportDeclContext(FromDC, true); 6090218893Sdim } 6091218893Sdim} 6092218893Sdim 6093203955SrdivackyDeclarationName ASTImporter::Import(DeclarationName FromName) { 6094203955Srdivacky if (!FromName) 6095203955Srdivacky return DeclarationName(); 6096203955Srdivacky 6097203955Srdivacky switch (FromName.getNameKind()) { 6098203955Srdivacky case DeclarationName::Identifier: 6099203955Srdivacky return Import(FromName.getAsIdentifierInfo()); 6100203955Srdivacky 6101203955Srdivacky case DeclarationName::ObjCZeroArgSelector: 6102203955Srdivacky case DeclarationName::ObjCOneArgSelector: 6103203955Srdivacky case DeclarationName::ObjCMultiArgSelector: 6104203955Srdivacky return Import(FromName.getObjCSelector()); 6105203955Srdivacky 6106203955Srdivacky case DeclarationName::CXXConstructorName: { 6107203955Srdivacky QualType T = Import(FromName.getCXXNameType()); 6108203955Srdivacky if (T.isNull()) 6109203955Srdivacky return DeclarationName(); 6110203955Srdivacky 6111203955Srdivacky return ToContext.DeclarationNames.getCXXConstructorName( 6112203955Srdivacky ToContext.getCanonicalType(T)); 6113203955Srdivacky } 6114203955Srdivacky 6115203955Srdivacky case DeclarationName::CXXDestructorName: { 6116203955Srdivacky QualType T = Import(FromName.getCXXNameType()); 6117203955Srdivacky if (T.isNull()) 6118203955Srdivacky return DeclarationName(); 6119203955Srdivacky 6120203955Srdivacky return ToContext.DeclarationNames.getCXXDestructorName( 6121203955Srdivacky ToContext.getCanonicalType(T)); 6122203955Srdivacky } 6123203955Srdivacky 6124321369Sdim case DeclarationName::CXXDeductionGuideName: { 6125321369Sdim TemplateDecl *Template = cast_or_null<TemplateDecl>( 6126321369Sdim Import(FromName.getCXXDeductionGuideTemplate())); 6127321369Sdim if (!Template) 6128321369Sdim return DeclarationName(); 6129321369Sdim return ToContext.DeclarationNames.getCXXDeductionGuideName(Template); 6130321369Sdim } 6131321369Sdim 6132203955Srdivacky case DeclarationName::CXXConversionFunctionName: { 6133203955Srdivacky QualType T = Import(FromName.getCXXNameType()); 6134203955Srdivacky if (T.isNull()) 6135203955Srdivacky return DeclarationName(); 6136203955Srdivacky 6137203955Srdivacky return ToContext.DeclarationNames.getCXXConversionFunctionName( 6138203955Srdivacky ToContext.getCanonicalType(T)); 6139203955Srdivacky } 6140203955Srdivacky 6141203955Srdivacky case DeclarationName::CXXOperatorName: 6142203955Srdivacky return ToContext.DeclarationNames.getCXXOperatorName( 6143203955Srdivacky FromName.getCXXOverloadedOperator()); 6144203955Srdivacky 6145203955Srdivacky case DeclarationName::CXXLiteralOperatorName: 6146203955Srdivacky return ToContext.DeclarationNames.getCXXLiteralOperatorName( 6147203955Srdivacky Import(FromName.getCXXLiteralIdentifier())); 6148203955Srdivacky 6149203955Srdivacky case DeclarationName::CXXUsingDirective: 6150203955Srdivacky // FIXME: STATICS! 6151203955Srdivacky return DeclarationName::getUsingDirectiveName(); 6152203955Srdivacky } 6153203955Srdivacky 6154234353Sdim llvm_unreachable("Invalid DeclarationName Kind!"); 6155203955Srdivacky} 6156203955Srdivacky 6157218893SdimIdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) { 6158203955Srdivacky if (!FromId) 6159276479Sdim return nullptr; 6160203955Srdivacky 6161309124Sdim IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName()); 6162309124Sdim 6163309124Sdim if (!ToId->getBuiltinID() && FromId->getBuiltinID()) 6164309124Sdim ToId->setBuiltinID(FromId->getBuiltinID()); 6165309124Sdim 6166309124Sdim return ToId; 6167203955Srdivacky} 6168203955Srdivacky 6169204643SrdivackySelector ASTImporter::Import(Selector FromSel) { 6170204643Srdivacky if (FromSel.isNull()) 6171204643Srdivacky return Selector(); 6172204643Srdivacky 6173226633Sdim SmallVector<IdentifierInfo *, 4> Idents; 6174204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0))); 6175204643Srdivacky for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I) 6176204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I))); 6177204643Srdivacky return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data()); 6178204643Srdivacky} 6179204643Srdivacky 6180203955SrdivackyDeclarationName ASTImporter::HandleNameConflict(DeclarationName Name, 6181203955Srdivacky DeclContext *DC, 6182203955Srdivacky unsigned IDNS, 6183203955Srdivacky NamedDecl **Decls, 6184203955Srdivacky unsigned NumDecls) { 6185203955Srdivacky return Name; 6186203955Srdivacky} 6187203955Srdivacky 6188203955SrdivackyDiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) { 6189249423Sdim if (LastDiagFromFrom) 6190249423Sdim ToContext.getDiagnostics().notePriorDiagnosticFrom( 6191249423Sdim FromContext.getDiagnostics()); 6192249423Sdim LastDiagFromFrom = false; 6193218893Sdim return ToContext.getDiagnostics().Report(Loc, DiagID); 6194203955Srdivacky} 6195203955Srdivacky 6196203955SrdivackyDiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) { 6197249423Sdim if (!LastDiagFromFrom) 6198249423Sdim FromContext.getDiagnostics().notePriorDiagnosticFrom( 6199249423Sdim ToContext.getDiagnostics()); 6200249423Sdim LastDiagFromFrom = true; 6201218893Sdim return FromContext.getDiagnostics().Report(Loc, DiagID); 6202203955Srdivacky} 6203203955Srdivacky 6204234353Sdimvoid ASTImporter::CompleteDecl (Decl *D) { 6205234353Sdim if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 6206234353Sdim if (!ID->getDefinition()) 6207234353Sdim ID->startDefinition(); 6208234353Sdim } 6209234353Sdim else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) { 6210234353Sdim if (!PD->getDefinition()) 6211234353Sdim PD->startDefinition(); 6212234353Sdim } 6213234353Sdim else if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 6214234353Sdim if (!TD->getDefinition() && !TD->isBeingDefined()) { 6215234353Sdim TD->startDefinition(); 6216234353Sdim TD->setCompleteDefinition(true); 6217234353Sdim } 6218234353Sdim } 6219234353Sdim else { 6220234353Sdim assert (0 && "CompleteDecl called on a Decl that can't be completed"); 6221234353Sdim } 6222234353Sdim} 6223234353Sdim 6224203955SrdivackyDecl *ASTImporter::Imported(Decl *From, Decl *To) { 6225309124Sdim if (From->hasAttrs()) { 6226309124Sdim for (Attr *FromAttr : From->getAttrs()) 6227309124Sdim To->addAttr(FromAttr->clone(To->getASTContext())); 6228309124Sdim } 6229309124Sdim if (From->isUsed()) { 6230309124Sdim To->setIsUsed(); 6231309124Sdim } 6232309124Sdim if (From->isImplicit()) { 6233309124Sdim To->setImplicit(); 6234309124Sdim } 6235203955Srdivacky ImportedDecls[From] = To; 6236203955Srdivacky return To; 6237203955Srdivacky} 6238203955Srdivacky 6239239462Sdimbool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To, 6240239462Sdim bool Complain) { 6241218893Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos 6242203955Srdivacky = ImportedTypes.find(From.getTypePtr()); 6243203955Srdivacky if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To)) 6244203955Srdivacky return true; 6245321369Sdim 6246239462Sdim StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls, 6247239462Sdim false, Complain); 6248204643Srdivacky return Ctx.IsStructurallyEquivalent(From, To); 6249203955Srdivacky} 6250