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