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