1 //===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the ASTImporter class which imports AST nodes from one
11 // context into another context.
12 //
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"
25 #include <deque>
26
27 namespace clang {
28 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
29 public DeclVisitor<ASTNodeImporter, Decl *>,
30 public StmtVisitor<ASTNodeImporter, Stmt *> {
31 ASTImporter &Importer;
32
33 public:
ASTNodeImporter(ASTImporter & Importer)34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
35
36 using TypeVisitor<ASTNodeImporter, QualType>::Visit;
37 using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
38 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
39
40 // Importing types
41 QualType VisitType(const Type *T);
42 QualType VisitBuiltinType(const BuiltinType *T);
43 QualType VisitComplexType(const ComplexType *T);
44 QualType VisitPointerType(const PointerType *T);
45 QualType VisitBlockPointerType(const BlockPointerType *T);
46 QualType VisitLValueReferenceType(const LValueReferenceType *T);
47 QualType VisitRValueReferenceType(const RValueReferenceType *T);
48 QualType VisitMemberPointerType(const MemberPointerType *T);
49 QualType VisitConstantArrayType(const ConstantArrayType *T);
50 QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
51 QualType VisitVariableArrayType(const VariableArrayType *T);
52 // FIXME: DependentSizedArrayType
53 // FIXME: DependentSizedExtVectorType
54 QualType VisitVectorType(const VectorType *T);
55 QualType VisitExtVectorType(const ExtVectorType *T);
56 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
57 QualType VisitFunctionProtoType(const FunctionProtoType *T);
58 // FIXME: UnresolvedUsingType
59 QualType VisitParenType(const ParenType *T);
60 QualType VisitTypedefType(const TypedefType *T);
61 QualType VisitTypeOfExprType(const TypeOfExprType *T);
62 // FIXME: DependentTypeOfExprType
63 QualType VisitTypeOfType(const TypeOfType *T);
64 QualType VisitDecltypeType(const DecltypeType *T);
65 QualType VisitUnaryTransformType(const UnaryTransformType *T);
66 QualType VisitAutoType(const AutoType *T);
67 // FIXME: DependentDecltypeType
68 QualType VisitRecordType(const RecordType *T);
69 QualType VisitEnumType(const EnumType *T);
70 // FIXME: TemplateTypeParmType
71 // FIXME: SubstTemplateTypeParmType
72 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
73 QualType VisitElaboratedType(const ElaboratedType *T);
74 // FIXME: DependentNameType
75 // FIXME: DependentTemplateSpecializationType
76 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
77 QualType VisitObjCObjectType(const ObjCObjectType *T);
78 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
79
80 // Importing declarations
81 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
82 DeclContext *&LexicalDC, DeclarationName &Name,
83 SourceLocation &Loc);
84 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
85 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
86 DeclarationNameInfo& To);
87 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
88
89 /// \brief What we should import from the definition.
90 enum ImportDefinitionKind {
91 /// \brief Import the default subset of the definition, which might be
92 /// nothing (if minimal import is set) or might be everything (if minimal
93 /// import is not set).
94 IDK_Default,
95 /// \brief Import everything.
96 IDK_Everything,
97 /// \brief Import only the bare bones needed to establish a valid
98 /// DeclContext.
99 IDK_Basic
100 };
101
shouldForceImportDeclContext(ImportDefinitionKind IDK)102 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
103 return IDK == IDK_Everything ||
104 (IDK == IDK_Default && !Importer.isMinimalImport());
105 }
106
107 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
108 ImportDefinitionKind Kind = IDK_Default);
109 bool ImportDefinition(VarDecl *From, VarDecl *To,
110 ImportDefinitionKind Kind = IDK_Default);
111 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
112 ImportDefinitionKind Kind = IDK_Default);
113 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
114 ImportDefinitionKind Kind = IDK_Default);
115 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
116 ImportDefinitionKind Kind = IDK_Default);
117 TemplateParameterList *ImportTemplateParameterList(
118 TemplateParameterList *Params);
119 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
120 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
121 unsigned NumFromArgs,
122 SmallVectorImpl<TemplateArgument> &ToArgs);
123 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
124 bool Complain = true);
125 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
126 bool Complain = true);
127 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
128 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
129 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
130 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
131 Decl *VisitDecl(Decl *D);
132 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
133 Decl *VisitNamespaceDecl(NamespaceDecl *D);
134 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
135 Decl *VisitTypedefDecl(TypedefDecl *D);
136 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
137 Decl *VisitEnumDecl(EnumDecl *D);
138 Decl *VisitRecordDecl(RecordDecl *D);
139 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
140 Decl *VisitFunctionDecl(FunctionDecl *D);
141 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
142 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
143 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
144 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
145 Decl *VisitFieldDecl(FieldDecl *D);
146 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
147 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
148 Decl *VisitVarDecl(VarDecl *D);
149 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
150 Decl *VisitParmVarDecl(ParmVarDecl *D);
151 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
152 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
153 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
154 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
155 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
156 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
157 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
158 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
159 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
160 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
161 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
162 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
163 Decl *VisitClassTemplateSpecializationDecl(
164 ClassTemplateSpecializationDecl *D);
165 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
166 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
167
168 // Importing statements
169 Stmt *VisitStmt(Stmt *S);
170
171 // Importing expressions
172 Expr *VisitExpr(Expr *E);
173 Expr *VisitDeclRefExpr(DeclRefExpr *E);
174 Expr *VisitIntegerLiteral(IntegerLiteral *E);
175 Expr *VisitCharacterLiteral(CharacterLiteral *E);
176 Expr *VisitParenExpr(ParenExpr *E);
177 Expr *VisitUnaryOperator(UnaryOperator *E);
178 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
179 Expr *VisitBinaryOperator(BinaryOperator *E);
180 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
181 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
182 Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
183 };
184 }
185 using namespace clang;
186
187 //----------------------------------------------------------------------------
188 // Structural Equivalence
189 //----------------------------------------------------------------------------
190
191 namespace {
192 struct StructuralEquivalenceContext {
193 /// \brief AST contexts for which we are checking structural equivalence.
194 ASTContext &C1, &C2;
195
196 /// \brief The set of "tentative" equivalences between two canonical
197 /// declarations, mapping from a declaration in the first context to the
198 /// declaration in the second context that we believe to be equivalent.
199 llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
200
201 /// \brief Queue of declarations in the first context whose equivalence
202 /// with a declaration in the second context still needs to be verified.
203 std::deque<Decl *> DeclsToCheck;
204
205 /// \brief Declaration (from, to) pairs that are known not to be equivalent
206 /// (which we have already complained about).
207 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
208
209 /// \brief Whether we're being strict about the spelling of types when
210 /// unifying two types.
211 bool StrictTypeSpelling;
212
213 /// \brief Whether to complain about failures.
214 bool Complain;
215
216 /// \brief \c true if the last diagnostic came from C2.
217 bool LastDiagFromC2;
218
StructuralEquivalenceContext__anon8a4aa3240111::StructuralEquivalenceContext219 StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
220 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
221 bool StrictTypeSpelling = false,
222 bool Complain = true)
223 : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
224 StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
225 LastDiagFromC2(false) {}
226
227 /// \brief Determine whether the two declarations are structurally
228 /// equivalent.
229 bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
230
231 /// \brief Determine whether the two types are structurally equivalent.
232 bool IsStructurallyEquivalent(QualType T1, QualType T2);
233
234 private:
235 /// \brief Finish checking all of the structural equivalences.
236 ///
237 /// \returns true if an error occurred, false otherwise.
238 bool Finish();
239
240 public:
Diag1__anon8a4aa3240111::StructuralEquivalenceContext241 DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
242 assert(Complain && "Not allowed to complain");
243 if (LastDiagFromC2)
244 C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
245 LastDiagFromC2 = false;
246 return C1.getDiagnostics().Report(Loc, DiagID);
247 }
248
Diag2__anon8a4aa3240111::StructuralEquivalenceContext249 DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
250 assert(Complain && "Not allowed to complain");
251 if (!LastDiagFromC2)
252 C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
253 LastDiagFromC2 = true;
254 return C2.getDiagnostics().Report(Loc, DiagID);
255 }
256 };
257 }
258
259 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
260 QualType T1, QualType T2);
261 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
262 Decl *D1, Decl *D2);
263
264 /// \brief Determine structural equivalence of two expressions.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,Expr * E1,Expr * E2)265 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
266 Expr *E1, Expr *E2) {
267 if (!E1 || !E2)
268 return E1 == E2;
269
270 // FIXME: Actually perform a structural comparison!
271 return true;
272 }
273
274 /// \brief Determine whether two identifiers are equivalent.
IsStructurallyEquivalent(const IdentifierInfo * Name1,const IdentifierInfo * Name2)275 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
276 const IdentifierInfo *Name2) {
277 if (!Name1 || !Name2)
278 return Name1 == Name2;
279
280 return Name1->getName() == Name2->getName();
281 }
282
283 /// \brief Determine whether two nested-name-specifiers are equivalent.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,NestedNameSpecifier * NNS1,NestedNameSpecifier * NNS2)284 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
285 NestedNameSpecifier *NNS1,
286 NestedNameSpecifier *NNS2) {
287 // FIXME: Implement!
288 return true;
289 }
290
291 /// \brief Determine whether two template arguments are equivalent.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,const TemplateArgument & Arg1,const TemplateArgument & Arg2)292 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
293 const TemplateArgument &Arg1,
294 const TemplateArgument &Arg2) {
295 if (Arg1.getKind() != Arg2.getKind())
296 return false;
297
298 switch (Arg1.getKind()) {
299 case TemplateArgument::Null:
300 return true;
301
302 case TemplateArgument::Type:
303 return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
304
305 case TemplateArgument::Integral:
306 if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
307 Arg2.getIntegralType()))
308 return false;
309
310 return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
311
312 case TemplateArgument::Declaration:
313 return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
314
315 case TemplateArgument::NullPtr:
316 return true; // FIXME: Is this correct?
317
318 case TemplateArgument::Template:
319 return IsStructurallyEquivalent(Context,
320 Arg1.getAsTemplate(),
321 Arg2.getAsTemplate());
322
323 case TemplateArgument::TemplateExpansion:
324 return IsStructurallyEquivalent(Context,
325 Arg1.getAsTemplateOrTemplatePattern(),
326 Arg2.getAsTemplateOrTemplatePattern());
327
328 case TemplateArgument::Expression:
329 return IsStructurallyEquivalent(Context,
330 Arg1.getAsExpr(), Arg2.getAsExpr());
331
332 case TemplateArgument::Pack:
333 if (Arg1.pack_size() != Arg2.pack_size())
334 return false;
335
336 for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
337 if (!IsStructurallyEquivalent(Context,
338 Arg1.pack_begin()[I],
339 Arg2.pack_begin()[I]))
340 return false;
341
342 return true;
343 }
344
345 llvm_unreachable("Invalid template argument kind");
346 }
347
348 /// \brief Determine structural equivalence for the common part of array
349 /// types.
IsArrayStructurallyEquivalent(StructuralEquivalenceContext & Context,const ArrayType * Array1,const ArrayType * Array2)350 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
351 const ArrayType *Array1,
352 const ArrayType *Array2) {
353 if (!IsStructurallyEquivalent(Context,
354 Array1->getElementType(),
355 Array2->getElementType()))
356 return false;
357 if (Array1->getSizeModifier() != Array2->getSizeModifier())
358 return false;
359 if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
360 return false;
361
362 return true;
363 }
364
365 /// \brief Determine structural equivalence of two types.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,QualType T1,QualType T2)366 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
367 QualType T1, QualType T2) {
368 if (T1.isNull() || T2.isNull())
369 return T1.isNull() && T2.isNull();
370
371 if (!Context.StrictTypeSpelling) {
372 // We aren't being strict about token-to-token equivalence of types,
373 // so map down to the canonical type.
374 T1 = Context.C1.getCanonicalType(T1);
375 T2 = Context.C2.getCanonicalType(T2);
376 }
377
378 if (T1.getQualifiers() != T2.getQualifiers())
379 return false;
380
381 Type::TypeClass TC = T1->getTypeClass();
382
383 if (T1->getTypeClass() != T2->getTypeClass()) {
384 // Compare function types with prototypes vs. without prototypes as if
385 // both did not have prototypes.
386 if (T1->getTypeClass() == Type::FunctionProto &&
387 T2->getTypeClass() == Type::FunctionNoProto)
388 TC = Type::FunctionNoProto;
389 else if (T1->getTypeClass() == Type::FunctionNoProto &&
390 T2->getTypeClass() == Type::FunctionProto)
391 TC = Type::FunctionNoProto;
392 else
393 return false;
394 }
395
396 switch (TC) {
397 case Type::Builtin:
398 // FIXME: Deal with Char_S/Char_U.
399 if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
400 return false;
401 break;
402
403 case Type::Complex:
404 if (!IsStructurallyEquivalent(Context,
405 cast<ComplexType>(T1)->getElementType(),
406 cast<ComplexType>(T2)->getElementType()))
407 return false;
408 break;
409
410 case Type::Adjusted:
411 case Type::Decayed:
412 if (!IsStructurallyEquivalent(Context,
413 cast<AdjustedType>(T1)->getOriginalType(),
414 cast<AdjustedType>(T2)->getOriginalType()))
415 return false;
416 break;
417
418 case Type::Pointer:
419 if (!IsStructurallyEquivalent(Context,
420 cast<PointerType>(T1)->getPointeeType(),
421 cast<PointerType>(T2)->getPointeeType()))
422 return false;
423 break;
424
425 case Type::BlockPointer:
426 if (!IsStructurallyEquivalent(Context,
427 cast<BlockPointerType>(T1)->getPointeeType(),
428 cast<BlockPointerType>(T2)->getPointeeType()))
429 return false;
430 break;
431
432 case Type::LValueReference:
433 case Type::RValueReference: {
434 const ReferenceType *Ref1 = cast<ReferenceType>(T1);
435 const ReferenceType *Ref2 = cast<ReferenceType>(T2);
436 if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
437 return false;
438 if (Ref1->isInnerRef() != Ref2->isInnerRef())
439 return false;
440 if (!IsStructurallyEquivalent(Context,
441 Ref1->getPointeeTypeAsWritten(),
442 Ref2->getPointeeTypeAsWritten()))
443 return false;
444 break;
445 }
446
447 case Type::MemberPointer: {
448 const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
449 const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
450 if (!IsStructurallyEquivalent(Context,
451 MemPtr1->getPointeeType(),
452 MemPtr2->getPointeeType()))
453 return false;
454 if (!IsStructurallyEquivalent(Context,
455 QualType(MemPtr1->getClass(), 0),
456 QualType(MemPtr2->getClass(), 0)))
457 return false;
458 break;
459 }
460
461 case Type::ConstantArray: {
462 const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
463 const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
464 if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
465 return false;
466
467 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
468 return false;
469 break;
470 }
471
472 case Type::IncompleteArray:
473 if (!IsArrayStructurallyEquivalent(Context,
474 cast<ArrayType>(T1),
475 cast<ArrayType>(T2)))
476 return false;
477 break;
478
479 case Type::VariableArray: {
480 const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
481 const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
482 if (!IsStructurallyEquivalent(Context,
483 Array1->getSizeExpr(), Array2->getSizeExpr()))
484 return false;
485
486 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
487 return false;
488
489 break;
490 }
491
492 case Type::DependentSizedArray: {
493 const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
494 const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
495 if (!IsStructurallyEquivalent(Context,
496 Array1->getSizeExpr(), Array2->getSizeExpr()))
497 return false;
498
499 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
500 return false;
501
502 break;
503 }
504
505 case Type::DependentSizedExtVector: {
506 const DependentSizedExtVectorType *Vec1
507 = cast<DependentSizedExtVectorType>(T1);
508 const DependentSizedExtVectorType *Vec2
509 = cast<DependentSizedExtVectorType>(T2);
510 if (!IsStructurallyEquivalent(Context,
511 Vec1->getSizeExpr(), Vec2->getSizeExpr()))
512 return false;
513 if (!IsStructurallyEquivalent(Context,
514 Vec1->getElementType(),
515 Vec2->getElementType()))
516 return false;
517 break;
518 }
519
520 case Type::Vector:
521 case Type::ExtVector: {
522 const VectorType *Vec1 = cast<VectorType>(T1);
523 const VectorType *Vec2 = cast<VectorType>(T2);
524 if (!IsStructurallyEquivalent(Context,
525 Vec1->getElementType(),
526 Vec2->getElementType()))
527 return false;
528 if (Vec1->getNumElements() != Vec2->getNumElements())
529 return false;
530 if (Vec1->getVectorKind() != Vec2->getVectorKind())
531 return false;
532 break;
533 }
534
535 case Type::FunctionProto: {
536 const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
537 const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
538 if (Proto1->getNumParams() != Proto2->getNumParams())
539 return false;
540 for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
541 if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
542 Proto2->getParamType(I)))
543 return false;
544 }
545 if (Proto1->isVariadic() != Proto2->isVariadic())
546 return false;
547 if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
548 return false;
549 if (Proto1->getExceptionSpecType() == EST_Dynamic) {
550 if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
551 return false;
552 for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
553 if (!IsStructurallyEquivalent(Context,
554 Proto1->getExceptionType(I),
555 Proto2->getExceptionType(I)))
556 return false;
557 }
558 } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
559 if (!IsStructurallyEquivalent(Context,
560 Proto1->getNoexceptExpr(),
561 Proto2->getNoexceptExpr()))
562 return false;
563 }
564 if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
565 return false;
566
567 // Fall through to check the bits common with FunctionNoProtoType.
568 }
569
570 case Type::FunctionNoProto: {
571 const FunctionType *Function1 = cast<FunctionType>(T1);
572 const FunctionType *Function2 = cast<FunctionType>(T2);
573 if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
574 Function2->getReturnType()))
575 return false;
576 if (Function1->getExtInfo() != Function2->getExtInfo())
577 return false;
578 break;
579 }
580
581 case Type::UnresolvedUsing:
582 if (!IsStructurallyEquivalent(Context,
583 cast<UnresolvedUsingType>(T1)->getDecl(),
584 cast<UnresolvedUsingType>(T2)->getDecl()))
585 return false;
586
587 break;
588
589 case Type::Attributed:
590 if (!IsStructurallyEquivalent(Context,
591 cast<AttributedType>(T1)->getModifiedType(),
592 cast<AttributedType>(T2)->getModifiedType()))
593 return false;
594 if (!IsStructurallyEquivalent(Context,
595 cast<AttributedType>(T1)->getEquivalentType(),
596 cast<AttributedType>(T2)->getEquivalentType()))
597 return false;
598 break;
599
600 case Type::Paren:
601 if (!IsStructurallyEquivalent(Context,
602 cast<ParenType>(T1)->getInnerType(),
603 cast<ParenType>(T2)->getInnerType()))
604 return false;
605 break;
606
607 case Type::Typedef:
608 if (!IsStructurallyEquivalent(Context,
609 cast<TypedefType>(T1)->getDecl(),
610 cast<TypedefType>(T2)->getDecl()))
611 return false;
612 break;
613
614 case Type::TypeOfExpr:
615 if (!IsStructurallyEquivalent(Context,
616 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
617 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
618 return false;
619 break;
620
621 case Type::TypeOf:
622 if (!IsStructurallyEquivalent(Context,
623 cast<TypeOfType>(T1)->getUnderlyingType(),
624 cast<TypeOfType>(T2)->getUnderlyingType()))
625 return false;
626 break;
627
628 case Type::UnaryTransform:
629 if (!IsStructurallyEquivalent(Context,
630 cast<UnaryTransformType>(T1)->getUnderlyingType(),
631 cast<UnaryTransformType>(T1)->getUnderlyingType()))
632 return false;
633 break;
634
635 case Type::Decltype:
636 if (!IsStructurallyEquivalent(Context,
637 cast<DecltypeType>(T1)->getUnderlyingExpr(),
638 cast<DecltypeType>(T2)->getUnderlyingExpr()))
639 return false;
640 break;
641
642 case Type::Auto:
643 if (!IsStructurallyEquivalent(Context,
644 cast<AutoType>(T1)->getDeducedType(),
645 cast<AutoType>(T2)->getDeducedType()))
646 return false;
647 break;
648
649 case Type::Record:
650 case Type::Enum:
651 if (!IsStructurallyEquivalent(Context,
652 cast<TagType>(T1)->getDecl(),
653 cast<TagType>(T2)->getDecl()))
654 return false;
655 break;
656
657 case Type::TemplateTypeParm: {
658 const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
659 const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
660 if (Parm1->getDepth() != Parm2->getDepth())
661 return false;
662 if (Parm1->getIndex() != Parm2->getIndex())
663 return false;
664 if (Parm1->isParameterPack() != Parm2->isParameterPack())
665 return false;
666
667 // Names of template type parameters are never significant.
668 break;
669 }
670
671 case Type::SubstTemplateTypeParm: {
672 const SubstTemplateTypeParmType *Subst1
673 = cast<SubstTemplateTypeParmType>(T1);
674 const SubstTemplateTypeParmType *Subst2
675 = cast<SubstTemplateTypeParmType>(T2);
676 if (!IsStructurallyEquivalent(Context,
677 QualType(Subst1->getReplacedParameter(), 0),
678 QualType(Subst2->getReplacedParameter(), 0)))
679 return false;
680 if (!IsStructurallyEquivalent(Context,
681 Subst1->getReplacementType(),
682 Subst2->getReplacementType()))
683 return false;
684 break;
685 }
686
687 case Type::SubstTemplateTypeParmPack: {
688 const SubstTemplateTypeParmPackType *Subst1
689 = cast<SubstTemplateTypeParmPackType>(T1);
690 const SubstTemplateTypeParmPackType *Subst2
691 = cast<SubstTemplateTypeParmPackType>(T2);
692 if (!IsStructurallyEquivalent(Context,
693 QualType(Subst1->getReplacedParameter(), 0),
694 QualType(Subst2->getReplacedParameter(), 0)))
695 return false;
696 if (!IsStructurallyEquivalent(Context,
697 Subst1->getArgumentPack(),
698 Subst2->getArgumentPack()))
699 return false;
700 break;
701 }
702 case Type::TemplateSpecialization: {
703 const TemplateSpecializationType *Spec1
704 = cast<TemplateSpecializationType>(T1);
705 const TemplateSpecializationType *Spec2
706 = cast<TemplateSpecializationType>(T2);
707 if (!IsStructurallyEquivalent(Context,
708 Spec1->getTemplateName(),
709 Spec2->getTemplateName()))
710 return false;
711 if (Spec1->getNumArgs() != Spec2->getNumArgs())
712 return false;
713 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
714 if (!IsStructurallyEquivalent(Context,
715 Spec1->getArg(I), Spec2->getArg(I)))
716 return false;
717 }
718 break;
719 }
720
721 case Type::Elaborated: {
722 const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
723 const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
724 // CHECKME: what if a keyword is ETK_None or ETK_typename ?
725 if (Elab1->getKeyword() != Elab2->getKeyword())
726 return false;
727 if (!IsStructurallyEquivalent(Context,
728 Elab1->getQualifier(),
729 Elab2->getQualifier()))
730 return false;
731 if (!IsStructurallyEquivalent(Context,
732 Elab1->getNamedType(),
733 Elab2->getNamedType()))
734 return false;
735 break;
736 }
737
738 case Type::InjectedClassName: {
739 const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
740 const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
741 if (!IsStructurallyEquivalent(Context,
742 Inj1->getInjectedSpecializationType(),
743 Inj2->getInjectedSpecializationType()))
744 return false;
745 break;
746 }
747
748 case Type::DependentName: {
749 const DependentNameType *Typename1 = cast<DependentNameType>(T1);
750 const DependentNameType *Typename2 = cast<DependentNameType>(T2);
751 if (!IsStructurallyEquivalent(Context,
752 Typename1->getQualifier(),
753 Typename2->getQualifier()))
754 return false;
755 if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
756 Typename2->getIdentifier()))
757 return false;
758
759 break;
760 }
761
762 case Type::DependentTemplateSpecialization: {
763 const DependentTemplateSpecializationType *Spec1 =
764 cast<DependentTemplateSpecializationType>(T1);
765 const DependentTemplateSpecializationType *Spec2 =
766 cast<DependentTemplateSpecializationType>(T2);
767 if (!IsStructurallyEquivalent(Context,
768 Spec1->getQualifier(),
769 Spec2->getQualifier()))
770 return false;
771 if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
772 Spec2->getIdentifier()))
773 return false;
774 if (Spec1->getNumArgs() != Spec2->getNumArgs())
775 return false;
776 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
777 if (!IsStructurallyEquivalent(Context,
778 Spec1->getArg(I), Spec2->getArg(I)))
779 return false;
780 }
781 break;
782 }
783
784 case Type::PackExpansion:
785 if (!IsStructurallyEquivalent(Context,
786 cast<PackExpansionType>(T1)->getPattern(),
787 cast<PackExpansionType>(T2)->getPattern()))
788 return false;
789 break;
790
791 case Type::ObjCInterface: {
792 const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
793 const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
794 if (!IsStructurallyEquivalent(Context,
795 Iface1->getDecl(), Iface2->getDecl()))
796 return false;
797 break;
798 }
799
800 case Type::ObjCObject: {
801 const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
802 const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
803 if (!IsStructurallyEquivalent(Context,
804 Obj1->getBaseType(),
805 Obj2->getBaseType()))
806 return false;
807 if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
808 return false;
809 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
810 if (!IsStructurallyEquivalent(Context,
811 Obj1->getProtocol(I),
812 Obj2->getProtocol(I)))
813 return false;
814 }
815 break;
816 }
817
818 case Type::ObjCObjectPointer: {
819 const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
820 const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
821 if (!IsStructurallyEquivalent(Context,
822 Ptr1->getPointeeType(),
823 Ptr2->getPointeeType()))
824 return false;
825 break;
826 }
827
828 case Type::Atomic: {
829 if (!IsStructurallyEquivalent(Context,
830 cast<AtomicType>(T1)->getValueType(),
831 cast<AtomicType>(T2)->getValueType()))
832 return false;
833 break;
834 }
835
836 } // end switch
837
838 return true;
839 }
840
841 /// \brief Determine structural equivalence of two fields.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,FieldDecl * Field1,FieldDecl * Field2)842 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
843 FieldDecl *Field1, FieldDecl *Field2) {
844 RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
845
846 // For anonymous structs/unions, match up the anonymous struct/union type
847 // declarations directly, so that we don't go off searching for anonymous
848 // types
849 if (Field1->isAnonymousStructOrUnion() &&
850 Field2->isAnonymousStructOrUnion()) {
851 RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
852 RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
853 return IsStructurallyEquivalent(Context, D1, D2);
854 }
855
856 // Check for equivalent field names.
857 IdentifierInfo *Name1 = Field1->getIdentifier();
858 IdentifierInfo *Name2 = Field2->getIdentifier();
859 if (!::IsStructurallyEquivalent(Name1, Name2))
860 return false;
861
862 if (!IsStructurallyEquivalent(Context,
863 Field1->getType(), Field2->getType())) {
864 if (Context.Complain) {
865 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
866 << Context.C2.getTypeDeclType(Owner2);
867 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
868 << Field2->getDeclName() << Field2->getType();
869 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
870 << Field1->getDeclName() << Field1->getType();
871 }
872 return false;
873 }
874
875 if (Field1->isBitField() != Field2->isBitField()) {
876 if (Context.Complain) {
877 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
878 << Context.C2.getTypeDeclType(Owner2);
879 if (Field1->isBitField()) {
880 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
881 << Field1->getDeclName() << Field1->getType()
882 << Field1->getBitWidthValue(Context.C1);
883 Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
884 << Field2->getDeclName();
885 } else {
886 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
887 << Field2->getDeclName() << Field2->getType()
888 << Field2->getBitWidthValue(Context.C2);
889 Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
890 << Field1->getDeclName();
891 }
892 }
893 return false;
894 }
895
896 if (Field1->isBitField()) {
897 // Make sure that the bit-fields are the same length.
898 unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
899 unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
900
901 if (Bits1 != Bits2) {
902 if (Context.Complain) {
903 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
904 << Context.C2.getTypeDeclType(Owner2);
905 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
906 << Field2->getDeclName() << Field2->getType() << Bits2;
907 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
908 << Field1->getDeclName() << Field1->getType() << Bits1;
909 }
910 return false;
911 }
912 }
913
914 return true;
915 }
916
917 /// \brief Find the index of the given anonymous struct/union within its
918 /// context.
919 ///
920 /// \returns Returns the index of this anonymous struct/union in its context,
921 /// including the next assigned index (if none of them match). Returns an
922 /// empty option if the context is not a record, i.e.. if the anonymous
923 /// struct/union is at namespace or block scope.
findAnonymousStructOrUnionIndex(RecordDecl * Anon)924 static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) {
925 ASTContext &Context = Anon->getASTContext();
926 QualType AnonTy = Context.getRecordType(Anon);
927
928 RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
929 if (!Owner)
930 return None;
931
932 unsigned Index = 0;
933 for (const auto *D : Owner->noload_decls()) {
934 const auto *F = dyn_cast<FieldDecl>(D);
935 if (!F || !F->isAnonymousStructOrUnion())
936 continue;
937
938 if (Context.hasSameType(F->getType(), AnonTy))
939 break;
940
941 ++Index;
942 }
943
944 return Index;
945 }
946
947 /// \brief Determine structural equivalence of two records.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,RecordDecl * D1,RecordDecl * D2)948 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
949 RecordDecl *D1, RecordDecl *D2) {
950 if (D1->isUnion() != D2->isUnion()) {
951 if (Context.Complain) {
952 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
953 << Context.C2.getTypeDeclType(D2);
954 Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
955 << D1->getDeclName() << (unsigned)D1->getTagKind();
956 }
957 return false;
958 }
959
960 if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
961 // If both anonymous structs/unions are in a record context, make sure
962 // they occur in the same location in the context records.
963 if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) {
964 if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) {
965 if (*Index1 != *Index2)
966 return false;
967 }
968 }
969 }
970
971 // If both declarations are class template specializations, we know
972 // the ODR applies, so check the template and template arguments.
973 ClassTemplateSpecializationDecl *Spec1
974 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
975 ClassTemplateSpecializationDecl *Spec2
976 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
977 if (Spec1 && Spec2) {
978 // Check that the specialized templates are the same.
979 if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
980 Spec2->getSpecializedTemplate()))
981 return false;
982
983 // Check that the template arguments are the same.
984 if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
985 return false;
986
987 for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
988 if (!IsStructurallyEquivalent(Context,
989 Spec1->getTemplateArgs().get(I),
990 Spec2->getTemplateArgs().get(I)))
991 return false;
992 }
993 // If one is a class template specialization and the other is not, these
994 // structures are different.
995 else if (Spec1 || Spec2)
996 return false;
997
998 // Compare the definitions of these two records. If either or both are
999 // incomplete, we assume that they are equivalent.
1000 D1 = D1->getDefinition();
1001 D2 = D2->getDefinition();
1002 if (!D1 || !D2)
1003 return true;
1004
1005 if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1006 if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1007 if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1008 if (Context.Complain) {
1009 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1010 << Context.C2.getTypeDeclType(D2);
1011 Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1012 << D2CXX->getNumBases();
1013 Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1014 << D1CXX->getNumBases();
1015 }
1016 return false;
1017 }
1018
1019 // Check the base classes.
1020 for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1021 BaseEnd1 = D1CXX->bases_end(),
1022 Base2 = D2CXX->bases_begin();
1023 Base1 != BaseEnd1;
1024 ++Base1, ++Base2) {
1025 if (!IsStructurallyEquivalent(Context,
1026 Base1->getType(), Base2->getType())) {
1027 if (Context.Complain) {
1028 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1029 << Context.C2.getTypeDeclType(D2);
1030 Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1031 << Base2->getType()
1032 << Base2->getSourceRange();
1033 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1034 << Base1->getType()
1035 << Base1->getSourceRange();
1036 }
1037 return false;
1038 }
1039
1040 // Check virtual vs. non-virtual inheritance mismatch.
1041 if (Base1->isVirtual() != Base2->isVirtual()) {
1042 if (Context.Complain) {
1043 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1044 << Context.C2.getTypeDeclType(D2);
1045 Context.Diag2(Base2->getLocStart(),
1046 diag::note_odr_virtual_base)
1047 << Base2->isVirtual() << Base2->getSourceRange();
1048 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1049 << Base1->isVirtual()
1050 << Base1->getSourceRange();
1051 }
1052 return false;
1053 }
1054 }
1055 } else if (D1CXX->getNumBases() > 0) {
1056 if (Context.Complain) {
1057 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1058 << Context.C2.getTypeDeclType(D2);
1059 const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1060 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1061 << Base1->getType()
1062 << Base1->getSourceRange();
1063 Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1064 }
1065 return false;
1066 }
1067 }
1068
1069 // Check the fields for consistency.
1070 RecordDecl::field_iterator Field2 = D2->field_begin(),
1071 Field2End = D2->field_end();
1072 for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1073 Field1End = D1->field_end();
1074 Field1 != Field1End;
1075 ++Field1, ++Field2) {
1076 if (Field2 == Field2End) {
1077 if (Context.Complain) {
1078 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1079 << Context.C2.getTypeDeclType(D2);
1080 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1081 << Field1->getDeclName() << Field1->getType();
1082 Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1083 }
1084 return false;
1085 }
1086
1087 if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1088 return false;
1089 }
1090
1091 if (Field2 != Field2End) {
1092 if (Context.Complain) {
1093 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1094 << Context.C2.getTypeDeclType(D2);
1095 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1096 << Field2->getDeclName() << Field2->getType();
1097 Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1098 }
1099 return false;
1100 }
1101
1102 return true;
1103 }
1104
1105 /// \brief Determine structural equivalence of two enums.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,EnumDecl * D1,EnumDecl * D2)1106 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1107 EnumDecl *D1, EnumDecl *D2) {
1108 EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1109 EC2End = D2->enumerator_end();
1110 for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1111 EC1End = D1->enumerator_end();
1112 EC1 != EC1End; ++EC1, ++EC2) {
1113 if (EC2 == EC2End) {
1114 if (Context.Complain) {
1115 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1116 << Context.C2.getTypeDeclType(D2);
1117 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1118 << EC1->getDeclName()
1119 << EC1->getInitVal().toString(10);
1120 Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1121 }
1122 return false;
1123 }
1124
1125 llvm::APSInt Val1 = EC1->getInitVal();
1126 llvm::APSInt Val2 = EC2->getInitVal();
1127 if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1128 !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1129 if (Context.Complain) {
1130 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1131 << Context.C2.getTypeDeclType(D2);
1132 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1133 << EC2->getDeclName()
1134 << EC2->getInitVal().toString(10);
1135 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1136 << EC1->getDeclName()
1137 << EC1->getInitVal().toString(10);
1138 }
1139 return false;
1140 }
1141 }
1142
1143 if (EC2 != EC2End) {
1144 if (Context.Complain) {
1145 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1146 << Context.C2.getTypeDeclType(D2);
1147 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1148 << EC2->getDeclName()
1149 << EC2->getInitVal().toString(10);
1150 Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1151 }
1152 return false;
1153 }
1154
1155 return true;
1156 }
1157
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,TemplateParameterList * Params1,TemplateParameterList * Params2)1158 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1159 TemplateParameterList *Params1,
1160 TemplateParameterList *Params2) {
1161 if (Params1->size() != Params2->size()) {
1162 if (Context.Complain) {
1163 Context.Diag2(Params2->getTemplateLoc(),
1164 diag::err_odr_different_num_template_parameters)
1165 << Params1->size() << Params2->size();
1166 Context.Diag1(Params1->getTemplateLoc(),
1167 diag::note_odr_template_parameter_list);
1168 }
1169 return false;
1170 }
1171
1172 for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1173 if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1174 if (Context.Complain) {
1175 Context.Diag2(Params2->getParam(I)->getLocation(),
1176 diag::err_odr_different_template_parameter_kind);
1177 Context.Diag1(Params1->getParam(I)->getLocation(),
1178 diag::note_odr_template_parameter_here);
1179 }
1180 return false;
1181 }
1182
1183 if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1184 Params2->getParam(I))) {
1185
1186 return false;
1187 }
1188 }
1189
1190 return true;
1191 }
1192
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,TemplateTypeParmDecl * D1,TemplateTypeParmDecl * D2)1193 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1194 TemplateTypeParmDecl *D1,
1195 TemplateTypeParmDecl *D2) {
1196 if (D1->isParameterPack() != D2->isParameterPack()) {
1197 if (Context.Complain) {
1198 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1199 << D2->isParameterPack();
1200 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1201 << D1->isParameterPack();
1202 }
1203 return false;
1204 }
1205
1206 return true;
1207 }
1208
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,NonTypeTemplateParmDecl * D1,NonTypeTemplateParmDecl * D2)1209 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1210 NonTypeTemplateParmDecl *D1,
1211 NonTypeTemplateParmDecl *D2) {
1212 if (D1->isParameterPack() != D2->isParameterPack()) {
1213 if (Context.Complain) {
1214 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1215 << D2->isParameterPack();
1216 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1217 << D1->isParameterPack();
1218 }
1219 return false;
1220 }
1221
1222 // Check types.
1223 if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1224 if (Context.Complain) {
1225 Context.Diag2(D2->getLocation(),
1226 diag::err_odr_non_type_parameter_type_inconsistent)
1227 << D2->getType() << D1->getType();
1228 Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1229 << D1->getType();
1230 }
1231 return false;
1232 }
1233
1234 return true;
1235 }
1236
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,TemplateTemplateParmDecl * D1,TemplateTemplateParmDecl * D2)1237 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1238 TemplateTemplateParmDecl *D1,
1239 TemplateTemplateParmDecl *D2) {
1240 if (D1->isParameterPack() != D2->isParameterPack()) {
1241 if (Context.Complain) {
1242 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1243 << D2->isParameterPack();
1244 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1245 << D1->isParameterPack();
1246 }
1247 return false;
1248 }
1249
1250 // Check template parameter lists.
1251 return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1252 D2->getTemplateParameters());
1253 }
1254
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,ClassTemplateDecl * D1,ClassTemplateDecl * D2)1255 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1256 ClassTemplateDecl *D1,
1257 ClassTemplateDecl *D2) {
1258 // Check template parameters.
1259 if (!IsStructurallyEquivalent(Context,
1260 D1->getTemplateParameters(),
1261 D2->getTemplateParameters()))
1262 return false;
1263
1264 // Check the templated declaration.
1265 return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1266 D2->getTemplatedDecl());
1267 }
1268
1269 /// \brief Determine structural equivalence of two declarations.
IsStructurallyEquivalent(StructuralEquivalenceContext & Context,Decl * D1,Decl * D2)1270 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1271 Decl *D1, Decl *D2) {
1272 // FIXME: Check for known structural equivalences via a callback of some sort.
1273
1274 // Check whether we already know that these two declarations are not
1275 // structurally equivalent.
1276 if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1277 D2->getCanonicalDecl())))
1278 return false;
1279
1280 // Determine whether we've already produced a tentative equivalence for D1.
1281 Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1282 if (EquivToD1)
1283 return EquivToD1 == D2->getCanonicalDecl();
1284
1285 // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1286 EquivToD1 = D2->getCanonicalDecl();
1287 Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1288 return true;
1289 }
1290
IsStructurallyEquivalent(Decl * D1,Decl * D2)1291 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1292 Decl *D2) {
1293 if (!::IsStructurallyEquivalent(*this, D1, D2))
1294 return false;
1295
1296 return !Finish();
1297 }
1298
IsStructurallyEquivalent(QualType T1,QualType T2)1299 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1300 QualType T2) {
1301 if (!::IsStructurallyEquivalent(*this, T1, T2))
1302 return false;
1303
1304 return !Finish();
1305 }
1306
Finish()1307 bool StructuralEquivalenceContext::Finish() {
1308 while (!DeclsToCheck.empty()) {
1309 // Check the next declaration.
1310 Decl *D1 = DeclsToCheck.front();
1311 DeclsToCheck.pop_front();
1312
1313 Decl *D2 = TentativeEquivalences[D1];
1314 assert(D2 && "Unrecorded tentative equivalence?");
1315
1316 bool Equivalent = true;
1317
1318 // FIXME: Switch on all declaration kinds. For now, we're just going to
1319 // check the obvious ones.
1320 if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1321 if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1322 // Check for equivalent structure names.
1323 IdentifierInfo *Name1 = Record1->getIdentifier();
1324 if (!Name1 && Record1->getTypedefNameForAnonDecl())
1325 Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1326 IdentifierInfo *Name2 = Record2->getIdentifier();
1327 if (!Name2 && Record2->getTypedefNameForAnonDecl())
1328 Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1329 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1330 !::IsStructurallyEquivalent(*this, Record1, Record2))
1331 Equivalent = false;
1332 } else {
1333 // Record/non-record mismatch.
1334 Equivalent = false;
1335 }
1336 } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1337 if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1338 // Check for equivalent enum names.
1339 IdentifierInfo *Name1 = Enum1->getIdentifier();
1340 if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1341 Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1342 IdentifierInfo *Name2 = Enum2->getIdentifier();
1343 if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1344 Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1345 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1346 !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1347 Equivalent = false;
1348 } else {
1349 // Enum/non-enum mismatch
1350 Equivalent = false;
1351 }
1352 } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1353 if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1354 if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1355 Typedef2->getIdentifier()) ||
1356 !::IsStructurallyEquivalent(*this,
1357 Typedef1->getUnderlyingType(),
1358 Typedef2->getUnderlyingType()))
1359 Equivalent = false;
1360 } else {
1361 // Typedef/non-typedef mismatch.
1362 Equivalent = false;
1363 }
1364 } else if (ClassTemplateDecl *ClassTemplate1
1365 = dyn_cast<ClassTemplateDecl>(D1)) {
1366 if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1367 if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1368 ClassTemplate2->getIdentifier()) ||
1369 !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1370 Equivalent = false;
1371 } else {
1372 // Class template/non-class-template mismatch.
1373 Equivalent = false;
1374 }
1375 } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1376 if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1377 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1378 Equivalent = false;
1379 } else {
1380 // Kind mismatch.
1381 Equivalent = false;
1382 }
1383 } else if (NonTypeTemplateParmDecl *NTTP1
1384 = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1385 if (NonTypeTemplateParmDecl *NTTP2
1386 = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1387 if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1388 Equivalent = false;
1389 } else {
1390 // Kind mismatch.
1391 Equivalent = false;
1392 }
1393 } else if (TemplateTemplateParmDecl *TTP1
1394 = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1395 if (TemplateTemplateParmDecl *TTP2
1396 = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1397 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1398 Equivalent = false;
1399 } else {
1400 // Kind mismatch.
1401 Equivalent = false;
1402 }
1403 }
1404
1405 if (!Equivalent) {
1406 // Note that these two declarations are not equivalent (and we already
1407 // know about it).
1408 NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1409 D2->getCanonicalDecl()));
1410 return true;
1411 }
1412 // FIXME: Check other declaration kinds!
1413 }
1414
1415 return false;
1416 }
1417
1418 //----------------------------------------------------------------------------
1419 // Import Types
1420 //----------------------------------------------------------------------------
1421
VisitType(const Type * T)1422 QualType ASTNodeImporter::VisitType(const Type *T) {
1423 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1424 << T->getTypeClassName();
1425 return QualType();
1426 }
1427
VisitBuiltinType(const BuiltinType * T)1428 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1429 switch (T->getKind()) {
1430 #define SHARED_SINGLETON_TYPE(Expansion)
1431 #define BUILTIN_TYPE(Id, SingletonId) \
1432 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1433 #include "clang/AST/BuiltinTypes.def"
1434
1435 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1436 // context supports C++.
1437
1438 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1439 // context supports ObjC.
1440
1441 case BuiltinType::Char_U:
1442 // The context we're importing from has an unsigned 'char'. If we're
1443 // importing into a context with a signed 'char', translate to
1444 // 'unsigned char' instead.
1445 if (Importer.getToContext().getLangOpts().CharIsSigned)
1446 return Importer.getToContext().UnsignedCharTy;
1447
1448 return Importer.getToContext().CharTy;
1449
1450 case BuiltinType::Char_S:
1451 // The context we're importing from has an unsigned 'char'. If we're
1452 // importing into a context with a signed 'char', translate to
1453 // 'unsigned char' instead.
1454 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1455 return Importer.getToContext().SignedCharTy;
1456
1457 return Importer.getToContext().CharTy;
1458
1459 case BuiltinType::WChar_S:
1460 case BuiltinType::WChar_U:
1461 // FIXME: If not in C++, shall we translate to the C equivalent of
1462 // wchar_t?
1463 return Importer.getToContext().WCharTy;
1464 }
1465
1466 llvm_unreachable("Invalid BuiltinType Kind!");
1467 }
1468
VisitComplexType(const ComplexType * T)1469 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1470 QualType ToElementType = Importer.Import(T->getElementType());
1471 if (ToElementType.isNull())
1472 return QualType();
1473
1474 return Importer.getToContext().getComplexType(ToElementType);
1475 }
1476
VisitPointerType(const PointerType * T)1477 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1478 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1479 if (ToPointeeType.isNull())
1480 return QualType();
1481
1482 return Importer.getToContext().getPointerType(ToPointeeType);
1483 }
1484
VisitBlockPointerType(const BlockPointerType * T)1485 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1486 // FIXME: Check for blocks support in "to" context.
1487 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1488 if (ToPointeeType.isNull())
1489 return QualType();
1490
1491 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1492 }
1493
1494 QualType
VisitLValueReferenceType(const LValueReferenceType * T)1495 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1496 // FIXME: Check for C++ support in "to" context.
1497 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1498 if (ToPointeeType.isNull())
1499 return QualType();
1500
1501 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1502 }
1503
1504 QualType
VisitRValueReferenceType(const RValueReferenceType * T)1505 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1506 // FIXME: Check for C++0x support in "to" context.
1507 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1508 if (ToPointeeType.isNull())
1509 return QualType();
1510
1511 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1512 }
1513
VisitMemberPointerType(const MemberPointerType * T)1514 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1515 // FIXME: Check for C++ support in "to" context.
1516 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1517 if (ToPointeeType.isNull())
1518 return QualType();
1519
1520 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1521 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1522 ClassType.getTypePtr());
1523 }
1524
VisitConstantArrayType(const ConstantArrayType * T)1525 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1526 QualType ToElementType = Importer.Import(T->getElementType());
1527 if (ToElementType.isNull())
1528 return QualType();
1529
1530 return Importer.getToContext().getConstantArrayType(ToElementType,
1531 T->getSize(),
1532 T->getSizeModifier(),
1533 T->getIndexTypeCVRQualifiers());
1534 }
1535
1536 QualType
VisitIncompleteArrayType(const IncompleteArrayType * T)1537 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1538 QualType ToElementType = Importer.Import(T->getElementType());
1539 if (ToElementType.isNull())
1540 return QualType();
1541
1542 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1543 T->getSizeModifier(),
1544 T->getIndexTypeCVRQualifiers());
1545 }
1546
VisitVariableArrayType(const VariableArrayType * T)1547 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1548 QualType ToElementType = Importer.Import(T->getElementType());
1549 if (ToElementType.isNull())
1550 return QualType();
1551
1552 Expr *Size = Importer.Import(T->getSizeExpr());
1553 if (!Size)
1554 return QualType();
1555
1556 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1557 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1558 T->getSizeModifier(),
1559 T->getIndexTypeCVRQualifiers(),
1560 Brackets);
1561 }
1562
VisitVectorType(const VectorType * T)1563 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1564 QualType ToElementType = Importer.Import(T->getElementType());
1565 if (ToElementType.isNull())
1566 return QualType();
1567
1568 return Importer.getToContext().getVectorType(ToElementType,
1569 T->getNumElements(),
1570 T->getVectorKind());
1571 }
1572
VisitExtVectorType(const ExtVectorType * T)1573 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1574 QualType ToElementType = Importer.Import(T->getElementType());
1575 if (ToElementType.isNull())
1576 return QualType();
1577
1578 return Importer.getToContext().getExtVectorType(ToElementType,
1579 T->getNumElements());
1580 }
1581
1582 QualType
VisitFunctionNoProtoType(const FunctionNoProtoType * T)1583 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1584 // FIXME: What happens if we're importing a function without a prototype
1585 // into C++? Should we make it variadic?
1586 QualType ToResultType = Importer.Import(T->getReturnType());
1587 if (ToResultType.isNull())
1588 return QualType();
1589
1590 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1591 T->getExtInfo());
1592 }
1593
VisitFunctionProtoType(const FunctionProtoType * T)1594 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1595 QualType ToResultType = Importer.Import(T->getReturnType());
1596 if (ToResultType.isNull())
1597 return QualType();
1598
1599 // Import argument types
1600 SmallVector<QualType, 4> ArgTypes;
1601 for (const auto &A : T->param_types()) {
1602 QualType ArgType = Importer.Import(A);
1603 if (ArgType.isNull())
1604 return QualType();
1605 ArgTypes.push_back(ArgType);
1606 }
1607
1608 // Import exception types
1609 SmallVector<QualType, 4> ExceptionTypes;
1610 for (const auto &E : T->exceptions()) {
1611 QualType ExceptionType = Importer.Import(E);
1612 if (ExceptionType.isNull())
1613 return QualType();
1614 ExceptionTypes.push_back(ExceptionType);
1615 }
1616
1617 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1618 FunctionProtoType::ExtProtoInfo ToEPI;
1619
1620 ToEPI.ExtInfo = FromEPI.ExtInfo;
1621 ToEPI.Variadic = FromEPI.Variadic;
1622 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1623 ToEPI.TypeQuals = FromEPI.TypeQuals;
1624 ToEPI.RefQualifier = FromEPI.RefQualifier;
1625 ToEPI.NumExceptions = ExceptionTypes.size();
1626 ToEPI.Exceptions = ExceptionTypes.data();
1627 ToEPI.ConsumedParameters = FromEPI.ConsumedParameters;
1628 ToEPI.ExceptionSpecType = FromEPI.ExceptionSpecType;
1629 ToEPI.NoexceptExpr = Importer.Import(FromEPI.NoexceptExpr);
1630 ToEPI.ExceptionSpecDecl = cast_or_null<FunctionDecl>(
1631 Importer.Import(FromEPI.ExceptionSpecDecl));
1632 ToEPI.ExceptionSpecTemplate = cast_or_null<FunctionDecl>(
1633 Importer.Import(FromEPI.ExceptionSpecTemplate));
1634
1635 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1636 }
1637
VisitParenType(const ParenType * T)1638 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1639 QualType ToInnerType = Importer.Import(T->getInnerType());
1640 if (ToInnerType.isNull())
1641 return QualType();
1642
1643 return Importer.getToContext().getParenType(ToInnerType);
1644 }
1645
VisitTypedefType(const TypedefType * T)1646 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1647 TypedefNameDecl *ToDecl
1648 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1649 if (!ToDecl)
1650 return QualType();
1651
1652 return Importer.getToContext().getTypeDeclType(ToDecl);
1653 }
1654
VisitTypeOfExprType(const TypeOfExprType * T)1655 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1656 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1657 if (!ToExpr)
1658 return QualType();
1659
1660 return Importer.getToContext().getTypeOfExprType(ToExpr);
1661 }
1662
VisitTypeOfType(const TypeOfType * T)1663 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1664 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1665 if (ToUnderlyingType.isNull())
1666 return QualType();
1667
1668 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1669 }
1670
VisitDecltypeType(const DecltypeType * T)1671 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1672 // FIXME: Make sure that the "to" context supports C++0x!
1673 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1674 if (!ToExpr)
1675 return QualType();
1676
1677 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1678 if (UnderlyingType.isNull())
1679 return QualType();
1680
1681 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1682 }
1683
VisitUnaryTransformType(const UnaryTransformType * T)1684 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1685 QualType ToBaseType = Importer.Import(T->getBaseType());
1686 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1687 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1688 return QualType();
1689
1690 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1691 ToUnderlyingType,
1692 T->getUTTKind());
1693 }
1694
VisitAutoType(const AutoType * T)1695 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1696 // FIXME: Make sure that the "to" context supports C++11!
1697 QualType FromDeduced = T->getDeducedType();
1698 QualType ToDeduced;
1699 if (!FromDeduced.isNull()) {
1700 ToDeduced = Importer.Import(FromDeduced);
1701 if (ToDeduced.isNull())
1702 return QualType();
1703 }
1704
1705 return Importer.getToContext().getAutoType(ToDeduced, T->isDecltypeAuto(),
1706 /*IsDependent*/false);
1707 }
1708
VisitRecordType(const RecordType * T)1709 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1710 RecordDecl *ToDecl
1711 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1712 if (!ToDecl)
1713 return QualType();
1714
1715 return Importer.getToContext().getTagDeclType(ToDecl);
1716 }
1717
VisitEnumType(const EnumType * T)1718 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1719 EnumDecl *ToDecl
1720 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1721 if (!ToDecl)
1722 return QualType();
1723
1724 return Importer.getToContext().getTagDeclType(ToDecl);
1725 }
1726
VisitTemplateSpecializationType(const TemplateSpecializationType * T)1727 QualType ASTNodeImporter::VisitTemplateSpecializationType(
1728 const TemplateSpecializationType *T) {
1729 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1730 if (ToTemplate.isNull())
1731 return QualType();
1732
1733 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1734 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1735 return QualType();
1736
1737 QualType ToCanonType;
1738 if (!QualType(T, 0).isCanonical()) {
1739 QualType FromCanonType
1740 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1741 ToCanonType =Importer.Import(FromCanonType);
1742 if (ToCanonType.isNull())
1743 return QualType();
1744 }
1745 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1746 ToTemplateArgs.data(),
1747 ToTemplateArgs.size(),
1748 ToCanonType);
1749 }
1750
VisitElaboratedType(const ElaboratedType * T)1751 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1752 NestedNameSpecifier *ToQualifier = nullptr;
1753 // Note: the qualifier in an ElaboratedType is optional.
1754 if (T->getQualifier()) {
1755 ToQualifier = Importer.Import(T->getQualifier());
1756 if (!ToQualifier)
1757 return QualType();
1758 }
1759
1760 QualType ToNamedType = Importer.Import(T->getNamedType());
1761 if (ToNamedType.isNull())
1762 return QualType();
1763
1764 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1765 ToQualifier, ToNamedType);
1766 }
1767
VisitObjCInterfaceType(const ObjCInterfaceType * T)1768 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1769 ObjCInterfaceDecl *Class
1770 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1771 if (!Class)
1772 return QualType();
1773
1774 return Importer.getToContext().getObjCInterfaceType(Class);
1775 }
1776
VisitObjCObjectType(const ObjCObjectType * T)1777 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1778 QualType ToBaseType = Importer.Import(T->getBaseType());
1779 if (ToBaseType.isNull())
1780 return QualType();
1781
1782 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1783 for (auto *P : T->quals()) {
1784 ObjCProtocolDecl *Protocol
1785 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1786 if (!Protocol)
1787 return QualType();
1788 Protocols.push_back(Protocol);
1789 }
1790
1791 return Importer.getToContext().getObjCObjectType(ToBaseType,
1792 Protocols.data(),
1793 Protocols.size());
1794 }
1795
1796 QualType
VisitObjCObjectPointerType(const ObjCObjectPointerType * T)1797 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1798 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1799 if (ToPointeeType.isNull())
1800 return QualType();
1801
1802 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1803 }
1804
1805 //----------------------------------------------------------------------------
1806 // Import Declarations
1807 //----------------------------------------------------------------------------
ImportDeclParts(NamedDecl * D,DeclContext * & DC,DeclContext * & LexicalDC,DeclarationName & Name,SourceLocation & Loc)1808 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1809 DeclContext *&LexicalDC,
1810 DeclarationName &Name,
1811 SourceLocation &Loc) {
1812 // Import the context of this declaration.
1813 DC = Importer.ImportContext(D->getDeclContext());
1814 if (!DC)
1815 return true;
1816
1817 LexicalDC = DC;
1818 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1819 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1820 if (!LexicalDC)
1821 return true;
1822 }
1823
1824 // Import the name of this declaration.
1825 Name = Importer.Import(D->getDeclName());
1826 if (D->getDeclName() && !Name)
1827 return true;
1828
1829 // Import the location of this declaration.
1830 Loc = Importer.Import(D->getLocation());
1831 return false;
1832 }
1833
ImportDefinitionIfNeeded(Decl * FromD,Decl * ToD)1834 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1835 if (!FromD)
1836 return;
1837
1838 if (!ToD) {
1839 ToD = Importer.Import(FromD);
1840 if (!ToD)
1841 return;
1842 }
1843
1844 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1845 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1846 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1847 ImportDefinition(FromRecord, ToRecord);
1848 }
1849 }
1850 return;
1851 }
1852
1853 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1854 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1855 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1856 ImportDefinition(FromEnum, ToEnum);
1857 }
1858 }
1859 return;
1860 }
1861 }
1862
1863 void
ImportDeclarationNameLoc(const DeclarationNameInfo & From,DeclarationNameInfo & To)1864 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1865 DeclarationNameInfo& To) {
1866 // NOTE: To.Name and To.Loc are already imported.
1867 // We only have to import To.LocInfo.
1868 switch (To.getName().getNameKind()) {
1869 case DeclarationName::Identifier:
1870 case DeclarationName::ObjCZeroArgSelector:
1871 case DeclarationName::ObjCOneArgSelector:
1872 case DeclarationName::ObjCMultiArgSelector:
1873 case DeclarationName::CXXUsingDirective:
1874 return;
1875
1876 case DeclarationName::CXXOperatorName: {
1877 SourceRange Range = From.getCXXOperatorNameRange();
1878 To.setCXXOperatorNameRange(Importer.Import(Range));
1879 return;
1880 }
1881 case DeclarationName::CXXLiteralOperatorName: {
1882 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1883 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1884 return;
1885 }
1886 case DeclarationName::CXXConstructorName:
1887 case DeclarationName::CXXDestructorName:
1888 case DeclarationName::CXXConversionFunctionName: {
1889 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1890 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1891 return;
1892 }
1893 }
1894 llvm_unreachable("Unknown name kind.");
1895 }
1896
ImportDeclContext(DeclContext * FromDC,bool ForceImport)1897 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1898 if (Importer.isMinimalImport() && !ForceImport) {
1899 Importer.ImportContext(FromDC);
1900 return;
1901 }
1902
1903 for (auto *From : FromDC->decls())
1904 Importer.Import(From);
1905 }
1906
ImportDefinition(RecordDecl * From,RecordDecl * To,ImportDefinitionKind Kind)1907 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
1908 ImportDefinitionKind Kind) {
1909 if (To->getDefinition() || To->isBeingDefined()) {
1910 if (Kind == IDK_Everything)
1911 ImportDeclContext(From, /*ForceImport=*/true);
1912
1913 return false;
1914 }
1915
1916 To->startDefinition();
1917
1918 // Add base classes.
1919 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1920 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
1921
1922 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1923 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1924 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
1925 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
1926 ToData.Aggregate = FromData.Aggregate;
1927 ToData.PlainOldData = FromData.PlainOldData;
1928 ToData.Empty = FromData.Empty;
1929 ToData.Polymorphic = FromData.Polymorphic;
1930 ToData.Abstract = FromData.Abstract;
1931 ToData.IsStandardLayout = FromData.IsStandardLayout;
1932 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
1933 ToData.HasPrivateFields = FromData.HasPrivateFields;
1934 ToData.HasProtectedFields = FromData.HasProtectedFields;
1935 ToData.HasPublicFields = FromData.HasPublicFields;
1936 ToData.HasMutableFields = FromData.HasMutableFields;
1937 ToData.HasVariantMembers = FromData.HasVariantMembers;
1938 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
1939 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
1940 ToData.HasUninitializedReferenceMember
1941 = FromData.HasUninitializedReferenceMember;
1942 ToData.NeedOverloadResolutionForMoveConstructor
1943 = FromData.NeedOverloadResolutionForMoveConstructor;
1944 ToData.NeedOverloadResolutionForMoveAssignment
1945 = FromData.NeedOverloadResolutionForMoveAssignment;
1946 ToData.NeedOverloadResolutionForDestructor
1947 = FromData.NeedOverloadResolutionForDestructor;
1948 ToData.DefaultedMoveConstructorIsDeleted
1949 = FromData.DefaultedMoveConstructorIsDeleted;
1950 ToData.DefaultedMoveAssignmentIsDeleted
1951 = FromData.DefaultedMoveAssignmentIsDeleted;
1952 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1953 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1954 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1955 ToData.HasConstexprNonCopyMoveConstructor
1956 = FromData.HasConstexprNonCopyMoveConstructor;
1957 ToData.DefaultedDefaultConstructorIsConstexpr
1958 = FromData.DefaultedDefaultConstructorIsConstexpr;
1959 ToData.HasConstexprDefaultConstructor
1960 = FromData.HasConstexprDefaultConstructor;
1961 ToData.HasNonLiteralTypeFieldsOrBases
1962 = FromData.HasNonLiteralTypeFieldsOrBases;
1963 // ComputedVisibleConversions not imported.
1964 ToData.UserProvidedDefaultConstructor
1965 = FromData.UserProvidedDefaultConstructor;
1966 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1967 ToData.ImplicitCopyConstructorHasConstParam
1968 = FromData.ImplicitCopyConstructorHasConstParam;
1969 ToData.ImplicitCopyAssignmentHasConstParam
1970 = FromData.ImplicitCopyAssignmentHasConstParam;
1971 ToData.HasDeclaredCopyConstructorWithConstParam
1972 = FromData.HasDeclaredCopyConstructorWithConstParam;
1973 ToData.HasDeclaredCopyAssignmentWithConstParam
1974 = FromData.HasDeclaredCopyAssignmentWithConstParam;
1975 ToData.IsLambda = FromData.IsLambda;
1976
1977 SmallVector<CXXBaseSpecifier *, 4> Bases;
1978 for (const auto &Base1 : FromCXX->bases()) {
1979 QualType T = Importer.Import(Base1.getType());
1980 if (T.isNull())
1981 return true;
1982
1983 SourceLocation EllipsisLoc;
1984 if (Base1.isPackExpansion())
1985 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
1986
1987 // Ensure that we have a definition for the base.
1988 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
1989
1990 Bases.push_back(
1991 new (Importer.getToContext())
1992 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
1993 Base1.isVirtual(),
1994 Base1.isBaseOfClass(),
1995 Base1.getAccessSpecifierAsWritten(),
1996 Importer.Import(Base1.getTypeSourceInfo()),
1997 EllipsisLoc));
1998 }
1999 if (!Bases.empty())
2000 ToCXX->setBases(Bases.data(), Bases.size());
2001 }
2002
2003 if (shouldForceImportDeclContext(Kind))
2004 ImportDeclContext(From, /*ForceImport=*/true);
2005
2006 To->completeDefinition();
2007 return false;
2008 }
2009
ImportDefinition(VarDecl * From,VarDecl * To,ImportDefinitionKind Kind)2010 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2011 ImportDefinitionKind Kind) {
2012 if (To->getDefinition())
2013 return false;
2014
2015 // FIXME: Can we really import any initializer? Alternatively, we could force
2016 // ourselves to import every declaration of a variable and then only use
2017 // getInit() here.
2018 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2019
2020 // FIXME: Other bits to merge?
2021
2022 return false;
2023 }
2024
ImportDefinition(EnumDecl * From,EnumDecl * To,ImportDefinitionKind Kind)2025 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2026 ImportDefinitionKind Kind) {
2027 if (To->getDefinition() || To->isBeingDefined()) {
2028 if (Kind == IDK_Everything)
2029 ImportDeclContext(From, /*ForceImport=*/true);
2030 return false;
2031 }
2032
2033 To->startDefinition();
2034
2035 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2036 if (T.isNull())
2037 return true;
2038
2039 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2040 if (ToPromotionType.isNull())
2041 return true;
2042
2043 if (shouldForceImportDeclContext(Kind))
2044 ImportDeclContext(From, /*ForceImport=*/true);
2045
2046 // FIXME: we might need to merge the number of positive or negative bits
2047 // if the enumerator lists don't match.
2048 To->completeDefinition(T, ToPromotionType,
2049 From->getNumPositiveBits(),
2050 From->getNumNegativeBits());
2051 return false;
2052 }
2053
ImportTemplateParameterList(TemplateParameterList * Params)2054 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2055 TemplateParameterList *Params) {
2056 SmallVector<NamedDecl *, 4> ToParams;
2057 ToParams.reserve(Params->size());
2058 for (TemplateParameterList::iterator P = Params->begin(),
2059 PEnd = Params->end();
2060 P != PEnd; ++P) {
2061 Decl *To = Importer.Import(*P);
2062 if (!To)
2063 return nullptr;
2064
2065 ToParams.push_back(cast<NamedDecl>(To));
2066 }
2067
2068 return TemplateParameterList::Create(Importer.getToContext(),
2069 Importer.Import(Params->getTemplateLoc()),
2070 Importer.Import(Params->getLAngleLoc()),
2071 ToParams.data(), ToParams.size(),
2072 Importer.Import(Params->getRAngleLoc()));
2073 }
2074
2075 TemplateArgument
ImportTemplateArgument(const TemplateArgument & From)2076 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2077 switch (From.getKind()) {
2078 case TemplateArgument::Null:
2079 return TemplateArgument();
2080
2081 case TemplateArgument::Type: {
2082 QualType ToType = Importer.Import(From.getAsType());
2083 if (ToType.isNull())
2084 return TemplateArgument();
2085 return TemplateArgument(ToType);
2086 }
2087
2088 case TemplateArgument::Integral: {
2089 QualType ToType = Importer.Import(From.getIntegralType());
2090 if (ToType.isNull())
2091 return TemplateArgument();
2092 return TemplateArgument(From, ToType);
2093 }
2094
2095 case TemplateArgument::Declaration: {
2096 ValueDecl *FromD = From.getAsDecl();
2097 if (ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(FromD)))
2098 return TemplateArgument(To, From.isDeclForReferenceParam());
2099 return TemplateArgument();
2100 }
2101
2102 case TemplateArgument::NullPtr: {
2103 QualType ToType = Importer.Import(From.getNullPtrType());
2104 if (ToType.isNull())
2105 return TemplateArgument();
2106 return TemplateArgument(ToType, /*isNullPtr*/true);
2107 }
2108
2109 case TemplateArgument::Template: {
2110 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2111 if (ToTemplate.isNull())
2112 return TemplateArgument();
2113
2114 return TemplateArgument(ToTemplate);
2115 }
2116
2117 case TemplateArgument::TemplateExpansion: {
2118 TemplateName ToTemplate
2119 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2120 if (ToTemplate.isNull())
2121 return TemplateArgument();
2122
2123 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2124 }
2125
2126 case TemplateArgument::Expression:
2127 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2128 return TemplateArgument(ToExpr);
2129 return TemplateArgument();
2130
2131 case TemplateArgument::Pack: {
2132 SmallVector<TemplateArgument, 2> ToPack;
2133 ToPack.reserve(From.pack_size());
2134 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2135 return TemplateArgument();
2136
2137 TemplateArgument *ToArgs
2138 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2139 std::copy(ToPack.begin(), ToPack.end(), ToArgs);
2140 return TemplateArgument(ToArgs, ToPack.size());
2141 }
2142 }
2143
2144 llvm_unreachable("Invalid template argument kind");
2145 }
2146
ImportTemplateArguments(const TemplateArgument * FromArgs,unsigned NumFromArgs,SmallVectorImpl<TemplateArgument> & ToArgs)2147 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2148 unsigned NumFromArgs,
2149 SmallVectorImpl<TemplateArgument> &ToArgs) {
2150 for (unsigned I = 0; I != NumFromArgs; ++I) {
2151 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2152 if (To.isNull() && !FromArgs[I].isNull())
2153 return true;
2154
2155 ToArgs.push_back(To);
2156 }
2157
2158 return false;
2159 }
2160
IsStructuralMatch(RecordDecl * FromRecord,RecordDecl * ToRecord,bool Complain)2161 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2162 RecordDecl *ToRecord, bool Complain) {
2163 // Eliminate a potential failure point where we attempt to re-import
2164 // something we're trying to import while completing ToRecord.
2165 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2166 if (ToOrigin) {
2167 RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2168 if (ToOriginRecord)
2169 ToRecord = ToOriginRecord;
2170 }
2171
2172 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2173 ToRecord->getASTContext(),
2174 Importer.getNonEquivalentDecls(),
2175 false, Complain);
2176 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2177 }
2178
IsStructuralMatch(VarDecl * FromVar,VarDecl * ToVar,bool Complain)2179 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2180 bool Complain) {
2181 StructuralEquivalenceContext Ctx(
2182 Importer.getFromContext(), Importer.getToContext(),
2183 Importer.getNonEquivalentDecls(), false, Complain);
2184 return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2185 }
2186
IsStructuralMatch(EnumDecl * FromEnum,EnumDecl * ToEnum)2187 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2188 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2189 Importer.getToContext(),
2190 Importer.getNonEquivalentDecls());
2191 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2192 }
2193
IsStructuralMatch(EnumConstantDecl * FromEC,EnumConstantDecl * ToEC)2194 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2195 EnumConstantDecl *ToEC)
2196 {
2197 const llvm::APSInt &FromVal = FromEC->getInitVal();
2198 const llvm::APSInt &ToVal = ToEC->getInitVal();
2199
2200 return FromVal.isSigned() == ToVal.isSigned() &&
2201 FromVal.getBitWidth() == ToVal.getBitWidth() &&
2202 FromVal == ToVal;
2203 }
2204
IsStructuralMatch(ClassTemplateDecl * From,ClassTemplateDecl * To)2205 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2206 ClassTemplateDecl *To) {
2207 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2208 Importer.getToContext(),
2209 Importer.getNonEquivalentDecls());
2210 return Ctx.IsStructurallyEquivalent(From, To);
2211 }
2212
IsStructuralMatch(VarTemplateDecl * From,VarTemplateDecl * To)2213 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2214 VarTemplateDecl *To) {
2215 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2216 Importer.getToContext(),
2217 Importer.getNonEquivalentDecls());
2218 return Ctx.IsStructurallyEquivalent(From, To);
2219 }
2220
VisitDecl(Decl * D)2221 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2222 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2223 << D->getDeclKindName();
2224 return nullptr;
2225 }
2226
VisitTranslationUnitDecl(TranslationUnitDecl * D)2227 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2228 TranslationUnitDecl *ToD =
2229 Importer.getToContext().getTranslationUnitDecl();
2230
2231 Importer.Imported(D, ToD);
2232
2233 return ToD;
2234 }
2235
VisitNamespaceDecl(NamespaceDecl * D)2236 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2237 // Import the major distinguishing characteristics of this namespace.
2238 DeclContext *DC, *LexicalDC;
2239 DeclarationName Name;
2240 SourceLocation Loc;
2241 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2242 return nullptr;
2243
2244 NamespaceDecl *MergeWithNamespace = nullptr;
2245 if (!Name) {
2246 // This is an anonymous namespace. Adopt an existing anonymous
2247 // namespace if we can.
2248 // FIXME: Not testable.
2249 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2250 MergeWithNamespace = TU->getAnonymousNamespace();
2251 else
2252 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2253 } else {
2254 SmallVector<NamedDecl *, 4> ConflictingDecls;
2255 SmallVector<NamedDecl *, 2> FoundDecls;
2256 DC->localUncachedLookup(Name, FoundDecls);
2257 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2258 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2259 continue;
2260
2261 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2262 MergeWithNamespace = FoundNS;
2263 ConflictingDecls.clear();
2264 break;
2265 }
2266
2267 ConflictingDecls.push_back(FoundDecls[I]);
2268 }
2269
2270 if (!ConflictingDecls.empty()) {
2271 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2272 ConflictingDecls.data(),
2273 ConflictingDecls.size());
2274 }
2275 }
2276
2277 // Create the "to" namespace, if needed.
2278 NamespaceDecl *ToNamespace = MergeWithNamespace;
2279 if (!ToNamespace) {
2280 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2281 D->isInline(),
2282 Importer.Import(D->getLocStart()),
2283 Loc, Name.getAsIdentifierInfo(),
2284 /*PrevDecl=*/nullptr);
2285 ToNamespace->setLexicalDeclContext(LexicalDC);
2286 LexicalDC->addDeclInternal(ToNamespace);
2287
2288 // If this is an anonymous namespace, register it as the anonymous
2289 // namespace within its context.
2290 if (!Name) {
2291 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2292 TU->setAnonymousNamespace(ToNamespace);
2293 else
2294 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2295 }
2296 }
2297 Importer.Imported(D, ToNamespace);
2298
2299 ImportDeclContext(D);
2300
2301 return ToNamespace;
2302 }
2303
VisitTypedefNameDecl(TypedefNameDecl * D,bool IsAlias)2304 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2305 // Import the major distinguishing characteristics of this typedef.
2306 DeclContext *DC, *LexicalDC;
2307 DeclarationName Name;
2308 SourceLocation Loc;
2309 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2310 return nullptr;
2311
2312 // If this typedef is not in block scope, determine whether we've
2313 // seen a typedef with the same name (that we can merge with) or any
2314 // other entity by that name (which name lookup could conflict with).
2315 if (!DC->isFunctionOrMethod()) {
2316 SmallVector<NamedDecl *, 4> ConflictingDecls;
2317 unsigned IDNS = Decl::IDNS_Ordinary;
2318 SmallVector<NamedDecl *, 2> FoundDecls;
2319 DC->localUncachedLookup(Name, FoundDecls);
2320 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2321 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2322 continue;
2323 if (TypedefNameDecl *FoundTypedef =
2324 dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2325 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2326 FoundTypedef->getUnderlyingType()))
2327 return Importer.Imported(D, FoundTypedef);
2328 }
2329
2330 ConflictingDecls.push_back(FoundDecls[I]);
2331 }
2332
2333 if (!ConflictingDecls.empty()) {
2334 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2335 ConflictingDecls.data(),
2336 ConflictingDecls.size());
2337 if (!Name)
2338 return nullptr;
2339 }
2340 }
2341
2342 // Import the underlying type of this typedef;
2343 QualType T = Importer.Import(D->getUnderlyingType());
2344 if (T.isNull())
2345 return nullptr;
2346
2347 // Create the new typedef node.
2348 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2349 SourceLocation StartL = Importer.Import(D->getLocStart());
2350 TypedefNameDecl *ToTypedef;
2351 if (IsAlias)
2352 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2353 StartL, Loc,
2354 Name.getAsIdentifierInfo(),
2355 TInfo);
2356 else
2357 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2358 StartL, Loc,
2359 Name.getAsIdentifierInfo(),
2360 TInfo);
2361
2362 ToTypedef->setAccess(D->getAccess());
2363 ToTypedef->setLexicalDeclContext(LexicalDC);
2364 Importer.Imported(D, ToTypedef);
2365 LexicalDC->addDeclInternal(ToTypedef);
2366
2367 return ToTypedef;
2368 }
2369
VisitTypedefDecl(TypedefDecl * D)2370 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2371 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2372 }
2373
VisitTypeAliasDecl(TypeAliasDecl * D)2374 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2375 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2376 }
2377
VisitEnumDecl(EnumDecl * D)2378 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2379 // Import the major distinguishing characteristics of this enum.
2380 DeclContext *DC, *LexicalDC;
2381 DeclarationName Name;
2382 SourceLocation Loc;
2383 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2384 return nullptr;
2385
2386 // Figure out what enum name we're looking for.
2387 unsigned IDNS = Decl::IDNS_Tag;
2388 DeclarationName SearchName = Name;
2389 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2390 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2391 IDNS = Decl::IDNS_Ordinary;
2392 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2393 IDNS |= Decl::IDNS_Ordinary;
2394
2395 // We may already have an enum of the same name; try to find and match it.
2396 if (!DC->isFunctionOrMethod() && SearchName) {
2397 SmallVector<NamedDecl *, 4> ConflictingDecls;
2398 SmallVector<NamedDecl *, 2> FoundDecls;
2399 DC->localUncachedLookup(SearchName, FoundDecls);
2400 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2401 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2402 continue;
2403
2404 Decl *Found = FoundDecls[I];
2405 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2406 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2407 Found = Tag->getDecl();
2408 }
2409
2410 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2411 if (IsStructuralMatch(D, FoundEnum))
2412 return Importer.Imported(D, FoundEnum);
2413 }
2414
2415 ConflictingDecls.push_back(FoundDecls[I]);
2416 }
2417
2418 if (!ConflictingDecls.empty()) {
2419 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2420 ConflictingDecls.data(),
2421 ConflictingDecls.size());
2422 }
2423 }
2424
2425 // Create the enum declaration.
2426 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2427 Importer.Import(D->getLocStart()),
2428 Loc, Name.getAsIdentifierInfo(), nullptr,
2429 D->isScoped(), D->isScopedUsingClassTag(),
2430 D->isFixed());
2431 // Import the qualifier, if any.
2432 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2433 D2->setAccess(D->getAccess());
2434 D2->setLexicalDeclContext(LexicalDC);
2435 Importer.Imported(D, D2);
2436 LexicalDC->addDeclInternal(D2);
2437
2438 // Import the integer type.
2439 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2440 if (ToIntegerType.isNull())
2441 return nullptr;
2442 D2->setIntegerType(ToIntegerType);
2443
2444 // Import the definition
2445 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2446 return nullptr;
2447
2448 return D2;
2449 }
2450
VisitRecordDecl(RecordDecl * D)2451 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2452 // If this record has a definition in the translation unit we're coming from,
2453 // but this particular declaration is not that definition, import the
2454 // definition and map to that.
2455 TagDecl *Definition = D->getDefinition();
2456 if (Definition && Definition != D) {
2457 Decl *ImportedDef = Importer.Import(Definition);
2458 if (!ImportedDef)
2459 return nullptr;
2460
2461 return Importer.Imported(D, ImportedDef);
2462 }
2463
2464 // Import the major distinguishing characteristics of this record.
2465 DeclContext *DC, *LexicalDC;
2466 DeclarationName Name;
2467 SourceLocation Loc;
2468 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2469 return nullptr;
2470
2471 // Figure out what structure name we're looking for.
2472 unsigned IDNS = Decl::IDNS_Tag;
2473 DeclarationName SearchName = Name;
2474 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2475 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2476 IDNS = Decl::IDNS_Ordinary;
2477 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2478 IDNS |= Decl::IDNS_Ordinary;
2479
2480 // We may already have a record of the same name; try to find and match it.
2481 RecordDecl *AdoptDecl = nullptr;
2482 if (!DC->isFunctionOrMethod()) {
2483 SmallVector<NamedDecl *, 4> ConflictingDecls;
2484 SmallVector<NamedDecl *, 2> FoundDecls;
2485 DC->localUncachedLookup(SearchName, FoundDecls);
2486 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2487 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2488 continue;
2489
2490 Decl *Found = FoundDecls[I];
2491 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2492 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2493 Found = Tag->getDecl();
2494 }
2495
2496 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2497 if (D->isAnonymousStructOrUnion() &&
2498 FoundRecord->isAnonymousStructOrUnion()) {
2499 // If both anonymous structs/unions are in a record context, make sure
2500 // they occur in the same location in the context records.
2501 if (Optional<unsigned> Index1
2502 = findAnonymousStructOrUnionIndex(D)) {
2503 if (Optional<unsigned> Index2 =
2504 findAnonymousStructOrUnionIndex(FoundRecord)) {
2505 if (*Index1 != *Index2)
2506 continue;
2507 }
2508 }
2509 }
2510
2511 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2512 if ((SearchName && !D->isCompleteDefinition())
2513 || (D->isCompleteDefinition() &&
2514 D->isAnonymousStructOrUnion()
2515 == FoundDef->isAnonymousStructOrUnion() &&
2516 IsStructuralMatch(D, FoundDef))) {
2517 // The record types structurally match, or the "from" translation
2518 // unit only had a forward declaration anyway; call it the same
2519 // function.
2520 // FIXME: For C++, we should also merge methods here.
2521 return Importer.Imported(D, FoundDef);
2522 }
2523 } else if (!D->isCompleteDefinition()) {
2524 // We have a forward declaration of this type, so adopt that forward
2525 // declaration rather than building a new one.
2526
2527 // If one or both can be completed from external storage then try one
2528 // last time to complete and compare them before doing this.
2529
2530 if (FoundRecord->hasExternalLexicalStorage() &&
2531 !FoundRecord->isCompleteDefinition())
2532 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2533 if (D->hasExternalLexicalStorage())
2534 D->getASTContext().getExternalSource()->CompleteType(D);
2535
2536 if (FoundRecord->isCompleteDefinition() &&
2537 D->isCompleteDefinition() &&
2538 !IsStructuralMatch(D, FoundRecord))
2539 continue;
2540
2541 AdoptDecl = FoundRecord;
2542 continue;
2543 } else if (!SearchName) {
2544 continue;
2545 }
2546 }
2547
2548 ConflictingDecls.push_back(FoundDecls[I]);
2549 }
2550
2551 if (!ConflictingDecls.empty() && SearchName) {
2552 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2553 ConflictingDecls.data(),
2554 ConflictingDecls.size());
2555 }
2556 }
2557
2558 // Create the record declaration.
2559 RecordDecl *D2 = AdoptDecl;
2560 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2561 if (!D2) {
2562 if (isa<CXXRecordDecl>(D)) {
2563 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2564 D->getTagKind(),
2565 DC, StartLoc, Loc,
2566 Name.getAsIdentifierInfo());
2567 D2 = D2CXX;
2568 D2->setAccess(D->getAccess());
2569 } else {
2570 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2571 DC, StartLoc, Loc, Name.getAsIdentifierInfo());
2572 }
2573
2574 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2575 D2->setLexicalDeclContext(LexicalDC);
2576 LexicalDC->addDeclInternal(D2);
2577 if (D->isAnonymousStructOrUnion())
2578 D2->setAnonymousStructOrUnion(true);
2579 }
2580
2581 Importer.Imported(D, D2);
2582
2583 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2584 return nullptr;
2585
2586 return D2;
2587 }
2588
VisitEnumConstantDecl(EnumConstantDecl * D)2589 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2590 // Import the major distinguishing characteristics of this enumerator.
2591 DeclContext *DC, *LexicalDC;
2592 DeclarationName Name;
2593 SourceLocation Loc;
2594 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2595 return nullptr;
2596
2597 QualType T = Importer.Import(D->getType());
2598 if (T.isNull())
2599 return nullptr;
2600
2601 // Determine whether there are any other declarations with the same name and
2602 // in the same context.
2603 if (!LexicalDC->isFunctionOrMethod()) {
2604 SmallVector<NamedDecl *, 4> ConflictingDecls;
2605 unsigned IDNS = Decl::IDNS_Ordinary;
2606 SmallVector<NamedDecl *, 2> FoundDecls;
2607 DC->localUncachedLookup(Name, FoundDecls);
2608 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2609 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2610 continue;
2611
2612 if (EnumConstantDecl *FoundEnumConstant
2613 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
2614 if (IsStructuralMatch(D, FoundEnumConstant))
2615 return Importer.Imported(D, FoundEnumConstant);
2616 }
2617
2618 ConflictingDecls.push_back(FoundDecls[I]);
2619 }
2620
2621 if (!ConflictingDecls.empty()) {
2622 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2623 ConflictingDecls.data(),
2624 ConflictingDecls.size());
2625 if (!Name)
2626 return nullptr;
2627 }
2628 }
2629
2630 Expr *Init = Importer.Import(D->getInitExpr());
2631 if (D->getInitExpr() && !Init)
2632 return nullptr;
2633
2634 EnumConstantDecl *ToEnumerator
2635 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2636 Name.getAsIdentifierInfo(), T,
2637 Init, D->getInitVal());
2638 ToEnumerator->setAccess(D->getAccess());
2639 ToEnumerator->setLexicalDeclContext(LexicalDC);
2640 Importer.Imported(D, ToEnumerator);
2641 LexicalDC->addDeclInternal(ToEnumerator);
2642 return ToEnumerator;
2643 }
2644
VisitFunctionDecl(FunctionDecl * D)2645 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2646 // Import the major distinguishing characteristics of this function.
2647 DeclContext *DC, *LexicalDC;
2648 DeclarationName Name;
2649 SourceLocation Loc;
2650 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2651 return nullptr;
2652
2653 // Try to find a function in our own ("to") context with the same name, same
2654 // type, and in the same context as the function we're importing.
2655 if (!LexicalDC->isFunctionOrMethod()) {
2656 SmallVector<NamedDecl *, 4> ConflictingDecls;
2657 unsigned IDNS = Decl::IDNS_Ordinary;
2658 SmallVector<NamedDecl *, 2> FoundDecls;
2659 DC->localUncachedLookup(Name, FoundDecls);
2660 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2661 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2662 continue;
2663
2664 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
2665 if (FoundFunction->hasExternalFormalLinkage() &&
2666 D->hasExternalFormalLinkage()) {
2667 if (Importer.IsStructurallyEquivalent(D->getType(),
2668 FoundFunction->getType())) {
2669 // FIXME: Actually try to merge the body and other attributes.
2670 return Importer.Imported(D, FoundFunction);
2671 }
2672
2673 // FIXME: Check for overloading more carefully, e.g., by boosting
2674 // Sema::IsOverload out to the AST library.
2675
2676 // Function overloading is okay in C++.
2677 if (Importer.getToContext().getLangOpts().CPlusPlus)
2678 continue;
2679
2680 // Complain about inconsistent function types.
2681 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2682 << Name << D->getType() << FoundFunction->getType();
2683 Importer.ToDiag(FoundFunction->getLocation(),
2684 diag::note_odr_value_here)
2685 << FoundFunction->getType();
2686 }
2687 }
2688
2689 ConflictingDecls.push_back(FoundDecls[I]);
2690 }
2691
2692 if (!ConflictingDecls.empty()) {
2693 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2694 ConflictingDecls.data(),
2695 ConflictingDecls.size());
2696 if (!Name)
2697 return nullptr;
2698 }
2699 }
2700
2701 DeclarationNameInfo NameInfo(Name, Loc);
2702 // Import additional name location/type info.
2703 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2704
2705 QualType FromTy = D->getType();
2706 bool usedDifferentExceptionSpec = false;
2707
2708 if (const FunctionProtoType *
2709 FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2710 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2711 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2712 // FunctionDecl that we are importing the FunctionProtoType for.
2713 // To avoid an infinite recursion when importing, create the FunctionDecl
2714 // with a simplified function type and update it afterwards.
2715 if (FromEPI.ExceptionSpecDecl || FromEPI.ExceptionSpecTemplate ||
2716 FromEPI.NoexceptExpr) {
2717 FunctionProtoType::ExtProtoInfo DefaultEPI;
2718 FromTy = Importer.getFromContext().getFunctionType(
2719 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2720 usedDifferentExceptionSpec = true;
2721 }
2722 }
2723
2724 // Import the type.
2725 QualType T = Importer.Import(FromTy);
2726 if (T.isNull())
2727 return nullptr;
2728
2729 // Import the function parameters.
2730 SmallVector<ParmVarDecl *, 8> Parameters;
2731 for (auto P : D->params()) {
2732 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2733 if (!ToP)
2734 return nullptr;
2735
2736 Parameters.push_back(ToP);
2737 }
2738
2739 // Create the imported function.
2740 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2741 FunctionDecl *ToFunction = nullptr;
2742 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2743 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2744 cast<CXXRecordDecl>(DC),
2745 D->getInnerLocStart(),
2746 NameInfo, T, TInfo,
2747 FromConstructor->isExplicit(),
2748 D->isInlineSpecified(),
2749 D->isImplicit(),
2750 D->isConstexpr());
2751 } else if (isa<CXXDestructorDecl>(D)) {
2752 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2753 cast<CXXRecordDecl>(DC),
2754 D->getInnerLocStart(),
2755 NameInfo, T, TInfo,
2756 D->isInlineSpecified(),
2757 D->isImplicit());
2758 } else if (CXXConversionDecl *FromConversion
2759 = dyn_cast<CXXConversionDecl>(D)) {
2760 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2761 cast<CXXRecordDecl>(DC),
2762 D->getInnerLocStart(),
2763 NameInfo, T, TInfo,
2764 D->isInlineSpecified(),
2765 FromConversion->isExplicit(),
2766 D->isConstexpr(),
2767 Importer.Import(D->getLocEnd()));
2768 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2769 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2770 cast<CXXRecordDecl>(DC),
2771 D->getInnerLocStart(),
2772 NameInfo, T, TInfo,
2773 Method->getStorageClass(),
2774 Method->isInlineSpecified(),
2775 D->isConstexpr(),
2776 Importer.Import(D->getLocEnd()));
2777 } else {
2778 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2779 D->getInnerLocStart(),
2780 NameInfo, T, TInfo, D->getStorageClass(),
2781 D->isInlineSpecified(),
2782 D->hasWrittenPrototype(),
2783 D->isConstexpr());
2784 }
2785
2786 // Import the qualifier, if any.
2787 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2788 ToFunction->setAccess(D->getAccess());
2789 ToFunction->setLexicalDeclContext(LexicalDC);
2790 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2791 ToFunction->setTrivial(D->isTrivial());
2792 ToFunction->setPure(D->isPure());
2793 Importer.Imported(D, ToFunction);
2794
2795 // Set the parameters.
2796 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
2797 Parameters[I]->setOwningFunction(ToFunction);
2798 ToFunction->addDeclInternal(Parameters[I]);
2799 }
2800 ToFunction->setParams(Parameters);
2801
2802 if (usedDifferentExceptionSpec) {
2803 // Update FunctionProtoType::ExtProtoInfo.
2804 QualType T = Importer.Import(D->getType());
2805 if (T.isNull())
2806 return nullptr;
2807 ToFunction->setType(T);
2808 }
2809
2810 // FIXME: Other bits to merge?
2811
2812 // Add this function to the lexical context.
2813 LexicalDC->addDeclInternal(ToFunction);
2814
2815 return ToFunction;
2816 }
2817
VisitCXXMethodDecl(CXXMethodDecl * D)2818 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2819 return VisitFunctionDecl(D);
2820 }
2821
VisitCXXConstructorDecl(CXXConstructorDecl * D)2822 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2823 return VisitCXXMethodDecl(D);
2824 }
2825
VisitCXXDestructorDecl(CXXDestructorDecl * D)2826 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2827 return VisitCXXMethodDecl(D);
2828 }
2829
VisitCXXConversionDecl(CXXConversionDecl * D)2830 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2831 return VisitCXXMethodDecl(D);
2832 }
2833
getFieldIndex(Decl * F)2834 static unsigned getFieldIndex(Decl *F) {
2835 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2836 if (!Owner)
2837 return 0;
2838
2839 unsigned Index = 1;
2840 for (const auto *D : Owner->noload_decls()) {
2841 if (D == F)
2842 return Index;
2843
2844 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2845 ++Index;
2846 }
2847
2848 return Index;
2849 }
2850
VisitFieldDecl(FieldDecl * D)2851 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2852 // Import the major distinguishing characteristics of a variable.
2853 DeclContext *DC, *LexicalDC;
2854 DeclarationName Name;
2855 SourceLocation Loc;
2856 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2857 return nullptr;
2858
2859 // Determine whether we've already imported this field.
2860 SmallVector<NamedDecl *, 2> FoundDecls;
2861 DC->localUncachedLookup(Name, FoundDecls);
2862 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2863 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
2864 // For anonymous fields, match up by index.
2865 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2866 continue;
2867
2868 if (Importer.IsStructurallyEquivalent(D->getType(),
2869 FoundField->getType())) {
2870 Importer.Imported(D, FoundField);
2871 return FoundField;
2872 }
2873
2874 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2875 << Name << D->getType() << FoundField->getType();
2876 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2877 << FoundField->getType();
2878 return nullptr;
2879 }
2880 }
2881
2882 // Import the type.
2883 QualType T = Importer.Import(D->getType());
2884 if (T.isNull())
2885 return nullptr;
2886
2887 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2888 Expr *BitWidth = Importer.Import(D->getBitWidth());
2889 if (!BitWidth && D->getBitWidth())
2890 return nullptr;
2891
2892 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2893 Importer.Import(D->getInnerLocStart()),
2894 Loc, Name.getAsIdentifierInfo(),
2895 T, TInfo, BitWidth, D->isMutable(),
2896 D->getInClassInitStyle());
2897 ToField->setAccess(D->getAccess());
2898 ToField->setLexicalDeclContext(LexicalDC);
2899 if (ToField->hasInClassInitializer())
2900 ToField->setInClassInitializer(D->getInClassInitializer());
2901 ToField->setImplicit(D->isImplicit());
2902 Importer.Imported(D, ToField);
2903 LexicalDC->addDeclInternal(ToField);
2904 return ToField;
2905 }
2906
VisitIndirectFieldDecl(IndirectFieldDecl * D)2907 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2908 // Import the major distinguishing characteristics of a variable.
2909 DeclContext *DC, *LexicalDC;
2910 DeclarationName Name;
2911 SourceLocation Loc;
2912 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2913 return nullptr;
2914
2915 // Determine whether we've already imported this field.
2916 SmallVector<NamedDecl *, 2> FoundDecls;
2917 DC->localUncachedLookup(Name, FoundDecls);
2918 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2919 if (IndirectFieldDecl *FoundField
2920 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2921 // For anonymous indirect fields, match up by index.
2922 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2923 continue;
2924
2925 if (Importer.IsStructurallyEquivalent(D->getType(),
2926 FoundField->getType(),
2927 !Name.isEmpty())) {
2928 Importer.Imported(D, FoundField);
2929 return FoundField;
2930 }
2931
2932 // If there are more anonymous fields to check, continue.
2933 if (!Name && I < N-1)
2934 continue;
2935
2936 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2937 << Name << D->getType() << FoundField->getType();
2938 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2939 << FoundField->getType();
2940 return nullptr;
2941 }
2942 }
2943
2944 // Import the type.
2945 QualType T = Importer.Import(D->getType());
2946 if (T.isNull())
2947 return nullptr;
2948
2949 NamedDecl **NamedChain =
2950 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2951
2952 unsigned i = 0;
2953 for (auto *PI : D->chain()) {
2954 Decl *D = Importer.Import(PI);
2955 if (!D)
2956 return nullptr;
2957 NamedChain[i++] = cast<NamedDecl>(D);
2958 }
2959
2960 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
2961 Importer.getToContext(), DC,
2962 Loc, Name.getAsIdentifierInfo(), T,
2963 NamedChain, D->getChainingSize());
2964 ToIndirectField->setAccess(D->getAccess());
2965 ToIndirectField->setLexicalDeclContext(LexicalDC);
2966 Importer.Imported(D, ToIndirectField);
2967 LexicalDC->addDeclInternal(ToIndirectField);
2968 return ToIndirectField;
2969 }
2970
VisitObjCIvarDecl(ObjCIvarDecl * D)2971 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
2972 // Import the major distinguishing characteristics of an ivar.
2973 DeclContext *DC, *LexicalDC;
2974 DeclarationName Name;
2975 SourceLocation Loc;
2976 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2977 return nullptr;
2978
2979 // Determine whether we've already imported this ivar
2980 SmallVector<NamedDecl *, 2> FoundDecls;
2981 DC->localUncachedLookup(Name, FoundDecls);
2982 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2983 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
2984 if (Importer.IsStructurallyEquivalent(D->getType(),
2985 FoundIvar->getType())) {
2986 Importer.Imported(D, FoundIvar);
2987 return FoundIvar;
2988 }
2989
2990 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
2991 << Name << D->getType() << FoundIvar->getType();
2992 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
2993 << FoundIvar->getType();
2994 return nullptr;
2995 }
2996 }
2997
2998 // Import the type.
2999 QualType T = Importer.Import(D->getType());
3000 if (T.isNull())
3001 return nullptr;
3002
3003 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3004 Expr *BitWidth = Importer.Import(D->getBitWidth());
3005 if (!BitWidth && D->getBitWidth())
3006 return nullptr;
3007
3008 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3009 cast<ObjCContainerDecl>(DC),
3010 Importer.Import(D->getInnerLocStart()),
3011 Loc, Name.getAsIdentifierInfo(),
3012 T, TInfo, D->getAccessControl(),
3013 BitWidth, D->getSynthesize());
3014 ToIvar->setLexicalDeclContext(LexicalDC);
3015 Importer.Imported(D, ToIvar);
3016 LexicalDC->addDeclInternal(ToIvar);
3017 return ToIvar;
3018
3019 }
3020
VisitVarDecl(VarDecl * D)3021 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3022 // Import the major distinguishing characteristics of a variable.
3023 DeclContext *DC, *LexicalDC;
3024 DeclarationName Name;
3025 SourceLocation Loc;
3026 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3027 return nullptr;
3028
3029 // Try to find a variable in our own ("to") context with the same name and
3030 // in the same context as the variable we're importing.
3031 if (D->isFileVarDecl()) {
3032 VarDecl *MergeWithVar = nullptr;
3033 SmallVector<NamedDecl *, 4> ConflictingDecls;
3034 unsigned IDNS = Decl::IDNS_Ordinary;
3035 SmallVector<NamedDecl *, 2> FoundDecls;
3036 DC->localUncachedLookup(Name, FoundDecls);
3037 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3038 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3039 continue;
3040
3041 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3042 // We have found a variable that we may need to merge with. Check it.
3043 if (FoundVar->hasExternalFormalLinkage() &&
3044 D->hasExternalFormalLinkage()) {
3045 if (Importer.IsStructurallyEquivalent(D->getType(),
3046 FoundVar->getType())) {
3047 MergeWithVar = FoundVar;
3048 break;
3049 }
3050
3051 const ArrayType *FoundArray
3052 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3053 const ArrayType *TArray
3054 = Importer.getToContext().getAsArrayType(D->getType());
3055 if (FoundArray && TArray) {
3056 if (isa<IncompleteArrayType>(FoundArray) &&
3057 isa<ConstantArrayType>(TArray)) {
3058 // Import the type.
3059 QualType T = Importer.Import(D->getType());
3060 if (T.isNull())
3061 return nullptr;
3062
3063 FoundVar->setType(T);
3064 MergeWithVar = FoundVar;
3065 break;
3066 } else if (isa<IncompleteArrayType>(TArray) &&
3067 isa<ConstantArrayType>(FoundArray)) {
3068 MergeWithVar = FoundVar;
3069 break;
3070 }
3071 }
3072
3073 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3074 << Name << D->getType() << FoundVar->getType();
3075 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3076 << FoundVar->getType();
3077 }
3078 }
3079
3080 ConflictingDecls.push_back(FoundDecls[I]);
3081 }
3082
3083 if (MergeWithVar) {
3084 // An equivalent variable with external linkage has been found. Link
3085 // the two declarations, then merge them.
3086 Importer.Imported(D, MergeWithVar);
3087
3088 if (VarDecl *DDef = D->getDefinition()) {
3089 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3090 Importer.ToDiag(ExistingDef->getLocation(),
3091 diag::err_odr_variable_multiple_def)
3092 << Name;
3093 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3094 } else {
3095 Expr *Init = Importer.Import(DDef->getInit());
3096 MergeWithVar->setInit(Init);
3097 if (DDef->isInitKnownICE()) {
3098 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3099 Eval->CheckedICE = true;
3100 Eval->IsICE = DDef->isInitICE();
3101 }
3102 }
3103 }
3104
3105 return MergeWithVar;
3106 }
3107
3108 if (!ConflictingDecls.empty()) {
3109 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3110 ConflictingDecls.data(),
3111 ConflictingDecls.size());
3112 if (!Name)
3113 return nullptr;
3114 }
3115 }
3116
3117 // Import the type.
3118 QualType T = Importer.Import(D->getType());
3119 if (T.isNull())
3120 return nullptr;
3121
3122 // Create the imported variable.
3123 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3124 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3125 Importer.Import(D->getInnerLocStart()),
3126 Loc, Name.getAsIdentifierInfo(),
3127 T, TInfo,
3128 D->getStorageClass());
3129 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3130 ToVar->setAccess(D->getAccess());
3131 ToVar->setLexicalDeclContext(LexicalDC);
3132 Importer.Imported(D, ToVar);
3133 LexicalDC->addDeclInternal(ToVar);
3134
3135 // Merge the initializer.
3136 if (ImportDefinition(D, ToVar))
3137 return nullptr;
3138
3139 return ToVar;
3140 }
3141
VisitImplicitParamDecl(ImplicitParamDecl * D)3142 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3143 // Parameters are created in the translation unit's context, then moved
3144 // into the function declaration's context afterward.
3145 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3146
3147 // Import the name of this declaration.
3148 DeclarationName Name = Importer.Import(D->getDeclName());
3149 if (D->getDeclName() && !Name)
3150 return nullptr;
3151
3152 // Import the location of this declaration.
3153 SourceLocation Loc = Importer.Import(D->getLocation());
3154
3155 // Import the parameter's type.
3156 QualType T = Importer.Import(D->getType());
3157 if (T.isNull())
3158 return nullptr;
3159
3160 // Create the imported parameter.
3161 ImplicitParamDecl *ToParm
3162 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3163 Loc, Name.getAsIdentifierInfo(),
3164 T);
3165 return Importer.Imported(D, ToParm);
3166 }
3167
VisitParmVarDecl(ParmVarDecl * D)3168 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3169 // Parameters are created in the translation unit's context, then moved
3170 // into the function declaration's context afterward.
3171 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3172
3173 // Import the name of this declaration.
3174 DeclarationName Name = Importer.Import(D->getDeclName());
3175 if (D->getDeclName() && !Name)
3176 return nullptr;
3177
3178 // Import the location of this declaration.
3179 SourceLocation Loc = Importer.Import(D->getLocation());
3180
3181 // Import the parameter's type.
3182 QualType T = Importer.Import(D->getType());
3183 if (T.isNull())
3184 return nullptr;
3185
3186 // Create the imported parameter.
3187 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3188 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3189 Importer.Import(D->getInnerLocStart()),
3190 Loc, Name.getAsIdentifierInfo(),
3191 T, TInfo, D->getStorageClass(),
3192 /*FIXME: Default argument*/nullptr);
3193 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3194 return Importer.Imported(D, ToParm);
3195 }
3196
VisitObjCMethodDecl(ObjCMethodDecl * D)3197 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3198 // Import the major distinguishing characteristics of a method.
3199 DeclContext *DC, *LexicalDC;
3200 DeclarationName Name;
3201 SourceLocation Loc;
3202 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3203 return nullptr;
3204
3205 SmallVector<NamedDecl *, 2> FoundDecls;
3206 DC->localUncachedLookup(Name, FoundDecls);
3207 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3208 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3209 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3210 continue;
3211
3212 // Check return types.
3213 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3214 FoundMethod->getReturnType())) {
3215 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3216 << D->isInstanceMethod() << Name << D->getReturnType()
3217 << FoundMethod->getReturnType();
3218 Importer.ToDiag(FoundMethod->getLocation(),
3219 diag::note_odr_objc_method_here)
3220 << D->isInstanceMethod() << Name;
3221 return nullptr;
3222 }
3223
3224 // Check the number of parameters.
3225 if (D->param_size() != FoundMethod->param_size()) {
3226 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3227 << D->isInstanceMethod() << Name
3228 << D->param_size() << FoundMethod->param_size();
3229 Importer.ToDiag(FoundMethod->getLocation(),
3230 diag::note_odr_objc_method_here)
3231 << D->isInstanceMethod() << Name;
3232 return nullptr;
3233 }
3234
3235 // Check parameter types.
3236 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3237 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3238 P != PEnd; ++P, ++FoundP) {
3239 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3240 (*FoundP)->getType())) {
3241 Importer.FromDiag((*P)->getLocation(),
3242 diag::err_odr_objc_method_param_type_inconsistent)
3243 << D->isInstanceMethod() << Name
3244 << (*P)->getType() << (*FoundP)->getType();
3245 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3246 << (*FoundP)->getType();
3247 return nullptr;
3248 }
3249 }
3250
3251 // Check variadic/non-variadic.
3252 // Check the number of parameters.
3253 if (D->isVariadic() != FoundMethod->isVariadic()) {
3254 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3255 << D->isInstanceMethod() << Name;
3256 Importer.ToDiag(FoundMethod->getLocation(),
3257 diag::note_odr_objc_method_here)
3258 << D->isInstanceMethod() << Name;
3259 return nullptr;
3260 }
3261
3262 // FIXME: Any other bits we need to merge?
3263 return Importer.Imported(D, FoundMethod);
3264 }
3265 }
3266
3267 // Import the result type.
3268 QualType ResultTy = Importer.Import(D->getReturnType());
3269 if (ResultTy.isNull())
3270 return nullptr;
3271
3272 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3273
3274 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3275 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3276 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3277 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3278 D->getImplementationControl(), D->hasRelatedResultType());
3279
3280 // FIXME: When we decide to merge method definitions, we'll need to
3281 // deal with implicit parameters.
3282
3283 // Import the parameters
3284 SmallVector<ParmVarDecl *, 5> ToParams;
3285 for (auto *FromP : D->params()) {
3286 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3287 if (!ToP)
3288 return nullptr;
3289
3290 ToParams.push_back(ToP);
3291 }
3292
3293 // Set the parameters.
3294 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3295 ToParams[I]->setOwningFunction(ToMethod);
3296 ToMethod->addDeclInternal(ToParams[I]);
3297 }
3298 SmallVector<SourceLocation, 12> SelLocs;
3299 D->getSelectorLocs(SelLocs);
3300 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3301
3302 ToMethod->setLexicalDeclContext(LexicalDC);
3303 Importer.Imported(D, ToMethod);
3304 LexicalDC->addDeclInternal(ToMethod);
3305 return ToMethod;
3306 }
3307
VisitObjCCategoryDecl(ObjCCategoryDecl * D)3308 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3309 // Import the major distinguishing characteristics of a category.
3310 DeclContext *DC, *LexicalDC;
3311 DeclarationName Name;
3312 SourceLocation Loc;
3313 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3314 return nullptr;
3315
3316 ObjCInterfaceDecl *ToInterface
3317 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3318 if (!ToInterface)
3319 return nullptr;
3320
3321 // Determine if we've already encountered this category.
3322 ObjCCategoryDecl *MergeWithCategory
3323 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3324 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3325 if (!ToCategory) {
3326 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3327 Importer.Import(D->getAtStartLoc()),
3328 Loc,
3329 Importer.Import(D->getCategoryNameLoc()),
3330 Name.getAsIdentifierInfo(),
3331 ToInterface,
3332 Importer.Import(D->getIvarLBraceLoc()),
3333 Importer.Import(D->getIvarRBraceLoc()));
3334 ToCategory->setLexicalDeclContext(LexicalDC);
3335 LexicalDC->addDeclInternal(ToCategory);
3336 Importer.Imported(D, ToCategory);
3337
3338 // Import protocols
3339 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3340 SmallVector<SourceLocation, 4> ProtocolLocs;
3341 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3342 = D->protocol_loc_begin();
3343 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3344 FromProtoEnd = D->protocol_end();
3345 FromProto != FromProtoEnd;
3346 ++FromProto, ++FromProtoLoc) {
3347 ObjCProtocolDecl *ToProto
3348 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3349 if (!ToProto)
3350 return nullptr;
3351 Protocols.push_back(ToProto);
3352 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3353 }
3354
3355 // FIXME: If we're merging, make sure that the protocol list is the same.
3356 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3357 ProtocolLocs.data(), Importer.getToContext());
3358
3359 } else {
3360 Importer.Imported(D, ToCategory);
3361 }
3362
3363 // Import all of the members of this category.
3364 ImportDeclContext(D);
3365
3366 // If we have an implementation, import it as well.
3367 if (D->getImplementation()) {
3368 ObjCCategoryImplDecl *Impl
3369 = cast_or_null<ObjCCategoryImplDecl>(
3370 Importer.Import(D->getImplementation()));
3371 if (!Impl)
3372 return nullptr;
3373
3374 ToCategory->setImplementation(Impl);
3375 }
3376
3377 return ToCategory;
3378 }
3379
ImportDefinition(ObjCProtocolDecl * From,ObjCProtocolDecl * To,ImportDefinitionKind Kind)3380 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3381 ObjCProtocolDecl *To,
3382 ImportDefinitionKind Kind) {
3383 if (To->getDefinition()) {
3384 if (shouldForceImportDeclContext(Kind))
3385 ImportDeclContext(From);
3386 return false;
3387 }
3388
3389 // Start the protocol definition
3390 To->startDefinition();
3391
3392 // Import protocols
3393 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3394 SmallVector<SourceLocation, 4> ProtocolLocs;
3395 ObjCProtocolDecl::protocol_loc_iterator
3396 FromProtoLoc = From->protocol_loc_begin();
3397 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3398 FromProtoEnd = From->protocol_end();
3399 FromProto != FromProtoEnd;
3400 ++FromProto, ++FromProtoLoc) {
3401 ObjCProtocolDecl *ToProto
3402 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3403 if (!ToProto)
3404 return true;
3405 Protocols.push_back(ToProto);
3406 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3407 }
3408
3409 // FIXME: If we're merging, make sure that the protocol list is the same.
3410 To->setProtocolList(Protocols.data(), Protocols.size(),
3411 ProtocolLocs.data(), Importer.getToContext());
3412
3413 if (shouldForceImportDeclContext(Kind)) {
3414 // Import all of the members of this protocol.
3415 ImportDeclContext(From, /*ForceImport=*/true);
3416 }
3417 return false;
3418 }
3419
VisitObjCProtocolDecl(ObjCProtocolDecl * D)3420 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3421 // If this protocol has a definition in the translation unit we're coming
3422 // from, but this particular declaration is not that definition, import the
3423 // definition and map to that.
3424 ObjCProtocolDecl *Definition = D->getDefinition();
3425 if (Definition && Definition != D) {
3426 Decl *ImportedDef = Importer.Import(Definition);
3427 if (!ImportedDef)
3428 return nullptr;
3429
3430 return Importer.Imported(D, ImportedDef);
3431 }
3432
3433 // Import the major distinguishing characteristics of a protocol.
3434 DeclContext *DC, *LexicalDC;
3435 DeclarationName Name;
3436 SourceLocation Loc;
3437 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3438 return nullptr;
3439
3440 ObjCProtocolDecl *MergeWithProtocol = nullptr;
3441 SmallVector<NamedDecl *, 2> FoundDecls;
3442 DC->localUncachedLookup(Name, FoundDecls);
3443 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3444 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3445 continue;
3446
3447 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
3448 break;
3449 }
3450
3451 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3452 if (!ToProto) {
3453 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3454 Name.getAsIdentifierInfo(), Loc,
3455 Importer.Import(D->getAtStartLoc()),
3456 /*PrevDecl=*/nullptr);
3457 ToProto->setLexicalDeclContext(LexicalDC);
3458 LexicalDC->addDeclInternal(ToProto);
3459 }
3460
3461 Importer.Imported(D, ToProto);
3462
3463 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3464 return nullptr;
3465
3466 return ToProto;
3467 }
3468
ImportDefinition(ObjCInterfaceDecl * From,ObjCInterfaceDecl * To,ImportDefinitionKind Kind)3469 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3470 ObjCInterfaceDecl *To,
3471 ImportDefinitionKind Kind) {
3472 if (To->getDefinition()) {
3473 // Check consistency of superclass.
3474 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3475 if (FromSuper) {
3476 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3477 if (!FromSuper)
3478 return true;
3479 }
3480
3481 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3482 if ((bool)FromSuper != (bool)ToSuper ||
3483 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3484 Importer.ToDiag(To->getLocation(),
3485 diag::err_odr_objc_superclass_inconsistent)
3486 << To->getDeclName();
3487 if (ToSuper)
3488 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3489 << To->getSuperClass()->getDeclName();
3490 else
3491 Importer.ToDiag(To->getLocation(),
3492 diag::note_odr_objc_missing_superclass);
3493 if (From->getSuperClass())
3494 Importer.FromDiag(From->getSuperClassLoc(),
3495 diag::note_odr_objc_superclass)
3496 << From->getSuperClass()->getDeclName();
3497 else
3498 Importer.FromDiag(From->getLocation(),
3499 diag::note_odr_objc_missing_superclass);
3500 }
3501
3502 if (shouldForceImportDeclContext(Kind))
3503 ImportDeclContext(From);
3504 return false;
3505 }
3506
3507 // Start the definition.
3508 To->startDefinition();
3509
3510 // If this class has a superclass, import it.
3511 if (From->getSuperClass()) {
3512 ObjCInterfaceDecl *Super = cast_or_null<ObjCInterfaceDecl>(
3513 Importer.Import(From->getSuperClass()));
3514 if (!Super)
3515 return true;
3516
3517 To->setSuperClass(Super);
3518 To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3519 }
3520
3521 // Import protocols
3522 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3523 SmallVector<SourceLocation, 4> ProtocolLocs;
3524 ObjCInterfaceDecl::protocol_loc_iterator
3525 FromProtoLoc = From->protocol_loc_begin();
3526
3527 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3528 FromProtoEnd = From->protocol_end();
3529 FromProto != FromProtoEnd;
3530 ++FromProto, ++FromProtoLoc) {
3531 ObjCProtocolDecl *ToProto
3532 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3533 if (!ToProto)
3534 return true;
3535 Protocols.push_back(ToProto);
3536 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3537 }
3538
3539 // FIXME: If we're merging, make sure that the protocol list is the same.
3540 To->setProtocolList(Protocols.data(), Protocols.size(),
3541 ProtocolLocs.data(), Importer.getToContext());
3542
3543 // Import categories. When the categories themselves are imported, they'll
3544 // hook themselves into this interface.
3545 for (auto *Cat : From->known_categories())
3546 Importer.Import(Cat);
3547
3548 // If we have an @implementation, import it as well.
3549 if (From->getImplementation()) {
3550 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3551 Importer.Import(From->getImplementation()));
3552 if (!Impl)
3553 return true;
3554
3555 To->setImplementation(Impl);
3556 }
3557
3558 if (shouldForceImportDeclContext(Kind)) {
3559 // Import all of the members of this class.
3560 ImportDeclContext(From, /*ForceImport=*/true);
3561 }
3562 return false;
3563 }
3564
VisitObjCInterfaceDecl(ObjCInterfaceDecl * D)3565 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3566 // If this class has a definition in the translation unit we're coming from,
3567 // but this particular declaration is not that definition, import the
3568 // definition and map to that.
3569 ObjCInterfaceDecl *Definition = D->getDefinition();
3570 if (Definition && Definition != D) {
3571 Decl *ImportedDef = Importer.Import(Definition);
3572 if (!ImportedDef)
3573 return nullptr;
3574
3575 return Importer.Imported(D, ImportedDef);
3576 }
3577
3578 // Import the major distinguishing characteristics of an @interface.
3579 DeclContext *DC, *LexicalDC;
3580 DeclarationName Name;
3581 SourceLocation Loc;
3582 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3583 return nullptr;
3584
3585 // Look for an existing interface with the same name.
3586 ObjCInterfaceDecl *MergeWithIface = nullptr;
3587 SmallVector<NamedDecl *, 2> FoundDecls;
3588 DC->localUncachedLookup(Name, FoundDecls);
3589 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3590 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3591 continue;
3592
3593 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
3594 break;
3595 }
3596
3597 // Create an interface declaration, if one does not already exist.
3598 ObjCInterfaceDecl *ToIface = MergeWithIface;
3599 if (!ToIface) {
3600 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3601 Importer.Import(D->getAtStartLoc()),
3602 Name.getAsIdentifierInfo(),
3603 /*PrevDecl=*/nullptr, Loc,
3604 D->isImplicitInterfaceDecl());
3605 ToIface->setLexicalDeclContext(LexicalDC);
3606 LexicalDC->addDeclInternal(ToIface);
3607 }
3608 Importer.Imported(D, ToIface);
3609
3610 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
3611 return nullptr;
3612
3613 return ToIface;
3614 }
3615
VisitObjCCategoryImplDecl(ObjCCategoryImplDecl * D)3616 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
3617 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
3618 Importer.Import(D->getCategoryDecl()));
3619 if (!Category)
3620 return nullptr;
3621
3622 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
3623 if (!ToImpl) {
3624 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3625 if (!DC)
3626 return nullptr;
3627
3628 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3629 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3630 Importer.Import(D->getIdentifier()),
3631 Category->getClassInterface(),
3632 Importer.Import(D->getLocation()),
3633 Importer.Import(D->getAtStartLoc()),
3634 CategoryNameLoc);
3635
3636 DeclContext *LexicalDC = DC;
3637 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3638 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3639 if (!LexicalDC)
3640 return nullptr;
3641
3642 ToImpl->setLexicalDeclContext(LexicalDC);
3643 }
3644
3645 LexicalDC->addDeclInternal(ToImpl);
3646 Category->setImplementation(ToImpl);
3647 }
3648
3649 Importer.Imported(D, ToImpl);
3650 ImportDeclContext(D);
3651 return ToImpl;
3652 }
3653
VisitObjCImplementationDecl(ObjCImplementationDecl * D)3654 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
3655 // Find the corresponding interface.
3656 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
3657 Importer.Import(D->getClassInterface()));
3658 if (!Iface)
3659 return nullptr;
3660
3661 // Import the superclass, if any.
3662 ObjCInterfaceDecl *Super = nullptr;
3663 if (D->getSuperClass()) {
3664 Super = cast_or_null<ObjCInterfaceDecl>(
3665 Importer.Import(D->getSuperClass()));
3666 if (!Super)
3667 return nullptr;
3668 }
3669
3670 ObjCImplementationDecl *Impl = Iface->getImplementation();
3671 if (!Impl) {
3672 // We haven't imported an implementation yet. Create a new @implementation
3673 // now.
3674 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3675 Importer.ImportContext(D->getDeclContext()),
3676 Iface, Super,
3677 Importer.Import(D->getLocation()),
3678 Importer.Import(D->getAtStartLoc()),
3679 Importer.Import(D->getSuperClassLoc()),
3680 Importer.Import(D->getIvarLBraceLoc()),
3681 Importer.Import(D->getIvarRBraceLoc()));
3682
3683 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3684 DeclContext *LexicalDC
3685 = Importer.ImportContext(D->getLexicalDeclContext());
3686 if (!LexicalDC)
3687 return nullptr;
3688 Impl->setLexicalDeclContext(LexicalDC);
3689 }
3690
3691 // Associate the implementation with the class it implements.
3692 Iface->setImplementation(Impl);
3693 Importer.Imported(D, Iface->getImplementation());
3694 } else {
3695 Importer.Imported(D, Iface->getImplementation());
3696
3697 // Verify that the existing @implementation has the same superclass.
3698 if ((Super && !Impl->getSuperClass()) ||
3699 (!Super && Impl->getSuperClass()) ||
3700 (Super && Impl->getSuperClass() &&
3701 !declaresSameEntity(Super->getCanonicalDecl(),
3702 Impl->getSuperClass()))) {
3703 Importer.ToDiag(Impl->getLocation(),
3704 diag::err_odr_objc_superclass_inconsistent)
3705 << Iface->getDeclName();
3706 // FIXME: It would be nice to have the location of the superclass
3707 // below.
3708 if (Impl->getSuperClass())
3709 Importer.ToDiag(Impl->getLocation(),
3710 diag::note_odr_objc_superclass)
3711 << Impl->getSuperClass()->getDeclName();
3712 else
3713 Importer.ToDiag(Impl->getLocation(),
3714 diag::note_odr_objc_missing_superclass);
3715 if (D->getSuperClass())
3716 Importer.FromDiag(D->getLocation(),
3717 diag::note_odr_objc_superclass)
3718 << D->getSuperClass()->getDeclName();
3719 else
3720 Importer.FromDiag(D->getLocation(),
3721 diag::note_odr_objc_missing_superclass);
3722 return nullptr;
3723 }
3724 }
3725
3726 // Import all of the members of this @implementation.
3727 ImportDeclContext(D);
3728
3729 return Impl;
3730 }
3731
VisitObjCPropertyDecl(ObjCPropertyDecl * D)3732 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
3733 // Import the major distinguishing characteristics of an @property.
3734 DeclContext *DC, *LexicalDC;
3735 DeclarationName Name;
3736 SourceLocation Loc;
3737 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3738 return nullptr;
3739
3740 // Check whether we have already imported this property.
3741 SmallVector<NamedDecl *, 2> FoundDecls;
3742 DC->localUncachedLookup(Name, FoundDecls);
3743 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3744 if (ObjCPropertyDecl *FoundProp
3745 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
3746 // Check property types.
3747 if (!Importer.IsStructurallyEquivalent(D->getType(),
3748 FoundProp->getType())) {
3749 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3750 << Name << D->getType() << FoundProp->getType();
3751 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3752 << FoundProp->getType();
3753 return nullptr;
3754 }
3755
3756 // FIXME: Check property attributes, getters, setters, etc.?
3757
3758 // Consider these properties to be equivalent.
3759 Importer.Imported(D, FoundProp);
3760 return FoundProp;
3761 }
3762 }
3763
3764 // Import the type.
3765 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3766 if (!T)
3767 return nullptr;
3768
3769 // Create the new property.
3770 ObjCPropertyDecl *ToProperty
3771 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3772 Name.getAsIdentifierInfo(),
3773 Importer.Import(D->getAtLoc()),
3774 Importer.Import(D->getLParenLoc()),
3775 T,
3776 D->getPropertyImplementation());
3777 Importer.Imported(D, ToProperty);
3778 ToProperty->setLexicalDeclContext(LexicalDC);
3779 LexicalDC->addDeclInternal(ToProperty);
3780
3781 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
3782 ToProperty->setPropertyAttributesAsWritten(
3783 D->getPropertyAttributesAsWritten());
3784 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3785 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3786 ToProperty->setGetterMethodDecl(
3787 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3788 ToProperty->setSetterMethodDecl(
3789 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3790 ToProperty->setPropertyIvarDecl(
3791 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3792 return ToProperty;
3793 }
3794
VisitObjCPropertyImplDecl(ObjCPropertyImplDecl * D)3795 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
3796 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
3797 Importer.Import(D->getPropertyDecl()));
3798 if (!Property)
3799 return nullptr;
3800
3801 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3802 if (!DC)
3803 return nullptr;
3804
3805 // Import the lexical declaration context.
3806 DeclContext *LexicalDC = DC;
3807 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3808 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3809 if (!LexicalDC)
3810 return nullptr;
3811 }
3812
3813 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
3814 if (!InImpl)
3815 return nullptr;
3816
3817 // Import the ivar (for an @synthesize).
3818 ObjCIvarDecl *Ivar = nullptr;
3819 if (D->getPropertyIvarDecl()) {
3820 Ivar = cast_or_null<ObjCIvarDecl>(
3821 Importer.Import(D->getPropertyIvarDecl()));
3822 if (!Ivar)
3823 return nullptr;
3824 }
3825
3826 ObjCPropertyImplDecl *ToImpl
3827 = InImpl->FindPropertyImplDecl(Property->getIdentifier());
3828 if (!ToImpl) {
3829 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3830 Importer.Import(D->getLocStart()),
3831 Importer.Import(D->getLocation()),
3832 Property,
3833 D->getPropertyImplementation(),
3834 Ivar,
3835 Importer.Import(D->getPropertyIvarDeclLoc()));
3836 ToImpl->setLexicalDeclContext(LexicalDC);
3837 Importer.Imported(D, ToImpl);
3838 LexicalDC->addDeclInternal(ToImpl);
3839 } else {
3840 // Check that we have the same kind of property implementation (@synthesize
3841 // vs. @dynamic).
3842 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
3843 Importer.ToDiag(ToImpl->getLocation(),
3844 diag::err_odr_objc_property_impl_kind_inconsistent)
3845 << Property->getDeclName()
3846 << (ToImpl->getPropertyImplementation()
3847 == ObjCPropertyImplDecl::Dynamic);
3848 Importer.FromDiag(D->getLocation(),
3849 diag::note_odr_objc_property_impl_kind)
3850 << D->getPropertyDecl()->getDeclName()
3851 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
3852 return nullptr;
3853 }
3854
3855 // For @synthesize, check that we have the same
3856 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
3857 Ivar != ToImpl->getPropertyIvarDecl()) {
3858 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3859 diag::err_odr_objc_synthesize_ivar_inconsistent)
3860 << Property->getDeclName()
3861 << ToImpl->getPropertyIvarDecl()->getDeclName()
3862 << Ivar->getDeclName();
3863 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3864 diag::note_odr_objc_synthesize_ivar_here)
3865 << D->getPropertyIvarDecl()->getDeclName();
3866 return nullptr;
3867 }
3868
3869 // Merge the existing implementation with the new implementation.
3870 Importer.Imported(D, ToImpl);
3871 }
3872
3873 return ToImpl;
3874 }
3875
VisitTemplateTypeParmDecl(TemplateTypeParmDecl * D)3876 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
3877 // For template arguments, we adopt the translation unit as our declaration
3878 // context. This context will be fixed when the actual template declaration
3879 // is created.
3880
3881 // FIXME: Import default argument.
3882 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3883 Importer.getToContext().getTranslationUnitDecl(),
3884 Importer.Import(D->getLocStart()),
3885 Importer.Import(D->getLocation()),
3886 D->getDepth(),
3887 D->getIndex(),
3888 Importer.Import(D->getIdentifier()),
3889 D->wasDeclaredWithTypename(),
3890 D->isParameterPack());
3891 }
3892
3893 Decl *
VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl * D)3894 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
3895 // Import the name of this declaration.
3896 DeclarationName Name = Importer.Import(D->getDeclName());
3897 if (D->getDeclName() && !Name)
3898 return nullptr;
3899
3900 // Import the location of this declaration.
3901 SourceLocation Loc = Importer.Import(D->getLocation());
3902
3903 // Import the type of this declaration.
3904 QualType T = Importer.Import(D->getType());
3905 if (T.isNull())
3906 return nullptr;
3907
3908 // Import type-source information.
3909 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3910 if (D->getTypeSourceInfo() && !TInfo)
3911 return nullptr;
3912
3913 // FIXME: Import default argument.
3914
3915 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3916 Importer.getToContext().getTranslationUnitDecl(),
3917 Importer.Import(D->getInnerLocStart()),
3918 Loc, D->getDepth(), D->getPosition(),
3919 Name.getAsIdentifierInfo(),
3920 T, D->isParameterPack(), TInfo);
3921 }
3922
3923 Decl *
VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl * D)3924 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
3925 // Import the name of this declaration.
3926 DeclarationName Name = Importer.Import(D->getDeclName());
3927 if (D->getDeclName() && !Name)
3928 return nullptr;
3929
3930 // Import the location of this declaration.
3931 SourceLocation Loc = Importer.Import(D->getLocation());
3932
3933 // Import template parameters.
3934 TemplateParameterList *TemplateParams
3935 = ImportTemplateParameterList(D->getTemplateParameters());
3936 if (!TemplateParams)
3937 return nullptr;
3938
3939 // FIXME: Import default argument.
3940
3941 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3942 Importer.getToContext().getTranslationUnitDecl(),
3943 Loc, D->getDepth(), D->getPosition(),
3944 D->isParameterPack(),
3945 Name.getAsIdentifierInfo(),
3946 TemplateParams);
3947 }
3948
VisitClassTemplateDecl(ClassTemplateDecl * D)3949 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
3950 // If this record has a definition in the translation unit we're coming from,
3951 // but this particular declaration is not that definition, import the
3952 // definition and map to that.
3953 CXXRecordDecl *Definition
3954 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
3955 if (Definition && Definition != D->getTemplatedDecl()) {
3956 Decl *ImportedDef
3957 = Importer.Import(Definition->getDescribedClassTemplate());
3958 if (!ImportedDef)
3959 return nullptr;
3960
3961 return Importer.Imported(D, ImportedDef);
3962 }
3963
3964 // Import the major distinguishing characteristics of this class template.
3965 DeclContext *DC, *LexicalDC;
3966 DeclarationName Name;
3967 SourceLocation Loc;
3968 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3969 return nullptr;
3970
3971 // We may already have a template of the same name; try to find and match it.
3972 if (!DC->isFunctionOrMethod()) {
3973 SmallVector<NamedDecl *, 4> ConflictingDecls;
3974 SmallVector<NamedDecl *, 2> FoundDecls;
3975 DC->localUncachedLookup(Name, FoundDecls);
3976 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3977 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3978 continue;
3979
3980 Decl *Found = FoundDecls[I];
3981 if (ClassTemplateDecl *FoundTemplate
3982 = dyn_cast<ClassTemplateDecl>(Found)) {
3983 if (IsStructuralMatch(D, FoundTemplate)) {
3984 // The class templates structurally match; call it the same template.
3985 // FIXME: We may be filling in a forward declaration here. Handle
3986 // this case!
3987 Importer.Imported(D->getTemplatedDecl(),
3988 FoundTemplate->getTemplatedDecl());
3989 return Importer.Imported(D, FoundTemplate);
3990 }
3991 }
3992
3993 ConflictingDecls.push_back(FoundDecls[I]);
3994 }
3995
3996 if (!ConflictingDecls.empty()) {
3997 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
3998 ConflictingDecls.data(),
3999 ConflictingDecls.size());
4000 }
4001
4002 if (!Name)
4003 return nullptr;
4004 }
4005
4006 CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4007
4008 // Create the declaration that is being templated.
4009 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4010 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4011 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4012 DTemplated->getTagKind(),
4013 DC, StartLoc, IdLoc,
4014 Name.getAsIdentifierInfo());
4015 D2Templated->setAccess(DTemplated->getAccess());
4016 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4017 D2Templated->setLexicalDeclContext(LexicalDC);
4018
4019 // Create the class template declaration itself.
4020 TemplateParameterList *TemplateParams
4021 = ImportTemplateParameterList(D->getTemplateParameters());
4022 if (!TemplateParams)
4023 return nullptr;
4024
4025 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4026 Loc, Name, TemplateParams,
4027 D2Templated,
4028 /*PrevDecl=*/nullptr);
4029 D2Templated->setDescribedClassTemplate(D2);
4030
4031 D2->setAccess(D->getAccess());
4032 D2->setLexicalDeclContext(LexicalDC);
4033 LexicalDC->addDeclInternal(D2);
4034
4035 // Note the relationship between the class templates.
4036 Importer.Imported(D, D2);
4037 Importer.Imported(DTemplated, D2Templated);
4038
4039 if (DTemplated->isCompleteDefinition() &&
4040 !D2Templated->isCompleteDefinition()) {
4041 // FIXME: Import definition!
4042 }
4043
4044 return D2;
4045 }
4046
VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl * D)4047 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4048 ClassTemplateSpecializationDecl *D) {
4049 // If this record has a definition in the translation unit we're coming from,
4050 // but this particular declaration is not that definition, import the
4051 // definition and map to that.
4052 TagDecl *Definition = D->getDefinition();
4053 if (Definition && Definition != D) {
4054 Decl *ImportedDef = Importer.Import(Definition);
4055 if (!ImportedDef)
4056 return nullptr;
4057
4058 return Importer.Imported(D, ImportedDef);
4059 }
4060
4061 ClassTemplateDecl *ClassTemplate
4062 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4063 D->getSpecializedTemplate()));
4064 if (!ClassTemplate)
4065 return nullptr;
4066
4067 // Import the context of this declaration.
4068 DeclContext *DC = ClassTemplate->getDeclContext();
4069 if (!DC)
4070 return nullptr;
4071
4072 DeclContext *LexicalDC = DC;
4073 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4074 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4075 if (!LexicalDC)
4076 return nullptr;
4077 }
4078
4079 // Import the location of this declaration.
4080 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4081 SourceLocation IdLoc = Importer.Import(D->getLocation());
4082
4083 // Import template arguments.
4084 SmallVector<TemplateArgument, 2> TemplateArgs;
4085 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4086 D->getTemplateArgs().size(),
4087 TemplateArgs))
4088 return nullptr;
4089
4090 // Try to find an existing specialization with these template arguments.
4091 void *InsertPos = nullptr;
4092 ClassTemplateSpecializationDecl *D2
4093 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4094 if (D2) {
4095 // We already have a class template specialization with these template
4096 // arguments.
4097
4098 // FIXME: Check for specialization vs. instantiation errors.
4099
4100 if (RecordDecl *FoundDef = D2->getDefinition()) {
4101 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4102 // The record types structurally match, or the "from" translation
4103 // unit only had a forward declaration anyway; call it the same
4104 // function.
4105 return Importer.Imported(D, FoundDef);
4106 }
4107 }
4108 } else {
4109 // Create a new specialization.
4110 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4111 D->getTagKind(), DC,
4112 StartLoc, IdLoc,
4113 ClassTemplate,
4114 TemplateArgs.data(),
4115 TemplateArgs.size(),
4116 /*PrevDecl=*/nullptr);
4117 D2->setSpecializationKind(D->getSpecializationKind());
4118
4119 // Add this specialization to the class template.
4120 ClassTemplate->AddSpecialization(D2, InsertPos);
4121
4122 // Import the qualifier, if any.
4123 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4124
4125 // Add the specialization to this context.
4126 D2->setLexicalDeclContext(LexicalDC);
4127 LexicalDC->addDeclInternal(D2);
4128 }
4129 Importer.Imported(D, D2);
4130
4131 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4132 return nullptr;
4133
4134 return D2;
4135 }
4136
VisitVarTemplateDecl(VarTemplateDecl * D)4137 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4138 // If this variable has a definition in the translation unit we're coming
4139 // from,
4140 // but this particular declaration is not that definition, import the
4141 // definition and map to that.
4142 VarDecl *Definition =
4143 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4144 if (Definition && Definition != D->getTemplatedDecl()) {
4145 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4146 if (!ImportedDef)
4147 return nullptr;
4148
4149 return Importer.Imported(D, ImportedDef);
4150 }
4151
4152 // Import the major distinguishing characteristics of this variable template.
4153 DeclContext *DC, *LexicalDC;
4154 DeclarationName Name;
4155 SourceLocation Loc;
4156 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
4157 return nullptr;
4158
4159 // We may already have a template of the same name; try to find and match it.
4160 assert(!DC->isFunctionOrMethod() &&
4161 "Variable templates cannot be declared at function scope");
4162 SmallVector<NamedDecl *, 4> ConflictingDecls;
4163 SmallVector<NamedDecl *, 2> FoundDecls;
4164 DC->localUncachedLookup(Name, FoundDecls);
4165 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4166 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4167 continue;
4168
4169 Decl *Found = FoundDecls[I];
4170 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4171 if (IsStructuralMatch(D, FoundTemplate)) {
4172 // The variable templates structurally match; call it the same template.
4173 Importer.Imported(D->getTemplatedDecl(),
4174 FoundTemplate->getTemplatedDecl());
4175 return Importer.Imported(D, FoundTemplate);
4176 }
4177 }
4178
4179 ConflictingDecls.push_back(FoundDecls[I]);
4180 }
4181
4182 if (!ConflictingDecls.empty()) {
4183 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4184 ConflictingDecls.data(),
4185 ConflictingDecls.size());
4186 }
4187
4188 if (!Name)
4189 return nullptr;
4190
4191 VarDecl *DTemplated = D->getTemplatedDecl();
4192
4193 // Import the type.
4194 QualType T = Importer.Import(DTemplated->getType());
4195 if (T.isNull())
4196 return nullptr;
4197
4198 // Create the declaration that is being templated.
4199 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4200 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4201 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4202 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4203 IdLoc, Name.getAsIdentifierInfo(), T,
4204 TInfo, DTemplated->getStorageClass());
4205 D2Templated->setAccess(DTemplated->getAccess());
4206 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4207 D2Templated->setLexicalDeclContext(LexicalDC);
4208
4209 // Importer.Imported(DTemplated, D2Templated);
4210 // LexicalDC->addDeclInternal(D2Templated);
4211
4212 // Merge the initializer.
4213 if (ImportDefinition(DTemplated, D2Templated))
4214 return nullptr;
4215
4216 // Create the variable template declaration itself.
4217 TemplateParameterList *TemplateParams =
4218 ImportTemplateParameterList(D->getTemplateParameters());
4219 if (!TemplateParams)
4220 return nullptr;
4221
4222 VarTemplateDecl *D2 = VarTemplateDecl::Create(
4223 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4224 D2Templated->setDescribedVarTemplate(D2);
4225
4226 D2->setAccess(D->getAccess());
4227 D2->setLexicalDeclContext(LexicalDC);
4228 LexicalDC->addDeclInternal(D2);
4229
4230 // Note the relationship between the variable templates.
4231 Importer.Imported(D, D2);
4232 Importer.Imported(DTemplated, D2Templated);
4233
4234 if (DTemplated->isThisDeclarationADefinition() &&
4235 !D2Templated->isThisDeclarationADefinition()) {
4236 // FIXME: Import definition!
4237 }
4238
4239 return D2;
4240 }
4241
VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl * D)4242 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4243 VarTemplateSpecializationDecl *D) {
4244 // If this record has a definition in the translation unit we're coming from,
4245 // but this particular declaration is not that definition, import the
4246 // definition and map to that.
4247 VarDecl *Definition = D->getDefinition();
4248 if (Definition && Definition != D) {
4249 Decl *ImportedDef = Importer.Import(Definition);
4250 if (!ImportedDef)
4251 return nullptr;
4252
4253 return Importer.Imported(D, ImportedDef);
4254 }
4255
4256 VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
4257 Importer.Import(D->getSpecializedTemplate()));
4258 if (!VarTemplate)
4259 return nullptr;
4260
4261 // Import the context of this declaration.
4262 DeclContext *DC = VarTemplate->getDeclContext();
4263 if (!DC)
4264 return nullptr;
4265
4266 DeclContext *LexicalDC = DC;
4267 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4268 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4269 if (!LexicalDC)
4270 return nullptr;
4271 }
4272
4273 // Import the location of this declaration.
4274 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4275 SourceLocation IdLoc = Importer.Import(D->getLocation());
4276
4277 // Import template arguments.
4278 SmallVector<TemplateArgument, 2> TemplateArgs;
4279 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4280 D->getTemplateArgs().size(), TemplateArgs))
4281 return nullptr;
4282
4283 // Try to find an existing specialization with these template arguments.
4284 void *InsertPos = nullptr;
4285 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4286 TemplateArgs, InsertPos);
4287 if (D2) {
4288 // We already have a variable template specialization with these template
4289 // arguments.
4290
4291 // FIXME: Check for specialization vs. instantiation errors.
4292
4293 if (VarDecl *FoundDef = D2->getDefinition()) {
4294 if (!D->isThisDeclarationADefinition() ||
4295 IsStructuralMatch(D, FoundDef)) {
4296 // The record types structurally match, or the "from" translation
4297 // unit only had a forward declaration anyway; call it the same
4298 // variable.
4299 return Importer.Imported(D, FoundDef);
4300 }
4301 }
4302 } else {
4303
4304 // Import the type.
4305 QualType T = Importer.Import(D->getType());
4306 if (T.isNull())
4307 return nullptr;
4308 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4309
4310 // Create a new specialization.
4311 D2 = VarTemplateSpecializationDecl::Create(
4312 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4313 D->getStorageClass(), TemplateArgs.data(), TemplateArgs.size());
4314 D2->setSpecializationKind(D->getSpecializationKind());
4315 D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
4316
4317 // Add this specialization to the class template.
4318 VarTemplate->AddSpecialization(D2, InsertPos);
4319
4320 // Import the qualifier, if any.
4321 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4322
4323 // Add the specialization to this context.
4324 D2->setLexicalDeclContext(LexicalDC);
4325 LexicalDC->addDeclInternal(D2);
4326 }
4327 Importer.Imported(D, D2);
4328
4329 if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
4330 return nullptr;
4331
4332 return D2;
4333 }
4334
4335 //----------------------------------------------------------------------------
4336 // Import Statements
4337 //----------------------------------------------------------------------------
4338
VisitStmt(Stmt * S)4339 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4340 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4341 << S->getStmtClassName();
4342 return nullptr;
4343 }
4344
4345 //----------------------------------------------------------------------------
4346 // Import Expressions
4347 //----------------------------------------------------------------------------
VisitExpr(Expr * E)4348 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
4349 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4350 << E->getStmtClassName();
4351 return nullptr;
4352 }
4353
VisitDeclRefExpr(DeclRefExpr * E)4354 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
4355 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4356 if (!ToD)
4357 return nullptr;
4358
4359 NamedDecl *FoundD = nullptr;
4360 if (E->getDecl() != E->getFoundDecl()) {
4361 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4362 if (!FoundD)
4363 return nullptr;
4364 }
4365
4366 QualType T = Importer.Import(E->getType());
4367 if (T.isNull())
4368 return nullptr;
4369
4370 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4371 Importer.Import(E->getQualifierLoc()),
4372 Importer.Import(E->getTemplateKeywordLoc()),
4373 ToD,
4374 E->refersToEnclosingLocal(),
4375 Importer.Import(E->getLocation()),
4376 T, E->getValueKind(),
4377 FoundD,
4378 /*FIXME:TemplateArgs=*/nullptr);
4379 if (E->hadMultipleCandidates())
4380 DRE->setHadMultipleCandidates(true);
4381 return DRE;
4382 }
4383
VisitIntegerLiteral(IntegerLiteral * E)4384 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
4385 QualType T = Importer.Import(E->getType());
4386 if (T.isNull())
4387 return nullptr;
4388
4389 return IntegerLiteral::Create(Importer.getToContext(),
4390 E->getValue(), T,
4391 Importer.Import(E->getLocation()));
4392 }
4393
VisitCharacterLiteral(CharacterLiteral * E)4394 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
4395 QualType T = Importer.Import(E->getType());
4396 if (T.isNull())
4397 return nullptr;
4398
4399 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4400 E->getKind(), T,
4401 Importer.Import(E->getLocation()));
4402 }
4403
VisitParenExpr(ParenExpr * E)4404 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
4405 Expr *SubExpr = Importer.Import(E->getSubExpr());
4406 if (!SubExpr)
4407 return nullptr;
4408
4409 return new (Importer.getToContext())
4410 ParenExpr(Importer.Import(E->getLParen()),
4411 Importer.Import(E->getRParen()),
4412 SubExpr);
4413 }
4414
VisitUnaryOperator(UnaryOperator * E)4415 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
4416 QualType T = Importer.Import(E->getType());
4417 if (T.isNull())
4418 return nullptr;
4419
4420 Expr *SubExpr = Importer.Import(E->getSubExpr());
4421 if (!SubExpr)
4422 return nullptr;
4423
4424 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4425 T, E->getValueKind(),
4426 E->getObjectKind(),
4427 Importer.Import(E->getOperatorLoc()));
4428 }
4429
VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr * E)4430 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
4431 UnaryExprOrTypeTraitExpr *E) {
4432 QualType ResultType = Importer.Import(E->getType());
4433
4434 if (E->isArgumentType()) {
4435 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4436 if (!TInfo)
4437 return nullptr;
4438
4439 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4440 TInfo, ResultType,
4441 Importer.Import(E->getOperatorLoc()),
4442 Importer.Import(E->getRParenLoc()));
4443 }
4444
4445 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4446 if (!SubExpr)
4447 return nullptr;
4448
4449 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4450 SubExpr, ResultType,
4451 Importer.Import(E->getOperatorLoc()),
4452 Importer.Import(E->getRParenLoc()));
4453 }
4454
VisitBinaryOperator(BinaryOperator * E)4455 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
4456 QualType T = Importer.Import(E->getType());
4457 if (T.isNull())
4458 return nullptr;
4459
4460 Expr *LHS = Importer.Import(E->getLHS());
4461 if (!LHS)
4462 return nullptr;
4463
4464 Expr *RHS = Importer.Import(E->getRHS());
4465 if (!RHS)
4466 return nullptr;
4467
4468 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4469 T, E->getValueKind(),
4470 E->getObjectKind(),
4471 Importer.Import(E->getOperatorLoc()),
4472 E->isFPContractable());
4473 }
4474
VisitCompoundAssignOperator(CompoundAssignOperator * E)4475 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
4476 QualType T = Importer.Import(E->getType());
4477 if (T.isNull())
4478 return nullptr;
4479
4480 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4481 if (CompLHSType.isNull())
4482 return nullptr;
4483
4484 QualType CompResultType = Importer.Import(E->getComputationResultType());
4485 if (CompResultType.isNull())
4486 return nullptr;
4487
4488 Expr *LHS = Importer.Import(E->getLHS());
4489 if (!LHS)
4490 return nullptr;
4491
4492 Expr *RHS = Importer.Import(E->getRHS());
4493 if (!RHS)
4494 return nullptr;
4495
4496 return new (Importer.getToContext())
4497 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
4498 T, E->getValueKind(),
4499 E->getObjectKind(),
4500 CompLHSType, CompResultType,
4501 Importer.Import(E->getOperatorLoc()),
4502 E->isFPContractable());
4503 }
4504
ImportCastPath(CastExpr * E,CXXCastPath & Path)4505 static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
4506 if (E->path_empty()) return false;
4507
4508 // TODO: import cast paths
4509 return true;
4510 }
4511
VisitImplicitCastExpr(ImplicitCastExpr * E)4512 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
4513 QualType T = Importer.Import(E->getType());
4514 if (T.isNull())
4515 return nullptr;
4516
4517 Expr *SubExpr = Importer.Import(E->getSubExpr());
4518 if (!SubExpr)
4519 return nullptr;
4520
4521 CXXCastPath BasePath;
4522 if (ImportCastPath(E, BasePath))
4523 return nullptr;
4524
4525 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4526 SubExpr, &BasePath, E->getValueKind());
4527 }
4528
VisitCStyleCastExpr(CStyleCastExpr * E)4529 Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
4530 QualType T = Importer.Import(E->getType());
4531 if (T.isNull())
4532 return nullptr;
4533
4534 Expr *SubExpr = Importer.Import(E->getSubExpr());
4535 if (!SubExpr)
4536 return nullptr;
4537
4538 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4539 if (!TInfo && E->getTypeInfoAsWritten())
4540 return nullptr;
4541
4542 CXXCastPath BasePath;
4543 if (ImportCastPath(E, BasePath))
4544 return nullptr;
4545
4546 return CStyleCastExpr::Create(Importer.getToContext(), T,
4547 E->getValueKind(), E->getCastKind(),
4548 SubExpr, &BasePath, TInfo,
4549 Importer.Import(E->getLParenLoc()),
4550 Importer.Import(E->getRParenLoc()));
4551 }
4552
ASTImporter(ASTContext & ToContext,FileManager & ToFileManager,ASTContext & FromContext,FileManager & FromFileManager,bool MinimalImport)4553 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
4554 ASTContext &FromContext, FileManager &FromFileManager,
4555 bool MinimalImport)
4556 : ToContext(ToContext), FromContext(FromContext),
4557 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
4558 Minimal(MinimalImport), LastDiagFromFrom(false)
4559 {
4560 ImportedDecls[FromContext.getTranslationUnitDecl()]
4561 = ToContext.getTranslationUnitDecl();
4562 }
4563
~ASTImporter()4564 ASTImporter::~ASTImporter() { }
4565
Import(QualType FromT)4566 QualType ASTImporter::Import(QualType FromT) {
4567 if (FromT.isNull())
4568 return QualType();
4569
4570 const Type *fromTy = FromT.getTypePtr();
4571
4572 // Check whether we've already imported this type.
4573 llvm::DenseMap<const Type *, const Type *>::iterator Pos
4574 = ImportedTypes.find(fromTy);
4575 if (Pos != ImportedTypes.end())
4576 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
4577
4578 // Import the type
4579 ASTNodeImporter Importer(*this);
4580 QualType ToT = Importer.Visit(fromTy);
4581 if (ToT.isNull())
4582 return ToT;
4583
4584 // Record the imported type.
4585 ImportedTypes[fromTy] = ToT.getTypePtr();
4586
4587 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
4588 }
4589
Import(TypeSourceInfo * FromTSI)4590 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
4591 if (!FromTSI)
4592 return FromTSI;
4593
4594 // FIXME: For now we just create a "trivial" type source info based
4595 // on the type and a single location. Implement a real version of this.
4596 QualType T = Import(FromTSI->getType());
4597 if (T.isNull())
4598 return nullptr;
4599
4600 return ToContext.getTrivialTypeSourceInfo(T,
4601 FromTSI->getTypeLoc().getLocStart());
4602 }
4603
Import(Decl * FromD)4604 Decl *ASTImporter::Import(Decl *FromD) {
4605 if (!FromD)
4606 return nullptr;
4607
4608 ASTNodeImporter Importer(*this);
4609
4610 // Check whether we've already imported this declaration.
4611 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
4612 if (Pos != ImportedDecls.end()) {
4613 Decl *ToD = Pos->second;
4614 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4615 return ToD;
4616 }
4617
4618 // Import the type
4619 Decl *ToD = Importer.Visit(FromD);
4620 if (!ToD)
4621 return nullptr;
4622
4623 // Record the imported declaration.
4624 ImportedDecls[FromD] = ToD;
4625
4626 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
4627 // Keep track of anonymous tags that have an associated typedef.
4628 if (FromTag->getTypedefNameForAnonDecl())
4629 AnonTagsWithPendingTypedefs.push_back(FromTag);
4630 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
4631 // When we've finished transforming a typedef, see whether it was the
4632 // typedef for an anonymous tag.
4633 for (SmallVectorImpl<TagDecl *>::iterator
4634 FromTag = AnonTagsWithPendingTypedefs.begin(),
4635 FromTagEnd = AnonTagsWithPendingTypedefs.end();
4636 FromTag != FromTagEnd; ++FromTag) {
4637 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
4638 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
4639 // We found the typedef for an anonymous tag; link them.
4640 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
4641 AnonTagsWithPendingTypedefs.erase(FromTag);
4642 break;
4643 }
4644 }
4645 }
4646 }
4647
4648 return ToD;
4649 }
4650
ImportContext(DeclContext * FromDC)4651 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
4652 if (!FromDC)
4653 return FromDC;
4654
4655 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
4656 if (!ToDC)
4657 return nullptr;
4658
4659 // When we're using a record/enum/Objective-C class/protocol as a context, we
4660 // need it to have a definition.
4661 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
4662 RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
4663 if (ToRecord->isCompleteDefinition()) {
4664 // Do nothing.
4665 } else if (FromRecord->isCompleteDefinition()) {
4666 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
4667 ASTNodeImporter::IDK_Basic);
4668 } else {
4669 CompleteDecl(ToRecord);
4670 }
4671 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
4672 EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
4673 if (ToEnum->isCompleteDefinition()) {
4674 // Do nothing.
4675 } else if (FromEnum->isCompleteDefinition()) {
4676 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
4677 ASTNodeImporter::IDK_Basic);
4678 } else {
4679 CompleteDecl(ToEnum);
4680 }
4681 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
4682 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
4683 if (ToClass->getDefinition()) {
4684 // Do nothing.
4685 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
4686 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
4687 ASTNodeImporter::IDK_Basic);
4688 } else {
4689 CompleteDecl(ToClass);
4690 }
4691 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
4692 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
4693 if (ToProto->getDefinition()) {
4694 // Do nothing.
4695 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
4696 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
4697 ASTNodeImporter::IDK_Basic);
4698 } else {
4699 CompleteDecl(ToProto);
4700 }
4701 }
4702
4703 return ToDC;
4704 }
4705
Import(Expr * FromE)4706 Expr *ASTImporter::Import(Expr *FromE) {
4707 if (!FromE)
4708 return nullptr;
4709
4710 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
4711 }
4712
Import(Stmt * FromS)4713 Stmt *ASTImporter::Import(Stmt *FromS) {
4714 if (!FromS)
4715 return nullptr;
4716
4717 // Check whether we've already imported this declaration.
4718 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
4719 if (Pos != ImportedStmts.end())
4720 return Pos->second;
4721
4722 // Import the type
4723 ASTNodeImporter Importer(*this);
4724 Stmt *ToS = Importer.Visit(FromS);
4725 if (!ToS)
4726 return nullptr;
4727
4728 // Record the imported declaration.
4729 ImportedStmts[FromS] = ToS;
4730 return ToS;
4731 }
4732
Import(NestedNameSpecifier * FromNNS)4733 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
4734 if (!FromNNS)
4735 return nullptr;
4736
4737 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
4738
4739 switch (FromNNS->getKind()) {
4740 case NestedNameSpecifier::Identifier:
4741 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
4742 return NestedNameSpecifier::Create(ToContext, prefix, II);
4743 }
4744 return nullptr;
4745
4746 case NestedNameSpecifier::Namespace:
4747 if (NamespaceDecl *NS =
4748 cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
4749 return NestedNameSpecifier::Create(ToContext, prefix, NS);
4750 }
4751 return nullptr;
4752
4753 case NestedNameSpecifier::NamespaceAlias:
4754 if (NamespaceAliasDecl *NSAD =
4755 cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
4756 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
4757 }
4758 return nullptr;
4759
4760 case NestedNameSpecifier::Global:
4761 return NestedNameSpecifier::GlobalSpecifier(ToContext);
4762
4763 case NestedNameSpecifier::TypeSpec:
4764 case NestedNameSpecifier::TypeSpecWithTemplate: {
4765 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
4766 if (!T.isNull()) {
4767 bool bTemplate = FromNNS->getKind() ==
4768 NestedNameSpecifier::TypeSpecWithTemplate;
4769 return NestedNameSpecifier::Create(ToContext, prefix,
4770 bTemplate, T.getTypePtr());
4771 }
4772 }
4773 return nullptr;
4774 }
4775
4776 llvm_unreachable("Invalid nested name specifier kind");
4777 }
4778
Import(NestedNameSpecifierLoc FromNNS)4779 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
4780 // FIXME: Implement!
4781 return NestedNameSpecifierLoc();
4782 }
4783
Import(TemplateName From)4784 TemplateName ASTImporter::Import(TemplateName From) {
4785 switch (From.getKind()) {
4786 case TemplateName::Template:
4787 if (TemplateDecl *ToTemplate
4788 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4789 return TemplateName(ToTemplate);
4790
4791 return TemplateName();
4792
4793 case TemplateName::OverloadedTemplate: {
4794 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
4795 UnresolvedSet<2> ToTemplates;
4796 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
4797 E = FromStorage->end();
4798 I != E; ++I) {
4799 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
4800 ToTemplates.addDecl(To);
4801 else
4802 return TemplateName();
4803 }
4804 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
4805 ToTemplates.end());
4806 }
4807
4808 case TemplateName::QualifiedTemplate: {
4809 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
4810 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
4811 if (!Qualifier)
4812 return TemplateName();
4813
4814 if (TemplateDecl *ToTemplate
4815 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4816 return ToContext.getQualifiedTemplateName(Qualifier,
4817 QTN->hasTemplateKeyword(),
4818 ToTemplate);
4819
4820 return TemplateName();
4821 }
4822
4823 case TemplateName::DependentTemplate: {
4824 DependentTemplateName *DTN = From.getAsDependentTemplateName();
4825 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
4826 if (!Qualifier)
4827 return TemplateName();
4828
4829 if (DTN->isIdentifier()) {
4830 return ToContext.getDependentTemplateName(Qualifier,
4831 Import(DTN->getIdentifier()));
4832 }
4833
4834 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
4835 }
4836
4837 case TemplateName::SubstTemplateTemplateParm: {
4838 SubstTemplateTemplateParmStorage *subst
4839 = From.getAsSubstTemplateTemplateParm();
4840 TemplateTemplateParmDecl *param
4841 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
4842 if (!param)
4843 return TemplateName();
4844
4845 TemplateName replacement = Import(subst->getReplacement());
4846 if (replacement.isNull()) return TemplateName();
4847
4848 return ToContext.getSubstTemplateTemplateParm(param, replacement);
4849 }
4850
4851 case TemplateName::SubstTemplateTemplateParmPack: {
4852 SubstTemplateTemplateParmPackStorage *SubstPack
4853 = From.getAsSubstTemplateTemplateParmPack();
4854 TemplateTemplateParmDecl *Param
4855 = cast_or_null<TemplateTemplateParmDecl>(
4856 Import(SubstPack->getParameterPack()));
4857 if (!Param)
4858 return TemplateName();
4859
4860 ASTNodeImporter Importer(*this);
4861 TemplateArgument ArgPack
4862 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4863 if (ArgPack.isNull())
4864 return TemplateName();
4865
4866 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
4867 }
4868 }
4869
4870 llvm_unreachable("Invalid template name kind");
4871 }
4872
Import(SourceLocation FromLoc)4873 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
4874 if (FromLoc.isInvalid())
4875 return SourceLocation();
4876
4877 SourceManager &FromSM = FromContext.getSourceManager();
4878
4879 // For now, map everything down to its spelling location, so that we
4880 // don't have to import macro expansions.
4881 // FIXME: Import macro expansions!
4882 FromLoc = FromSM.getSpellingLoc(FromLoc);
4883 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
4884 SourceManager &ToSM = ToContext.getSourceManager();
4885 return ToSM.getLocForStartOfFile(Import(Decomposed.first))
4886 .getLocWithOffset(Decomposed.second);
4887 }
4888
Import(SourceRange FromRange)4889 SourceRange ASTImporter::Import(SourceRange FromRange) {
4890 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
4891 }
4892
Import(FileID FromID)4893 FileID ASTImporter::Import(FileID FromID) {
4894 llvm::DenseMap<FileID, FileID>::iterator Pos
4895 = ImportedFileIDs.find(FromID);
4896 if (Pos != ImportedFileIDs.end())
4897 return Pos->second;
4898
4899 SourceManager &FromSM = FromContext.getSourceManager();
4900 SourceManager &ToSM = ToContext.getSourceManager();
4901 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
4902 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
4903
4904 // Include location of this file.
4905 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
4906
4907 // Map the FileID for to the "to" source manager.
4908 FileID ToID;
4909 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
4910 if (Cache->OrigEntry) {
4911 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
4912 // disk again
4913 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
4914 // than mmap the files several times.
4915 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
4916 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
4917 FromSLoc.getFile().getFileCharacteristic());
4918 } else {
4919 // FIXME: We want to re-use the existing MemoryBuffer!
4920 const llvm::MemoryBuffer *
4921 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
4922 llvm::MemoryBuffer *ToBuf
4923 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
4924 FromBuf->getBufferIdentifier());
4925 ToID = ToSM.createFileID(ToBuf, FromSLoc.getFile().getFileCharacteristic());
4926 }
4927
4928
4929 ImportedFileIDs[FromID] = ToID;
4930 return ToID;
4931 }
4932
ImportDefinition(Decl * From)4933 void ASTImporter::ImportDefinition(Decl *From) {
4934 Decl *To = Import(From);
4935 if (!To)
4936 return;
4937
4938 if (DeclContext *FromDC = cast<DeclContext>(From)) {
4939 ASTNodeImporter Importer(*this);
4940
4941 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
4942 if (!ToRecord->getDefinition()) {
4943 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4944 ASTNodeImporter::IDK_Everything);
4945 return;
4946 }
4947 }
4948
4949 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
4950 if (!ToEnum->getDefinition()) {
4951 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4952 ASTNodeImporter::IDK_Everything);
4953 return;
4954 }
4955 }
4956
4957 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
4958 if (!ToIFace->getDefinition()) {
4959 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
4960 ASTNodeImporter::IDK_Everything);
4961 return;
4962 }
4963 }
4964
4965 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
4966 if (!ToProto->getDefinition()) {
4967 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
4968 ASTNodeImporter::IDK_Everything);
4969 return;
4970 }
4971 }
4972
4973 Importer.ImportDeclContext(FromDC, true);
4974 }
4975 }
4976
Import(DeclarationName FromName)4977 DeclarationName ASTImporter::Import(DeclarationName FromName) {
4978 if (!FromName)
4979 return DeclarationName();
4980
4981 switch (FromName.getNameKind()) {
4982 case DeclarationName::Identifier:
4983 return Import(FromName.getAsIdentifierInfo());
4984
4985 case DeclarationName::ObjCZeroArgSelector:
4986 case DeclarationName::ObjCOneArgSelector:
4987 case DeclarationName::ObjCMultiArgSelector:
4988 return Import(FromName.getObjCSelector());
4989
4990 case DeclarationName::CXXConstructorName: {
4991 QualType T = Import(FromName.getCXXNameType());
4992 if (T.isNull())
4993 return DeclarationName();
4994
4995 return ToContext.DeclarationNames.getCXXConstructorName(
4996 ToContext.getCanonicalType(T));
4997 }
4998
4999 case DeclarationName::CXXDestructorName: {
5000 QualType T = Import(FromName.getCXXNameType());
5001 if (T.isNull())
5002 return DeclarationName();
5003
5004 return ToContext.DeclarationNames.getCXXDestructorName(
5005 ToContext.getCanonicalType(T));
5006 }
5007
5008 case DeclarationName::CXXConversionFunctionName: {
5009 QualType T = Import(FromName.getCXXNameType());
5010 if (T.isNull())
5011 return DeclarationName();
5012
5013 return ToContext.DeclarationNames.getCXXConversionFunctionName(
5014 ToContext.getCanonicalType(T));
5015 }
5016
5017 case DeclarationName::CXXOperatorName:
5018 return ToContext.DeclarationNames.getCXXOperatorName(
5019 FromName.getCXXOverloadedOperator());
5020
5021 case DeclarationName::CXXLiteralOperatorName:
5022 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
5023 Import(FromName.getCXXLiteralIdentifier()));
5024
5025 case DeclarationName::CXXUsingDirective:
5026 // FIXME: STATICS!
5027 return DeclarationName::getUsingDirectiveName();
5028 }
5029
5030 llvm_unreachable("Invalid DeclarationName Kind!");
5031 }
5032
Import(const IdentifierInfo * FromId)5033 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
5034 if (!FromId)
5035 return nullptr;
5036
5037 return &ToContext.Idents.get(FromId->getName());
5038 }
5039
Import(Selector FromSel)5040 Selector ASTImporter::Import(Selector FromSel) {
5041 if (FromSel.isNull())
5042 return Selector();
5043
5044 SmallVector<IdentifierInfo *, 4> Idents;
5045 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
5046 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
5047 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
5048 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
5049 }
5050
HandleNameConflict(DeclarationName Name,DeclContext * DC,unsigned IDNS,NamedDecl ** Decls,unsigned NumDecls)5051 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
5052 DeclContext *DC,
5053 unsigned IDNS,
5054 NamedDecl **Decls,
5055 unsigned NumDecls) {
5056 return Name;
5057 }
5058
ToDiag(SourceLocation Loc,unsigned DiagID)5059 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
5060 if (LastDiagFromFrom)
5061 ToContext.getDiagnostics().notePriorDiagnosticFrom(
5062 FromContext.getDiagnostics());
5063 LastDiagFromFrom = false;
5064 return ToContext.getDiagnostics().Report(Loc, DiagID);
5065 }
5066
FromDiag(SourceLocation Loc,unsigned DiagID)5067 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
5068 if (!LastDiagFromFrom)
5069 FromContext.getDiagnostics().notePriorDiagnosticFrom(
5070 ToContext.getDiagnostics());
5071 LastDiagFromFrom = true;
5072 return FromContext.getDiagnostics().Report(Loc, DiagID);
5073 }
5074
CompleteDecl(Decl * D)5075 void ASTImporter::CompleteDecl (Decl *D) {
5076 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
5077 if (!ID->getDefinition())
5078 ID->startDefinition();
5079 }
5080 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
5081 if (!PD->getDefinition())
5082 PD->startDefinition();
5083 }
5084 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
5085 if (!TD->getDefinition() && !TD->isBeingDefined()) {
5086 TD->startDefinition();
5087 TD->setCompleteDefinition(true);
5088 }
5089 }
5090 else {
5091 assert (0 && "CompleteDecl called on a Decl that can't be completed");
5092 }
5093 }
5094
Imported(Decl * From,Decl * To)5095 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
5096 ImportedDecls[From] = To;
5097 return To;
5098 }
5099
IsStructurallyEquivalent(QualType From,QualType To,bool Complain)5100 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
5101 bool Complain) {
5102 llvm::DenseMap<const Type *, const Type *>::iterator Pos
5103 = ImportedTypes.find(From.getTypePtr());
5104 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
5105 return true;
5106
5107 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
5108 false, Complain);
5109 return Ctx.IsStructurallyEquivalent(From, To);
5110 }
5111