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