1 //===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ASTImporter class which imports AST nodes from one
11 // context into another context.
13 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTImporter.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTDiagnostic.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclVisitor.h"
20 #include "clang/AST/StmtVisitor.h"
21 #include "clang/AST/TypeVisitor.h"
22 #include "clang/Basic/FileManager.h"
23 #include "clang/Basic/SourceManager.h"
24 #include "llvm/Support/MemoryBuffer.h"
28 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
29 public DeclVisitor<ASTNodeImporter, Decl *>,
30 public StmtVisitor<ASTNodeImporter, Stmt *> {
31 ASTImporter &Importer;
34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
36 using TypeVisitor<ASTNodeImporter, QualType>::Visit;
37 using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
38 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
41 QualType VisitType(const Type *T);
42 QualType VisitAtomicType(const AtomicType *T);
43 QualType VisitBuiltinType(const BuiltinType *T);
44 QualType VisitDecayedType(const DecayedType *T);
45 QualType VisitComplexType(const ComplexType *T);
46 QualType VisitPointerType(const PointerType *T);
47 QualType VisitBlockPointerType(const BlockPointerType *T);
48 QualType VisitLValueReferenceType(const LValueReferenceType *T);
49 QualType VisitRValueReferenceType(const RValueReferenceType *T);
50 QualType VisitMemberPointerType(const MemberPointerType *T);
51 QualType VisitConstantArrayType(const ConstantArrayType *T);
52 QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
53 QualType VisitVariableArrayType(const VariableArrayType *T);
54 // FIXME: DependentSizedArrayType
55 // FIXME: DependentSizedExtVectorType
56 QualType VisitVectorType(const VectorType *T);
57 QualType VisitExtVectorType(const ExtVectorType *T);
58 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
59 QualType VisitFunctionProtoType(const FunctionProtoType *T);
60 // FIXME: UnresolvedUsingType
61 QualType VisitParenType(const ParenType *T);
62 QualType VisitTypedefType(const TypedefType *T);
63 QualType VisitTypeOfExprType(const TypeOfExprType *T);
64 // FIXME: DependentTypeOfExprType
65 QualType VisitTypeOfType(const TypeOfType *T);
66 QualType VisitDecltypeType(const DecltypeType *T);
67 QualType VisitUnaryTransformType(const UnaryTransformType *T);
68 QualType VisitAutoType(const AutoType *T);
69 QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
70 // FIXME: DependentDecltypeType
71 QualType VisitRecordType(const RecordType *T);
72 QualType VisitEnumType(const EnumType *T);
73 QualType VisitAttributedType(const AttributedType *T);
74 QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
75 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
76 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
77 QualType VisitElaboratedType(const ElaboratedType *T);
78 // FIXME: DependentNameType
79 // FIXME: DependentTemplateSpecializationType
80 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
81 QualType VisitObjCObjectType(const ObjCObjectType *T);
82 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
84 // Importing declarations
85 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
86 DeclContext *&LexicalDC, DeclarationName &Name,
87 NamedDecl *&ToD, SourceLocation &Loc);
88 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
89 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
90 DeclarationNameInfo& To);
91 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
93 bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
95 typedef DesignatedInitExpr::Designator Designator;
96 Designator ImportDesignator(const Designator &D);
99 /// \brief What we should import from the definition.
100 enum ImportDefinitionKind {
101 /// \brief Import the default subset of the definition, which might be
102 /// nothing (if minimal import is set) or might be everything (if minimal
103 /// import is not set).
105 /// \brief Import everything.
107 /// \brief Import only the bare bones needed to establish a valid
112 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
113 return IDK == IDK_Everything ||
114 (IDK == IDK_Default && !Importer.isMinimalImport());
117 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
118 ImportDefinitionKind Kind = IDK_Default);
119 bool ImportDefinition(VarDecl *From, VarDecl *To,
120 ImportDefinitionKind Kind = IDK_Default);
121 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
122 ImportDefinitionKind Kind = IDK_Default);
123 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
124 ImportDefinitionKind Kind = IDK_Default);
125 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
126 ImportDefinitionKind Kind = IDK_Default);
127 TemplateParameterList *ImportTemplateParameterList(
128 TemplateParameterList *Params);
129 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
130 TemplateArgumentLoc ImportTemplateArgumentLoc(
131 const TemplateArgumentLoc &TALoc, bool &Error);
132 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
133 unsigned NumFromArgs,
134 SmallVectorImpl<TemplateArgument> &ToArgs);
135 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
136 bool Complain = true);
137 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
138 bool Complain = true);
139 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
140 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
141 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
142 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
143 Decl *VisitDecl(Decl *D);
144 Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
145 Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
146 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
147 Decl *VisitNamespaceDecl(NamespaceDecl *D);
148 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
149 Decl *VisitTypedefDecl(TypedefDecl *D);
150 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
151 Decl *VisitLabelDecl(LabelDecl *D);
152 Decl *VisitEnumDecl(EnumDecl *D);
153 Decl *VisitRecordDecl(RecordDecl *D);
154 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
155 Decl *VisitFunctionDecl(FunctionDecl *D);
156 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
157 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
158 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
159 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
160 Decl *VisitFieldDecl(FieldDecl *D);
161 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
162 Decl *VisitFriendDecl(FriendDecl *D);
163 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
164 Decl *VisitVarDecl(VarDecl *D);
165 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
166 Decl *VisitParmVarDecl(ParmVarDecl *D);
167 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
168 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
169 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
170 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
171 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
173 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
174 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
175 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
176 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
177 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
178 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
179 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
180 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
181 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
182 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
183 Decl *VisitClassTemplateSpecializationDecl(
184 ClassTemplateSpecializationDecl *D);
185 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
186 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
188 // Importing statements
189 DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
191 Stmt *VisitStmt(Stmt *S);
192 Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
193 Stmt *VisitDeclStmt(DeclStmt *S);
194 Stmt *VisitNullStmt(NullStmt *S);
195 Stmt *VisitCompoundStmt(CompoundStmt *S);
196 Stmt *VisitCaseStmt(CaseStmt *S);
197 Stmt *VisitDefaultStmt(DefaultStmt *S);
198 Stmt *VisitLabelStmt(LabelStmt *S);
199 Stmt *VisitAttributedStmt(AttributedStmt *S);
200 Stmt *VisitIfStmt(IfStmt *S);
201 Stmt *VisitSwitchStmt(SwitchStmt *S);
202 Stmt *VisitWhileStmt(WhileStmt *S);
203 Stmt *VisitDoStmt(DoStmt *S);
204 Stmt *VisitForStmt(ForStmt *S);
205 Stmt *VisitGotoStmt(GotoStmt *S);
206 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
207 Stmt *VisitContinueStmt(ContinueStmt *S);
208 Stmt *VisitBreakStmt(BreakStmt *S);
209 Stmt *VisitReturnStmt(ReturnStmt *S);
211 // FIXME: SEHExceptStmt
212 // FIXME: SEHFinallyStmt
214 // FIXME: SEHLeaveStmt
215 // FIXME: CapturedStmt
216 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
217 Stmt *VisitCXXTryStmt(CXXTryStmt *S);
218 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
219 // FIXME: MSDependentExistsStmt
220 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
221 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
222 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
223 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
224 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
225 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
226 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
228 // Importing expressions
229 Expr *VisitExpr(Expr *E);
230 Expr *VisitVAArgExpr(VAArgExpr *E);
231 Expr *VisitGNUNullExpr(GNUNullExpr *E);
232 Expr *VisitPredefinedExpr(PredefinedExpr *E);
233 Expr *VisitDeclRefExpr(DeclRefExpr *E);
234 Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
235 Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
236 Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
237 Expr *VisitIntegerLiteral(IntegerLiteral *E);
238 Expr *VisitFloatingLiteral(FloatingLiteral *E);
239 Expr *VisitCharacterLiteral(CharacterLiteral *E);
240 Expr *VisitStringLiteral(StringLiteral *E);
241 Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
242 Expr *VisitAtomicExpr(AtomicExpr *E);
243 Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
244 Expr *VisitParenExpr(ParenExpr *E);
245 Expr *VisitParenListExpr(ParenListExpr *E);
246 Expr *VisitStmtExpr(StmtExpr *E);
247 Expr *VisitUnaryOperator(UnaryOperator *E);
248 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
249 Expr *VisitBinaryOperator(BinaryOperator *E);
250 Expr *VisitConditionalOperator(ConditionalOperator *E);
251 Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
252 Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
253 Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
254 Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
255 Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
256 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
257 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
258 Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
259 Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
260 Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
261 Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
262 Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
263 Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
264 Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
265 Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
266 Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
267 Expr *VisitCXXNewExpr(CXXNewExpr *CE);
268 Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
269 Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
270 Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
271 Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
272 Expr *VisitCXXThisExpr(CXXThisExpr *E);
273 Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
274 Expr *VisitMemberExpr(MemberExpr *E);
275 Expr *VisitCallExpr(CallExpr *E);
276 Expr *VisitInitListExpr(InitListExpr *E);
277 Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
278 Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
279 Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
280 Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
281 Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
284 template<typename IIter, typename OIter>
285 void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
286 typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;
287 ASTImporter &ImporterRef = Importer;
288 std::transform(Ibegin, Iend, Obegin,
289 [&ImporterRef](ItemT From) -> ItemT {
290 return ImporterRef.Import(From);
294 template<typename IIter, typename OIter>
295 bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
296 typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT;
297 ASTImporter &ImporterRef = Importer;
299 std::transform(Ibegin, Iend, Obegin,
300 [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
301 ItemT *To = cast_or_null<ItemT>(
302 ImporterRef.Import(From));
310 template<typename InContainerTy, typename OutContainerTy>
311 bool ImportContainerChecked(const InContainerTy &InContainer,
312 OutContainerTy &OutContainer) {
313 return ImportArrayChecked(InContainer.begin(), InContainer.end(),
314 OutContainer.begin());
317 template<typename InContainerTy, typename OIter>
318 bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
319 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
324 using namespace clang;
326 //----------------------------------------------------------------------------
327 // Structural Equivalence
328 //----------------------------------------------------------------------------
331 struct StructuralEquivalenceContext {
332 /// \brief AST contexts for which we are checking structural equivalence.
335 /// \brief The set of "tentative" equivalences between two canonical
336 /// declarations, mapping from a declaration in the first context to the
337 /// declaration in the second context that we believe to be equivalent.
338 llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
340 /// \brief Queue of declarations in the first context whose equivalence
341 /// with a declaration in the second context still needs to be verified.
342 std::deque<Decl *> DeclsToCheck;
344 /// \brief Declaration (from, to) pairs that are known not to be equivalent
345 /// (which we have already complained about).
346 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
348 /// \brief Whether we're being strict about the spelling of types when
349 /// unifying two types.
350 bool StrictTypeSpelling;
352 /// \brief Whether to complain about failures.
355 /// \brief \c true if the last diagnostic came from C2.
358 StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
359 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
360 bool StrictTypeSpelling = false,
361 bool Complain = true)
362 : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
363 StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
364 LastDiagFromC2(false) {}
366 /// \brief Determine whether the two declarations are structurally
368 bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
370 /// \brief Determine whether the two types are structurally equivalent.
371 bool IsStructurallyEquivalent(QualType T1, QualType T2);
374 /// \brief Finish checking all of the structural equivalences.
376 /// \returns true if an error occurred, false otherwise.
380 DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
381 assert(Complain && "Not allowed to complain");
383 C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
384 LastDiagFromC2 = false;
385 return C1.getDiagnostics().Report(Loc, DiagID);
388 DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
389 assert(Complain && "Not allowed to complain");
391 C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
392 LastDiagFromC2 = true;
393 return C2.getDiagnostics().Report(Loc, DiagID);
398 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
399 QualType T1, QualType T2);
400 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
402 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
403 const TemplateArgument &Arg1,
404 const TemplateArgument &Arg2);
406 /// \brief Determine structural equivalence of two expressions.
407 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
408 Expr *E1, Expr *E2) {
412 // FIXME: Actually perform a structural comparison!
416 /// \brief Determine whether two identifiers are equivalent.
417 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
418 const IdentifierInfo *Name2) {
419 if (!Name1 || !Name2)
420 return Name1 == Name2;
422 return Name1->getName() == Name2->getName();
425 /// \brief Determine whether two nested-name-specifiers are equivalent.
426 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
427 NestedNameSpecifier *NNS1,
428 NestedNameSpecifier *NNS2) {
429 if (NNS1->getKind() != NNS2->getKind())
432 NestedNameSpecifier *Prefix1 = NNS1->getPrefix(),
433 *Prefix2 = NNS2->getPrefix();
434 if ((bool)Prefix1 != (bool)Prefix2)
438 if (!IsStructurallyEquivalent(Context, Prefix1, Prefix2))
441 switch (NNS1->getKind()) {
442 case NestedNameSpecifier::Identifier:
443 return IsStructurallyEquivalent(NNS1->getAsIdentifier(),
444 NNS2->getAsIdentifier());
445 case NestedNameSpecifier::Namespace:
446 return IsStructurallyEquivalent(Context, NNS1->getAsNamespace(),
447 NNS2->getAsNamespace());
448 case NestedNameSpecifier::NamespaceAlias:
449 return IsStructurallyEquivalent(Context, NNS1->getAsNamespaceAlias(),
450 NNS2->getAsNamespaceAlias());
451 case NestedNameSpecifier::TypeSpec:
452 case NestedNameSpecifier::TypeSpecWithTemplate:
453 return IsStructurallyEquivalent(Context, QualType(NNS1->getAsType(), 0),
454 QualType(NNS2->getAsType(), 0));
455 case NestedNameSpecifier::Global:
457 case NestedNameSpecifier::Super:
458 return IsStructurallyEquivalent(Context, NNS1->getAsRecordDecl(),
459 NNS2->getAsRecordDecl());
464 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
465 const TemplateName &N1,
466 const TemplateName &N2) {
467 if (N1.getKind() != N2.getKind())
469 switch (N1.getKind()) {
470 case TemplateName::Template:
471 return IsStructurallyEquivalent(Context, N1.getAsTemplateDecl(),
472 N2.getAsTemplateDecl());
474 case TemplateName::OverloadedTemplate: {
475 OverloadedTemplateStorage *OS1 = N1.getAsOverloadedTemplate(),
476 *OS2 = N2.getAsOverloadedTemplate();
477 OverloadedTemplateStorage::iterator I1 = OS1->begin(), I2 = OS2->begin(),
478 E1 = OS1->end(), E2 = OS2->end();
479 for (; I1 != E1 && I2 != E2; ++I1, ++I2)
480 if (!IsStructurallyEquivalent(Context, *I1, *I2))
482 return I1 == E1 && I2 == E2;
485 case TemplateName::QualifiedTemplate: {
486 QualifiedTemplateName *QN1 = N1.getAsQualifiedTemplateName(),
487 *QN2 = N2.getAsQualifiedTemplateName();
488 return IsStructurallyEquivalent(Context, QN1->getDecl(), QN2->getDecl()) &&
489 IsStructurallyEquivalent(Context, QN1->getQualifier(),
490 QN2->getQualifier());
493 case TemplateName::DependentTemplate: {
494 DependentTemplateName *DN1 = N1.getAsDependentTemplateName(),
495 *DN2 = N2.getAsDependentTemplateName();
496 if (!IsStructurallyEquivalent(Context, DN1->getQualifier(),
497 DN2->getQualifier()))
499 if (DN1->isIdentifier() && DN2->isIdentifier())
500 return IsStructurallyEquivalent(DN1->getIdentifier(),
501 DN2->getIdentifier());
502 else if (DN1->isOverloadedOperator() && DN2->isOverloadedOperator())
503 return DN1->getOperator() == DN2->getOperator();
507 case TemplateName::SubstTemplateTemplateParm: {
508 SubstTemplateTemplateParmStorage *TS1 = N1.getAsSubstTemplateTemplateParm(),
509 *TS2 = N2.getAsSubstTemplateTemplateParm();
510 return IsStructurallyEquivalent(Context, TS1->getParameter(),
511 TS2->getParameter()) &&
512 IsStructurallyEquivalent(Context, TS1->getReplacement(),
513 TS2->getReplacement());
515 case TemplateName::SubstTemplateTemplateParmPack: {
516 SubstTemplateTemplateParmPackStorage
517 *P1 = N1.getAsSubstTemplateTemplateParmPack(),
518 *P2 = N2.getAsSubstTemplateTemplateParmPack();
519 return IsStructurallyEquivalent(Context, P1->getArgumentPack(),
520 P2->getArgumentPack()) &&
521 IsStructurallyEquivalent(Context, P1->getParameterPack(),
522 P2->getParameterPack());
528 /// \brief Determine whether two template arguments are equivalent.
529 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
530 const TemplateArgument &Arg1,
531 const TemplateArgument &Arg2) {
532 if (Arg1.getKind() != Arg2.getKind())
535 switch (Arg1.getKind()) {
536 case TemplateArgument::Null:
539 case TemplateArgument::Type:
540 return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
542 case TemplateArgument::Integral:
543 if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
544 Arg2.getIntegralType()))
547 return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
549 case TemplateArgument::Declaration:
550 return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
552 case TemplateArgument::NullPtr:
553 return true; // FIXME: Is this correct?
555 case TemplateArgument::Template:
556 return IsStructurallyEquivalent(Context,
557 Arg1.getAsTemplate(),
558 Arg2.getAsTemplate());
560 case TemplateArgument::TemplateExpansion:
561 return IsStructurallyEquivalent(Context,
562 Arg1.getAsTemplateOrTemplatePattern(),
563 Arg2.getAsTemplateOrTemplatePattern());
565 case TemplateArgument::Expression:
566 return IsStructurallyEquivalent(Context,
567 Arg1.getAsExpr(), Arg2.getAsExpr());
569 case TemplateArgument::Pack:
570 if (Arg1.pack_size() != Arg2.pack_size())
573 for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
574 if (!IsStructurallyEquivalent(Context,
575 Arg1.pack_begin()[I],
576 Arg2.pack_begin()[I]))
582 llvm_unreachable("Invalid template argument kind");
585 /// \brief Determine structural equivalence for the common part of array
587 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
588 const ArrayType *Array1,
589 const ArrayType *Array2) {
590 if (!IsStructurallyEquivalent(Context,
591 Array1->getElementType(),
592 Array2->getElementType()))
594 if (Array1->getSizeModifier() != Array2->getSizeModifier())
596 if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
602 /// \brief Determine structural equivalence of two types.
603 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
604 QualType T1, QualType T2) {
605 if (T1.isNull() || T2.isNull())
606 return T1.isNull() && T2.isNull();
608 if (!Context.StrictTypeSpelling) {
609 // We aren't being strict about token-to-token equivalence of types,
610 // so map down to the canonical type.
611 T1 = Context.C1.getCanonicalType(T1);
612 T2 = Context.C2.getCanonicalType(T2);
615 if (T1.getQualifiers() != T2.getQualifiers())
618 Type::TypeClass TC = T1->getTypeClass();
620 if (T1->getTypeClass() != T2->getTypeClass()) {
621 // Compare function types with prototypes vs. without prototypes as if
622 // both did not have prototypes.
623 if (T1->getTypeClass() == Type::FunctionProto &&
624 T2->getTypeClass() == Type::FunctionNoProto)
625 TC = Type::FunctionNoProto;
626 else if (T1->getTypeClass() == Type::FunctionNoProto &&
627 T2->getTypeClass() == Type::FunctionProto)
628 TC = Type::FunctionNoProto;
635 // FIXME: Deal with Char_S/Char_U.
636 if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
641 if (!IsStructurallyEquivalent(Context,
642 cast<ComplexType>(T1)->getElementType(),
643 cast<ComplexType>(T2)->getElementType()))
649 if (!IsStructurallyEquivalent(Context,
650 cast<AdjustedType>(T1)->getOriginalType(),
651 cast<AdjustedType>(T2)->getOriginalType()))
656 if (!IsStructurallyEquivalent(Context,
657 cast<PointerType>(T1)->getPointeeType(),
658 cast<PointerType>(T2)->getPointeeType()))
662 case Type::BlockPointer:
663 if (!IsStructurallyEquivalent(Context,
664 cast<BlockPointerType>(T1)->getPointeeType(),
665 cast<BlockPointerType>(T2)->getPointeeType()))
669 case Type::LValueReference:
670 case Type::RValueReference: {
671 const ReferenceType *Ref1 = cast<ReferenceType>(T1);
672 const ReferenceType *Ref2 = cast<ReferenceType>(T2);
673 if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
675 if (Ref1->isInnerRef() != Ref2->isInnerRef())
677 if (!IsStructurallyEquivalent(Context,
678 Ref1->getPointeeTypeAsWritten(),
679 Ref2->getPointeeTypeAsWritten()))
684 case Type::MemberPointer: {
685 const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
686 const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
687 if (!IsStructurallyEquivalent(Context,
688 MemPtr1->getPointeeType(),
689 MemPtr2->getPointeeType()))
691 if (!IsStructurallyEquivalent(Context,
692 QualType(MemPtr1->getClass(), 0),
693 QualType(MemPtr2->getClass(), 0)))
698 case Type::ConstantArray: {
699 const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
700 const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
701 if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
704 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
709 case Type::IncompleteArray:
710 if (!IsArrayStructurallyEquivalent(Context,
712 cast<ArrayType>(T2)))
716 case Type::VariableArray: {
717 const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
718 const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
719 if (!IsStructurallyEquivalent(Context,
720 Array1->getSizeExpr(), Array2->getSizeExpr()))
723 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
729 case Type::DependentSizedArray: {
730 const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
731 const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
732 if (!IsStructurallyEquivalent(Context,
733 Array1->getSizeExpr(), Array2->getSizeExpr()))
736 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
742 case Type::DependentSizedExtVector: {
743 const DependentSizedExtVectorType *Vec1
744 = cast<DependentSizedExtVectorType>(T1);
745 const DependentSizedExtVectorType *Vec2
746 = cast<DependentSizedExtVectorType>(T2);
747 if (!IsStructurallyEquivalent(Context,
748 Vec1->getSizeExpr(), Vec2->getSizeExpr()))
750 if (!IsStructurallyEquivalent(Context,
751 Vec1->getElementType(),
752 Vec2->getElementType()))
758 case Type::ExtVector: {
759 const VectorType *Vec1 = cast<VectorType>(T1);
760 const VectorType *Vec2 = cast<VectorType>(T2);
761 if (!IsStructurallyEquivalent(Context,
762 Vec1->getElementType(),
763 Vec2->getElementType()))
765 if (Vec1->getNumElements() != Vec2->getNumElements())
767 if (Vec1->getVectorKind() != Vec2->getVectorKind())
772 case Type::FunctionProto: {
773 const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
774 const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
775 if (Proto1->getNumParams() != Proto2->getNumParams())
777 for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
778 if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
779 Proto2->getParamType(I)))
782 if (Proto1->isVariadic() != Proto2->isVariadic())
784 if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
786 if (Proto1->getExceptionSpecType() == EST_Dynamic) {
787 if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
789 for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
790 if (!IsStructurallyEquivalent(Context,
791 Proto1->getExceptionType(I),
792 Proto2->getExceptionType(I)))
795 } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
796 if (!IsStructurallyEquivalent(Context,
797 Proto1->getNoexceptExpr(),
798 Proto2->getNoexceptExpr()))
801 if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
804 // Fall through to check the bits common with FunctionNoProtoType.
807 case Type::FunctionNoProto: {
808 const FunctionType *Function1 = cast<FunctionType>(T1);
809 const FunctionType *Function2 = cast<FunctionType>(T2);
810 if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
811 Function2->getReturnType()))
813 if (Function1->getExtInfo() != Function2->getExtInfo())
818 case Type::UnresolvedUsing:
819 if (!IsStructurallyEquivalent(Context,
820 cast<UnresolvedUsingType>(T1)->getDecl(),
821 cast<UnresolvedUsingType>(T2)->getDecl()))
826 case Type::Attributed:
827 if (!IsStructurallyEquivalent(Context,
828 cast<AttributedType>(T1)->getModifiedType(),
829 cast<AttributedType>(T2)->getModifiedType()))
831 if (!IsStructurallyEquivalent(Context,
832 cast<AttributedType>(T1)->getEquivalentType(),
833 cast<AttributedType>(T2)->getEquivalentType()))
838 if (!IsStructurallyEquivalent(Context,
839 cast<ParenType>(T1)->getInnerType(),
840 cast<ParenType>(T2)->getInnerType()))
845 if (!IsStructurallyEquivalent(Context,
846 cast<TypedefType>(T1)->getDecl(),
847 cast<TypedefType>(T2)->getDecl()))
851 case Type::TypeOfExpr:
852 if (!IsStructurallyEquivalent(Context,
853 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
854 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
859 if (!IsStructurallyEquivalent(Context,
860 cast<TypeOfType>(T1)->getUnderlyingType(),
861 cast<TypeOfType>(T2)->getUnderlyingType()))
865 case Type::UnaryTransform:
866 if (!IsStructurallyEquivalent(Context,
867 cast<UnaryTransformType>(T1)->getUnderlyingType(),
868 cast<UnaryTransformType>(T1)->getUnderlyingType()))
873 if (!IsStructurallyEquivalent(Context,
874 cast<DecltypeType>(T1)->getUnderlyingExpr(),
875 cast<DecltypeType>(T2)->getUnderlyingExpr()))
880 if (!IsStructurallyEquivalent(Context,
881 cast<AutoType>(T1)->getDeducedType(),
882 cast<AutoType>(T2)->getDeducedType()))
886 case Type::DeducedTemplateSpecialization: {
887 auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
888 auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
889 if (!IsStructurallyEquivalent(Context,
890 DT1->getTemplateName(),
891 DT2->getTemplateName()))
893 if (!IsStructurallyEquivalent(Context,
894 DT1->getDeducedType(),
895 DT2->getDeducedType()))
902 if (!IsStructurallyEquivalent(Context,
903 cast<TagType>(T1)->getDecl(),
904 cast<TagType>(T2)->getDecl()))
908 case Type::TemplateTypeParm: {
909 const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
910 const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
911 if (Parm1->getDepth() != Parm2->getDepth())
913 if (Parm1->getIndex() != Parm2->getIndex())
915 if (Parm1->isParameterPack() != Parm2->isParameterPack())
918 // Names of template type parameters are never significant.
922 case Type::SubstTemplateTypeParm: {
923 const SubstTemplateTypeParmType *Subst1
924 = cast<SubstTemplateTypeParmType>(T1);
925 const SubstTemplateTypeParmType *Subst2
926 = cast<SubstTemplateTypeParmType>(T2);
927 if (!IsStructurallyEquivalent(Context,
928 QualType(Subst1->getReplacedParameter(), 0),
929 QualType(Subst2->getReplacedParameter(), 0)))
931 if (!IsStructurallyEquivalent(Context,
932 Subst1->getReplacementType(),
933 Subst2->getReplacementType()))
938 case Type::SubstTemplateTypeParmPack: {
939 const SubstTemplateTypeParmPackType *Subst1
940 = cast<SubstTemplateTypeParmPackType>(T1);
941 const SubstTemplateTypeParmPackType *Subst2
942 = cast<SubstTemplateTypeParmPackType>(T2);
943 if (!IsStructurallyEquivalent(Context,
944 QualType(Subst1->getReplacedParameter(), 0),
945 QualType(Subst2->getReplacedParameter(), 0)))
947 if (!IsStructurallyEquivalent(Context,
948 Subst1->getArgumentPack(),
949 Subst2->getArgumentPack()))
953 case Type::TemplateSpecialization: {
954 const TemplateSpecializationType *Spec1
955 = cast<TemplateSpecializationType>(T1);
956 const TemplateSpecializationType *Spec2
957 = cast<TemplateSpecializationType>(T2);
958 if (!IsStructurallyEquivalent(Context,
959 Spec1->getTemplateName(),
960 Spec2->getTemplateName()))
962 if (Spec1->getNumArgs() != Spec2->getNumArgs())
964 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
965 if (!IsStructurallyEquivalent(Context,
966 Spec1->getArg(I), Spec2->getArg(I)))
972 case Type::Elaborated: {
973 const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
974 const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
975 // CHECKME: what if a keyword is ETK_None or ETK_typename ?
976 if (Elab1->getKeyword() != Elab2->getKeyword())
978 if (!IsStructurallyEquivalent(Context,
979 Elab1->getQualifier(),
980 Elab2->getQualifier()))
982 if (!IsStructurallyEquivalent(Context,
983 Elab1->getNamedType(),
984 Elab2->getNamedType()))
989 case Type::InjectedClassName: {
990 const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
991 const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
992 if (!IsStructurallyEquivalent(Context,
993 Inj1->getInjectedSpecializationType(),
994 Inj2->getInjectedSpecializationType()))
999 case Type::DependentName: {
1000 const DependentNameType *Typename1 = cast<DependentNameType>(T1);
1001 const DependentNameType *Typename2 = cast<DependentNameType>(T2);
1002 if (!IsStructurallyEquivalent(Context,
1003 Typename1->getQualifier(),
1004 Typename2->getQualifier()))
1006 if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
1007 Typename2->getIdentifier()))
1013 case Type::DependentTemplateSpecialization: {
1014 const DependentTemplateSpecializationType *Spec1 =
1015 cast<DependentTemplateSpecializationType>(T1);
1016 const DependentTemplateSpecializationType *Spec2 =
1017 cast<DependentTemplateSpecializationType>(T2);
1018 if (!IsStructurallyEquivalent(Context,
1019 Spec1->getQualifier(),
1020 Spec2->getQualifier()))
1022 if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
1023 Spec2->getIdentifier()))
1025 if (Spec1->getNumArgs() != Spec2->getNumArgs())
1027 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
1028 if (!IsStructurallyEquivalent(Context,
1029 Spec1->getArg(I), Spec2->getArg(I)))
1035 case Type::PackExpansion:
1036 if (!IsStructurallyEquivalent(Context,
1037 cast<PackExpansionType>(T1)->getPattern(),
1038 cast<PackExpansionType>(T2)->getPattern()))
1042 case Type::ObjCInterface: {
1043 const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
1044 const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
1045 if (!IsStructurallyEquivalent(Context,
1046 Iface1->getDecl(), Iface2->getDecl()))
1051 case Type::ObjCTypeParam: {
1052 const ObjCTypeParamType *Obj1 = cast<ObjCTypeParamType>(T1);
1053 const ObjCTypeParamType *Obj2 = cast<ObjCTypeParamType>(T2);
1054 if (!IsStructurallyEquivalent(Context, Obj1->getDecl(),
1058 if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
1060 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
1061 if (!IsStructurallyEquivalent(Context,
1062 Obj1->getProtocol(I),
1063 Obj2->getProtocol(I)))
1068 case Type::ObjCObject: {
1069 const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
1070 const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
1071 if (!IsStructurallyEquivalent(Context,
1072 Obj1->getBaseType(),
1073 Obj2->getBaseType()))
1075 if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
1077 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
1078 if (!IsStructurallyEquivalent(Context,
1079 Obj1->getProtocol(I),
1080 Obj2->getProtocol(I)))
1086 case Type::ObjCObjectPointer: {
1087 const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
1088 const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
1089 if (!IsStructurallyEquivalent(Context,
1090 Ptr1->getPointeeType(),
1091 Ptr2->getPointeeType()))
1096 case Type::Atomic: {
1097 if (!IsStructurallyEquivalent(Context,
1098 cast<AtomicType>(T1)->getValueType(),
1099 cast<AtomicType>(T2)->getValueType()))
1105 if (!IsStructurallyEquivalent(Context,
1106 cast<PipeType>(T1)->getElementType(),
1107 cast<PipeType>(T2)->getElementType()))
1117 /// \brief Determine structural equivalence of two fields.
1118 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1119 FieldDecl *Field1, FieldDecl *Field2) {
1120 RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
1122 // For anonymous structs/unions, match up the anonymous struct/union type
1123 // declarations directly, so that we don't go off searching for anonymous
1125 if (Field1->isAnonymousStructOrUnion() &&
1126 Field2->isAnonymousStructOrUnion()) {
1127 RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
1128 RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
1129 return IsStructurallyEquivalent(Context, D1, D2);
1132 // Check for equivalent field names.
1133 IdentifierInfo *Name1 = Field1->getIdentifier();
1134 IdentifierInfo *Name2 = Field2->getIdentifier();
1135 if (!::IsStructurallyEquivalent(Name1, Name2))
1138 if (!IsStructurallyEquivalent(Context,
1139 Field1->getType(), Field2->getType())) {
1140 if (Context.Complain) {
1141 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1142 << Context.C2.getTypeDeclType(Owner2);
1143 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1144 << Field2->getDeclName() << Field2->getType();
1145 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1146 << Field1->getDeclName() << Field1->getType();
1151 if (Field1->isBitField() != Field2->isBitField()) {
1152 if (Context.Complain) {
1153 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1154 << Context.C2.getTypeDeclType(Owner2);
1155 if (Field1->isBitField()) {
1156 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
1157 << Field1->getDeclName() << Field1->getType()
1158 << Field1->getBitWidthValue(Context.C1);
1159 Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
1160 << Field2->getDeclName();
1162 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
1163 << Field2->getDeclName() << Field2->getType()
1164 << Field2->getBitWidthValue(Context.C2);
1165 Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
1166 << Field1->getDeclName();
1172 if (Field1->isBitField()) {
1173 // Make sure that the bit-fields are the same length.
1174 unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
1175 unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
1177 if (Bits1 != Bits2) {
1178 if (Context.Complain) {
1179 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1180 << Context.C2.getTypeDeclType(Owner2);
1181 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
1182 << Field2->getDeclName() << Field2->getType() << Bits2;
1183 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
1184 << Field1->getDeclName() << Field1->getType() << Bits1;
1193 /// \brief Find the index of the given anonymous struct/union within its
1196 /// \returns Returns the index of this anonymous struct/union in its context,
1197 /// including the next assigned index (if none of them match). Returns an
1198 /// empty option if the context is not a record, i.e.. if the anonymous
1199 /// struct/union is at namespace or block scope.
1200 static Optional<unsigned> findUntaggedStructOrUnionIndex(RecordDecl *Anon) {
1201 ASTContext &Context = Anon->getASTContext();
1202 QualType AnonTy = Context.getRecordType(Anon);
1204 RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
1209 for (const auto *D : Owner->noload_decls()) {
1210 const auto *F = dyn_cast<FieldDecl>(D);
1214 if (F->isAnonymousStructOrUnion()) {
1215 if (Context.hasSameType(F->getType(), AnonTy))
1221 // If the field looks like this:
1222 // struct { ... } A;
1223 QualType FieldType = F->getType();
1224 if (const auto *RecType = dyn_cast<RecordType>(FieldType)) {
1225 const RecordDecl *RecDecl = RecType->getDecl();
1226 if (RecDecl->getDeclContext() == Owner &&
1227 !RecDecl->getIdentifier()) {
1228 if (Context.hasSameType(FieldType, AnonTy))
1239 /// \brief Determine structural equivalence of two records.
1240 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1241 RecordDecl *D1, RecordDecl *D2) {
1242 if (D1->isUnion() != D2->isUnion()) {
1243 if (Context.Complain) {
1244 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1245 << Context.C2.getTypeDeclType(D2);
1246 Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
1247 << D1->getDeclName() << (unsigned)D1->getTagKind();
1252 if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
1253 // If both anonymous structs/unions are in a record context, make sure
1254 // they occur in the same location in the context records.
1255 if (Optional<unsigned> Index1 = findUntaggedStructOrUnionIndex(D1)) {
1256 if (Optional<unsigned> Index2 = findUntaggedStructOrUnionIndex(D2)) {
1257 if (*Index1 != *Index2)
1263 // If both declarations are class template specializations, we know
1264 // the ODR applies, so check the template and template arguments.
1265 ClassTemplateSpecializationDecl *Spec1
1266 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
1267 ClassTemplateSpecializationDecl *Spec2
1268 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
1269 if (Spec1 && Spec2) {
1270 // Check that the specialized templates are the same.
1271 if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
1272 Spec2->getSpecializedTemplate()))
1275 // Check that the template arguments are the same.
1276 if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
1279 for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
1280 if (!IsStructurallyEquivalent(Context,
1281 Spec1->getTemplateArgs().get(I),
1282 Spec2->getTemplateArgs().get(I)))
1285 // If one is a class template specialization and the other is not, these
1286 // structures are different.
1287 else if (Spec1 || Spec2)
1290 // Compare the definitions of these two records. If either or both are
1291 // incomplete, we assume that they are equivalent.
1292 D1 = D1->getDefinition();
1293 D2 = D2->getDefinition();
1297 if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1298 if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1299 if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1300 if (Context.Complain) {
1301 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1302 << Context.C2.getTypeDeclType(D2);
1303 Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1304 << D2CXX->getNumBases();
1305 Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1306 << D1CXX->getNumBases();
1311 // Check the base classes.
1312 for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1313 BaseEnd1 = D1CXX->bases_end(),
1314 Base2 = D2CXX->bases_begin();
1317 if (!IsStructurallyEquivalent(Context,
1318 Base1->getType(), Base2->getType())) {
1319 if (Context.Complain) {
1320 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1321 << Context.C2.getTypeDeclType(D2);
1322 Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1324 << Base2->getSourceRange();
1325 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1327 << Base1->getSourceRange();
1332 // Check virtual vs. non-virtual inheritance mismatch.
1333 if (Base1->isVirtual() != Base2->isVirtual()) {
1334 if (Context.Complain) {
1335 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1336 << Context.C2.getTypeDeclType(D2);
1337 Context.Diag2(Base2->getLocStart(),
1338 diag::note_odr_virtual_base)
1339 << Base2->isVirtual() << Base2->getSourceRange();
1340 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1341 << Base1->isVirtual()
1342 << Base1->getSourceRange();
1347 } else if (D1CXX->getNumBases() > 0) {
1348 if (Context.Complain) {
1349 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1350 << Context.C2.getTypeDeclType(D2);
1351 const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1352 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1354 << Base1->getSourceRange();
1355 Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1361 // Check the fields for consistency.
1362 RecordDecl::field_iterator Field2 = D2->field_begin(),
1363 Field2End = D2->field_end();
1364 for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1365 Field1End = D1->field_end();
1366 Field1 != Field1End;
1367 ++Field1, ++Field2) {
1368 if (Field2 == Field2End) {
1369 if (Context.Complain) {
1370 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1371 << Context.C2.getTypeDeclType(D2);
1372 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1373 << Field1->getDeclName() << Field1->getType();
1374 Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1379 if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1383 if (Field2 != Field2End) {
1384 if (Context.Complain) {
1385 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1386 << Context.C2.getTypeDeclType(D2);
1387 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1388 << Field2->getDeclName() << Field2->getType();
1389 Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1397 /// \brief Determine structural equivalence of two enums.
1398 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1399 EnumDecl *D1, EnumDecl *D2) {
1400 EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1401 EC2End = D2->enumerator_end();
1402 for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1403 EC1End = D1->enumerator_end();
1404 EC1 != EC1End; ++EC1, ++EC2) {
1405 if (EC2 == EC2End) {
1406 if (Context.Complain) {
1407 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1408 << Context.C2.getTypeDeclType(D2);
1409 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1410 << EC1->getDeclName()
1411 << EC1->getInitVal().toString(10);
1412 Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1417 llvm::APSInt Val1 = EC1->getInitVal();
1418 llvm::APSInt Val2 = EC2->getInitVal();
1419 if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1420 !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1421 if (Context.Complain) {
1422 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1423 << Context.C2.getTypeDeclType(D2);
1424 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1425 << EC2->getDeclName()
1426 << EC2->getInitVal().toString(10);
1427 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1428 << EC1->getDeclName()
1429 << EC1->getInitVal().toString(10);
1435 if (EC2 != EC2End) {
1436 if (Context.Complain) {
1437 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1438 << Context.C2.getTypeDeclType(D2);
1439 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1440 << EC2->getDeclName()
1441 << EC2->getInitVal().toString(10);
1442 Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1450 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1451 TemplateParameterList *Params1,
1452 TemplateParameterList *Params2) {
1453 if (Params1->size() != Params2->size()) {
1454 if (Context.Complain) {
1455 Context.Diag2(Params2->getTemplateLoc(),
1456 diag::err_odr_different_num_template_parameters)
1457 << Params1->size() << Params2->size();
1458 Context.Diag1(Params1->getTemplateLoc(),
1459 diag::note_odr_template_parameter_list);
1464 for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1465 if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1466 if (Context.Complain) {
1467 Context.Diag2(Params2->getParam(I)->getLocation(),
1468 diag::err_odr_different_template_parameter_kind);
1469 Context.Diag1(Params1->getParam(I)->getLocation(),
1470 diag::note_odr_template_parameter_here);
1475 if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1476 Params2->getParam(I))) {
1485 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1486 TemplateTypeParmDecl *D1,
1487 TemplateTypeParmDecl *D2) {
1488 if (D1->isParameterPack() != D2->isParameterPack()) {
1489 if (Context.Complain) {
1490 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1491 << D2->isParameterPack();
1492 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1493 << D1->isParameterPack();
1501 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1502 NonTypeTemplateParmDecl *D1,
1503 NonTypeTemplateParmDecl *D2) {
1504 if (D1->isParameterPack() != D2->isParameterPack()) {
1505 if (Context.Complain) {
1506 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1507 << D2->isParameterPack();
1508 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1509 << D1->isParameterPack();
1515 if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1516 if (Context.Complain) {
1517 Context.Diag2(D2->getLocation(),
1518 diag::err_odr_non_type_parameter_type_inconsistent)
1519 << D2->getType() << D1->getType();
1520 Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1529 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1530 TemplateTemplateParmDecl *D1,
1531 TemplateTemplateParmDecl *D2) {
1532 if (D1->isParameterPack() != D2->isParameterPack()) {
1533 if (Context.Complain) {
1534 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1535 << D2->isParameterPack();
1536 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1537 << D1->isParameterPack();
1542 // Check template parameter lists.
1543 return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1544 D2->getTemplateParameters());
1547 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1548 ClassTemplateDecl *D1,
1549 ClassTemplateDecl *D2) {
1550 // Check template parameters.
1551 if (!IsStructurallyEquivalent(Context,
1552 D1->getTemplateParameters(),
1553 D2->getTemplateParameters()))
1556 // Check the templated declaration.
1557 return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1558 D2->getTemplatedDecl());
1561 /// \brief Determine structural equivalence of two declarations.
1562 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1563 Decl *D1, Decl *D2) {
1564 // FIXME: Check for known structural equivalences via a callback of some sort.
1566 // Check whether we already know that these two declarations are not
1567 // structurally equivalent.
1568 if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1569 D2->getCanonicalDecl())))
1572 // Determine whether we've already produced a tentative equivalence for D1.
1573 Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1575 return EquivToD1 == D2->getCanonicalDecl();
1577 // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1578 EquivToD1 = D2->getCanonicalDecl();
1579 Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1583 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1585 if (!::IsStructurallyEquivalent(*this, D1, D2))
1591 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1593 if (!::IsStructurallyEquivalent(*this, T1, T2))
1599 bool StructuralEquivalenceContext::Finish() {
1600 while (!DeclsToCheck.empty()) {
1601 // Check the next declaration.
1602 Decl *D1 = DeclsToCheck.front();
1603 DeclsToCheck.pop_front();
1605 Decl *D2 = TentativeEquivalences[D1];
1606 assert(D2 && "Unrecorded tentative equivalence?");
1608 bool Equivalent = true;
1610 // FIXME: Switch on all declaration kinds. For now, we're just going to
1611 // check the obvious ones.
1612 if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1613 if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1614 // Check for equivalent structure names.
1615 IdentifierInfo *Name1 = Record1->getIdentifier();
1616 if (!Name1 && Record1->getTypedefNameForAnonDecl())
1617 Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1618 IdentifierInfo *Name2 = Record2->getIdentifier();
1619 if (!Name2 && Record2->getTypedefNameForAnonDecl())
1620 Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1621 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1622 !::IsStructurallyEquivalent(*this, Record1, Record2))
1625 // Record/non-record mismatch.
1628 } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1629 if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1630 // Check for equivalent enum names.
1631 IdentifierInfo *Name1 = Enum1->getIdentifier();
1632 if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1633 Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1634 IdentifierInfo *Name2 = Enum2->getIdentifier();
1635 if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1636 Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1637 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1638 !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1641 // Enum/non-enum mismatch
1644 } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1645 if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1646 if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1647 Typedef2->getIdentifier()) ||
1648 !::IsStructurallyEquivalent(*this,
1649 Typedef1->getUnderlyingType(),
1650 Typedef2->getUnderlyingType()))
1653 // Typedef/non-typedef mismatch.
1656 } else if (ClassTemplateDecl *ClassTemplate1
1657 = dyn_cast<ClassTemplateDecl>(D1)) {
1658 if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1659 if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1660 ClassTemplate2->getIdentifier()) ||
1661 !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1664 // Class template/non-class-template mismatch.
1667 } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1668 if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1669 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1675 } else if (NonTypeTemplateParmDecl *NTTP1
1676 = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1677 if (NonTypeTemplateParmDecl *NTTP2
1678 = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1679 if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1685 } else if (TemplateTemplateParmDecl *TTP1
1686 = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1687 if (TemplateTemplateParmDecl *TTP2
1688 = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1689 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1698 // Note that these two declarations are not equivalent (and we already
1700 NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1701 D2->getCanonicalDecl()));
1704 // FIXME: Check other declaration kinds!
1710 //----------------------------------------------------------------------------
1712 //----------------------------------------------------------------------------
1714 QualType ASTNodeImporter::VisitType(const Type *T) {
1715 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1716 << T->getTypeClassName();
1720 QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
1721 QualType UnderlyingType = Importer.Import(T->getValueType());
1722 if(UnderlyingType.isNull())
1725 return Importer.getToContext().getAtomicType(UnderlyingType);
1728 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1729 switch (T->getKind()) {
1730 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1731 case BuiltinType::Id: \
1732 return Importer.getToContext().SingletonId;
1733 #include "clang/Basic/OpenCLImageTypes.def"
1734 #define SHARED_SINGLETON_TYPE(Expansion)
1735 #define BUILTIN_TYPE(Id, SingletonId) \
1736 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1737 #include "clang/AST/BuiltinTypes.def"
1739 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1740 // context supports C++.
1742 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1743 // context supports ObjC.
1745 case BuiltinType::Char_U:
1746 // The context we're importing from has an unsigned 'char'. If we're
1747 // importing into a context with a signed 'char', translate to
1748 // 'unsigned char' instead.
1749 if (Importer.getToContext().getLangOpts().CharIsSigned)
1750 return Importer.getToContext().UnsignedCharTy;
1752 return Importer.getToContext().CharTy;
1754 case BuiltinType::Char_S:
1755 // The context we're importing from has an unsigned 'char'. If we're
1756 // importing into a context with a signed 'char', translate to
1757 // 'unsigned char' instead.
1758 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1759 return Importer.getToContext().SignedCharTy;
1761 return Importer.getToContext().CharTy;
1763 case BuiltinType::WChar_S:
1764 case BuiltinType::WChar_U:
1765 // FIXME: If not in C++, shall we translate to the C equivalent of
1767 return Importer.getToContext().WCharTy;
1770 llvm_unreachable("Invalid BuiltinType Kind!");
1773 QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
1774 QualType OrigT = Importer.Import(T->getOriginalType());
1778 return Importer.getToContext().getDecayedType(OrigT);
1781 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1782 QualType ToElementType = Importer.Import(T->getElementType());
1783 if (ToElementType.isNull())
1786 return Importer.getToContext().getComplexType(ToElementType);
1789 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1790 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1791 if (ToPointeeType.isNull())
1794 return Importer.getToContext().getPointerType(ToPointeeType);
1797 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1798 // FIXME: Check for blocks support in "to" context.
1799 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1800 if (ToPointeeType.isNull())
1803 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1807 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1808 // FIXME: Check for C++ support in "to" context.
1809 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1810 if (ToPointeeType.isNull())
1813 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1817 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1818 // FIXME: Check for C++0x support in "to" context.
1819 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1820 if (ToPointeeType.isNull())
1823 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1826 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1827 // FIXME: Check for C++ support in "to" context.
1828 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1829 if (ToPointeeType.isNull())
1832 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1833 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1834 ClassType.getTypePtr());
1837 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1838 QualType ToElementType = Importer.Import(T->getElementType());
1839 if (ToElementType.isNull())
1842 return Importer.getToContext().getConstantArrayType(ToElementType,
1844 T->getSizeModifier(),
1845 T->getIndexTypeCVRQualifiers());
1849 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1850 QualType ToElementType = Importer.Import(T->getElementType());
1851 if (ToElementType.isNull())
1854 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1855 T->getSizeModifier(),
1856 T->getIndexTypeCVRQualifiers());
1859 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1860 QualType ToElementType = Importer.Import(T->getElementType());
1861 if (ToElementType.isNull())
1864 Expr *Size = Importer.Import(T->getSizeExpr());
1868 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1869 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1870 T->getSizeModifier(),
1871 T->getIndexTypeCVRQualifiers(),
1875 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1876 QualType ToElementType = Importer.Import(T->getElementType());
1877 if (ToElementType.isNull())
1880 return Importer.getToContext().getVectorType(ToElementType,
1881 T->getNumElements(),
1882 T->getVectorKind());
1885 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1886 QualType ToElementType = Importer.Import(T->getElementType());
1887 if (ToElementType.isNull())
1890 return Importer.getToContext().getExtVectorType(ToElementType,
1891 T->getNumElements());
1895 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1896 // FIXME: What happens if we're importing a function without a prototype
1897 // into C++? Should we make it variadic?
1898 QualType ToResultType = Importer.Import(T->getReturnType());
1899 if (ToResultType.isNull())
1902 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1906 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1907 QualType ToResultType = Importer.Import(T->getReturnType());
1908 if (ToResultType.isNull())
1911 // Import argument types
1912 SmallVector<QualType, 4> ArgTypes;
1913 for (const auto &A : T->param_types()) {
1914 QualType ArgType = Importer.Import(A);
1915 if (ArgType.isNull())
1917 ArgTypes.push_back(ArgType);
1920 // Import exception types
1921 SmallVector<QualType, 4> ExceptionTypes;
1922 for (const auto &E : T->exceptions()) {
1923 QualType ExceptionType = Importer.Import(E);
1924 if (ExceptionType.isNull())
1926 ExceptionTypes.push_back(ExceptionType);
1929 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1930 FunctionProtoType::ExtProtoInfo ToEPI;
1932 ToEPI.ExtInfo = FromEPI.ExtInfo;
1933 ToEPI.Variadic = FromEPI.Variadic;
1934 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1935 ToEPI.TypeQuals = FromEPI.TypeQuals;
1936 ToEPI.RefQualifier = FromEPI.RefQualifier;
1937 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1938 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1939 ToEPI.ExceptionSpec.NoexceptExpr =
1940 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1941 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
1942 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1943 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
1944 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1946 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1949 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1950 QualType ToInnerType = Importer.Import(T->getInnerType());
1951 if (ToInnerType.isNull())
1954 return Importer.getToContext().getParenType(ToInnerType);
1957 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1958 TypedefNameDecl *ToDecl
1959 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1963 return Importer.getToContext().getTypeDeclType(ToDecl);
1966 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1967 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1971 return Importer.getToContext().getTypeOfExprType(ToExpr);
1974 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1975 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1976 if (ToUnderlyingType.isNull())
1979 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1982 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1983 // FIXME: Make sure that the "to" context supports C++0x!
1984 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1988 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1989 if (UnderlyingType.isNull())
1992 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1995 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1996 QualType ToBaseType = Importer.Import(T->getBaseType());
1997 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1998 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
2001 return Importer.getToContext().getUnaryTransformType(ToBaseType,
2006 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
2007 // FIXME: Make sure that the "to" context supports C++11!
2008 QualType FromDeduced = T->getDeducedType();
2010 if (!FromDeduced.isNull()) {
2011 ToDeduced = Importer.Import(FromDeduced);
2012 if (ToDeduced.isNull())
2016 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
2017 /*IsDependent*/false);
2020 QualType ASTNodeImporter::VisitInjectedClassNameType(
2021 const InjectedClassNameType *T) {
2022 CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
2026 QualType InjType = Importer.Import(T->getInjectedSpecializationType());
2027 if (InjType.isNull())
2030 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
2031 // See comments in InjectedClassNameType definition for details
2032 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
2034 TypeAlignmentInBits = 4,
2035 TypeAlignment = 1 << TypeAlignmentInBits
2038 return QualType(new (Importer.getToContext(), TypeAlignment)
2039 InjectedClassNameType(D, InjType), 0);
2042 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
2044 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
2048 return Importer.getToContext().getTagDeclType(ToDecl);
2051 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
2053 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
2057 return Importer.getToContext().getTagDeclType(ToDecl);
2060 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
2061 QualType FromModifiedType = T->getModifiedType();
2062 QualType FromEquivalentType = T->getEquivalentType();
2063 QualType ToModifiedType;
2064 QualType ToEquivalentType;
2066 if (!FromModifiedType.isNull()) {
2067 ToModifiedType = Importer.Import(FromModifiedType);
2068 if (ToModifiedType.isNull())
2071 if (!FromEquivalentType.isNull()) {
2072 ToEquivalentType = Importer.Import(FromEquivalentType);
2073 if (ToEquivalentType.isNull())
2077 return Importer.getToContext().getAttributedType(T->getAttrKind(),
2078 ToModifiedType, ToEquivalentType);
2082 QualType ASTNodeImporter::VisitTemplateTypeParmType(
2083 const TemplateTypeParmType *T) {
2084 TemplateTypeParmDecl *ParmDecl =
2085 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
2086 if (!ParmDecl && T->getDecl())
2089 return Importer.getToContext().getTemplateTypeParmType(
2090 T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
2093 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
2094 const SubstTemplateTypeParmType *T) {
2095 const TemplateTypeParmType *Replaced =
2096 cast_or_null<TemplateTypeParmType>(Importer.Import(
2097 QualType(T->getReplacedParameter(), 0)).getTypePtr());
2101 QualType Replacement = Importer.Import(T->getReplacementType());
2102 if (Replacement.isNull())
2104 Replacement = Replacement.getCanonicalType();
2106 return Importer.getToContext().getSubstTemplateTypeParmType(
2107 Replaced, Replacement);
2110 QualType ASTNodeImporter::VisitTemplateSpecializationType(
2111 const TemplateSpecializationType *T) {
2112 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
2113 if (ToTemplate.isNull())
2116 SmallVector<TemplateArgument, 2> ToTemplateArgs;
2117 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
2120 QualType ToCanonType;
2121 if (!QualType(T, 0).isCanonical()) {
2122 QualType FromCanonType
2123 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
2124 ToCanonType =Importer.Import(FromCanonType);
2125 if (ToCanonType.isNull())
2128 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
2133 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
2134 NestedNameSpecifier *ToQualifier = nullptr;
2135 // Note: the qualifier in an ElaboratedType is optional.
2136 if (T->getQualifier()) {
2137 ToQualifier = Importer.Import(T->getQualifier());
2142 QualType ToNamedType = Importer.Import(T->getNamedType());
2143 if (ToNamedType.isNull())
2146 return Importer.getToContext().getElaboratedType(T->getKeyword(),
2147 ToQualifier, ToNamedType);
2150 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
2151 ObjCInterfaceDecl *Class
2152 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
2156 return Importer.getToContext().getObjCInterfaceType(Class);
2159 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
2160 QualType ToBaseType = Importer.Import(T->getBaseType());
2161 if (ToBaseType.isNull())
2164 SmallVector<QualType, 4> TypeArgs;
2165 for (auto TypeArg : T->getTypeArgsAsWritten()) {
2166 QualType ImportedTypeArg = Importer.Import(TypeArg);
2167 if (ImportedTypeArg.isNull())
2170 TypeArgs.push_back(ImportedTypeArg);
2173 SmallVector<ObjCProtocolDecl *, 4> Protocols;
2174 for (auto *P : T->quals()) {
2175 ObjCProtocolDecl *Protocol
2176 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
2179 Protocols.push_back(Protocol);
2182 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
2184 T->isKindOfTypeAsWritten());
2188 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
2189 QualType ToPointeeType = Importer.Import(T->getPointeeType());
2190 if (ToPointeeType.isNull())
2193 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
2196 //----------------------------------------------------------------------------
2197 // Import Declarations
2198 //----------------------------------------------------------------------------
2199 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
2200 DeclContext *&LexicalDC,
2201 DeclarationName &Name,
2203 SourceLocation &Loc) {
2204 // Import the context of this declaration.
2205 DC = Importer.ImportContext(D->getDeclContext());
2210 if (D->getDeclContext() != D->getLexicalDeclContext()) {
2211 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
2216 // Import the name of this declaration.
2217 Name = Importer.Import(D->getDeclName());
2218 if (D->getDeclName() && !Name)
2221 // Import the location of this declaration.
2222 Loc = Importer.Import(D->getLocation());
2223 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
2227 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
2232 ToD = Importer.Import(FromD);
2237 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
2238 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
2239 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
2240 ImportDefinition(FromRecord, ToRecord);
2246 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
2247 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
2248 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2249 ImportDefinition(FromEnum, ToEnum);
2257 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
2258 DeclarationNameInfo& To) {
2259 // NOTE: To.Name and To.Loc are already imported.
2260 // We only have to import To.LocInfo.
2261 switch (To.getName().getNameKind()) {
2262 case DeclarationName::Identifier:
2263 case DeclarationName::ObjCZeroArgSelector:
2264 case DeclarationName::ObjCOneArgSelector:
2265 case DeclarationName::ObjCMultiArgSelector:
2266 case DeclarationName::CXXUsingDirective:
2267 case DeclarationName::CXXDeductionGuideName:
2270 case DeclarationName::CXXOperatorName: {
2271 SourceRange Range = From.getCXXOperatorNameRange();
2272 To.setCXXOperatorNameRange(Importer.Import(Range));
2275 case DeclarationName::CXXLiteralOperatorName: {
2276 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
2277 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
2280 case DeclarationName::CXXConstructorName:
2281 case DeclarationName::CXXDestructorName:
2282 case DeclarationName::CXXConversionFunctionName: {
2283 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
2284 To.setNamedTypeInfo(Importer.Import(FromTInfo));
2288 llvm_unreachable("Unknown name kind.");
2291 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
2292 if (Importer.isMinimalImport() && !ForceImport) {
2293 Importer.ImportContext(FromDC);
2297 for (auto *From : FromDC->decls())
2298 Importer.Import(From);
2301 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
2302 ImportDefinitionKind Kind) {
2303 if (To->getDefinition() || To->isBeingDefined()) {
2304 if (Kind == IDK_Everything)
2305 ImportDeclContext(From, /*ForceImport=*/true);
2310 To->startDefinition();
2312 // Add base classes.
2313 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
2314 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
2316 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2317 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2318 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
2319 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
2320 ToData.Aggregate = FromData.Aggregate;
2321 ToData.PlainOldData = FromData.PlainOldData;
2322 ToData.Empty = FromData.Empty;
2323 ToData.Polymorphic = FromData.Polymorphic;
2324 ToData.Abstract = FromData.Abstract;
2325 ToData.IsStandardLayout = FromData.IsStandardLayout;
2326 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
2327 ToData.HasPrivateFields = FromData.HasPrivateFields;
2328 ToData.HasProtectedFields = FromData.HasProtectedFields;
2329 ToData.HasPublicFields = FromData.HasPublicFields;
2330 ToData.HasMutableFields = FromData.HasMutableFields;
2331 ToData.HasVariantMembers = FromData.HasVariantMembers;
2332 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
2333 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
2334 ToData.HasUninitializedReferenceMember
2335 = FromData.HasUninitializedReferenceMember;
2336 ToData.HasUninitializedFields = FromData.HasUninitializedFields;
2337 ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
2338 ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
2339 ToData.NeedOverloadResolutionForMoveConstructor
2340 = FromData.NeedOverloadResolutionForMoveConstructor;
2341 ToData.NeedOverloadResolutionForMoveAssignment
2342 = FromData.NeedOverloadResolutionForMoveAssignment;
2343 ToData.NeedOverloadResolutionForDestructor
2344 = FromData.NeedOverloadResolutionForDestructor;
2345 ToData.DefaultedMoveConstructorIsDeleted
2346 = FromData.DefaultedMoveConstructorIsDeleted;
2347 ToData.DefaultedMoveAssignmentIsDeleted
2348 = FromData.DefaultedMoveAssignmentIsDeleted;
2349 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
2350 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
2351 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
2352 ToData.HasConstexprNonCopyMoveConstructor
2353 = FromData.HasConstexprNonCopyMoveConstructor;
2354 ToData.HasDefaultedDefaultConstructor
2355 = FromData.HasDefaultedDefaultConstructor;
2356 ToData.DefaultedDefaultConstructorIsConstexpr
2357 = FromData.DefaultedDefaultConstructorIsConstexpr;
2358 ToData.HasConstexprDefaultConstructor
2359 = FromData.HasConstexprDefaultConstructor;
2360 ToData.HasNonLiteralTypeFieldsOrBases
2361 = FromData.HasNonLiteralTypeFieldsOrBases;
2362 // ComputedVisibleConversions not imported.
2363 ToData.UserProvidedDefaultConstructor
2364 = FromData.UserProvidedDefaultConstructor;
2365 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
2366 ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
2367 = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
2368 ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
2369 = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
2370 ToData.ImplicitCopyAssignmentHasConstParam
2371 = FromData.ImplicitCopyAssignmentHasConstParam;
2372 ToData.HasDeclaredCopyConstructorWithConstParam
2373 = FromData.HasDeclaredCopyConstructorWithConstParam;
2374 ToData.HasDeclaredCopyAssignmentWithConstParam
2375 = FromData.HasDeclaredCopyAssignmentWithConstParam;
2376 ToData.IsLambda = FromData.IsLambda;
2378 SmallVector<CXXBaseSpecifier *, 4> Bases;
2379 for (const auto &Base1 : FromCXX->bases()) {
2380 QualType T = Importer.Import(Base1.getType());
2384 SourceLocation EllipsisLoc;
2385 if (Base1.isPackExpansion())
2386 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2388 // Ensure that we have a definition for the base.
2389 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
2392 new (Importer.getToContext())
2393 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2395 Base1.isBaseOfClass(),
2396 Base1.getAccessSpecifierAsWritten(),
2397 Importer.Import(Base1.getTypeSourceInfo()),
2401 ToCXX->setBases(Bases.data(), Bases.size());
2404 if (shouldForceImportDeclContext(Kind))
2405 ImportDeclContext(From, /*ForceImport=*/true);
2407 To->completeDefinition();
2411 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2412 ImportDefinitionKind Kind) {
2413 if (To->getAnyInitializer())
2416 // FIXME: Can we really import any initializer? Alternatively, we could force
2417 // ourselves to import every declaration of a variable and then only use
2419 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2421 // FIXME: Other bits to merge?
2426 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2427 ImportDefinitionKind Kind) {
2428 if (To->getDefinition() || To->isBeingDefined()) {
2429 if (Kind == IDK_Everything)
2430 ImportDeclContext(From, /*ForceImport=*/true);
2434 To->startDefinition();
2436 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2440 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2441 if (ToPromotionType.isNull())
2444 if (shouldForceImportDeclContext(Kind))
2445 ImportDeclContext(From, /*ForceImport=*/true);
2447 // FIXME: we might need to merge the number of positive or negative bits
2448 // if the enumerator lists don't match.
2449 To->completeDefinition(T, ToPromotionType,
2450 From->getNumPositiveBits(),
2451 From->getNumNegativeBits());
2455 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2456 TemplateParameterList *Params) {
2457 SmallVector<NamedDecl *, 4> ToParams(Params->size());
2458 if (ImportContainerChecked(*Params, ToParams))
2461 Expr *ToRequiresClause;
2462 if (Expr *const R = Params->getRequiresClause()) {
2463 ToRequiresClause = Importer.Import(R);
2464 if (!ToRequiresClause)
2467 ToRequiresClause = nullptr;
2470 return TemplateParameterList::Create(Importer.getToContext(),
2471 Importer.Import(Params->getTemplateLoc()),
2472 Importer.Import(Params->getLAngleLoc()),
2474 Importer.Import(Params->getRAngleLoc()),
2479 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2480 switch (From.getKind()) {
2481 case TemplateArgument::Null:
2482 return TemplateArgument();
2484 case TemplateArgument::Type: {
2485 QualType ToType = Importer.Import(From.getAsType());
2486 if (ToType.isNull())
2487 return TemplateArgument();
2488 return TemplateArgument(ToType);
2491 case TemplateArgument::Integral: {
2492 QualType ToType = Importer.Import(From.getIntegralType());
2493 if (ToType.isNull())
2494 return TemplateArgument();
2495 return TemplateArgument(From, ToType);
2498 case TemplateArgument::Declaration: {
2499 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2500 QualType ToType = Importer.Import(From.getParamTypeForDecl());
2501 if (!To || ToType.isNull())
2502 return TemplateArgument();
2503 return TemplateArgument(To, ToType);
2506 case TemplateArgument::NullPtr: {
2507 QualType ToType = Importer.Import(From.getNullPtrType());
2508 if (ToType.isNull())
2509 return TemplateArgument();
2510 return TemplateArgument(ToType, /*isNullPtr*/true);
2513 case TemplateArgument::Template: {
2514 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2515 if (ToTemplate.isNull())
2516 return TemplateArgument();
2518 return TemplateArgument(ToTemplate);
2521 case TemplateArgument::TemplateExpansion: {
2522 TemplateName ToTemplate
2523 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2524 if (ToTemplate.isNull())
2525 return TemplateArgument();
2527 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2530 case TemplateArgument::Expression:
2531 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2532 return TemplateArgument(ToExpr);
2533 return TemplateArgument();
2535 case TemplateArgument::Pack: {
2536 SmallVector<TemplateArgument, 2> ToPack;
2537 ToPack.reserve(From.pack_size());
2538 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2539 return TemplateArgument();
2541 return TemplateArgument(
2542 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
2546 llvm_unreachable("Invalid template argument kind");
2549 TemplateArgumentLoc ASTNodeImporter::ImportTemplateArgumentLoc(
2550 const TemplateArgumentLoc &TALoc, bool &Error) {
2552 TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
2553 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
2554 TemplateArgumentLocInfo ToInfo;
2555 if (Arg.getKind() == TemplateArgument::Expression) {
2556 Expr *E = Importer.Import(FromInfo.getAsExpr());
2557 ToInfo = TemplateArgumentLocInfo(E);
2560 } else if (Arg.getKind() == TemplateArgument::Type) {
2561 if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
2562 ToInfo = TemplateArgumentLocInfo(TSI);
2566 ToInfo = TemplateArgumentLocInfo(
2567 Importer.Import(FromInfo.getTemplateQualifierLoc()),
2568 Importer.Import(FromInfo.getTemplateNameLoc()),
2569 Importer.Import(FromInfo.getTemplateEllipsisLoc()));
2571 return TemplateArgumentLoc(Arg, ToInfo);
2574 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2575 unsigned NumFromArgs,
2576 SmallVectorImpl<TemplateArgument> &ToArgs) {
2577 for (unsigned I = 0; I != NumFromArgs; ++I) {
2578 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2579 if (To.isNull() && !FromArgs[I].isNull())
2582 ToArgs.push_back(To);
2588 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2589 RecordDecl *ToRecord, bool Complain) {
2590 // Eliminate a potential failure point where we attempt to re-import
2591 // something we're trying to import while completing ToRecord.
2592 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2594 RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2596 ToRecord = ToOriginRecord;
2599 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2600 ToRecord->getASTContext(),
2601 Importer.getNonEquivalentDecls(),
2603 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2606 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2608 StructuralEquivalenceContext Ctx(
2609 Importer.getFromContext(), Importer.getToContext(),
2610 Importer.getNonEquivalentDecls(), false, Complain);
2611 return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2614 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2615 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2616 Importer.getToContext(),
2617 Importer.getNonEquivalentDecls());
2618 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2621 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2622 EnumConstantDecl *ToEC)
2624 const llvm::APSInt &FromVal = FromEC->getInitVal();
2625 const llvm::APSInt &ToVal = ToEC->getInitVal();
2627 return FromVal.isSigned() == ToVal.isSigned() &&
2628 FromVal.getBitWidth() == ToVal.getBitWidth() &&
2632 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2633 ClassTemplateDecl *To) {
2634 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2635 Importer.getToContext(),
2636 Importer.getNonEquivalentDecls());
2637 return Ctx.IsStructurallyEquivalent(From, To);
2640 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2641 VarTemplateDecl *To) {
2642 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2643 Importer.getToContext(),
2644 Importer.getNonEquivalentDecls());
2645 return Ctx.IsStructurallyEquivalent(From, To);
2648 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2649 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2650 << D->getDeclKindName();
2654 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2655 TranslationUnitDecl *ToD =
2656 Importer.getToContext().getTranslationUnitDecl();
2658 Importer.Imported(D, ToD);
2663 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2665 SourceLocation Loc = Importer.Import(D->getLocation());
2666 SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
2668 // Import the context of this declaration.
2669 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2673 AccessSpecDecl *accessSpecDecl
2674 = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(),
2677 if (!accessSpecDecl)
2680 // Lexical DeclContext and Semantic DeclContext
2681 // is always the same for the accessSpec.
2682 accessSpecDecl->setLexicalDeclContext(DC);
2683 DC->addDeclInternal(accessSpecDecl);
2685 return accessSpecDecl;
2688 Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2689 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2693 DeclContext *LexicalDC = DC;
2695 // Import the location of this declaration.
2696 SourceLocation Loc = Importer.Import(D->getLocation());
2698 Expr *AssertExpr = Importer.Import(D->getAssertExpr());
2702 StringLiteral *FromMsg = D->getMessage();
2703 StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
2704 if (!ToMsg && FromMsg)
2707 StaticAssertDecl *ToD = StaticAssertDecl::Create(
2708 Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
2709 Importer.Import(D->getRParenLoc()), D->isFailed());
2711 ToD->setLexicalDeclContext(LexicalDC);
2712 LexicalDC->addDeclInternal(ToD);
2713 Importer.Imported(D, ToD);
2717 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2718 // Import the major distinguishing characteristics of this namespace.
2719 DeclContext *DC, *LexicalDC;
2720 DeclarationName Name;
2723 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2728 NamespaceDecl *MergeWithNamespace = nullptr;
2730 // This is an anonymous namespace. Adopt an existing anonymous
2731 // namespace if we can.
2732 // FIXME: Not testable.
2733 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2734 MergeWithNamespace = TU->getAnonymousNamespace();
2736 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2738 SmallVector<NamedDecl *, 4> ConflictingDecls;
2739 SmallVector<NamedDecl *, 2> FoundDecls;
2740 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2741 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2742 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2745 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2746 MergeWithNamespace = FoundNS;
2747 ConflictingDecls.clear();
2751 ConflictingDecls.push_back(FoundDecls[I]);
2754 if (!ConflictingDecls.empty()) {
2755 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2756 ConflictingDecls.data(),
2757 ConflictingDecls.size());
2761 // Create the "to" namespace, if needed.
2762 NamespaceDecl *ToNamespace = MergeWithNamespace;
2764 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2766 Importer.Import(D->getLocStart()),
2767 Loc, Name.getAsIdentifierInfo(),
2768 /*PrevDecl=*/nullptr);
2769 ToNamespace->setLexicalDeclContext(LexicalDC);
2770 LexicalDC->addDeclInternal(ToNamespace);
2772 // If this is an anonymous namespace, register it as the anonymous
2773 // namespace within its context.
2775 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2776 TU->setAnonymousNamespace(ToNamespace);
2778 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2781 Importer.Imported(D, ToNamespace);
2783 ImportDeclContext(D);
2788 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2789 // Import the major distinguishing characteristics of this typedef.
2790 DeclContext *DC, *LexicalDC;
2791 DeclarationName Name;
2794 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2799 // If this typedef is not in block scope, determine whether we've
2800 // seen a typedef with the same name (that we can merge with) or any
2801 // other entity by that name (which name lookup could conflict with).
2802 if (!DC->isFunctionOrMethod()) {
2803 SmallVector<NamedDecl *, 4> ConflictingDecls;
2804 unsigned IDNS = Decl::IDNS_Ordinary;
2805 SmallVector<NamedDecl *, 2> FoundDecls;
2806 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2807 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2808 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2810 if (TypedefNameDecl *FoundTypedef =
2811 dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2812 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2813 FoundTypedef->getUnderlyingType()))
2814 return Importer.Imported(D, FoundTypedef);
2817 ConflictingDecls.push_back(FoundDecls[I]);
2820 if (!ConflictingDecls.empty()) {
2821 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2822 ConflictingDecls.data(),
2823 ConflictingDecls.size());
2829 // Import the underlying type of this typedef;
2830 QualType T = Importer.Import(D->getUnderlyingType());
2834 // Create the new typedef node.
2835 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2836 SourceLocation StartL = Importer.Import(D->getLocStart());
2837 TypedefNameDecl *ToTypedef;
2839 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2841 Name.getAsIdentifierInfo(),
2844 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2846 Name.getAsIdentifierInfo(),
2849 ToTypedef->setAccess(D->getAccess());
2850 ToTypedef->setLexicalDeclContext(LexicalDC);
2851 Importer.Imported(D, ToTypedef);
2852 LexicalDC->addDeclInternal(ToTypedef);
2857 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2858 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2861 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2862 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2865 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2866 // Import the major distinguishing characteristics of this label.
2867 DeclContext *DC, *LexicalDC;
2868 DeclarationName Name;
2871 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2876 assert(LexicalDC->isFunctionOrMethod());
2878 LabelDecl *ToLabel = D->isGnuLocal()
2879 ? LabelDecl::Create(Importer.getToContext(),
2880 DC, Importer.Import(D->getLocation()),
2881 Name.getAsIdentifierInfo(),
2882 Importer.Import(D->getLocStart()))
2883 : LabelDecl::Create(Importer.getToContext(),
2884 DC, Importer.Import(D->getLocation()),
2885 Name.getAsIdentifierInfo());
2886 Importer.Imported(D, ToLabel);
2888 LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2892 ToLabel->setStmt(Label);
2893 ToLabel->setLexicalDeclContext(LexicalDC);
2894 LexicalDC->addDeclInternal(ToLabel);
2898 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2899 // Import the major distinguishing characteristics of this enum.
2900 DeclContext *DC, *LexicalDC;
2901 DeclarationName Name;
2904 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2909 // Figure out what enum name we're looking for.
2910 unsigned IDNS = Decl::IDNS_Tag;
2911 DeclarationName SearchName = Name;
2912 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2913 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2914 IDNS = Decl::IDNS_Ordinary;
2915 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2916 IDNS |= Decl::IDNS_Ordinary;
2918 // We may already have an enum of the same name; try to find and match it.
2919 if (!DC->isFunctionOrMethod() && SearchName) {
2920 SmallVector<NamedDecl *, 4> ConflictingDecls;
2921 SmallVector<NamedDecl *, 2> FoundDecls;
2922 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
2923 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2924 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2927 Decl *Found = FoundDecls[I];
2928 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2929 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2930 Found = Tag->getDecl();
2933 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2934 if (IsStructuralMatch(D, FoundEnum))
2935 return Importer.Imported(D, FoundEnum);
2938 ConflictingDecls.push_back(FoundDecls[I]);
2941 if (!ConflictingDecls.empty()) {
2942 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2943 ConflictingDecls.data(),
2944 ConflictingDecls.size());
2948 // Create the enum declaration.
2949 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2950 Importer.Import(D->getLocStart()),
2951 Loc, Name.getAsIdentifierInfo(), nullptr,
2952 D->isScoped(), D->isScopedUsingClassTag(),
2954 // Import the qualifier, if any.
2955 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2956 D2->setAccess(D->getAccess());
2957 D2->setLexicalDeclContext(LexicalDC);
2958 Importer.Imported(D, D2);
2959 LexicalDC->addDeclInternal(D2);
2961 // Import the integer type.
2962 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2963 if (ToIntegerType.isNull())
2965 D2->setIntegerType(ToIntegerType);
2967 // Import the definition
2968 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2974 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2975 // If this record has a definition in the translation unit we're coming from,
2976 // but this particular declaration is not that definition, import the
2977 // definition and map to that.
2978 TagDecl *Definition = D->getDefinition();
2979 if (Definition && Definition != D) {
2980 Decl *ImportedDef = Importer.Import(Definition);
2984 return Importer.Imported(D, ImportedDef);
2987 // Import the major distinguishing characteristics of this record.
2988 DeclContext *DC, *LexicalDC;
2989 DeclarationName Name;
2992 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2997 // Figure out what structure name we're looking for.
2998 unsigned IDNS = Decl::IDNS_Tag;
2999 DeclarationName SearchName = Name;
3000 if (!SearchName && D->getTypedefNameForAnonDecl()) {
3001 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
3002 IDNS = Decl::IDNS_Ordinary;
3003 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3004 IDNS |= Decl::IDNS_Ordinary;
3006 // We may already have a record of the same name; try to find and match it.
3007 RecordDecl *AdoptDecl = nullptr;
3008 if (!DC->isFunctionOrMethod()) {
3009 SmallVector<NamedDecl *, 4> ConflictingDecls;
3010 SmallVector<NamedDecl *, 2> FoundDecls;
3011 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
3012 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3013 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3016 Decl *Found = FoundDecls[I];
3017 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
3018 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3019 Found = Tag->getDecl();
3022 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
3023 if (D->isAnonymousStructOrUnion() &&
3024 FoundRecord->isAnonymousStructOrUnion()) {
3025 // If both anonymous structs/unions are in a record context, make sure
3026 // they occur in the same location in the context records.
3027 if (Optional<unsigned> Index1
3028 = findUntaggedStructOrUnionIndex(D)) {
3029 if (Optional<unsigned> Index2 =
3030 findUntaggedStructOrUnionIndex(FoundRecord)) {
3031 if (*Index1 != *Index2)
3037 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
3038 if ((SearchName && !D->isCompleteDefinition())
3039 || (D->isCompleteDefinition() &&
3040 D->isAnonymousStructOrUnion()
3041 == FoundDef->isAnonymousStructOrUnion() &&
3042 IsStructuralMatch(D, FoundDef))) {
3043 // The record types structurally match, or the "from" translation
3044 // unit only had a forward declaration anyway; call it the same
3046 // FIXME: For C++, we should also merge methods here.
3047 return Importer.Imported(D, FoundDef);
3049 } else if (!D->isCompleteDefinition()) {
3050 // We have a forward declaration of this type, so adopt that forward
3051 // declaration rather than building a new one.
3053 // If one or both can be completed from external storage then try one
3054 // last time to complete and compare them before doing this.
3056 if (FoundRecord->hasExternalLexicalStorage() &&
3057 !FoundRecord->isCompleteDefinition())
3058 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
3059 if (D->hasExternalLexicalStorage())
3060 D->getASTContext().getExternalSource()->CompleteType(D);
3062 if (FoundRecord->isCompleteDefinition() &&
3063 D->isCompleteDefinition() &&
3064 !IsStructuralMatch(D, FoundRecord))
3067 AdoptDecl = FoundRecord;
3069 } else if (!SearchName) {
3074 ConflictingDecls.push_back(FoundDecls[I]);
3077 if (!ConflictingDecls.empty() && SearchName) {
3078 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3079 ConflictingDecls.data(),
3080 ConflictingDecls.size());
3084 // Create the record declaration.
3085 RecordDecl *D2 = AdoptDecl;
3086 SourceLocation StartLoc = Importer.Import(D->getLocStart());
3088 CXXRecordDecl *D2CXX = nullptr;
3089 if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) {
3090 if (DCXX->isLambda()) {
3091 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
3092 D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
3094 DCXX->isDependentLambda(),
3095 DCXX->isGenericLambda(),
3096 DCXX->getLambdaCaptureDefault());
3097 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
3098 if (DCXX->getLambdaContextDecl() && !CDecl)
3100 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
3101 } else if (DCXX->isInjectedClassName()) {
3102 // We have to be careful to do a similar dance to the one in
3103 // Sema::ActOnStartCXXMemberDeclarations
3104 CXXRecordDecl *const PrevDecl = nullptr;
3105 const bool DelayTypeCreation = true;
3106 D2CXX = CXXRecordDecl::Create(
3107 Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
3108 Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation);
3109 Importer.getToContext().getTypeDeclType(
3110 D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
3112 D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
3115 Name.getAsIdentifierInfo());
3118 D2->setAccess(D->getAccess());
3120 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
3121 DC, StartLoc, Loc, Name.getAsIdentifierInfo());
3124 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3125 D2->setLexicalDeclContext(LexicalDC);
3126 LexicalDC->addDeclInternal(D2);
3127 if (D->isAnonymousStructOrUnion())
3128 D2->setAnonymousStructOrUnion(true);
3131 Importer.Imported(D, D2);
3133 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
3139 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
3140 // Import the major distinguishing characteristics of this enumerator.
3141 DeclContext *DC, *LexicalDC;
3142 DeclarationName Name;
3145 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3150 QualType T = Importer.Import(D->getType());
3154 // Determine whether there are any other declarations with the same name and
3155 // in the same context.
3156 if (!LexicalDC->isFunctionOrMethod()) {
3157 SmallVector<NamedDecl *, 4> ConflictingDecls;
3158 unsigned IDNS = Decl::IDNS_Ordinary;
3159 SmallVector<NamedDecl *, 2> FoundDecls;
3160 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3161 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3162 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3165 if (EnumConstantDecl *FoundEnumConstant
3166 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
3167 if (IsStructuralMatch(D, FoundEnumConstant))
3168 return Importer.Imported(D, FoundEnumConstant);
3171 ConflictingDecls.push_back(FoundDecls[I]);
3174 if (!ConflictingDecls.empty()) {
3175 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3176 ConflictingDecls.data(),
3177 ConflictingDecls.size());
3183 Expr *Init = Importer.Import(D->getInitExpr());
3184 if (D->getInitExpr() && !Init)
3187 EnumConstantDecl *ToEnumerator
3188 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
3189 Name.getAsIdentifierInfo(), T,
3190 Init, D->getInitVal());
3191 ToEnumerator->setAccess(D->getAccess());
3192 ToEnumerator->setLexicalDeclContext(LexicalDC);
3193 Importer.Imported(D, ToEnumerator);
3194 LexicalDC->addDeclInternal(ToEnumerator);
3195 return ToEnumerator;
3198 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3199 // Import the major distinguishing characteristics of this function.
3200 DeclContext *DC, *LexicalDC;
3201 DeclarationName Name;
3204 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3209 // Try to find a function in our own ("to") context with the same name, same
3210 // type, and in the same context as the function we're importing.
3211 if (!LexicalDC->isFunctionOrMethod()) {
3212 SmallVector<NamedDecl *, 4> ConflictingDecls;
3213 unsigned IDNS = Decl::IDNS_Ordinary;
3214 SmallVector<NamedDecl *, 2> FoundDecls;
3215 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3216 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3217 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3220 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
3221 if (FoundFunction->hasExternalFormalLinkage() &&
3222 D->hasExternalFormalLinkage()) {
3223 if (Importer.IsStructurallyEquivalent(D->getType(),
3224 FoundFunction->getType())) {
3225 // FIXME: Actually try to merge the body and other attributes.
3226 return Importer.Imported(D, FoundFunction);
3229 // FIXME: Check for overloading more carefully, e.g., by boosting
3230 // Sema::IsOverload out to the AST library.
3232 // Function overloading is okay in C++.
3233 if (Importer.getToContext().getLangOpts().CPlusPlus)
3236 // Complain about inconsistent function types.
3237 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
3238 << Name << D->getType() << FoundFunction->getType();
3239 Importer.ToDiag(FoundFunction->getLocation(),
3240 diag::note_odr_value_here)
3241 << FoundFunction->getType();
3245 ConflictingDecls.push_back(FoundDecls[I]);
3248 if (!ConflictingDecls.empty()) {
3249 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3250 ConflictingDecls.data(),
3251 ConflictingDecls.size());
3257 DeclarationNameInfo NameInfo(Name, Loc);
3258 // Import additional name location/type info.
3259 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3261 QualType FromTy = D->getType();
3262 bool usedDifferentExceptionSpec = false;
3264 if (const FunctionProtoType *
3265 FromFPT = D->getType()->getAs<FunctionProtoType>()) {
3266 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3267 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3268 // FunctionDecl that we are importing the FunctionProtoType for.
3269 // To avoid an infinite recursion when importing, create the FunctionDecl
3270 // with a simplified function type and update it afterwards.
3271 if (FromEPI.ExceptionSpec.SourceDecl ||
3272 FromEPI.ExceptionSpec.SourceTemplate ||
3273 FromEPI.ExceptionSpec.NoexceptExpr) {
3274 FunctionProtoType::ExtProtoInfo DefaultEPI;
3275 FromTy = Importer.getFromContext().getFunctionType(
3276 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
3277 usedDifferentExceptionSpec = true;
3282 QualType T = Importer.Import(FromTy);
3286 // Import the function parameters.
3287 SmallVector<ParmVarDecl *, 8> Parameters;
3288 for (auto P : D->parameters()) {
3289 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
3293 Parameters.push_back(ToP);
3296 // Create the imported function.
3297 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3298 FunctionDecl *ToFunction = nullptr;
3299 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
3300 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3301 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
3302 cast<CXXRecordDecl>(DC),
3305 FromConstructor->isExplicit(),
3306 D->isInlineSpecified(),
3309 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3310 SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
3311 for (CXXCtorInitializer *I : FromConstructor->inits()) {
3312 CXXCtorInitializer *ToI =
3313 cast_or_null<CXXCtorInitializer>(Importer.Import(I));
3316 CtorInitializers.push_back(ToI);
3318 CXXCtorInitializer **Memory =
3319 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3320 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3321 CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction);
3322 ToCtor->setCtorInitializers(Memory);
3323 ToCtor->setNumCtorInitializers(NumInitializers);
3325 } else if (isa<CXXDestructorDecl>(D)) {
3326 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
3327 cast<CXXRecordDecl>(DC),
3330 D->isInlineSpecified(),
3332 } else if (CXXConversionDecl *FromConversion
3333 = dyn_cast<CXXConversionDecl>(D)) {
3334 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
3335 cast<CXXRecordDecl>(DC),
3338 D->isInlineSpecified(),
3339 FromConversion->isExplicit(),
3341 Importer.Import(D->getLocEnd()));
3342 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3343 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
3344 cast<CXXRecordDecl>(DC),
3347 Method->getStorageClass(),
3348 Method->isInlineSpecified(),
3350 Importer.Import(D->getLocEnd()));
3352 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
3354 NameInfo, T, TInfo, D->getStorageClass(),
3355 D->isInlineSpecified(),
3356 D->hasWrittenPrototype(),
3360 // Import the qualifier, if any.
3361 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3362 ToFunction->setAccess(D->getAccess());
3363 ToFunction->setLexicalDeclContext(LexicalDC);
3364 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3365 ToFunction->setTrivial(D->isTrivial());
3366 ToFunction->setPure(D->isPure());
3367 Importer.Imported(D, ToFunction);
3369 // Set the parameters.
3370 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
3371 Parameters[I]->setOwningFunction(ToFunction);
3372 ToFunction->addDeclInternal(Parameters[I]);
3374 ToFunction->setParams(Parameters);
3376 if (usedDifferentExceptionSpec) {
3377 // Update FunctionProtoType::ExtProtoInfo.
3378 QualType T = Importer.Import(D->getType());
3381 ToFunction->setType(T);
3384 // Import the body, if any.
3385 if (Stmt *FromBody = D->getBody()) {
3386 if (Stmt *ToBody = Importer.Import(FromBody)) {
3387 ToFunction->setBody(ToBody);
3391 // FIXME: Other bits to merge?
3393 // Add this function to the lexical context.
3394 LexicalDC->addDeclInternal(ToFunction);
3399 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3400 return VisitFunctionDecl(D);
3403 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3404 return VisitCXXMethodDecl(D);
3407 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3408 return VisitCXXMethodDecl(D);
3411 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3412 return VisitCXXMethodDecl(D);
3415 static unsigned getFieldIndex(Decl *F) {
3416 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
3421 for (const auto *D : Owner->noload_decls()) {
3425 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
3432 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3433 // Import the major distinguishing characteristics of a variable.
3434 DeclContext *DC, *LexicalDC;
3435 DeclarationName Name;
3438 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3443 // Determine whether we've already imported this field.
3444 SmallVector<NamedDecl *, 2> FoundDecls;
3445 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3446 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3447 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
3448 // For anonymous fields, match up by index.
3449 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3452 if (Importer.IsStructurallyEquivalent(D->getType(),
3453 FoundField->getType())) {
3454 Importer.Imported(D, FoundField);
3458 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3459 << Name << D->getType() << FoundField->getType();
3460 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3461 << FoundField->getType();
3467 QualType T = Importer.Import(D->getType());
3471 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3472 Expr *BitWidth = Importer.Import(D->getBitWidth());
3473 if (!BitWidth && D->getBitWidth())
3476 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3477 Importer.Import(D->getInnerLocStart()),
3478 Loc, Name.getAsIdentifierInfo(),
3479 T, TInfo, BitWidth, D->isMutable(),
3480 D->getInClassInitStyle());
3481 ToField->setAccess(D->getAccess());
3482 ToField->setLexicalDeclContext(LexicalDC);
3483 if (Expr *FromInitializer = D->getInClassInitializer()) {
3484 Expr *ToInitializer = Importer.Import(FromInitializer);
3486 ToField->setInClassInitializer(ToInitializer);
3490 ToField->setImplicit(D->isImplicit());
3491 Importer.Imported(D, ToField);
3492 LexicalDC->addDeclInternal(ToField);
3496 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3497 // Import the major distinguishing characteristics of a variable.
3498 DeclContext *DC, *LexicalDC;
3499 DeclarationName Name;
3502 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3507 // Determine whether we've already imported this field.
3508 SmallVector<NamedDecl *, 2> FoundDecls;
3509 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3510 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3511 if (IndirectFieldDecl *FoundField
3512 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3513 // For anonymous indirect fields, match up by index.
3514 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3517 if (Importer.IsStructurallyEquivalent(D->getType(),
3518 FoundField->getType(),
3520 Importer.Imported(D, FoundField);
3524 // If there are more anonymous fields to check, continue.
3525 if (!Name && I < N-1)
3528 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3529 << Name << D->getType() << FoundField->getType();
3530 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3531 << FoundField->getType();
3537 QualType T = Importer.Import(D->getType());
3541 NamedDecl **NamedChain =
3542 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3545 for (auto *PI : D->chain()) {
3546 Decl *D = Importer.Import(PI);
3549 NamedChain[i++] = cast<NamedDecl>(D);
3552 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
3553 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3554 {NamedChain, D->getChainingSize()});
3556 for (const auto *Attr : D->attrs())
3557 ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3559 ToIndirectField->setAccess(D->getAccess());
3560 ToIndirectField->setLexicalDeclContext(LexicalDC);
3561 Importer.Imported(D, ToIndirectField);
3562 LexicalDC->addDeclInternal(ToIndirectField);
3563 return ToIndirectField;
3566 Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3567 // Import the major distinguishing characteristics of a declaration.
3568 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3569 DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
3570 ? DC : Importer.ImportContext(D->getLexicalDeclContext());
3571 if (!DC || !LexicalDC)
3574 // Determine whether we've already imported this decl.
3575 // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
3576 auto *RD = cast<CXXRecordDecl>(DC);
3577 FriendDecl *ImportedFriend = RD->getFirstFriend();
3578 StructuralEquivalenceContext Context(
3579 Importer.getFromContext(), Importer.getToContext(),
3580 Importer.getNonEquivalentDecls(), false, false);
3582 while (ImportedFriend) {
3583 if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
3584 if (Context.IsStructurallyEquivalent(D->getFriendDecl(),
3585 ImportedFriend->getFriendDecl()))
3586 return Importer.Imported(D, ImportedFriend);
3588 } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3589 if (Importer.IsStructurallyEquivalent(
3590 D->getFriendType()->getType(),
3591 ImportedFriend->getFriendType()->getType(), true))
3592 return Importer.Imported(D, ImportedFriend);
3594 ImportedFriend = ImportedFriend->getNextFriend();
3597 // Not found. Create it.
3598 FriendDecl::FriendUnion ToFU;
3599 if (NamedDecl *FriendD = D->getFriendDecl())
3600 ToFU = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3602 ToFU = Importer.Import(D->getFriendType());
3606 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3607 TemplateParameterList **FromTPLists =
3608 D->getTrailingObjects<TemplateParameterList *>();
3609 for (unsigned I = 0; I < D->NumTPLists; I++) {
3610 TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3613 ToTPLists[I] = List;
3616 FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC,
3617 Importer.Import(D->getLocation()),
3618 ToFU, Importer.Import(D->getFriendLoc()),
3621 Importer.Imported(D, FrD);
3622 RD->pushFriendDecl(FrD);
3624 FrD->setAccess(D->getAccess());
3625 FrD->setLexicalDeclContext(LexicalDC);
3626 LexicalDC->addDeclInternal(FrD);
3630 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3631 // Import the major distinguishing characteristics of an ivar.
3632 DeclContext *DC, *LexicalDC;
3633 DeclarationName Name;
3636 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3641 // Determine whether we've already imported this ivar
3642 SmallVector<NamedDecl *, 2> FoundDecls;
3643 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3644 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3645 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
3646 if (Importer.IsStructurallyEquivalent(D->getType(),
3647 FoundIvar->getType())) {
3648 Importer.Imported(D, FoundIvar);
3652 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3653 << Name << D->getType() << FoundIvar->getType();
3654 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3655 << FoundIvar->getType();
3661 QualType T = Importer.Import(D->getType());
3665 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3666 Expr *BitWidth = Importer.Import(D->getBitWidth());
3667 if (!BitWidth && D->getBitWidth())
3670 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3671 cast<ObjCContainerDecl>(DC),
3672 Importer.Import(D->getInnerLocStart()),
3673 Loc, Name.getAsIdentifierInfo(),
3674 T, TInfo, D->getAccessControl(),
3675 BitWidth, D->getSynthesize());
3676 ToIvar->setLexicalDeclContext(LexicalDC);
3677 Importer.Imported(D, ToIvar);
3678 LexicalDC->addDeclInternal(ToIvar);
3683 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3684 // Import the major distinguishing characteristics of a variable.
3685 DeclContext *DC, *LexicalDC;
3686 DeclarationName Name;
3689 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3694 // Try to find a variable in our own ("to") context with the same name and
3695 // in the same context as the variable we're importing.
3696 if (D->isFileVarDecl()) {
3697 VarDecl *MergeWithVar = nullptr;
3698 SmallVector<NamedDecl *, 4> ConflictingDecls;
3699 unsigned IDNS = Decl::IDNS_Ordinary;
3700 SmallVector<NamedDecl *, 2> FoundDecls;
3701 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3702 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3703 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3706 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3707 // We have found a variable that we may need to merge with. Check it.
3708 if (FoundVar->hasExternalFormalLinkage() &&
3709 D->hasExternalFormalLinkage()) {
3710 if (Importer.IsStructurallyEquivalent(D->getType(),
3711 FoundVar->getType())) {
3712 MergeWithVar = FoundVar;
3716 const ArrayType *FoundArray
3717 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3718 const ArrayType *TArray
3719 = Importer.getToContext().getAsArrayType(D->getType());
3720 if (FoundArray && TArray) {
3721 if (isa<IncompleteArrayType>(FoundArray) &&
3722 isa<ConstantArrayType>(TArray)) {
3724 QualType T = Importer.Import(D->getType());
3728 FoundVar->setType(T);
3729 MergeWithVar = FoundVar;
3731 } else if (isa<IncompleteArrayType>(TArray) &&
3732 isa<ConstantArrayType>(FoundArray)) {
3733 MergeWithVar = FoundVar;
3738 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3739 << Name << D->getType() << FoundVar->getType();
3740 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3741 << FoundVar->getType();
3745 ConflictingDecls.push_back(FoundDecls[I]);
3749 // An equivalent variable with external linkage has been found. Link
3750 // the two declarations, then merge them.
3751 Importer.Imported(D, MergeWithVar);
3753 if (VarDecl *DDef = D->getDefinition()) {
3754 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3755 Importer.ToDiag(ExistingDef->getLocation(),
3756 diag::err_odr_variable_multiple_def)
3758 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3760 Expr *Init = Importer.Import(DDef->getInit());
3761 MergeWithVar->setInit(Init);
3762 if (DDef->isInitKnownICE()) {
3763 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3764 Eval->CheckedICE = true;
3765 Eval->IsICE = DDef->isInitICE();
3770 return MergeWithVar;
3773 if (!ConflictingDecls.empty()) {
3774 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3775 ConflictingDecls.data(),
3776 ConflictingDecls.size());
3783 QualType T = Importer.Import(D->getType());
3787 // Create the imported variable.
3788 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3789 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3790 Importer.Import(D->getInnerLocStart()),
3791 Loc, Name.getAsIdentifierInfo(),
3793 D->getStorageClass());
3794 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3795 ToVar->setAccess(D->getAccess());
3796 ToVar->setLexicalDeclContext(LexicalDC);
3797 Importer.Imported(D, ToVar);
3798 LexicalDC->addDeclInternal(ToVar);
3800 if (!D->isFileVarDecl() &&
3804 // Merge the initializer.
3805 if (ImportDefinition(D, ToVar))
3808 if (D->isConstexpr())
3809 ToVar->setConstexpr(true);
3814 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3815 // Parameters are created in the translation unit's context, then moved
3816 // into the function declaration's context afterward.
3817 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3819 // Import the name of this declaration.
3820 DeclarationName Name = Importer.Import(D->getDeclName());
3821 if (D->getDeclName() && !Name)
3824 // Import the location of this declaration.
3825 SourceLocation Loc = Importer.Import(D->getLocation());
3827 // Import the parameter's type.
3828 QualType T = Importer.Import(D->getType());
3832 // Create the imported parameter.
3833 ImplicitParamDecl *ToParm
3834 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3835 Loc, Name.getAsIdentifierInfo(),
3837 return Importer.Imported(D, ToParm);
3840 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3841 // Parameters are created in the translation unit's context, then moved
3842 // into the function declaration's context afterward.
3843 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3845 // Import the name of this declaration.
3846 DeclarationName Name = Importer.Import(D->getDeclName());
3847 if (D->getDeclName() && !Name)
3850 // Import the location of this declaration.
3851 SourceLocation Loc = Importer.Import(D->getLocation());
3853 // Import the parameter's type.
3854 QualType T = Importer.Import(D->getType());
3858 // Create the imported parameter.
3859 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3860 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3861 Importer.Import(D->getInnerLocStart()),
3862 Loc, Name.getAsIdentifierInfo(),
3863 T, TInfo, D->getStorageClass(),
3864 /*DefaultArg*/ nullptr);
3866 // Set the default argument.
3867 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3868 ToParm->setKNRPromoted(D->isKNRPromoted());
3870 Expr *ToDefArg = nullptr;
3871 Expr *FromDefArg = nullptr;
3872 if (D->hasUninstantiatedDefaultArg()) {
3873 FromDefArg = D->getUninstantiatedDefaultArg();
3874 ToDefArg = Importer.Import(FromDefArg);
3875 ToParm->setUninstantiatedDefaultArg(ToDefArg);
3876 } else if (D->hasUnparsedDefaultArg()) {
3877 ToParm->setUnparsedDefaultArg();
3878 } else if (D->hasDefaultArg()) {
3879 FromDefArg = D->getDefaultArg();
3880 ToDefArg = Importer.Import(FromDefArg);
3881 ToParm->setDefaultArg(ToDefArg);
3883 if (FromDefArg && !ToDefArg)
3887 ToParm->setIsUsed();
3889 return Importer.Imported(D, ToParm);
3892 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3893 // Import the major distinguishing characteristics of a method.
3894 DeclContext *DC, *LexicalDC;
3895 DeclarationName Name;
3898 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3903 SmallVector<NamedDecl *, 2> FoundDecls;
3904 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3905 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3906 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3907 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3910 // Check return types.
3911 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3912 FoundMethod->getReturnType())) {
3913 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3914 << D->isInstanceMethod() << Name << D->getReturnType()
3915 << FoundMethod->getReturnType();
3916 Importer.ToDiag(FoundMethod->getLocation(),
3917 diag::note_odr_objc_method_here)
3918 << D->isInstanceMethod() << Name;
3922 // Check the number of parameters.
3923 if (D->param_size() != FoundMethod->param_size()) {
3924 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3925 << D->isInstanceMethod() << Name
3926 << D->param_size() << FoundMethod->param_size();
3927 Importer.ToDiag(FoundMethod->getLocation(),
3928 diag::note_odr_objc_method_here)
3929 << D->isInstanceMethod() << Name;
3933 // Check parameter types.
3934 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3935 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3936 P != PEnd; ++P, ++FoundP) {
3937 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3938 (*FoundP)->getType())) {
3939 Importer.FromDiag((*P)->getLocation(),
3940 diag::err_odr_objc_method_param_type_inconsistent)
3941 << D->isInstanceMethod() << Name
3942 << (*P)->getType() << (*FoundP)->getType();
3943 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3944 << (*FoundP)->getType();
3949 // Check variadic/non-variadic.
3950 // Check the number of parameters.
3951 if (D->isVariadic() != FoundMethod->isVariadic()) {
3952 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3953 << D->isInstanceMethod() << Name;
3954 Importer.ToDiag(FoundMethod->getLocation(),
3955 diag::note_odr_objc_method_here)
3956 << D->isInstanceMethod() << Name;
3960 // FIXME: Any other bits we need to merge?
3961 return Importer.Imported(D, FoundMethod);
3965 // Import the result type.
3966 QualType ResultTy = Importer.Import(D->getReturnType());
3967 if (ResultTy.isNull())
3970 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3972 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3973 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3974 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3975 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3976 D->getImplementationControl(), D->hasRelatedResultType());
3978 // FIXME: When we decide to merge method definitions, we'll need to
3979 // deal with implicit parameters.
3981 // Import the parameters
3982 SmallVector<ParmVarDecl *, 5> ToParams;
3983 for (auto *FromP : D->parameters()) {
3984 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3988 ToParams.push_back(ToP);
3991 // Set the parameters.
3992 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3993 ToParams[I]->setOwningFunction(ToMethod);
3994 ToMethod->addDeclInternal(ToParams[I]);
3996 SmallVector<SourceLocation, 12> SelLocs;
3997 D->getSelectorLocs(SelLocs);
3998 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
4000 ToMethod->setLexicalDeclContext(LexicalDC);
4001 Importer.Imported(D, ToMethod);
4002 LexicalDC->addDeclInternal(ToMethod);
4006 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
4007 // Import the major distinguishing characteristics of a category.
4008 DeclContext *DC, *LexicalDC;
4009 DeclarationName Name;
4012 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4017 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
4021 ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create(
4022 Importer.getToContext(), DC,
4024 Importer.Import(D->getVarianceLoc()),
4026 Importer.Import(D->getLocation()),
4027 Name.getAsIdentifierInfo(),
4028 Importer.Import(D->getColonLoc()),
4030 Importer.Imported(D, Result);
4031 Result->setLexicalDeclContext(LexicalDC);
4035 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
4036 // Import the major distinguishing characteristics of a category.
4037 DeclContext *DC, *LexicalDC;
4038 DeclarationName Name;
4041 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4046 ObjCInterfaceDecl *ToInterface
4047 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
4051 // Determine if we've already encountered this category.
4052 ObjCCategoryDecl *MergeWithCategory
4053 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4054 ObjCCategoryDecl *ToCategory = MergeWithCategory;
4056 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
4057 Importer.Import(D->getAtStartLoc()),
4059 Importer.Import(D->getCategoryNameLoc()),
4060 Name.getAsIdentifierInfo(),
4062 /*TypeParamList=*/nullptr,
4063 Importer.Import(D->getIvarLBraceLoc()),
4064 Importer.Import(D->getIvarRBraceLoc()));
4065 ToCategory->setLexicalDeclContext(LexicalDC);
4066 LexicalDC->addDeclInternal(ToCategory);
4067 Importer.Imported(D, ToCategory);
4068 // Import the type parameter list after calling Imported, to avoid
4069 // loops when bringing in their DeclContext.
4070 ToCategory->setTypeParamList(ImportObjCTypeParamList(
4071 D->getTypeParamList()));
4074 SmallVector<ObjCProtocolDecl *, 4> Protocols;
4075 SmallVector<SourceLocation, 4> ProtocolLocs;
4076 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
4077 = D->protocol_loc_begin();
4078 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4079 FromProtoEnd = D->protocol_end();
4080 FromProto != FromProtoEnd;
4081 ++FromProto, ++FromProtoLoc) {
4082 ObjCProtocolDecl *ToProto
4083 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4086 Protocols.push_back(ToProto);
4087 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4090 // FIXME: If we're merging, make sure that the protocol list is the same.
4091 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4092 ProtocolLocs.data(), Importer.getToContext());
4095 Importer.Imported(D, ToCategory);
4098 // Import all of the members of this category.
4099 ImportDeclContext(D);
4101 // If we have an implementation, import it as well.
4102 if (D->getImplementation()) {
4103 ObjCCategoryImplDecl *Impl
4104 = cast_or_null<ObjCCategoryImplDecl>(
4105 Importer.Import(D->getImplementation()));
4109 ToCategory->setImplementation(Impl);
4115 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
4116 ObjCProtocolDecl *To,
4117 ImportDefinitionKind Kind) {
4118 if (To->getDefinition()) {
4119 if (shouldForceImportDeclContext(Kind))
4120 ImportDeclContext(From);
4124 // Start the protocol definition
4125 To->startDefinition();
4128 SmallVector<ObjCProtocolDecl *, 4> Protocols;
4129 SmallVector<SourceLocation, 4> ProtocolLocs;
4130 ObjCProtocolDecl::protocol_loc_iterator
4131 FromProtoLoc = From->protocol_loc_begin();
4132 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4133 FromProtoEnd = From->protocol_end();
4134 FromProto != FromProtoEnd;
4135 ++FromProto, ++FromProtoLoc) {
4136 ObjCProtocolDecl *ToProto
4137 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4140 Protocols.push_back(ToProto);
4141 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4144 // FIXME: If we're merging, make sure that the protocol list is the same.
4145 To->setProtocolList(Protocols.data(), Protocols.size(),
4146 ProtocolLocs.data(), Importer.getToContext());
4148 if (shouldForceImportDeclContext(Kind)) {
4149 // Import all of the members of this protocol.
4150 ImportDeclContext(From, /*ForceImport=*/true);
4155 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
4156 // If this protocol has a definition in the translation unit we're coming
4157 // from, but this particular declaration is not that definition, import the
4158 // definition and map to that.
4159 ObjCProtocolDecl *Definition = D->getDefinition();
4160 if (Definition && Definition != D) {
4161 Decl *ImportedDef = Importer.Import(Definition);
4165 return Importer.Imported(D, ImportedDef);
4168 // Import the major distinguishing characteristics of a protocol.
4169 DeclContext *DC, *LexicalDC;
4170 DeclarationName Name;
4173 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4178 ObjCProtocolDecl *MergeWithProtocol = nullptr;
4179 SmallVector<NamedDecl *, 2> FoundDecls;
4180 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4181 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4182 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
4185 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
4189 ObjCProtocolDecl *ToProto = MergeWithProtocol;
4191 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
4192 Name.getAsIdentifierInfo(), Loc,
4193 Importer.Import(D->getAtStartLoc()),
4194 /*PrevDecl=*/nullptr);
4195 ToProto->setLexicalDeclContext(LexicalDC);
4196 LexicalDC->addDeclInternal(ToProto);
4199 Importer.Imported(D, ToProto);
4201 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
4207 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
4208 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4209 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4211 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
4212 SourceLocation LangLoc = Importer.Import(D->getLocation());
4214 bool HasBraces = D->hasBraces();
4216 LinkageSpecDecl *ToLinkageSpec =
4217 LinkageSpecDecl::Create(Importer.getToContext(),
4225 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
4226 ToLinkageSpec->setRBraceLoc(RBraceLoc);
4229 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
4230 LexicalDC->addDeclInternal(ToLinkageSpec);
4232 Importer.Imported(D, ToLinkageSpec);
4234 return ToLinkageSpec;
4237 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
4238 ObjCInterfaceDecl *To,
4239 ImportDefinitionKind Kind) {
4240 if (To->getDefinition()) {
4241 // Check consistency of superclass.
4242 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
4244 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
4249 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
4250 if ((bool)FromSuper != (bool)ToSuper ||
4251 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
4252 Importer.ToDiag(To->getLocation(),
4253 diag::err_odr_objc_superclass_inconsistent)
4254 << To->getDeclName();
4256 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
4257 << To->getSuperClass()->getDeclName();
4259 Importer.ToDiag(To->getLocation(),
4260 diag::note_odr_objc_missing_superclass);
4261 if (From->getSuperClass())
4262 Importer.FromDiag(From->getSuperClassLoc(),
4263 diag::note_odr_objc_superclass)
4264 << From->getSuperClass()->getDeclName();
4266 Importer.FromDiag(From->getLocation(),
4267 diag::note_odr_objc_missing_superclass);
4270 if (shouldForceImportDeclContext(Kind))
4271 ImportDeclContext(From);
4275 // Start the definition.
4276 To->startDefinition();
4278 // If this class has a superclass, import it.
4279 if (From->getSuperClass()) {
4280 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
4284 To->setSuperClass(SuperTInfo);
4288 SmallVector<ObjCProtocolDecl *, 4> Protocols;
4289 SmallVector<SourceLocation, 4> ProtocolLocs;
4290 ObjCInterfaceDecl::protocol_loc_iterator
4291 FromProtoLoc = From->protocol_loc_begin();
4293 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
4294 FromProtoEnd = From->protocol_end();
4295 FromProto != FromProtoEnd;
4296 ++FromProto, ++FromProtoLoc) {
4297 ObjCProtocolDecl *ToProto
4298 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4301 Protocols.push_back(ToProto);
4302 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4305 // FIXME: If we're merging, make sure that the protocol list is the same.
4306 To->setProtocolList(Protocols.data(), Protocols.size(),
4307 ProtocolLocs.data(), Importer.getToContext());
4309 // Import categories. When the categories themselves are imported, they'll
4310 // hook themselves into this interface.
4311 for (auto *Cat : From->known_categories())
4312 Importer.Import(Cat);
4314 // If we have an @implementation, import it as well.
4315 if (From->getImplementation()) {
4316 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
4317 Importer.Import(From->getImplementation()));
4321 To->setImplementation(Impl);
4324 if (shouldForceImportDeclContext(Kind)) {
4325 // Import all of the members of this class.
4326 ImportDeclContext(From, /*ForceImport=*/true);
4332 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
4336 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
4337 for (auto fromTypeParam : *list) {
4338 auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
4339 Importer.Import(fromTypeParam));
4343 toTypeParams.push_back(toTypeParam);
4346 return ObjCTypeParamList::create(Importer.getToContext(),
4347 Importer.Import(list->getLAngleLoc()),
4349 Importer.Import(list->getRAngleLoc()));
4352 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
4353 // If this class has a definition in the translation unit we're coming from,
4354 // but this particular declaration is not that definition, import the
4355 // definition and map to that.
4356 ObjCInterfaceDecl *Definition = D->getDefinition();
4357 if (Definition && Definition != D) {
4358 Decl *ImportedDef = Importer.Import(Definition);
4362 return Importer.Imported(D, ImportedDef);
4365 // Import the major distinguishing characteristics of an @interface.
4366 DeclContext *DC, *LexicalDC;
4367 DeclarationName Name;
4370 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4375 // Look for an existing interface with the same name.
4376 ObjCInterfaceDecl *MergeWithIface = nullptr;
4377 SmallVector<NamedDecl *, 2> FoundDecls;
4378 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4379 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4380 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4383 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
4387 // Create an interface declaration, if one does not already exist.
4388 ObjCInterfaceDecl *ToIface = MergeWithIface;
4390 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
4391 Importer.Import(D->getAtStartLoc()),
4392 Name.getAsIdentifierInfo(),
4393 /*TypeParamList=*/nullptr,
4394 /*PrevDecl=*/nullptr, Loc,
4395 D->isImplicitInterfaceDecl());
4396 ToIface->setLexicalDeclContext(LexicalDC);
4397 LexicalDC->addDeclInternal(ToIface);
4399 Importer.Imported(D, ToIface);
4400 // Import the type parameter list after calling Imported, to avoid
4401 // loops when bringing in their DeclContext.
4402 ToIface->setTypeParamList(ImportObjCTypeParamList(
4403 D->getTypeParamListAsWritten()));
4405 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4411 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4412 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
4413 Importer.Import(D->getCategoryDecl()));
4417 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4419 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4423 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4424 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
4425 Importer.Import(D->getIdentifier()),
4426 Category->getClassInterface(),
4427 Importer.Import(D->getLocation()),
4428 Importer.Import(D->getAtStartLoc()),
4431 DeclContext *LexicalDC = DC;
4432 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4433 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4437 ToImpl->setLexicalDeclContext(LexicalDC);
4440 LexicalDC->addDeclInternal(ToImpl);
4441 Category->setImplementation(ToImpl);
4444 Importer.Imported(D, ToImpl);
4445 ImportDeclContext(D);
4449 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4450 // Find the corresponding interface.
4451 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
4452 Importer.Import(D->getClassInterface()));
4456 // Import the superclass, if any.
4457 ObjCInterfaceDecl *Super = nullptr;
4458 if (D->getSuperClass()) {
4459 Super = cast_or_null<ObjCInterfaceDecl>(
4460 Importer.Import(D->getSuperClass()));
4465 ObjCImplementationDecl *Impl = Iface->getImplementation();
4467 // We haven't imported an implementation yet. Create a new @implementation
4469 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
4470 Importer.ImportContext(D->getDeclContext()),
4472 Importer.Import(D->getLocation()),
4473 Importer.Import(D->getAtStartLoc()),
4474 Importer.Import(D->getSuperClassLoc()),
4475 Importer.Import(D->getIvarLBraceLoc()),
4476 Importer.Import(D->getIvarRBraceLoc()));
4478 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4479 DeclContext *LexicalDC
4480 = Importer.ImportContext(D->getLexicalDeclContext());
4483 Impl->setLexicalDeclContext(LexicalDC);
4486 // Associate the implementation with the class it implements.
4487 Iface->setImplementation(Impl);
4488 Importer.Imported(D, Iface->getImplementation());
4490 Importer.Imported(D, Iface->getImplementation());
4492 // Verify that the existing @implementation has the same superclass.
4493 if ((Super && !Impl->getSuperClass()) ||
4494 (!Super && Impl->getSuperClass()) ||
4495 (Super && Impl->getSuperClass() &&
4496 !declaresSameEntity(Super->getCanonicalDecl(),
4497 Impl->getSuperClass()))) {
4498 Importer.ToDiag(Impl->getLocation(),
4499 diag::err_odr_objc_superclass_inconsistent)
4500 << Iface->getDeclName();
4501 // FIXME: It would be nice to have the location of the superclass
4503 if (Impl->getSuperClass())
4504 Importer.ToDiag(Impl->getLocation(),
4505 diag::note_odr_objc_superclass)
4506 << Impl->getSuperClass()->getDeclName();
4508 Importer.ToDiag(Impl->getLocation(),
4509 diag::note_odr_objc_missing_superclass);
4510 if (D->getSuperClass())
4511 Importer.FromDiag(D->getLocation(),
4512 diag::note_odr_objc_superclass)
4513 << D->getSuperClass()->getDeclName();
4515 Importer.FromDiag(D->getLocation(),
4516 diag::note_odr_objc_missing_superclass);
4521 // Import all of the members of this @implementation.
4522 ImportDeclContext(D);
4527 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4528 // Import the major distinguishing characteristics of an @property.
4529 DeclContext *DC, *LexicalDC;
4530 DeclarationName Name;
4533 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4538 // Check whether we have already imported this property.
4539 SmallVector<NamedDecl *, 2> FoundDecls;
4540 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4541 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4542 if (ObjCPropertyDecl *FoundProp
4543 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
4544 // Check property types.
4545 if (!Importer.IsStructurallyEquivalent(D->getType(),
4546 FoundProp->getType())) {
4547 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4548 << Name << D->getType() << FoundProp->getType();
4549 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4550 << FoundProp->getType();
4554 // FIXME: Check property attributes, getters, setters, etc.?
4556 // Consider these properties to be equivalent.
4557 Importer.Imported(D, FoundProp);
4563 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4567 // Create the new property.
4568 ObjCPropertyDecl *ToProperty
4569 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4570 Name.getAsIdentifierInfo(),
4571 Importer.Import(D->getAtLoc()),
4572 Importer.Import(D->getLParenLoc()),
4573 Importer.Import(D->getType()),
4575 D->getPropertyImplementation());
4576 Importer.Imported(D, ToProperty);
4577 ToProperty->setLexicalDeclContext(LexicalDC);
4578 LexicalDC->addDeclInternal(ToProperty);
4580 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4581 ToProperty->setPropertyAttributesAsWritten(
4582 D->getPropertyAttributesAsWritten());
4583 ToProperty->setGetterName(Importer.Import(D->getGetterName()),
4584 Importer.Import(D->getGetterNameLoc()));
4585 ToProperty->setSetterName(Importer.Import(D->getSetterName()),
4586 Importer.Import(D->getSetterNameLoc()));
4587 ToProperty->setGetterMethodDecl(
4588 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4589 ToProperty->setSetterMethodDecl(
4590 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4591 ToProperty->setPropertyIvarDecl(
4592 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4596 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4597 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
4598 Importer.Import(D->getPropertyDecl()));
4602 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4606 // Import the lexical declaration context.
4607 DeclContext *LexicalDC = DC;
4608 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4609 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4614 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4618 // Import the ivar (for an @synthesize).
4619 ObjCIvarDecl *Ivar = nullptr;
4620 if (D->getPropertyIvarDecl()) {
4621 Ivar = cast_or_null<ObjCIvarDecl>(
4622 Importer.Import(D->getPropertyIvarDecl()));
4627 ObjCPropertyImplDecl *ToImpl
4628 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4629 Property->getQueryKind());
4631 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4632 Importer.Import(D->getLocStart()),
4633 Importer.Import(D->getLocation()),
4635 D->getPropertyImplementation(),
4637 Importer.Import(D->getPropertyIvarDeclLoc()));
4638 ToImpl->setLexicalDeclContext(LexicalDC);
4639 Importer.Imported(D, ToImpl);
4640 LexicalDC->addDeclInternal(ToImpl);
4642 // Check that we have the same kind of property implementation (@synthesize
4644 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4645 Importer.ToDiag(ToImpl->getLocation(),
4646 diag::err_odr_objc_property_impl_kind_inconsistent)
4647 << Property->getDeclName()
4648 << (ToImpl->getPropertyImplementation()
4649 == ObjCPropertyImplDecl::Dynamic);
4650 Importer.FromDiag(D->getLocation(),
4651 diag::note_odr_objc_property_impl_kind)
4652 << D->getPropertyDecl()->getDeclName()
4653 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4657 // For @synthesize, check that we have the same
4658 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4659 Ivar != ToImpl->getPropertyIvarDecl()) {
4660 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4661 diag::err_odr_objc_synthesize_ivar_inconsistent)
4662 << Property->getDeclName()
4663 << ToImpl->getPropertyIvarDecl()->getDeclName()
4664 << Ivar->getDeclName();
4665 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4666 diag::note_odr_objc_synthesize_ivar_here)
4667 << D->getPropertyIvarDecl()->getDeclName();
4671 // Merge the existing implementation with the new implementation.
4672 Importer.Imported(D, ToImpl);
4678 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4679 // For template arguments, we adopt the translation unit as our declaration
4680 // context. This context will be fixed when the actual template declaration
4683 // FIXME: Import default argument.
4684 return TemplateTypeParmDecl::Create(Importer.getToContext(),
4685 Importer.getToContext().getTranslationUnitDecl(),
4686 Importer.Import(D->getLocStart()),
4687 Importer.Import(D->getLocation()),
4690 Importer.Import(D->getIdentifier()),
4691 D->wasDeclaredWithTypename(),
4692 D->isParameterPack());
4696 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4697 // Import the name of this declaration.
4698 DeclarationName Name = Importer.Import(D->getDeclName());
4699 if (D->getDeclName() && !Name)
4702 // Import the location of this declaration.
4703 SourceLocation Loc = Importer.Import(D->getLocation());
4705 // Import the type of this declaration.
4706 QualType T = Importer.Import(D->getType());
4710 // Import type-source information.
4711 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4712 if (D->getTypeSourceInfo() && !TInfo)
4715 // FIXME: Import default argument.
4717 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4718 Importer.getToContext().getTranslationUnitDecl(),
4719 Importer.Import(D->getInnerLocStart()),
4720 Loc, D->getDepth(), D->getPosition(),
4721 Name.getAsIdentifierInfo(),
4722 T, D->isParameterPack(), TInfo);
4726 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4727 // Import the name of this declaration.
4728 DeclarationName Name = Importer.Import(D->getDeclName());
4729 if (D->getDeclName() && !Name)
4732 // Import the location of this declaration.
4733 SourceLocation Loc = Importer.Import(D->getLocation());
4735 // Import template parameters.
4736 TemplateParameterList *TemplateParams
4737 = ImportTemplateParameterList(D->getTemplateParameters());
4738 if (!TemplateParams)
4741 // FIXME: Import default argument.
4743 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4744 Importer.getToContext().getTranslationUnitDecl(),
4745 Loc, D->getDepth(), D->getPosition(),
4746 D->isParameterPack(),
4747 Name.getAsIdentifierInfo(),
4751 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4752 // If this record has a definition in the translation unit we're coming from,
4753 // but this particular declaration is not that definition, import the
4754 // definition and map to that.
4755 CXXRecordDecl *Definition
4756 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4757 if (Definition && Definition != D->getTemplatedDecl()) {
4759 = Importer.Import(Definition->getDescribedClassTemplate());
4763 return Importer.Imported(D, ImportedDef);
4766 // Import the major distinguishing characteristics of this class template.
4767 DeclContext *DC, *LexicalDC;
4768 DeclarationName Name;
4771 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4776 // We may already have a template of the same name; try to find and match it.
4777 if (!DC->isFunctionOrMethod()) {
4778 SmallVector<NamedDecl *, 4> ConflictingDecls;
4779 SmallVector<NamedDecl *, 2> FoundDecls;
4780 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4781 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4782 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4785 Decl *Found = FoundDecls[I];
4786 if (ClassTemplateDecl *FoundTemplate
4787 = dyn_cast<ClassTemplateDecl>(Found)) {
4788 if (IsStructuralMatch(D, FoundTemplate)) {
4789 // The class templates structurally match; call it the same template.
4790 // FIXME: We may be filling in a forward declaration here. Handle
4792 Importer.Imported(D->getTemplatedDecl(),
4793 FoundTemplate->getTemplatedDecl());
4794 return Importer.Imported(D, FoundTemplate);
4798 ConflictingDecls.push_back(FoundDecls[I]);
4801 if (!ConflictingDecls.empty()) {
4802 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4803 ConflictingDecls.data(),
4804 ConflictingDecls.size());
4811 CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4813 // Create the declaration that is being templated.
4814 // Create the declaration that is being templated.
4815 CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>(
4816 Importer.Import(DTemplated));
4820 // Resolve possible cyclic import.
4821 if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
4822 return AlreadyImported;
4824 // Create the class template declaration itself.
4825 TemplateParameterList *TemplateParams
4826 = ImportTemplateParameterList(D->getTemplateParameters());
4827 if (!TemplateParams)
4830 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4831 Loc, Name, TemplateParams,
4833 D2Templated->setDescribedClassTemplate(D2);
4835 D2->setAccess(D->getAccess());
4836 D2->setLexicalDeclContext(LexicalDC);
4837 LexicalDC->addDeclInternal(D2);
4839 // Note the relationship between the class templates.
4840 Importer.Imported(D, D2);
4841 Importer.Imported(DTemplated, D2Templated);
4843 if (DTemplated->isCompleteDefinition() &&
4844 !D2Templated->isCompleteDefinition()) {
4845 // FIXME: Import definition!
4851 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4852 ClassTemplateSpecializationDecl *D) {
4853 // If this record has a definition in the translation unit we're coming from,
4854 // but this particular declaration is not that definition, import the
4855 // definition and map to that.
4856 TagDecl *Definition = D->getDefinition();
4857 if (Definition && Definition != D) {
4858 Decl *ImportedDef = Importer.Import(Definition);
4862 return Importer.Imported(D, ImportedDef);
4865 ClassTemplateDecl *ClassTemplate
4866 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4867 D->getSpecializedTemplate()));
4871 // Import the context of this declaration.
4872 DeclContext *DC = ClassTemplate->getDeclContext();
4876 DeclContext *LexicalDC = DC;
4877 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4878 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4883 // Import the location of this declaration.
4884 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4885 SourceLocation IdLoc = Importer.Import(D->getLocation());
4887 // Import template arguments.
4888 SmallVector<TemplateArgument, 2> TemplateArgs;
4889 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4890 D->getTemplateArgs().size(),
4894 // Try to find an existing specialization with these template arguments.
4895 void *InsertPos = nullptr;
4896 ClassTemplateSpecializationDecl *D2
4897 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4899 // We already have a class template specialization with these template
4902 // FIXME: Check for specialization vs. instantiation errors.
4904 if (RecordDecl *FoundDef = D2->getDefinition()) {
4905 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4906 // The record types structurally match, or the "from" translation
4907 // unit only had a forward declaration anyway; call it the same
4909 return Importer.Imported(D, FoundDef);
4913 // Create a new specialization.
4914 if (ClassTemplatePartialSpecializationDecl *PartialSpec =
4915 dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
4917 // Import TemplateArgumentListInfo
4918 TemplateArgumentListInfo ToTAInfo;
4919 auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4920 for (unsigned I = 0, E = ASTTemplateArgs.NumTemplateArgs; I < E; ++I) {
4922 auto ToLoc = ImportTemplateArgumentLoc(ASTTemplateArgs[I], Error);
4925 ToTAInfo.addArgument(ToLoc);
4928 QualType CanonInjType = Importer.Import(
4929 PartialSpec->getInjectedSpecializationType());
4930 if (CanonInjType.isNull())
4932 CanonInjType = CanonInjType.getCanonicalType();
4934 TemplateParameterList *ToTPList = ImportTemplateParameterList(
4935 PartialSpec->getTemplateParameters());
4936 if (!ToTPList && PartialSpec->getTemplateParameters())
4939 D2 = ClassTemplatePartialSpecializationDecl::Create(
4940 Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc,
4941 ToTPList, ClassTemplate,
4942 llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
4943 ToTAInfo, CanonInjType, nullptr);
4946 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4947 D->getTagKind(), DC,
4951 /*PrevDecl=*/nullptr);
4954 D2->setSpecializationKind(D->getSpecializationKind());
4956 // Add this specialization to the class template.
4957 ClassTemplate->AddSpecialization(D2, InsertPos);
4959 // Import the qualifier, if any.
4960 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4962 Importer.Imported(D, D2);
4964 if (auto *TSI = D->getTypeAsWritten()) {
4965 TypeSourceInfo *TInfo = Importer.Import(TSI);
4968 D2->setTypeAsWritten(TInfo);
4969 D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4970 D2->setExternLoc(Importer.Import(D->getExternLoc()));
4973 SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4975 D2->setPointOfInstantiation(POI);
4976 else if (D->getPointOfInstantiation().isValid())
4979 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4981 // Add the specialization to this context.
4982 D2->setLexicalDeclContext(LexicalDC);
4983 LexicalDC->addDeclInternal(D2);
4985 Importer.Imported(D, D2);
4986 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4992 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4993 // If this variable has a definition in the translation unit we're coming
4995 // but this particular declaration is not that definition, import the
4996 // definition and map to that.
4997 VarDecl *Definition =
4998 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4999 if (Definition && Definition != D->getTemplatedDecl()) {
5000 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
5004 return Importer.Imported(D, ImportedDef);
5007 // Import the major distinguishing characteristics of this variable template.
5008 DeclContext *DC, *LexicalDC;
5009 DeclarationName Name;
5012 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5017 // We may already have a template of the same name; try to find and match it.
5018 assert(!DC->isFunctionOrMethod() &&
5019 "Variable templates cannot be declared at function scope");
5020 SmallVector<NamedDecl *, 4> ConflictingDecls;
5021 SmallVector<NamedDecl *, 2> FoundDecls;
5022 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
5023 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
5024 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5027 Decl *Found = FoundDecls[I];
5028 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
5029 if (IsStructuralMatch(D, FoundTemplate)) {
5030 // The variable templates structurally match; call it the same template.
5031 Importer.Imported(D->getTemplatedDecl(),
5032 FoundTemplate->getTemplatedDecl());
5033 return Importer.Imported(D, FoundTemplate);
5037 ConflictingDecls.push_back(FoundDecls[I]);
5040 if (!ConflictingDecls.empty()) {
5041 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
5042 ConflictingDecls.data(),
5043 ConflictingDecls.size());
5049 VarDecl *DTemplated = D->getTemplatedDecl();
5052 QualType T = Importer.Import(DTemplated->getType());
5056 // Create the declaration that is being templated.
5057 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
5058 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
5059 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
5060 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
5061 IdLoc, Name.getAsIdentifierInfo(), T,
5062 TInfo, DTemplated->getStorageClass());
5063 D2Templated->setAccess(DTemplated->getAccess());
5064 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
5065 D2Templated->setLexicalDeclContext(LexicalDC);
5067 // Importer.Imported(DTemplated, D2Templated);
5068 // LexicalDC->addDeclInternal(D2Templated);
5070 // Merge the initializer.
5071 if (ImportDefinition(DTemplated, D2Templated))
5074 // Create the variable template declaration itself.
5075 TemplateParameterList *TemplateParams =
5076 ImportTemplateParameterList(D->getTemplateParameters());
5077 if (!TemplateParams)
5080 VarTemplateDecl *D2 = VarTemplateDecl::Create(
5081 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
5082 D2Templated->setDescribedVarTemplate(D2);
5084 D2->setAccess(D->getAccess());
5085 D2->setLexicalDeclContext(LexicalDC);
5086 LexicalDC->addDeclInternal(D2);
5088 // Note the relationship between the variable templates.
5089 Importer.Imported(D, D2);
5090 Importer.Imported(DTemplated, D2Templated);
5092 if (DTemplated->isThisDeclarationADefinition() &&
5093 !D2Templated->isThisDeclarationADefinition()) {
5094 // FIXME: Import definition!
5100 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
5101 VarTemplateSpecializationDecl *D) {
5102 // If this record has a definition in the translation unit we're coming from,
5103 // but this particular declaration is not that definition, import the
5104 // definition and map to that.
5105 VarDecl *Definition = D->getDefinition();
5106 if (Definition && Definition != D) {
5107 Decl *ImportedDef = Importer.Import(Definition);
5111 return Importer.Imported(D, ImportedDef);
5114 VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
5115 Importer.Import(D->getSpecializedTemplate()));
5119 // Import the context of this declaration.
5120 DeclContext *DC = VarTemplate->getDeclContext();
5124 DeclContext *LexicalDC = DC;
5125 if (D->getDeclContext() != D->getLexicalDeclContext()) {
5126 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
5131 // Import the location of this declaration.
5132 SourceLocation StartLoc = Importer.Import(D->getLocStart());
5133 SourceLocation IdLoc = Importer.Import(D->getLocation());
5135 // Import template arguments.
5136 SmallVector<TemplateArgument, 2> TemplateArgs;
5137 if (ImportTemplateArguments(D->getTemplateArgs().data(),
5138 D->getTemplateArgs().size(), TemplateArgs))
5141 // Try to find an existing specialization with these template arguments.
5142 void *InsertPos = nullptr;
5143 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
5144 TemplateArgs, InsertPos);
5146 // We already have a variable template specialization with these template
5149 // FIXME: Check for specialization vs. instantiation errors.
5151 if (VarDecl *FoundDef = D2->getDefinition()) {
5152 if (!D->isThisDeclarationADefinition() ||
5153 IsStructuralMatch(D, FoundDef)) {
5154 // The record types structurally match, or the "from" translation
5155 // unit only had a forward declaration anyway; call it the same
5157 return Importer.Imported(D, FoundDef);
5163 QualType T = Importer.Import(D->getType());
5166 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
5168 // Create a new specialization.
5169 D2 = VarTemplateSpecializationDecl::Create(
5170 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
5171 D->getStorageClass(), TemplateArgs);
5172 D2->setSpecializationKind(D->getSpecializationKind());
5173 D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
5175 // Add this specialization to the class template.
5176 VarTemplate->AddSpecialization(D2, InsertPos);
5178 // Import the qualifier, if any.
5179 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
5181 // Add the specialization to this context.
5182 D2->setLexicalDeclContext(LexicalDC);
5183 LexicalDC->addDeclInternal(D2);
5185 Importer.Imported(D, D2);
5187 if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
5193 //----------------------------------------------------------------------------
5194 // Import Statements
5195 //----------------------------------------------------------------------------
5197 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
5199 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
5200 size_t NumDecls = DG.end() - DG.begin();
5201 SmallVector<Decl *, 1> ToDecls(NumDecls);
5202 auto &_Importer = this->Importer;
5203 std::transform(DG.begin(), DG.end(), ToDecls.begin(),
5204 [&_Importer](Decl *D) -> Decl * {
5205 return _Importer.Import(D);
5207 return DeclGroupRef::Create(Importer.getToContext(),
5212 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
5213 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
5214 << S->getStmtClassName();
5219 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
5220 SmallVector<IdentifierInfo *, 4> Names;
5221 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5222 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
5223 // ToII is nullptr when no symbolic name is given for output operand
5224 // see ParseStmtAsm::ParseAsmOperandsOpt
5225 if (!ToII && S->getOutputIdentifier(I))
5227 Names.push_back(ToII);
5229 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5230 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
5231 // ToII is nullptr when no symbolic name is given for input operand
5232 // see ParseStmtAsm::ParseAsmOperandsOpt
5233 if (!ToII && S->getInputIdentifier(I))
5235 Names.push_back(ToII);
5238 SmallVector<StringLiteral *, 4> Clobbers;
5239 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
5240 StringLiteral *Clobber = cast_or_null<StringLiteral>(
5241 Importer.Import(S->getClobberStringLiteral(I)));
5244 Clobbers.push_back(Clobber);
5247 SmallVector<StringLiteral *, 4> Constraints;
5248 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5249 StringLiteral *Output = cast_or_null<StringLiteral>(
5250 Importer.Import(S->getOutputConstraintLiteral(I)));
5253 Constraints.push_back(Output);
5256 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5257 StringLiteral *Input = cast_or_null<StringLiteral>(
5258 Importer.Import(S->getInputConstraintLiteral(I)));
5261 Constraints.push_back(Input);
5264 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
5265 if (ImportContainerChecked(S->outputs(), Exprs))
5268 if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
5271 StringLiteral *AsmStr = cast_or_null<StringLiteral>(
5272 Importer.Import(S->getAsmString()));
5276 return new (Importer.getToContext()) GCCAsmStmt(
5277 Importer.getToContext(),
5278 Importer.Import(S->getAsmLoc()),
5287 S->getNumClobbers(),
5289 Importer.Import(S->getRParenLoc()));
5292 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
5293 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
5294 for (Decl *ToD : ToDG) {
5298 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
5299 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5300 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5303 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
5304 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5305 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5306 S->hasLeadingEmptyMacro());
5309 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
5310 llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
5312 if (ImportContainerChecked(S->body(), ToStmts))
5315 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5316 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
5317 return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
5319 ToLBraceLoc, ToRBraceLoc);
5322 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
5323 Expr *ToLHS = Importer.Import(S->getLHS());
5326 Expr *ToRHS = Importer.Import(S->getRHS());
5327 if (!ToRHS && S->getRHS())
5329 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5330 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5331 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5332 return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
5333 ToCaseLoc, ToEllipsisLoc,
5337 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
5338 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5339 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5340 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5341 if (!ToSubStmt && S->getSubStmt())
5343 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5347 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
5348 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
5349 LabelDecl *ToLabelDecl =
5350 cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
5351 if (!ToLabelDecl && S->getDecl())
5353 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5354 if (!ToSubStmt && S->getSubStmt())
5356 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5360 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
5361 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5362 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5363 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
5364 ASTContext &_ToContext = Importer.getToContext();
5365 std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(),
5366 [&_ToContext](const Attr *A) -> const Attr * {
5367 return A->clone(_ToContext);
5369 for (const Attr *ToA : ToAttrs) {
5373 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5374 if (!ToSubStmt && S->getSubStmt())
5376 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5377 ToAttrs, ToSubStmt);
5380 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
5381 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
5382 Stmt *ToInit = Importer.Import(S->getInit());
5383 if (!ToInit && S->getInit())
5385 VarDecl *ToConditionVariable = nullptr;
5386 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5387 ToConditionVariable =
5388 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5389 if (!ToConditionVariable)
5392 Expr *ToCondition = Importer.Import(S->getCond());
5393 if (!ToCondition && S->getCond())
5395 Stmt *ToThenStmt = Importer.Import(S->getThen());
5396 if (!ToThenStmt && S->getThen())
5398 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5399 Stmt *ToElseStmt = Importer.Import(S->getElse());
5400 if (!ToElseStmt && S->getElse())
5402 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5403 ToIfLoc, S->isConstexpr(),
5405 ToConditionVariable,
5406 ToCondition, ToThenStmt,
5407 ToElseLoc, ToElseStmt);
5410 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
5411 Stmt *ToInit = Importer.Import(S->getInit());
5412 if (!ToInit && S->getInit())
5414 VarDecl *ToConditionVariable = nullptr;
5415 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5416 ToConditionVariable =
5417 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5418 if (!ToConditionVariable)
5421 Expr *ToCondition = Importer.Import(S->getCond());
5422 if (!ToCondition && S->getCond())
5424 SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
5425 Importer.getToContext(), ToInit,
5426 ToConditionVariable, ToCondition);
5427 Stmt *ToBody = Importer.Import(S->getBody());
5428 if (!ToBody && S->getBody())
5430 ToStmt->setBody(ToBody);
5431 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5432 // Now we have to re-chain the cases.
5433 SwitchCase *LastChainedSwitchCase = nullptr;
5434 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5435 SC = SC->getNextSwitchCase()) {
5436 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5439 if (LastChainedSwitchCase)
5440 LastChainedSwitchCase->setNextSwitchCase(ToSC);
5442 ToStmt->setSwitchCaseList(ToSC);
5443 LastChainedSwitchCase = ToSC;
5448 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5449 VarDecl *ToConditionVariable = nullptr;
5450 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5451 ToConditionVariable =
5452 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5453 if (!ToConditionVariable)
5456 Expr *ToCondition = Importer.Import(S->getCond());
5457 if (!ToCondition && S->getCond())
5459 Stmt *ToBody = Importer.Import(S->getBody());
5460 if (!ToBody && S->getBody())
5462 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5463 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5464 ToConditionVariable,
5465 ToCondition, ToBody,
5469 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5470 Stmt *ToBody = Importer.Import(S->getBody());
5471 if (!ToBody && S->getBody())
5473 Expr *ToCondition = Importer.Import(S->getCond());
5474 if (!ToCondition && S->getCond())
5476 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5477 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5478 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5479 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5480 ToDoLoc, ToWhileLoc,
5484 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5485 Stmt *ToInit = Importer.Import(S->getInit());
5486 if (!ToInit && S->getInit())
5488 Expr *ToCondition = Importer.Import(S->getCond());
5489 if (!ToCondition && S->getCond())
5491 VarDecl *ToConditionVariable = nullptr;
5492 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5493 ToConditionVariable =
5494 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5495 if (!ToConditionVariable)
5498 Expr *ToInc = Importer.Import(S->getInc());
5499 if (!ToInc && S->getInc())
5501 Stmt *ToBody = Importer.Import(S->getBody());
5502 if (!ToBody && S->getBody())
5504 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5505 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5506 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5507 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5508 ToInit, ToCondition,
5509 ToConditionVariable,
5511 ToForLoc, ToLParenLoc,
5515 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5516 LabelDecl *ToLabel = nullptr;
5517 if (LabelDecl *FromLabel = S->getLabel()) {
5518 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5522 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5523 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5524 return new (Importer.getToContext()) GotoStmt(ToLabel,
5525 ToGotoLoc, ToLabelLoc);
5528 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5529 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5530 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5531 Expr *ToTarget = Importer.Import(S->getTarget());
5532 if (!ToTarget && S->getTarget())
5534 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5538 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5539 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5540 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5543 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5544 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5545 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5548 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5549 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5550 Expr *ToRetExpr = Importer.Import(S->getRetValue());
5551 if (!ToRetExpr && S->getRetValue())
5553 VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
5554 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5555 if (!ToNRVOCandidate && NRVOCandidate)
5557 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5561 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5562 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5563 VarDecl *ToExceptionDecl = nullptr;
5564 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5566 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5567 if (!ToExceptionDecl)
5570 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5571 if (!ToHandlerBlock && S->getHandlerBlock())
5573 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5578 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5579 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5580 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5581 if (!ToTryBlock && S->getTryBlock())
5583 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5584 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5585 CXXCatchStmt *FromHandler = S->getHandler(HI);
5586 if (Stmt *ToHandler = Importer.Import(FromHandler))
5587 ToHandlers[HI] = ToHandler;
5591 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5595 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
5597 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5598 if (!ToRange && S->getRangeStmt())
5601 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5602 if (!ToBegin && S->getBeginStmt())
5605 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5606 if (!ToEnd && S->getEndStmt())
5608 Expr *ToCond = Importer.Import(S->getCond());
5609 if (!ToCond && S->getCond())
5611 Expr *ToInc = Importer.Import(S->getInc());
5612 if (!ToInc && S->getInc())
5614 DeclStmt *ToLoopVar =
5615 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5616 if (!ToLoopVar && S->getLoopVarStmt())
5618 Stmt *ToBody = Importer.Import(S->getBody());
5619 if (!ToBody && S->getBody())
5621 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5622 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5623 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5624 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5625 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5628 ToForLoc, ToCoawaitLoc,
5629 ToColonLoc, ToRParenLoc);
5632 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5633 Stmt *ToElem = Importer.Import(S->getElement());
5634 if (!ToElem && S->getElement())
5636 Expr *ToCollect = Importer.Import(S->getCollection());
5637 if (!ToCollect && S->getCollection())
5639 Stmt *ToBody = Importer.Import(S->getBody());
5640 if (!ToBody && S->getBody())
5642 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5643 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5644 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5650 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5651 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5652 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5653 VarDecl *ToExceptionDecl = nullptr;
5654 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5656 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5657 if (!ToExceptionDecl)
5660 Stmt *ToBody = Importer.Import(S->getCatchBody());
5661 if (!ToBody && S->getCatchBody())
5663 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5669 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5670 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5671 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5672 if (!ToAtFinallyStmt && S->getFinallyBody())
5674 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5678 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5679 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5680 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5681 if (!ToAtTryStmt && S->getTryBody())
5683 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5684 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5685 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5686 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5687 ToCatchStmts[CI] = ToCatchStmt;
5691 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5692 if (!ToAtFinallyStmt && S->getFinallyStmt())
5694 return ObjCAtTryStmt::Create(Importer.getToContext(),
5695 ToAtTryLoc, ToAtTryStmt,
5696 ToCatchStmts.begin(), ToCatchStmts.size(),
5700 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5701 (ObjCAtSynchronizedStmt *S) {
5702 SourceLocation ToAtSynchronizedLoc =
5703 Importer.Import(S->getAtSynchronizedLoc());
5704 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5705 if (!ToSynchExpr && S->getSynchExpr())
5707 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5708 if (!ToSynchBody && S->getSynchBody())
5710 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5711 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5714 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5715 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5716 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5717 if (!ToThrow && S->getThrowExpr())
5719 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5722 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5723 (ObjCAutoreleasePoolStmt *S) {
5724 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5725 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5726 if (!ToSubStmt && S->getSubStmt())
5728 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5732 //----------------------------------------------------------------------------
5733 // Import Expressions
5734 //----------------------------------------------------------------------------
5735 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5736 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5737 << E->getStmtClassName();
5741 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5742 QualType T = Importer.Import(E->getType());
5746 Expr *SubExpr = Importer.Import(E->getSubExpr());
5747 if (!SubExpr && E->getSubExpr())
5750 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5754 return new (Importer.getToContext()) VAArgExpr(
5755 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5756 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5760 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5761 QualType T = Importer.Import(E->getType());
5765 return new (Importer.getToContext()) GNUNullExpr(
5766 T, Importer.Import(E->getLocStart()));
5769 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5770 QualType T = Importer.Import(E->getType());
5774 StringLiteral *SL = cast_or_null<StringLiteral>(
5775 Importer.Import(E->getFunctionName()));
5776 if (!SL && E->getFunctionName())
5779 return new (Importer.getToContext()) PredefinedExpr(
5780 Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5783 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5784 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5788 NamedDecl *FoundD = nullptr;
5789 if (E->getDecl() != E->getFoundDecl()) {
5790 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5795 QualType T = Importer.Import(E->getType());
5800 TemplateArgumentListInfo ToTAInfo;
5801 TemplateArgumentListInfo *ResInfo = nullptr;
5802 if (E->hasExplicitTemplateArgs()) {
5803 for (const auto &FromLoc : E->template_arguments()) {
5805 TemplateArgumentLoc ToTALoc = ImportTemplateArgumentLoc(FromLoc, Error);
5808 ToTAInfo.addArgument(ToTALoc);
5810 ResInfo = &ToTAInfo;
5813 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5814 Importer.Import(E->getQualifierLoc()),
5815 Importer.Import(E->getTemplateKeywordLoc()),
5817 E->refersToEnclosingVariableOrCapture(),
5818 Importer.Import(E->getLocation()),
5819 T, E->getValueKind(),
5821 if (E->hadMultipleCandidates())
5822 DRE->setHadMultipleCandidates(true);
5826 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5827 QualType T = Importer.Import(E->getType());
5831 return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5834 ASTNodeImporter::Designator
5835 ASTNodeImporter::ImportDesignator(const Designator &D) {
5836 if (D.isFieldDesignator()) {
5837 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5838 // Caller checks for import error
5839 return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5840 Importer.Import(D.getFieldLoc()));
5842 if (D.isArrayDesignator())
5843 return Designator(D.getFirstExprIndex(),
5844 Importer.Import(D.getLBracketLoc()),
5845 Importer.Import(D.getRBracketLoc()));
5847 assert(D.isArrayRangeDesignator());
5848 return Designator(D.getFirstExprIndex(),
5849 Importer.Import(D.getLBracketLoc()),
5850 Importer.Import(D.getEllipsisLoc()),
5851 Importer.Import(D.getRBracketLoc()));
5855 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
5856 Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5860 SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5861 // List elements from the second, the first is Init itself
5862 for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5863 if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5864 IndexExprs[I - 1] = Arg;
5869 SmallVector<Designator, 4> Designators(DIE->size());
5870 llvm::transform(DIE->designators(), Designators.begin(),
5871 [this](const Designator &D) -> Designator {
5872 return ImportDesignator(D);
5875 for (const Designator &D : DIE->designators())
5876 if (D.isFieldDesignator() && !D.getFieldName())
5879 return DesignatedInitExpr::Create(
5880 Importer.getToContext(), Designators,
5881 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5882 DIE->usesGNUSyntax(), Init);
5885 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5886 QualType T = Importer.Import(E->getType());
5890 return new (Importer.getToContext())
5891 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5894 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5895 QualType T = Importer.Import(E->getType());
5899 return IntegerLiteral::Create(Importer.getToContext(),
5901 Importer.Import(E->getLocation()));
5904 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5905 QualType T = Importer.Import(E->getType());
5909 return FloatingLiteral::Create(Importer.getToContext(),
5910 E->getValue(), E->isExact(), T,
5911 Importer.Import(E->getLocation()));
5914 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5915 QualType T = Importer.Import(E->getType());
5919 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5921 Importer.Import(E->getLocation()));
5924 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5925 QualType T = Importer.Import(E->getType());
5929 SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5930 ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5932 return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5933 E->getKind(), E->isPascal(), T,
5934 Locations.data(), Locations.size());
5937 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5938 QualType T = Importer.Import(E->getType());
5942 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5946 Expr *Init = Importer.Import(E->getInitializer());
5950 return new (Importer.getToContext()) CompoundLiteralExpr(
5951 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5952 Init, E->isFileScope());
5955 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5956 QualType T = Importer.Import(E->getType());
5960 SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5961 if (ImportArrayChecked(
5962 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5966 return new (Importer.getToContext()) AtomicExpr(
5967 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5968 Importer.Import(E->getRParenLoc()));
5971 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5972 QualType T = Importer.Import(E->getType());
5976 LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5980 return new (Importer.getToContext()) AddrLabelExpr(
5981 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5985 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5986 Expr *SubExpr = Importer.Import(E->getSubExpr());
5990 return new (Importer.getToContext())
5991 ParenExpr(Importer.Import(E->getLParen()),
5992 Importer.Import(E->getRParen()),
5996 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5997 SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5998 if (ImportContainerChecked(E->exprs(), Exprs))
6001 return new (Importer.getToContext()) ParenListExpr(
6002 Importer.getToContext(), Importer.Import(E->getLParenLoc()),
6003 Exprs, Importer.Import(E->getLParenLoc()));
6006 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
6007 QualType T = Importer.Import(E->getType());
6011 CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
6012 Importer.Import(E->getSubStmt()));
6013 if (!ToSubStmt && E->getSubStmt())
6016 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
6017 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
6020 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
6021 QualType T = Importer.Import(E->getType());
6025 Expr *SubExpr = Importer.Import(E->getSubExpr());
6029 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
6030 T, E->getValueKind(),
6032 Importer.Import(E->getOperatorLoc()));
6035 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
6036 UnaryExprOrTypeTraitExpr *E) {
6037 QualType ResultType = Importer.Import(E->getType());
6039 if (E->isArgumentType()) {
6040 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
6044 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6046 Importer.Import(E->getOperatorLoc()),
6047 Importer.Import(E->getRParenLoc()));
6050 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
6054 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6055 SubExpr, ResultType,
6056 Importer.Import(E->getOperatorLoc()),
6057 Importer.Import(E->getRParenLoc()));
6060 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
6061 QualType T = Importer.Import(E->getType());
6065 Expr *LHS = Importer.Import(E->getLHS());
6069 Expr *RHS = Importer.Import(E->getRHS());
6073 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
6074 T, E->getValueKind(),
6076 Importer.Import(E->getOperatorLoc()),
6077 E->getFPFeatures());
6080 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
6081 QualType T = Importer.Import(E->getType());
6085 Expr *ToLHS = Importer.Import(E->getLHS());
6089 Expr *ToRHS = Importer.Import(E->getRHS());
6093 Expr *ToCond = Importer.Import(E->getCond());
6097 return new (Importer.getToContext()) ConditionalOperator(
6098 ToCond, Importer.Import(E->getQuestionLoc()),
6099 ToLHS, Importer.Import(E->getColonLoc()),
6100 ToRHS, T, E->getValueKind(), E->getObjectKind());
6103 Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
6104 BinaryConditionalOperator *E) {
6105 QualType T = Importer.Import(E->getType());
6109 Expr *Common = Importer.Import(E->getCommon());
6113 Expr *Cond = Importer.Import(E->getCond());
6117 OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
6118 Importer.Import(E->getOpaqueValue()));
6122 Expr *TrueExpr = Importer.Import(E->getTrueExpr());
6126 Expr *FalseExpr = Importer.Import(E->getFalseExpr());
6130 return new (Importer.getToContext()) BinaryConditionalOperator(
6131 Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
6132 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
6133 T, E->getValueKind(), E->getObjectKind());
6136 Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
6137 QualType T = Importer.Import(E->getType());
6141 TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
6145 Expr *Dim = Importer.Import(E->getDimensionExpression());
6146 if (!Dim && E->getDimensionExpression())
6149 return new (Importer.getToContext()) ArrayTypeTraitExpr(
6150 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6151 E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
6154 Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
6155 QualType T = Importer.Import(E->getType());
6159 Expr *ToQueried = Importer.Import(E->getQueriedExpression());
6163 return new (Importer.getToContext()) ExpressionTraitExpr(
6164 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6165 E->getValue(), Importer.Import(E->getLocEnd()), T);
6168 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
6169 QualType T = Importer.Import(E->getType());
6173 Expr *SourceExpr = Importer.Import(E->getSourceExpr());
6174 if (!SourceExpr && E->getSourceExpr())
6177 return new (Importer.getToContext()) OpaqueValueExpr(
6178 Importer.Import(E->getLocation()), T, E->getValueKind(),
6179 E->getObjectKind(), SourceExpr);
6182 Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
6183 QualType T = Importer.Import(E->getType());
6187 Expr *ToLHS = Importer.Import(E->getLHS());
6191 Expr *ToRHS = Importer.Import(E->getRHS());
6195 return new (Importer.getToContext()) ArraySubscriptExpr(
6196 ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
6197 Importer.Import(E->getRBracketLoc()));
6200 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
6201 QualType T = Importer.Import(E->getType());
6205 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
6206 if (CompLHSType.isNull())
6209 QualType CompResultType = Importer.Import(E->getComputationResultType());
6210 if (CompResultType.isNull())
6213 Expr *LHS = Importer.Import(E->getLHS());
6217 Expr *RHS = Importer.Import(E->getRHS());
6221 return new (Importer.getToContext())
6222 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
6223 T, E->getValueKind(),
6225 CompLHSType, CompResultType,
6226 Importer.Import(E->getOperatorLoc()),
6227 E->getFPFeatures());
6230 bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
6231 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
6232 if (CXXBaseSpecifier *Spec = Importer.Import(*I))
6233 Path.push_back(Spec);
6240 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
6241 QualType T = Importer.Import(E->getType());
6245 Expr *SubExpr = Importer.Import(E->getSubExpr());
6249 CXXCastPath BasePath;
6250 if (ImportCastPath(E, BasePath))
6253 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
6254 SubExpr, &BasePath, E->getValueKind());
6257 Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
6258 QualType T = Importer.Import(E->getType());
6262 Expr *SubExpr = Importer.Import(E->getSubExpr());
6266 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
6267 if (!TInfo && E->getTypeInfoAsWritten())
6270 CXXCastPath BasePath;
6271 if (ImportCastPath(E, BasePath))
6274 switch (E->getStmtClass()) {
6275 case Stmt::CStyleCastExprClass: {
6276 CStyleCastExpr *CCE = cast<CStyleCastExpr>(E);
6277 return CStyleCastExpr::Create(Importer.getToContext(), T,
6278 E->getValueKind(), E->getCastKind(),
6279 SubExpr, &BasePath, TInfo,
6280 Importer.Import(CCE->getLParenLoc()),
6281 Importer.Import(CCE->getRParenLoc()));
6284 case Stmt::CXXFunctionalCastExprClass: {
6285 CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E);
6286 return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
6287 E->getValueKind(), TInfo,
6288 E->getCastKind(), SubExpr, &BasePath,
6289 Importer.Import(FCE->getLParenLoc()),
6290 Importer.Import(FCE->getRParenLoc()));
6293 case Stmt::ObjCBridgedCastExprClass: {
6294 ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E);
6295 return new (Importer.getToContext()) ObjCBridgedCastExpr(
6296 Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
6297 E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
6301 break; // just fall through
6304 CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E);
6305 SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
6306 RParenLoc = Importer.Import(Named->getRParenLoc());
6307 SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
6309 switch (E->getStmtClass()) {
6310 case Stmt::CXXStaticCastExprClass:
6311 return CXXStaticCastExpr::Create(Importer.getToContext(), T,
6312 E->getValueKind(), E->getCastKind(),
6313 SubExpr, &BasePath, TInfo,
6314 ExprLoc, RParenLoc, Brackets);
6316 case Stmt::CXXDynamicCastExprClass:
6317 return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6318 E->getValueKind(), E->getCastKind(),
6319 SubExpr, &BasePath, TInfo,
6320 ExprLoc, RParenLoc, Brackets);
6322 case Stmt::CXXReinterpretCastExprClass:
6323 return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6324 E->getValueKind(), E->getCastKind(),
6325 SubExpr, &BasePath, TInfo,
6326 ExprLoc, RParenLoc, Brackets);
6328 case Stmt::CXXConstCastExprClass:
6329 return CXXConstCastExpr::Create(Importer.getToContext(), T,
6330 E->getValueKind(), SubExpr, TInfo, ExprLoc,
6331 RParenLoc, Brackets);
6333 llvm_unreachable("Cast expression of unsupported type!");
6338 Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
6339 QualType T = Importer.Import(OE->getType());
6343 SmallVector<OffsetOfNode, 4> Nodes;
6344 for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6345 const OffsetOfNode &Node = OE->getComponent(I);
6347 switch (Node.getKind()) {
6348 case OffsetOfNode::Array:
6349 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
6350 Node.getArrayExprIndex(),
6351 Importer.Import(Node.getLocEnd())));
6354 case OffsetOfNode::Base: {
6355 CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6356 if (!BS && Node.getBase())
6358 Nodes.push_back(OffsetOfNode(BS));
6361 case OffsetOfNode::Field: {
6362 FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
6365 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
6366 Importer.Import(Node.getLocEnd())));
6369 case OffsetOfNode::Identifier: {
6370 IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6373 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
6374 Importer.Import(Node.getLocEnd())));
6380 SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
6381 for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6382 Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6385 Exprs[I] = ToIndexExpr;
6388 TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6389 if (!TInfo && OE->getTypeSourceInfo())
6392 return OffsetOfExpr::Create(Importer.getToContext(), T,
6393 Importer.Import(OE->getOperatorLoc()),
6394 TInfo, Nodes, Exprs,
6395 Importer.Import(OE->getRParenLoc()));
6398 Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
6399 QualType T = Importer.Import(E->getType());
6403 Expr *Operand = Importer.Import(E->getOperand());
6407 CanThrowResult CanThrow;
6408 if (E->isValueDependent())
6409 CanThrow = CT_Dependent;
6411 CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6413 return new (Importer.getToContext()) CXXNoexceptExpr(
6414 T, Operand, CanThrow,
6415 Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6418 Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
6419 QualType T = Importer.Import(E->getType());
6423 Expr *SubExpr = Importer.Import(E->getSubExpr());
6424 if (!SubExpr && E->getSubExpr())
6427 return new (Importer.getToContext()) CXXThrowExpr(
6428 SubExpr, T, Importer.Import(E->getThrowLoc()),
6429 E->isThrownVariableInScope());
6432 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
6433 ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
6434 Importer.Import(E->getParam()));
6438 return CXXDefaultArgExpr::Create(
6439 Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6442 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
6443 QualType T = Importer.Import(E->getType());
6447 TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6451 return new (Importer.getToContext()) CXXScalarValueInitExpr(
6452 T, TypeInfo, Importer.Import(E->getRParenLoc()));
6455 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
6456 Expr *SubExpr = Importer.Import(E->getSubExpr());
6460 auto *Dtor = cast_or_null<CXXDestructorDecl>(
6461 Importer.Import(const_cast<CXXDestructorDecl *>(
6462 E->getTemporary()->getDestructor())));
6466 ASTContext &ToCtx = Importer.getToContext();
6467 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6468 return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6471 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
6472 QualType T = Importer.Import(CE->getType());
6476 SmallVector<Expr *, 8> Args(CE->getNumArgs());
6477 if (ImportContainerChecked(CE->arguments(), Args))
6480 auto *Ctor = cast_or_null<CXXConstructorDecl>(
6481 Importer.Import(CE->getConstructor()));
6485 return CXXTemporaryObjectExpr::Create(
6486 Importer.getToContext(), T,
6487 Importer.Import(CE->getLocStart()),
6491 CE->hadMultipleCandidates(),
6492 CE->isListInitialization(),
6493 CE->isStdInitListInitialization(),
6494 CE->requiresZeroInitialization(),
6495 CE->getConstructionKind(),
6496 Importer.Import(CE->getParenOrBraceRange()));
6500 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
6501 QualType T = Importer.Import(E->getType());
6505 Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6509 ValueDecl *ExtendedBy = cast_or_null<ValueDecl>(
6510 Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6511 if (!ExtendedBy && E->getExtendingDecl())
6514 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
6515 T, TempE, E->isBoundToLvalueReference());
6517 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6518 ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6522 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
6523 QualType T = Importer.Import(CE->getType());
6527 SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6528 if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6531 FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>(
6532 Importer.Import(CE->getOperatorNew()));
6533 if (!OperatorNewDecl && CE->getOperatorNew())
6536 FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6537 Importer.Import(CE->getOperatorDelete()));
6538 if (!OperatorDeleteDecl && CE->getOperatorDelete())
6541 Expr *ToInit = Importer.Import(CE->getInitializer());
6542 if (!ToInit && CE->getInitializer())
6545 TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6549 Expr *ToArrSize = Importer.Import(CE->getArraySize());
6550 if (!ToArrSize && CE->getArraySize())
6553 return new (Importer.getToContext()) CXXNewExpr(
6554 Importer.getToContext(),
6556 OperatorNewDecl, OperatorDeleteDecl,
6557 CE->passAlignment(),
6558 CE->doesUsualArrayDeleteWantSize(),
6560 Importer.Import(CE->getTypeIdParens()),
6561 ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6562 Importer.Import(CE->getSourceRange()),
6563 Importer.Import(CE->getDirectInitRange()));
6566 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
6567 QualType T = Importer.Import(E->getType());
6571 FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6572 Importer.Import(E->getOperatorDelete()));
6573 if (!OperatorDeleteDecl && E->getOperatorDelete())
6576 Expr *ToArg = Importer.Import(E->getArgument());
6577 if (!ToArg && E->getArgument())
6580 return new (Importer.getToContext()) CXXDeleteExpr(
6581 T, E->isGlobalDelete(),
6583 E->isArrayFormAsWritten(),
6584 E->doesUsualArrayDeleteWantSize(),
6587 Importer.Import(E->getLocStart()));
6590 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
6591 QualType T = Importer.Import(E->getType());
6595 CXXConstructorDecl *ToCCD =
6596 dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
6600 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
6601 if (ImportContainerChecked(E->arguments(), ToArgs))
6604 return CXXConstructExpr::Create(Importer.getToContext(), T,
6605 Importer.Import(E->getLocation()),
6606 ToCCD, E->isElidable(),
6607 ToArgs, E->hadMultipleCandidates(),
6608 E->isListInitialization(),
6609 E->isStdInitListInitialization(),
6610 E->requiresZeroInitialization(),
6611 E->getConstructionKind(),
6612 Importer.Import(E->getParenOrBraceRange()));
6615 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
6616 Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6617 if (!SubExpr && EWC->getSubExpr())
6620 SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
6621 for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6622 if (ExprWithCleanups::CleanupObject Obj =
6623 cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6628 return ExprWithCleanups::Create(Importer.getToContext(),
6629 SubExpr, EWC->cleanupsHaveSideEffects(),
6633 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
6634 QualType T = Importer.Import(E->getType());
6638 Expr *ToFn = Importer.Import(E->getCallee());
6642 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
6643 if (ImportContainerChecked(E->arguments(), ToArgs))
6646 return new (Importer.getToContext()) CXXMemberCallExpr(
6647 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6648 Importer.Import(E->getRParenLoc()));
6651 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
6652 QualType T = Importer.Import(E->getType());
6656 return new (Importer.getToContext())
6657 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6660 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
6661 QualType T = Importer.Import(E->getType());
6665 return new (Importer.getToContext())
6666 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6670 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
6671 QualType T = Importer.Import(E->getType());
6675 Expr *ToBase = Importer.Import(E->getBase());
6676 if (!ToBase && E->getBase())
6679 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
6680 if (!ToMember && E->getMemberDecl())
6683 DeclAccessPair ToFoundDecl = DeclAccessPair::make(
6684 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
6685 E->getFoundDecl().getAccess());
6687 DeclarationNameInfo ToMemberNameInfo(
6688 Importer.Import(E->getMemberNameInfo().getName()),
6689 Importer.Import(E->getMemberNameInfo().getLoc()));
6691 if (E->hasExplicitTemplateArgs()) {
6692 return nullptr; // FIXME: handle template arguments
6695 return MemberExpr::Create(Importer.getToContext(), ToBase,
6697 Importer.Import(E->getOperatorLoc()),
6698 Importer.Import(E->getQualifierLoc()),
6699 Importer.Import(E->getTemplateKeywordLoc()),
6700 ToMember, ToFoundDecl, ToMemberNameInfo,
6701 nullptr, T, E->getValueKind(),
6702 E->getObjectKind());
6705 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
6706 QualType T = Importer.Import(E->getType());
6710 Expr *ToCallee = Importer.Import(E->getCallee());
6711 if (!ToCallee && E->getCallee())
6714 unsigned NumArgs = E->getNumArgs();
6716 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
6718 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) {
6719 Expr *FromArg = E->getArg(ai);
6720 Expr *ToArg = Importer.Import(FromArg);
6726 Expr **ToArgs_Copied = new (Importer.getToContext())
6729 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
6730 ToArgs_Copied[ai] = ToArgs[ai];
6732 return new (Importer.getToContext())
6733 CallExpr(Importer.getToContext(), ToCallee,
6734 llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
6735 Importer.Import(E->getRParenLoc()));
6738 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
6739 QualType T = Importer.Import(ILE->getType());
6743 llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
6744 if (ImportContainerChecked(ILE->inits(), Exprs))
6747 ASTContext &ToCtx = Importer.getToContext();
6748 InitListExpr *To = new (ToCtx) InitListExpr(
6749 ToCtx, Importer.Import(ILE->getLBraceLoc()),
6750 Exprs, Importer.Import(ILE->getLBraceLoc()));
6753 if (ILE->hasArrayFiller()) {
6754 Expr *Filler = Importer.Import(ILE->getArrayFiller());
6757 To->setArrayFiller(Filler);
6760 if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
6761 FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
6764 To->setInitializedFieldInUnion(ToFD);
6767 if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
6768 InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
6769 Importer.Import(SyntForm));
6772 To->setSyntacticForm(ToSyntForm);
6775 To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
6776 To->setValueDependent(ILE->isValueDependent());
6777 To->setInstantiationDependent(ILE->isInstantiationDependent());
6782 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
6783 QualType ToType = Importer.Import(E->getType());
6784 if (ToType.isNull())
6787 Expr *ToCommon = Importer.Import(E->getCommonExpr());
6788 if (!ToCommon && E->getCommonExpr())
6791 Expr *ToSubExpr = Importer.Import(E->getSubExpr());
6792 if (!ToSubExpr && E->getSubExpr())
6795 return new (Importer.getToContext())
6796 ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
6799 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
6800 QualType ToType = Importer.Import(E->getType());
6801 if (ToType.isNull())
6803 return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6806 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
6807 FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>(
6808 Importer.Import(DIE->getField()));
6809 if (!ToField && DIE->getField())
6812 return CXXDefaultInitExpr::Create(
6813 Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6816 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
6817 QualType ToType = Importer.Import(E->getType());
6818 if (ToType.isNull() && !E->getType().isNull())
6820 ExprValueKind VK = E->getValueKind();
6821 CastKind CK = E->getCastKind();
6822 Expr *ToOp = Importer.Import(E->getSubExpr());
6823 if (!ToOp && E->getSubExpr())
6825 CXXCastPath BasePath;
6826 if (ImportCastPath(E, BasePath))
6828 TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6829 SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6830 SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6831 SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6833 if (isa<CXXStaticCastExpr>(E)) {
6834 return CXXStaticCastExpr::Create(
6835 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6836 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6837 } else if (isa<CXXDynamicCastExpr>(E)) {
6838 return CXXDynamicCastExpr::Create(
6839 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6840 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6841 } else if (isa<CXXReinterpretCastExpr>(E)) {
6842 return CXXReinterpretCastExpr::Create(
6843 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6844 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6851 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
6852 SubstNonTypeTemplateParmExpr *E) {
6853 QualType T = Importer.Import(E->getType());
6857 NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>(
6858 Importer.Import(E->getParameter()));
6862 Expr *Replacement = Importer.Import(E->getReplacement());
6866 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6867 T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6871 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
6872 ASTContext &FromContext, FileManager &FromFileManager,
6874 : ToContext(ToContext), FromContext(FromContext),
6875 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
6876 Minimal(MinimalImport), LastDiagFromFrom(false)
6878 ImportedDecls[FromContext.getTranslationUnitDecl()]
6879 = ToContext.getTranslationUnitDecl();
6882 ASTImporter::~ASTImporter() { }
6884 QualType ASTImporter::Import(QualType FromT) {
6888 const Type *fromTy = FromT.getTypePtr();
6890 // Check whether we've already imported this type.
6891 llvm::DenseMap<const Type *, const Type *>::iterator Pos
6892 = ImportedTypes.find(fromTy);
6893 if (Pos != ImportedTypes.end())
6894 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6897 ASTNodeImporter Importer(*this);
6898 QualType ToT = Importer.Visit(fromTy);
6902 // Record the imported type.
6903 ImportedTypes[fromTy] = ToT.getTypePtr();
6905 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6908 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
6912 // FIXME: For now we just create a "trivial" type source info based
6913 // on the type and a single location. Implement a real version of this.
6914 QualType T = Import(FromTSI->getType());
6918 return ToContext.getTrivialTypeSourceInfo(T,
6919 Import(FromTSI->getTypeLoc().getLocStart()));
6922 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
6923 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6924 if (Pos != ImportedDecls.end()) {
6925 Decl *ToD = Pos->second;
6926 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6933 Decl *ASTImporter::Import(Decl *FromD) {
6937 ASTNodeImporter Importer(*this);
6939 // Check whether we've already imported this declaration.
6940 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6941 if (Pos != ImportedDecls.end()) {
6942 Decl *ToD = Pos->second;
6943 Importer.ImportDefinitionIfNeeded(FromD, ToD);
6948 Decl *ToD = Importer.Visit(FromD);
6952 // Record the imported declaration.
6953 ImportedDecls[FromD] = ToD;
6955 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
6956 // Keep track of anonymous tags that have an associated typedef.
6957 if (FromTag->getTypedefNameForAnonDecl())
6958 AnonTagsWithPendingTypedefs.push_back(FromTag);
6959 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
6960 // When we've finished transforming a typedef, see whether it was the
6961 // typedef for an anonymous tag.
6962 for (SmallVectorImpl<TagDecl *>::iterator
6963 FromTag = AnonTagsWithPendingTypedefs.begin(),
6964 FromTagEnd = AnonTagsWithPendingTypedefs.end();
6965 FromTag != FromTagEnd; ++FromTag) {
6966 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
6967 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
6968 // We found the typedef for an anonymous tag; link them.
6969 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
6970 AnonTagsWithPendingTypedefs.erase(FromTag);
6980 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
6984 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
6988 // When we're using a record/enum/Objective-C class/protocol as a context, we
6989 // need it to have a definition.
6990 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
6991 RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
6992 if (ToRecord->isCompleteDefinition()) {
6994 } else if (FromRecord->isCompleteDefinition()) {
6995 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
6996 ASTNodeImporter::IDK_Basic);
6998 CompleteDecl(ToRecord);
7000 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
7001 EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
7002 if (ToEnum->isCompleteDefinition()) {
7004 } else if (FromEnum->isCompleteDefinition()) {
7005 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
7006 ASTNodeImporter::IDK_Basic);
7008 CompleteDecl(ToEnum);
7010 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
7011 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
7012 if (ToClass->getDefinition()) {
7014 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
7015 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
7016 ASTNodeImporter::IDK_Basic);
7018 CompleteDecl(ToClass);
7020 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
7021 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
7022 if (ToProto->getDefinition()) {
7024 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
7025 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
7026 ASTNodeImporter::IDK_Basic);
7028 CompleteDecl(ToProto);
7035 Expr *ASTImporter::Import(Expr *FromE) {
7039 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
7042 Stmt *ASTImporter::Import(Stmt *FromS) {
7046 // Check whether we've already imported this declaration.
7047 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
7048 if (Pos != ImportedStmts.end())
7052 ASTNodeImporter Importer(*this);
7053 Stmt *ToS = Importer.Visit(FromS);
7057 // Record the imported declaration.
7058 ImportedStmts[FromS] = ToS;
7062 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
7066 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
7068 switch (FromNNS->getKind()) {
7069 case NestedNameSpecifier::Identifier:
7070 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
7071 return NestedNameSpecifier::Create(ToContext, prefix, II);
7075 case NestedNameSpecifier::Namespace:
7076 if (NamespaceDecl *NS =
7077 cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
7078 return NestedNameSpecifier::Create(ToContext, prefix, NS);
7082 case NestedNameSpecifier::NamespaceAlias:
7083 if (NamespaceAliasDecl *NSAD =
7084 cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
7085 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
7089 case NestedNameSpecifier::Global:
7090 return NestedNameSpecifier::GlobalSpecifier(ToContext);
7092 case NestedNameSpecifier::Super:
7093 if (CXXRecordDecl *RD =
7094 cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
7095 return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
7099 case NestedNameSpecifier::TypeSpec:
7100 case NestedNameSpecifier::TypeSpecWithTemplate: {
7101 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
7103 bool bTemplate = FromNNS->getKind() ==
7104 NestedNameSpecifier::TypeSpecWithTemplate;
7105 return NestedNameSpecifier::Create(ToContext, prefix,
7106 bTemplate, T.getTypePtr());
7112 llvm_unreachable("Invalid nested name specifier kind");
7115 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
7116 // Copied from NestedNameSpecifier mostly.
7117 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
7118 NestedNameSpecifierLoc NNS = FromNNS;
7120 // Push each of the nested-name-specifiers's onto a stack for
7121 // serialization in reverse order.
7123 NestedNames.push_back(NNS);
7124 NNS = NNS.getPrefix();
7127 NestedNameSpecifierLocBuilder Builder;
7129 while (!NestedNames.empty()) {
7130 NNS = NestedNames.pop_back_val();
7131 NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
7133 return NestedNameSpecifierLoc();
7135 NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
7137 case NestedNameSpecifier::Identifier:
7138 Builder.Extend(getToContext(),
7139 Spec->getAsIdentifier(),
7140 Import(NNS.getLocalBeginLoc()),
7141 Import(NNS.getLocalEndLoc()));
7144 case NestedNameSpecifier::Namespace:
7145 Builder.Extend(getToContext(),
7146 Spec->getAsNamespace(),
7147 Import(NNS.getLocalBeginLoc()),
7148 Import(NNS.getLocalEndLoc()));
7151 case NestedNameSpecifier::NamespaceAlias:
7152 Builder.Extend(getToContext(),
7153 Spec->getAsNamespaceAlias(),
7154 Import(NNS.getLocalBeginLoc()),
7155 Import(NNS.getLocalEndLoc()));
7158 case NestedNameSpecifier::TypeSpec:
7159 case NestedNameSpecifier::TypeSpecWithTemplate: {
7160 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
7161 QualType(Spec->getAsType(), 0));
7162 Builder.Extend(getToContext(),
7163 Import(NNS.getLocalBeginLoc()),
7165 Import(NNS.getLocalEndLoc()));
7169 case NestedNameSpecifier::Global:
7170 Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
7173 case NestedNameSpecifier::Super: {
7174 SourceRange ToRange = Import(NNS.getSourceRange());
7175 Builder.MakeSuper(getToContext(),
7176 Spec->getAsRecordDecl(),
7183 return Builder.getWithLocInContext(getToContext());
7186 TemplateName ASTImporter::Import(TemplateName From) {
7187 switch (From.getKind()) {
7188 case TemplateName::Template:
7189 if (TemplateDecl *ToTemplate
7190 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7191 return TemplateName(ToTemplate);
7193 return TemplateName();
7195 case TemplateName::OverloadedTemplate: {
7196 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
7197 UnresolvedSet<2> ToTemplates;
7198 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
7199 E = FromStorage->end();
7201 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
7202 ToTemplates.addDecl(To);
7204 return TemplateName();
7206 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
7210 case TemplateName::QualifiedTemplate: {
7211 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
7212 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
7214 return TemplateName();
7216 if (TemplateDecl *ToTemplate
7217 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7218 return ToContext.getQualifiedTemplateName(Qualifier,
7219 QTN->hasTemplateKeyword(),
7222 return TemplateName();
7225 case TemplateName::DependentTemplate: {
7226 DependentTemplateName *DTN = From.getAsDependentTemplateName();
7227 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
7229 return TemplateName();
7231 if (DTN->isIdentifier()) {
7232 return ToContext.getDependentTemplateName(Qualifier,
7233 Import(DTN->getIdentifier()));
7236 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
7239 case TemplateName::SubstTemplateTemplateParm: {
7240 SubstTemplateTemplateParmStorage *subst
7241 = From.getAsSubstTemplateTemplateParm();
7242 TemplateTemplateParmDecl *param
7243 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
7245 return TemplateName();
7247 TemplateName replacement = Import(subst->getReplacement());
7248 if (replacement.isNull()) return TemplateName();
7250 return ToContext.getSubstTemplateTemplateParm(param, replacement);
7253 case TemplateName::SubstTemplateTemplateParmPack: {
7254 SubstTemplateTemplateParmPackStorage *SubstPack
7255 = From.getAsSubstTemplateTemplateParmPack();
7256 TemplateTemplateParmDecl *Param
7257 = cast_or_null<TemplateTemplateParmDecl>(
7258 Import(SubstPack->getParameterPack()));
7260 return TemplateName();
7262 ASTNodeImporter Importer(*this);
7263 TemplateArgument ArgPack
7264 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
7265 if (ArgPack.isNull())
7266 return TemplateName();
7268 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
7272 llvm_unreachable("Invalid template name kind");
7275 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
7276 if (FromLoc.isInvalid())
7277 return SourceLocation();
7279 SourceManager &FromSM = FromContext.getSourceManager();
7281 // For now, map everything down to its file location, so that we
7282 // don't have to import macro expansions.
7283 // FIXME: Import macro expansions!
7284 FromLoc = FromSM.getFileLoc(FromLoc);
7285 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
7286 SourceManager &ToSM = ToContext.getSourceManager();
7287 FileID ToFileID = Import(Decomposed.first);
7288 if (ToFileID.isInvalid())
7289 return SourceLocation();
7290 SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
7291 .getLocWithOffset(Decomposed.second);
7295 SourceRange ASTImporter::Import(SourceRange FromRange) {
7296 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7299 FileID ASTImporter::Import(FileID FromID) {
7300 llvm::DenseMap<FileID, FileID>::iterator Pos
7301 = ImportedFileIDs.find(FromID);
7302 if (Pos != ImportedFileIDs.end())
7305 SourceManager &FromSM = FromContext.getSourceManager();
7306 SourceManager &ToSM = ToContext.getSourceManager();
7307 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
7308 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
7310 // Include location of this file.
7311 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
7313 // Map the FileID for to the "to" source manager.
7315 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
7316 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
7317 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
7319 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
7320 // than mmap the files several times.
7321 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
7324 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
7325 FromSLoc.getFile().getFileCharacteristic());
7327 // FIXME: We want to re-use the existing MemoryBuffer!
7328 const llvm::MemoryBuffer *
7329 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
7330 std::unique_ptr<llvm::MemoryBuffer> ToBuf
7331 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
7332 FromBuf->getBufferIdentifier());
7333 ToID = ToSM.createFileID(std::move(ToBuf),
7334 FromSLoc.getFile().getFileCharacteristic());
7338 ImportedFileIDs[FromID] = ToID;
7342 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
7343 Expr *ToExpr = Import(From->getInit());
7344 if (!ToExpr && From->getInit())
7347 if (From->isBaseInitializer()) {
7348 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7349 if (!ToTInfo && From->getTypeSourceInfo())
7352 return new (ToContext) CXXCtorInitializer(
7353 ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
7354 ToExpr, Import(From->getRParenLoc()),
7355 From->isPackExpansion() ? Import(From->getEllipsisLoc())
7356 : SourceLocation());
7357 } else if (From->isMemberInitializer()) {
7358 FieldDecl *ToField =
7359 llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
7360 if (!ToField && From->getMember())
7363 return new (ToContext) CXXCtorInitializer(
7364 ToContext, ToField, Import(From->getMemberLocation()),
7365 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7366 } else if (From->isIndirectMemberInitializer()) {
7367 IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(
7368 Import(From->getIndirectMember()));
7369 if (!ToIField && From->getIndirectMember())
7372 return new (ToContext) CXXCtorInitializer(
7373 ToContext, ToIField, Import(From->getMemberLocation()),
7374 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7375 } else if (From->isDelegatingInitializer()) {
7376 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7377 if (!ToTInfo && From->getTypeSourceInfo())
7380 return new (ToContext)
7381 CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
7382 ToExpr, Import(From->getRParenLoc()));
7389 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
7390 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
7391 if (Pos != ImportedCXXBaseSpecifiers.end())
7394 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
7395 Import(BaseSpec->getSourceRange()),
7396 BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
7397 BaseSpec->getAccessSpecifierAsWritten(),
7398 Import(BaseSpec->getTypeSourceInfo()),
7399 Import(BaseSpec->getEllipsisLoc()));
7400 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
7404 void ASTImporter::ImportDefinition(Decl *From) {
7405 Decl *To = Import(From);
7409 if (DeclContext *FromDC = cast<DeclContext>(From)) {
7410 ASTNodeImporter Importer(*this);
7412 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
7413 if (!ToRecord->getDefinition()) {
7414 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
7415 ASTNodeImporter::IDK_Everything);
7420 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
7421 if (!ToEnum->getDefinition()) {
7422 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
7423 ASTNodeImporter::IDK_Everything);
7428 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
7429 if (!ToIFace->getDefinition()) {
7430 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
7431 ASTNodeImporter::IDK_Everything);
7436 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
7437 if (!ToProto->getDefinition()) {
7438 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
7439 ASTNodeImporter::IDK_Everything);
7444 Importer.ImportDeclContext(FromDC, true);
7448 DeclarationName ASTImporter::Import(DeclarationName FromName) {
7450 return DeclarationName();
7452 switch (FromName.getNameKind()) {
7453 case DeclarationName::Identifier:
7454 return Import(FromName.getAsIdentifierInfo());
7456 case DeclarationName::ObjCZeroArgSelector:
7457 case DeclarationName::ObjCOneArgSelector:
7458 case DeclarationName::ObjCMultiArgSelector:
7459 return Import(FromName.getObjCSelector());
7461 case DeclarationName::CXXConstructorName: {
7462 QualType T = Import(FromName.getCXXNameType());
7464 return DeclarationName();
7466 return ToContext.DeclarationNames.getCXXConstructorName(
7467 ToContext.getCanonicalType(T));
7470 case DeclarationName::CXXDestructorName: {
7471 QualType T = Import(FromName.getCXXNameType());
7473 return DeclarationName();
7475 return ToContext.DeclarationNames.getCXXDestructorName(
7476 ToContext.getCanonicalType(T));
7479 case DeclarationName::CXXDeductionGuideName: {
7480 TemplateDecl *Template = cast_or_null<TemplateDecl>(
7481 Import(FromName.getCXXDeductionGuideTemplate()));
7483 return DeclarationName();
7484 return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
7487 case DeclarationName::CXXConversionFunctionName: {
7488 QualType T = Import(FromName.getCXXNameType());
7490 return DeclarationName();
7492 return ToContext.DeclarationNames.getCXXConversionFunctionName(
7493 ToContext.getCanonicalType(T));
7496 case DeclarationName::CXXOperatorName:
7497 return ToContext.DeclarationNames.getCXXOperatorName(
7498 FromName.getCXXOverloadedOperator());
7500 case DeclarationName::CXXLiteralOperatorName:
7501 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
7502 Import(FromName.getCXXLiteralIdentifier()));
7504 case DeclarationName::CXXUsingDirective:
7506 return DeclarationName::getUsingDirectiveName();
7509 llvm_unreachable("Invalid DeclarationName Kind!");
7512 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
7516 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
7518 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
7519 ToId->setBuiltinID(FromId->getBuiltinID());
7524 Selector ASTImporter::Import(Selector FromSel) {
7525 if (FromSel.isNull())
7528 SmallVector<IdentifierInfo *, 4> Idents;
7529 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
7530 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
7531 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
7532 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7535 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
7539 unsigned NumDecls) {
7543 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
7544 if (LastDiagFromFrom)
7545 ToContext.getDiagnostics().notePriorDiagnosticFrom(
7546 FromContext.getDiagnostics());
7547 LastDiagFromFrom = false;
7548 return ToContext.getDiagnostics().Report(Loc, DiagID);
7551 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
7552 if (!LastDiagFromFrom)
7553 FromContext.getDiagnostics().notePriorDiagnosticFrom(
7554 ToContext.getDiagnostics());
7555 LastDiagFromFrom = true;
7556 return FromContext.getDiagnostics().Report(Loc, DiagID);
7559 void ASTImporter::CompleteDecl (Decl *D) {
7560 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
7561 if (!ID->getDefinition())
7562 ID->startDefinition();
7564 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
7565 if (!PD->getDefinition())
7566 PD->startDefinition();
7568 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
7569 if (!TD->getDefinition() && !TD->isBeingDefined()) {
7570 TD->startDefinition();
7571 TD->setCompleteDefinition(true);
7575 assert (0 && "CompleteDecl called on a Decl that can't be completed");
7579 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
7580 if (From->hasAttrs()) {
7581 for (Attr *FromAttr : From->getAttrs())
7582 To->addAttr(FromAttr->clone(To->getASTContext()));
7584 if (From->isUsed()) {
7587 if (From->isImplicit()) {
7590 ImportedDecls[From] = To;
7594 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
7596 llvm::DenseMap<const Type *, const Type *>::iterator Pos
7597 = ImportedTypes.find(From.getTypePtr());
7598 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
7601 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
7603 return Ctx.IsStructurallyEquivalent(From, To);