Bug Summary

File:tools/clang/include/clang/AST/Expr.h
Warning:line 4591, column 48
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTImporter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/AST -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp

1//===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
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
15#include "clang/AST/ASTImporter.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTDiagnostic.h"
18#include "clang/AST/ASTStructuralEquivalence.h"
19#include "clang/AST/Attr.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclAccessPair.h"
22#include "clang/AST/DeclBase.h"
23#include "clang/AST/DeclCXX.h"
24#include "clang/AST/DeclFriend.h"
25#include "clang/AST/DeclGroup.h"
26#include "clang/AST/DeclObjC.h"
27#include "clang/AST/DeclTemplate.h"
28#include "clang/AST/DeclVisitor.h"
29#include "clang/AST/DeclarationName.h"
30#include "clang/AST/Expr.h"
31#include "clang/AST/ExprCXX.h"
32#include "clang/AST/ExprObjC.h"
33#include "clang/AST/ExternalASTSource.h"
34#include "clang/AST/LambdaCapture.h"
35#include "clang/AST/NestedNameSpecifier.h"
36#include "clang/AST/OperationKinds.h"
37#include "clang/AST/Stmt.h"
38#include "clang/AST/StmtCXX.h"
39#include "clang/AST/StmtObjC.h"
40#include "clang/AST/StmtVisitor.h"
41#include "clang/AST/TemplateBase.h"
42#include "clang/AST/TemplateName.h"
43#include "clang/AST/Type.h"
44#include "clang/AST/TypeLoc.h"
45#include "clang/AST/TypeVisitor.h"
46#include "clang/AST/UnresolvedSet.h"
47#include "clang/Basic/ExceptionSpecificationType.h"
48#include "clang/Basic/FileManager.h"
49#include "clang/Basic/IdentifierTable.h"
50#include "clang/Basic/LLVM.h"
51#include "clang/Basic/LangOptions.h"
52#include "clang/Basic/SourceLocation.h"
53#include "clang/Basic/SourceManager.h"
54#include "clang/Basic/Specifiers.h"
55#include "llvm/ADT/APSInt.h"
56#include "llvm/ADT/ArrayRef.h"
57#include "llvm/ADT/DenseMap.h"
58#include "llvm/ADT/None.h"
59#include "llvm/ADT/Optional.h"
60#include "llvm/ADT/STLExtras.h"
61#include "llvm/ADT/SmallVector.h"
62#include "llvm/Support/Casting.h"
63#include "llvm/Support/ErrorHandling.h"
64#include "llvm/Support/MemoryBuffer.h"
65#include <algorithm>
66#include <cassert>
67#include <cstddef>
68#include <memory>
69#include <type_traits>
70#include <utility>
71
72namespace clang {
73
74 template <class T>
75 SmallVector<Decl*, 2>
76 getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
77 SmallVector<Decl*, 2> Redecls;
78 for (auto *R : D->getFirstDecl()->redecls()) {
79 if (R != D->getFirstDecl())
80 Redecls.push_back(R);
81 }
82 Redecls.push_back(D->getFirstDecl());
83 std::reverse(Redecls.begin(), Redecls.end());
84 return Redecls;
85 }
86
87 SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
88 // Currently only FunctionDecl is supported
89 auto FD = cast<FunctionDecl>(D);
90 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
91 }
92
93 void updateFlags(const Decl *From, Decl *To) {
94 // Check if some flags or attrs are new in 'From' and copy into 'To'.
95 // FIXME: Other flags or attrs?
96 if (From->isUsed(false) && !To->isUsed(false))
97 To->setIsUsed();
98 }
99
100 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
101 public DeclVisitor<ASTNodeImporter, Decl *>,
102 public StmtVisitor<ASTNodeImporter, Stmt *> {
103 ASTImporter &Importer;
104
105 // Wrapper for an overload set.
106 template <typename ToDeclT> struct CallOverloadedCreateFun {
107 template <typename... Args>
108 auto operator()(Args &&... args)
109 -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
110 return ToDeclT::Create(std::forward<Args>(args)...);
111 }
112 };
113
114 // Always use these functions to create a Decl during import. There are
115 // certain tasks which must be done after the Decl was created, e.g. we
116 // must immediately register that as an imported Decl. The parameter `ToD`
117 // will be set to the newly created Decl or if had been imported before
118 // then to the already imported Decl. Returns a bool value set to true if
119 // the `FromD` had been imported before.
120 template <typename ToDeclT, typename FromDeclT, typename... Args>
121 LLVM_NODISCARD[[clang::warn_unused_result]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
122 Args &&... args) {
123 // There may be several overloads of ToDeclT::Create. We must make sure
124 // to call the one which would be chosen by the arguments, thus we use a
125 // wrapper for the overload set.
126 CallOverloadedCreateFun<ToDeclT> OC;
127 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
128 std::forward<Args>(args)...);
129 }
130 // Use this overload if a special Type is needed to be created. E.g if we
131 // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
132 // then:
133 // TypedefNameDecl *ToTypedef;
134 // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
135 template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
136 typename... Args>
137 LLVM_NODISCARD[[clang::warn_unused_result]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
138 Args &&... args) {
139 CallOverloadedCreateFun<NewDeclT> OC;
140 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
141 std::forward<Args>(args)...);
142 }
143 // Use this version if a special create function must be
144 // used, e.g. CXXRecordDecl::CreateLambda .
145 template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
146 typename... Args>
147 LLVM_NODISCARD[[clang::warn_unused_result]] bool
148 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
149 FromDeclT *FromD, Args &&... args) {
150 ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
151 if (ToD)
152 return true; // Already imported.
153 ToD = CreateFun(std::forward<Args>(args)...);
154 InitializeImportedDecl(FromD, ToD);
155 return false; // A new Decl is created.
156 }
157
158 void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
159 Importer.MapImported(FromD, ToD);
160 ToD->IdentifierNamespace = FromD->IdentifierNamespace;
161 if (FromD->hasAttrs())
162 for (const Attr *FromAttr : FromD->getAttrs())
163 ToD->addAttr(Importer.Import(FromAttr));
164 if (FromD->isUsed())
165 ToD->setIsUsed();
166 if (FromD->isImplicit())
167 ToD->setImplicit();
168 }
169
170 public:
171 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
172
173 using TypeVisitor<ASTNodeImporter, QualType>::Visit;
174 using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
175 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
176
177 // Importing types
178 QualType VisitType(const Type *T);
179 QualType VisitAtomicType(const AtomicType *T);
180 QualType VisitBuiltinType(const BuiltinType *T);
181 QualType VisitDecayedType(const DecayedType *T);
182 QualType VisitComplexType(const ComplexType *T);
183 QualType VisitPointerType(const PointerType *T);
184 QualType VisitBlockPointerType(const BlockPointerType *T);
185 QualType VisitLValueReferenceType(const LValueReferenceType *T);
186 QualType VisitRValueReferenceType(const RValueReferenceType *T);
187 QualType VisitMemberPointerType(const MemberPointerType *T);
188 QualType VisitConstantArrayType(const ConstantArrayType *T);
189 QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
190 QualType VisitVariableArrayType(const VariableArrayType *T);
191 QualType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
192 // FIXME: DependentSizedExtVectorType
193 QualType VisitVectorType(const VectorType *T);
194 QualType VisitExtVectorType(const ExtVectorType *T);
195 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
196 QualType VisitFunctionProtoType(const FunctionProtoType *T);
197 QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
198 QualType VisitParenType(const ParenType *T);
199 QualType VisitTypedefType(const TypedefType *T);
200 QualType VisitTypeOfExprType(const TypeOfExprType *T);
201 // FIXME: DependentTypeOfExprType
202 QualType VisitTypeOfType(const TypeOfType *T);
203 QualType VisitDecltypeType(const DecltypeType *T);
204 QualType VisitUnaryTransformType(const UnaryTransformType *T);
205 QualType VisitAutoType(const AutoType *T);
206 QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
207 // FIXME: DependentDecltypeType
208 QualType VisitRecordType(const RecordType *T);
209 QualType VisitEnumType(const EnumType *T);
210 QualType VisitAttributedType(const AttributedType *T);
211 QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
212 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
213 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
214 QualType VisitElaboratedType(const ElaboratedType *T);
215 QualType VisitDependentNameType(const DependentNameType *T);
216 QualType VisitPackExpansionType(const PackExpansionType *T);
217 QualType VisitDependentTemplateSpecializationType(
218 const DependentTemplateSpecializationType *T);
219 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
220 QualType VisitObjCObjectType(const ObjCObjectType *T);
221 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
222
223 // Importing declarations
224 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
225 DeclContext *&LexicalDC, DeclarationName &Name,
226 NamedDecl *&ToD, SourceLocation &Loc);
227 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
228 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
229 DeclarationNameInfo& To);
230 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
231 void ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
232
233 bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
234
235 using Designator = DesignatedInitExpr::Designator;
236
237 Designator ImportDesignator(const Designator &D);
238
239 Optional<LambdaCapture> ImportLambdaCapture(const LambdaCapture &From);
240
241 /// What we should import from the definition.
242 enum ImportDefinitionKind {
243 /// Import the default subset of the definition, which might be
244 /// nothing (if minimal import is set) or might be everything (if minimal
245 /// import is not set).
246 IDK_Default,
247
248 /// Import everything.
249 IDK_Everything,
250
251 /// Import only the bare bones needed to establish a valid
252 /// DeclContext.
253 IDK_Basic
254 };
255
256 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
257 return IDK == IDK_Everything ||
258 (IDK == IDK_Default && !Importer.isMinimalImport());
259 }
260
261 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
262 ImportDefinitionKind Kind = IDK_Default);
263 bool ImportDefinition(VarDecl *From, VarDecl *To,
264 ImportDefinitionKind Kind = IDK_Default);
265 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
266 ImportDefinitionKind Kind = IDK_Default);
267 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
268 ImportDefinitionKind Kind = IDK_Default);
269 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
270 ImportDefinitionKind Kind = IDK_Default);
271 TemplateParameterList *ImportTemplateParameterList(
272 TemplateParameterList *Params);
273 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
274 Optional<TemplateArgumentLoc> ImportTemplateArgumentLoc(
275 const TemplateArgumentLoc &TALoc);
276 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
277 unsigned NumFromArgs,
278 SmallVectorImpl<TemplateArgument> &ToArgs);
279
280 template <typename InContainerTy>
281 bool ImportTemplateArgumentListInfo(const InContainerTy &Container,
282 TemplateArgumentListInfo &ToTAInfo);
283
284 template<typename InContainerTy>
285 bool ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc,
286 SourceLocation FromRAngleLoc,
287 const InContainerTy &Container,
288 TemplateArgumentListInfo &Result);
289
290 using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
291 using OptionalTemplateArgsTy = Optional<TemplateArgsTy>;
292 std::tuple<FunctionTemplateDecl *, OptionalTemplateArgsTy>
293 ImportFunctionTemplateWithTemplateArgsFromSpecialization(
294 FunctionDecl *FromFD);
295
296 bool ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
297
298 bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
299 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
300 bool Complain = true);
301 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
302 bool Complain = true);
303 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
304 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
305 bool IsStructuralMatch(FunctionTemplateDecl *From,
306 FunctionTemplateDecl *To);
307 bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
308 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
309 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
310 Decl *VisitDecl(Decl *D);
311 Decl *VisitEmptyDecl(EmptyDecl *D);
312 Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
313 Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
314 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
315 Decl *VisitNamespaceDecl(NamespaceDecl *D);
316 Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
317 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
318 Decl *VisitTypedefDecl(TypedefDecl *D);
319 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
320 Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
321 Decl *VisitLabelDecl(LabelDecl *D);
322 Decl *VisitEnumDecl(EnumDecl *D);
323 Decl *VisitRecordDecl(RecordDecl *D);
324 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
325 Decl *VisitFunctionDecl(FunctionDecl *D);
326 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
327 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
328 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
329 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
330 Decl *VisitFieldDecl(FieldDecl *D);
331 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
332 Decl *VisitFriendDecl(FriendDecl *D);
333 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
334 Decl *VisitVarDecl(VarDecl *D);
335 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
336 Decl *VisitParmVarDecl(ParmVarDecl *D);
337 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
338 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
339 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
340 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
341 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
342 Decl *VisitUsingDecl(UsingDecl *D);
343 Decl *VisitUsingShadowDecl(UsingShadowDecl *D);
344 Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
345 Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
346 Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
347
348 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
349 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
350 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
351 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
352 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
353 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
354 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
355 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
356 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
357 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
358 Decl *VisitClassTemplateSpecializationDecl(
359 ClassTemplateSpecializationDecl *D);
360 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
361 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
362 Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
363
364 // Importing statements
365 DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
366
367 Stmt *VisitStmt(Stmt *S);
368 Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
369 Stmt *VisitDeclStmt(DeclStmt *S);
370 Stmt *VisitNullStmt(NullStmt *S);
371 Stmt *VisitCompoundStmt(CompoundStmt *S);
372 Stmt *VisitCaseStmt(CaseStmt *S);
373 Stmt *VisitDefaultStmt(DefaultStmt *S);
374 Stmt *VisitLabelStmt(LabelStmt *S);
375 Stmt *VisitAttributedStmt(AttributedStmt *S);
376 Stmt *VisitIfStmt(IfStmt *S);
377 Stmt *VisitSwitchStmt(SwitchStmt *S);
378 Stmt *VisitWhileStmt(WhileStmt *S);
379 Stmt *VisitDoStmt(DoStmt *S);
380 Stmt *VisitForStmt(ForStmt *S);
381 Stmt *VisitGotoStmt(GotoStmt *S);
382 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
383 Stmt *VisitContinueStmt(ContinueStmt *S);
384 Stmt *VisitBreakStmt(BreakStmt *S);
385 Stmt *VisitReturnStmt(ReturnStmt *S);
386 // FIXME: MSAsmStmt
387 // FIXME: SEHExceptStmt
388 // FIXME: SEHFinallyStmt
389 // FIXME: SEHTryStmt
390 // FIXME: SEHLeaveStmt
391 // FIXME: CapturedStmt
392 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
393 Stmt *VisitCXXTryStmt(CXXTryStmt *S);
394 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
395 // FIXME: MSDependentExistsStmt
396 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
397 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
398 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
399 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
400 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
401 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
402 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
403
404 // Importing expressions
405 Expr *VisitExpr(Expr *E);
406 Expr *VisitVAArgExpr(VAArgExpr *E);
407 Expr *VisitGNUNullExpr(GNUNullExpr *E);
408 Expr *VisitPredefinedExpr(PredefinedExpr *E);
409 Expr *VisitDeclRefExpr(DeclRefExpr *E);
410 Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
411 Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
412 Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
413 Expr *VisitIntegerLiteral(IntegerLiteral *E);
414 Expr *VisitFloatingLiteral(FloatingLiteral *E);
415 Expr *VisitCharacterLiteral(CharacterLiteral *E);
416 Expr *VisitStringLiteral(StringLiteral *E);
417 Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
418 Expr *VisitAtomicExpr(AtomicExpr *E);
419 Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
420 Expr *VisitParenExpr(ParenExpr *E);
421 Expr *VisitParenListExpr(ParenListExpr *E);
422 Expr *VisitStmtExpr(StmtExpr *E);
423 Expr *VisitUnaryOperator(UnaryOperator *E);
424 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
425 Expr *VisitBinaryOperator(BinaryOperator *E);
426 Expr *VisitConditionalOperator(ConditionalOperator *E);
427 Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
428 Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
429 Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
430 Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
431 Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
432 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
433 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
434 Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
435 Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
436 Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
437 Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
438 Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
439 Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
440 Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
441 Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
442 Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
443 Expr *VisitPackExpansionExpr(PackExpansionExpr *E);
444 Expr *VisitSizeOfPackExpr(SizeOfPackExpr *E);
445 Expr *VisitCXXNewExpr(CXXNewExpr *CE);
446 Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
447 Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
448 Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
449 Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
450 Expr *VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
451 Expr *VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *CE);
452 Expr *VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
453 Expr *VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
454 Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
455 Expr *VisitCXXThisExpr(CXXThisExpr *E);
456 Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
457 Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
458 Expr *VisitMemberExpr(MemberExpr *E);
459 Expr *VisitCallExpr(CallExpr *E);
460 Expr *VisitLambdaExpr(LambdaExpr *LE);
461 Expr *VisitInitListExpr(InitListExpr *E);
462 Expr *VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
463 Expr *VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
464 Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
465 Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
466 Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
467 Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
468 Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
469 Expr *VisitTypeTraitExpr(TypeTraitExpr *E);
470 Expr *VisitCXXTypeidExpr(CXXTypeidExpr *E);
471
472 template<typename IIter, typename OIter>
473 void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
474 using ItemT = typename std::remove_reference<decltype(*Obegin)>::type;
475
476 ASTImporter &ImporterRef = Importer;
477 std::transform(Ibegin, Iend, Obegin,
478 [&ImporterRef](ItemT From) -> ItemT {
479 return ImporterRef.Import(From);
480 });
481 }
482
483 template<typename IIter, typename OIter>
484 bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
485 using ItemT = typename std::remove_reference<decltype(**Obegin)>::type;
486
487 ASTImporter &ImporterRef = Importer;
488 bool Failed = false;
489 std::transform(Ibegin, Iend, Obegin,
490 [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
491 auto *To = cast_or_null<ItemT>(ImporterRef.Import(From));
492 if (!To && From)
493 Failed = true;
494 return To;
495 });
496 return Failed;
497 }
498
499 template<typename InContainerTy, typename OutContainerTy>
500 bool ImportContainerChecked(const InContainerTy &InContainer,
501 OutContainerTy &OutContainer) {
502 return ImportArrayChecked(InContainer.begin(), InContainer.end(),
503 OutContainer.begin());
504 }
505
506 template<typename InContainerTy, typename OIter>
507 bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
508 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
509 }
510
511 // Importing overrides.
512 void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);
513
514 FunctionDecl *FindFunctionTemplateSpecialization(FunctionDecl *FromFD);
515 };
516
517template <typename InContainerTy>
518bool ASTNodeImporter::ImportTemplateArgumentListInfo(
519 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
520 const InContainerTy &Container, TemplateArgumentListInfo &Result) {
521 TemplateArgumentListInfo ToTAInfo(Importer.Import(FromLAngleLoc),
522 Importer.Import(FromRAngleLoc));
523 if (ImportTemplateArgumentListInfo(Container, ToTAInfo))
524 return true;
525 Result = ToTAInfo;
526 return false;
527}
528
529template <>
530bool ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
531 const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
532 return ImportTemplateArgumentListInfo(
533 From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
534}
535
536template <>
537bool ASTNodeImporter::ImportTemplateArgumentListInfo<
538 ASTTemplateArgumentListInfo>(const ASTTemplateArgumentListInfo &From,
539 TemplateArgumentListInfo &Result) {
540 return ImportTemplateArgumentListInfo(From.LAngleLoc, From.RAngleLoc,
541 From.arguments(), Result);
542}
543
544std::tuple<FunctionTemplateDecl *, ASTNodeImporter::OptionalTemplateArgsTy>
545ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
546 FunctionDecl *FromFD) {
547 assert(FromFD->getTemplatedKind() ==(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 548, __extension__ __PRETTY_FUNCTION__))
548 FunctionDecl::TK_FunctionTemplateSpecialization)(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 548, __extension__ __PRETTY_FUNCTION__))
;
549 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
550 auto *Template = cast_or_null<FunctionTemplateDecl>(
551 Importer.Import(FTSInfo->getTemplate()));
552
553 // Import template arguments.
554 auto TemplArgs = FTSInfo->TemplateArguments->asArray();
555 TemplateArgsTy ToTemplArgs;
556 if (ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
557 ToTemplArgs)) // Error during import.
558 return std::make_tuple(Template, OptionalTemplateArgsTy());
559
560 return std::make_tuple(Template, ToTemplArgs);
561}
562
563} // namespace clang
564
565//----------------------------------------------------------------------------
566// Import Types
567//----------------------------------------------------------------------------
568
569using namespace clang;
570
571QualType ASTNodeImporter::VisitType(const Type *T) {
572 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
573 << T->getTypeClassName();
574 return {};
575}
576
577QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
578 QualType UnderlyingType = Importer.Import(T->getValueType());
579 if(UnderlyingType.isNull())
580 return {};
581
582 return Importer.getToContext().getAtomicType(UnderlyingType);
583}
584
585QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
586 switch (T->getKind()) {
587#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
588 case BuiltinType::Id: \
589 return Importer.getToContext().SingletonId;
590#include "clang/Basic/OpenCLImageTypes.def"
591#define SHARED_SINGLETON_TYPE(Expansion)
592#define BUILTIN_TYPE(Id, SingletonId) \
593 case BuiltinType::Id: return Importer.getToContext().SingletonId;
594#include "clang/AST/BuiltinTypes.def"
595
596 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
597 // context supports C++.
598
599 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
600 // context supports ObjC.
601
602 case BuiltinType::Char_U:
603 // The context we're importing from has an unsigned 'char'. If we're
604 // importing into a context with a signed 'char', translate to
605 // 'unsigned char' instead.
606 if (Importer.getToContext().getLangOpts().CharIsSigned)
607 return Importer.getToContext().UnsignedCharTy;
608
609 return Importer.getToContext().CharTy;
610
611 case BuiltinType::Char_S:
612 // The context we're importing from has an unsigned 'char'. If we're
613 // importing into a context with a signed 'char', translate to
614 // 'unsigned char' instead.
615 if (!Importer.getToContext().getLangOpts().CharIsSigned)
616 return Importer.getToContext().SignedCharTy;
617
618 return Importer.getToContext().CharTy;
619
620 case BuiltinType::WChar_S:
621 case BuiltinType::WChar_U:
622 // FIXME: If not in C++, shall we translate to the C equivalent of
623 // wchar_t?
624 return Importer.getToContext().WCharTy;
625 }
626
627 llvm_unreachable("Invalid BuiltinType Kind!")::llvm::llvm_unreachable_internal("Invalid BuiltinType Kind!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 627)
;
628}
629
630QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
631 QualType OrigT = Importer.Import(T->getOriginalType());
632 if (OrigT.isNull())
633 return {};
634
635 return Importer.getToContext().getDecayedType(OrigT);
636}
637
638QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
639 QualType ToElementType = Importer.Import(T->getElementType());
640 if (ToElementType.isNull())
641 return {};
642
643 return Importer.getToContext().getComplexType(ToElementType);
644}
645
646QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
647 QualType ToPointeeType = Importer.Import(T->getPointeeType());
648 if (ToPointeeType.isNull())
649 return {};
650
651 return Importer.getToContext().getPointerType(ToPointeeType);
652}
653
654QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
655 // FIXME: Check for blocks support in "to" context.
656 QualType ToPointeeType = Importer.Import(T->getPointeeType());
657 if (ToPointeeType.isNull())
658 return {};
659
660 return Importer.getToContext().getBlockPointerType(ToPointeeType);
661}
662
663QualType
664ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
665 // FIXME: Check for C++ support in "to" context.
666 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
667 if (ToPointeeType.isNull())
668 return {};
669
670 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
671}
672
673QualType
674ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
675 // FIXME: Check for C++0x support in "to" context.
676 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
677 if (ToPointeeType.isNull())
678 return {};
679
680 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
681}
682
683QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
684 // FIXME: Check for C++ support in "to" context.
685 QualType ToPointeeType = Importer.Import(T->getPointeeType());
686 if (ToPointeeType.isNull())
687 return {};
688
689 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
690 return Importer.getToContext().getMemberPointerType(ToPointeeType,
691 ClassType.getTypePtr());
692}
693
694QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
695 QualType ToElementType = Importer.Import(T->getElementType());
696 if (ToElementType.isNull())
697 return {};
698
699 return Importer.getToContext().getConstantArrayType(ToElementType,
700 T->getSize(),
701 T->getSizeModifier(),
702 T->getIndexTypeCVRQualifiers());
703}
704
705QualType
706ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
707 QualType ToElementType = Importer.Import(T->getElementType());
708 if (ToElementType.isNull())
709 return {};
710
711 return Importer.getToContext().getIncompleteArrayType(ToElementType,
712 T->getSizeModifier(),
713 T->getIndexTypeCVRQualifiers());
714}
715
716QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
717 QualType ToElementType = Importer.Import(T->getElementType());
718 if (ToElementType.isNull())
719 return {};
720
721 Expr *Size = Importer.Import(T->getSizeExpr());
722 if (!Size)
723 return {};
724
725 SourceRange Brackets = Importer.Import(T->getBracketsRange());
726 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
727 T->getSizeModifier(),
728 T->getIndexTypeCVRQualifiers(),
729 Brackets);
730}
731
732QualType ASTNodeImporter::VisitDependentSizedArrayType(
733 const DependentSizedArrayType *T) {
734 QualType ToElementType = Importer.Import(T->getElementType());
735 if (ToElementType.isNull())
736 return {};
737
738 // SizeExpr may be null if size is not specified directly.
739 // For example, 'int a[]'.
740 Expr *Size = Importer.Import(T->getSizeExpr());
741 if (!Size && T->getSizeExpr())
742 return {};
743
744 SourceRange Brackets = Importer.Import(T->getBracketsRange());
745 return Importer.getToContext().getDependentSizedArrayType(
746 ToElementType, Size, T->getSizeModifier(), T->getIndexTypeCVRQualifiers(),
747 Brackets);
748}
749
750QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
751 QualType ToElementType = Importer.Import(T->getElementType());
752 if (ToElementType.isNull())
753 return {};
754
755 return Importer.getToContext().getVectorType(ToElementType,
756 T->getNumElements(),
757 T->getVectorKind());
758}
759
760QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
761 QualType ToElementType = Importer.Import(T->getElementType());
762 if (ToElementType.isNull())
763 return {};
764
765 return Importer.getToContext().getExtVectorType(ToElementType,
766 T->getNumElements());
767}
768
769QualType
770ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
771 // FIXME: What happens if we're importing a function without a prototype
772 // into C++? Should we make it variadic?
773 QualType ToResultType = Importer.Import(T->getReturnType());
774 if (ToResultType.isNull())
775 return {};
776
777 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
778 T->getExtInfo());
779}
780
781QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
782 QualType ToResultType = Importer.Import(T->getReturnType());
783 if (ToResultType.isNull())
784 return {};
785
786 // Import argument types
787 SmallVector<QualType, 4> ArgTypes;
788 for (const auto &A : T->param_types()) {
789 QualType ArgType = Importer.Import(A);
790 if (ArgType.isNull())
791 return {};
792 ArgTypes.push_back(ArgType);
793 }
794
795 // Import exception types
796 SmallVector<QualType, 4> ExceptionTypes;
797 for (const auto &E : T->exceptions()) {
798 QualType ExceptionType = Importer.Import(E);
799 if (ExceptionType.isNull())
800 return {};
801 ExceptionTypes.push_back(ExceptionType);
802 }
803
804 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
805 FunctionProtoType::ExtProtoInfo ToEPI;
806
807 ToEPI.ExtInfo = FromEPI.ExtInfo;
808 ToEPI.Variadic = FromEPI.Variadic;
809 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
810 ToEPI.TypeQuals = FromEPI.TypeQuals;
811 ToEPI.RefQualifier = FromEPI.RefQualifier;
812 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
813 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
814 ToEPI.ExceptionSpec.NoexceptExpr =
815 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
816 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
817 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
818 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
819 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
820
821 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
822}
823
824QualType ASTNodeImporter::VisitUnresolvedUsingType(
825 const UnresolvedUsingType *T) {
826 const auto *ToD =
827 cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl()));
828 if (!ToD)
829 return {};
830
831 auto *ToPrevD =
832 cast_or_null<UnresolvedUsingTypenameDecl>(
833 Importer.Import(T->getDecl()->getPreviousDecl()));
834 if (!ToPrevD && T->getDecl()->getPreviousDecl())
835 return {};
836
837 return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
838}
839
840QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
841 QualType ToInnerType = Importer.Import(T->getInnerType());
842 if (ToInnerType.isNull())
843 return {};
844
845 return Importer.getToContext().getParenType(ToInnerType);
846}
847
848QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
849 auto *ToDecl =
850 dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
851 if (!ToDecl)
852 return {};
853
854 return Importer.getToContext().getTypeDeclType(ToDecl);
855}
856
857QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
858 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
859 if (!ToExpr)
860 return {};
861
862 return Importer.getToContext().getTypeOfExprType(ToExpr);
863}
864
865QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
866 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
867 if (ToUnderlyingType.isNull())
868 return {};
869
870 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
871}
872
873QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
874 // FIXME: Make sure that the "to" context supports C++0x!
875 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
876 if (!ToExpr)
877 return {};
878
879 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
880 if (UnderlyingType.isNull())
881 return {};
882
883 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
884}
885
886QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
887 QualType ToBaseType = Importer.Import(T->getBaseType());
888 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
889 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
890 return {};
891
892 return Importer.getToContext().getUnaryTransformType(ToBaseType,
893 ToUnderlyingType,
894 T->getUTTKind());
895}
896
897QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
898 // FIXME: Make sure that the "to" context supports C++11!
899 QualType FromDeduced = T->getDeducedType();
900 QualType ToDeduced;
901 if (!FromDeduced.isNull()) {
902 ToDeduced = Importer.Import(FromDeduced);
903 if (ToDeduced.isNull())
904 return {};
905 }
906
907 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
908 /*IsDependent*/false);
909}
910
911QualType ASTNodeImporter::VisitInjectedClassNameType(
912 const InjectedClassNameType *T) {
913 auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
914 if (!D)
915 return {};
916
917 QualType InjType = Importer.Import(T->getInjectedSpecializationType());
918 if (InjType.isNull())
919 return {};
920
921 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
922 // See comments in InjectedClassNameType definition for details
923 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
924 enum {
925 TypeAlignmentInBits = 4,
926 TypeAlignment = 1 << TypeAlignmentInBits
927 };
928
929 return QualType(new (Importer.getToContext(), TypeAlignment)
930 InjectedClassNameType(D, InjType), 0);
931}
932
933QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
934 auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
935 if (!ToDecl)
936 return {};
937
938 return Importer.getToContext().getTagDeclType(ToDecl);
939}
940
941QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
942 auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
943 if (!ToDecl)
944 return {};
945
946 return Importer.getToContext().getTagDeclType(ToDecl);
947}
948
949QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
950 QualType FromModifiedType = T->getModifiedType();
951 QualType FromEquivalentType = T->getEquivalentType();
952 QualType ToModifiedType;
953 QualType ToEquivalentType;
954
955 if (!FromModifiedType.isNull()) {
956 ToModifiedType = Importer.Import(FromModifiedType);
957 if (ToModifiedType.isNull())
958 return {};
959 }
960 if (!FromEquivalentType.isNull()) {
961 ToEquivalentType = Importer.Import(FromEquivalentType);
962 if (ToEquivalentType.isNull())
963 return {};
964 }
965
966 return Importer.getToContext().getAttributedType(T->getAttrKind(),
967 ToModifiedType, ToEquivalentType);
968}
969
970QualType ASTNodeImporter::VisitTemplateTypeParmType(
971 const TemplateTypeParmType *T) {
972 auto *ParmDecl =
973 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
974 if (!ParmDecl && T->getDecl())
975 return {};
976
977 return Importer.getToContext().getTemplateTypeParmType(
978 T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
979}
980
981QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
982 const SubstTemplateTypeParmType *T) {
983 const auto *Replaced =
984 cast_or_null<TemplateTypeParmType>(Importer.Import(
985 QualType(T->getReplacedParameter(), 0)).getTypePtr());
986 if (!Replaced)
987 return {};
988
989 QualType Replacement = Importer.Import(T->getReplacementType());
990 if (Replacement.isNull())
991 return {};
992 Replacement = Replacement.getCanonicalType();
993
994 return Importer.getToContext().getSubstTemplateTypeParmType(
995 Replaced, Replacement);
996}
997
998QualType ASTNodeImporter::VisitTemplateSpecializationType(
999 const TemplateSpecializationType *T) {
1000 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1001 if (ToTemplate.isNull())
1002 return {};
1003
1004 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1005 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1006 return {};
1007
1008 QualType ToCanonType;
1009 if (!QualType(T, 0).isCanonical()) {
1010 QualType FromCanonType
1011 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1012 ToCanonType =Importer.Import(FromCanonType);
1013 if (ToCanonType.isNull())
1014 return {};
1015 }
1016 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1017 ToTemplateArgs,
1018 ToCanonType);
1019}
1020
1021QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1022 NestedNameSpecifier *ToQualifier = nullptr;
1023 // Note: the qualifier in an ElaboratedType is optional.
1024 if (T->getQualifier()) {
1025 ToQualifier = Importer.Import(T->getQualifier());
1026 if (!ToQualifier)
1027 return {};
1028 }
1029
1030 QualType ToNamedType = Importer.Import(T->getNamedType());
1031 if (ToNamedType.isNull())
1032 return {};
1033
1034 TagDecl *OwnedTagDecl =
1035 cast_or_null<TagDecl>(Importer.Import(T->getOwnedTagDecl()));
1036 if (!OwnedTagDecl && T->getOwnedTagDecl())
1037 return {};
1038
1039 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1040 ToQualifier, ToNamedType,
1041 OwnedTagDecl);
1042}
1043
1044QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1045 QualType Pattern = Importer.Import(T->getPattern());
1046 if (Pattern.isNull())
1047 return {};
1048
1049 return Importer.getToContext().getPackExpansionType(Pattern,
1050 T->getNumExpansions());
1051}
1052
1053QualType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1054 const DependentTemplateSpecializationType *T) {
1055 NestedNameSpecifier *Qualifier = Importer.Import(T->getQualifier());
1056 if (!Qualifier && T->getQualifier())
1057 return {};
1058
1059 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1060 if (!Name && T->getIdentifier())
1061 return {};
1062
1063 SmallVector<TemplateArgument, 2> ToPack;
1064 ToPack.reserve(T->getNumArgs());
1065 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack))
1066 return {};
1067
1068 return Importer.getToContext().getDependentTemplateSpecializationType(
1069 T->getKeyword(), Qualifier, Name, ToPack);
1070}
1071
1072QualType ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1073 NestedNameSpecifier *NNS = Importer.Import(T->getQualifier());
1074 if (!NNS && T->getQualifier())
1075 return QualType();
1076
1077 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1078 if (!Name && T->getIdentifier())
1079 return QualType();
1080
1081 QualType Canon = (T == T->getCanonicalTypeInternal().getTypePtr())
1082 ? QualType()
1083 : Importer.Import(T->getCanonicalTypeInternal());
1084 if (!Canon.isNull())
1085 Canon = Canon.getCanonicalType();
1086
1087 return Importer.getToContext().getDependentNameType(T->getKeyword(), NNS,
1088 Name, Canon);
1089}
1090
1091QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1092 auto *Class =
1093 dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1094 if (!Class)
1095 return {};
1096
1097 return Importer.getToContext().getObjCInterfaceType(Class);
1098}
1099
1100QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1101 QualType ToBaseType = Importer.Import(T->getBaseType());
1102 if (ToBaseType.isNull())
1103 return {};
1104
1105 SmallVector<QualType, 4> TypeArgs;
1106 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1107 QualType ImportedTypeArg = Importer.Import(TypeArg);
1108 if (ImportedTypeArg.isNull())
1109 return {};
1110
1111 TypeArgs.push_back(ImportedTypeArg);
1112 }
1113
1114 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1115 for (auto *P : T->quals()) {
1116 auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1117 if (!Protocol)
1118 return {};
1119 Protocols.push_back(Protocol);
1120 }
1121
1122 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
1123 Protocols,
1124 T->isKindOfTypeAsWritten());
1125}
1126
1127QualType
1128ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1129 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1130 if (ToPointeeType.isNull())
1131 return {};
1132
1133 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1134}
1135
1136//----------------------------------------------------------------------------
1137// Import Declarations
1138//----------------------------------------------------------------------------
1139bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1140 DeclContext *&LexicalDC,
1141 DeclarationName &Name,
1142 NamedDecl *&ToD,
1143 SourceLocation &Loc) {
1144 // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
1145 // example: int struct_in_proto(struct data_t{int a;int b;} *d);
1146 DeclContext *OrigDC = D->getDeclContext();
1147 FunctionDecl *FunDecl;
1148 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1149 FunDecl->hasBody()) {
1150 SourceRange RecR = D->getSourceRange();
1151 SourceRange BodyR = FunDecl->getBody()->getSourceRange();
1152 // If RecordDecl is not in Body (it is a param), we bail out.
1153 if (RecR.isValid() && BodyR.isValid() &&
1154 (RecR.getBegin() < BodyR.getBegin() ||
1155 BodyR.getEnd() < RecR.getEnd())) {
1156 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1157 << D->getDeclKindName();
1158 return true;
1159 }
1160 }
1161
1162 // Import the context of this declaration.
1163 DC = Importer.ImportContext(OrigDC);
1164 if (!DC)
1165 return true;
1166
1167 LexicalDC = DC;
1168 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1169 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1170 if (!LexicalDC)
1171 return true;
1172 }
1173
1174 // Import the name of this declaration.
1175 Name = Importer.Import(D->getDeclName());
1176 if (D->getDeclName() && !Name)
1177 return true;
1178
1179 // Import the location of this declaration.
1180 Loc = Importer.Import(D->getLocation());
1181 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1182 return false;
1183}
1184
1185void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1186 if (!FromD)
1187 return;
1188
1189 if (!ToD) {
1190 ToD = Importer.Import(FromD);
1191 if (!ToD)
1192 return;
1193 }
1194
1195 if (auto *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1196 if (auto *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1197 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1198 ImportDefinition(FromRecord, ToRecord);
1199 }
1200 }
1201 return;
1202 }
1203
1204 if (auto *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1205 if (auto *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1206 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1207 ImportDefinition(FromEnum, ToEnum);
1208 }
1209 }
1210 return;
1211 }
1212}
1213
1214void
1215ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1216 DeclarationNameInfo& To) {
1217 // NOTE: To.Name and To.Loc are already imported.
1218 // We only have to import To.LocInfo.
1219 switch (To.getName().getNameKind()) {
1220 case DeclarationName::Identifier:
1221 case DeclarationName::ObjCZeroArgSelector:
1222 case DeclarationName::ObjCOneArgSelector:
1223 case DeclarationName::ObjCMultiArgSelector:
1224 case DeclarationName::CXXUsingDirective:
1225 case DeclarationName::CXXDeductionGuideName:
1226 return;
1227
1228 case DeclarationName::CXXOperatorName: {
1229 SourceRange Range = From.getCXXOperatorNameRange();
1230 To.setCXXOperatorNameRange(Importer.Import(Range));
1231 return;
1232 }
1233 case DeclarationName::CXXLiteralOperatorName: {
1234 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1235 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1236 return;
1237 }
1238 case DeclarationName::CXXConstructorName:
1239 case DeclarationName::CXXDestructorName:
1240 case DeclarationName::CXXConversionFunctionName: {
1241 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1242 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1243 return;
1244 }
1245 }
1246 llvm_unreachable("Unknown name kind.")::llvm::llvm_unreachable_internal("Unknown name kind.", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1246)
;
1247}
1248
1249void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1250 if (Importer.isMinimalImport() && !ForceImport) {
1251 Importer.ImportContext(FromDC);
1252 return;
1253 }
1254
1255 for (auto *From : FromDC->decls())
1256 Importer.Import(From);
1257}
1258
1259void ASTNodeImporter::ImportImplicitMethods(
1260 const CXXRecordDecl *From, CXXRecordDecl *To) {
1261 assert(From->isCompleteDefinition() && To->getDefinition() == To &&(static_cast <bool> (From->isCompleteDefinition() &&
To->getDefinition() == To && "Import implicit methods to or from non-definition"
) ? void (0) : __assert_fail ("From->isCompleteDefinition() && To->getDefinition() == To && \"Import implicit methods to or from non-definition\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1262, __extension__ __PRETTY_FUNCTION__))
1262 "Import implicit methods to or from non-definition")(static_cast <bool> (From->isCompleteDefinition() &&
To->getDefinition() == To && "Import implicit methods to or from non-definition"
) ? void (0) : __assert_fail ("From->isCompleteDefinition() && To->getDefinition() == To && \"Import implicit methods to or from non-definition\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1262, __extension__ __PRETTY_FUNCTION__))
;
1263
1264 for (CXXMethodDecl *FromM : From->methods())
1265 if (FromM->isImplicit())
1266 Importer.Import(FromM);
1267}
1268
1269static void setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
1270 ASTImporter &Importer) {
1271 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
1272 auto *ToTypedef =
1273 cast_or_null<TypedefNameDecl>(Importer.Import(FromTypedef));
1274 assert (ToTypedef && "Failed to import typedef of an anonymous structure")(static_cast <bool> (ToTypedef && "Failed to import typedef of an anonymous structure"
) ? void (0) : __assert_fail ("ToTypedef && \"Failed to import typedef of an anonymous structure\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1274, __extension__ __PRETTY_FUNCTION__))
;
1275
1276 To->setTypedefNameForAnonDecl(ToTypedef);
1277 }
1278}
1279
1280bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
1281 ImportDefinitionKind Kind) {
1282 if (To->getDefinition() || To->isBeingDefined()) {
1283 if (Kind == IDK_Everything)
1284 ImportDeclContext(From, /*ForceImport=*/true);
1285
1286 return false;
1287 }
1288
1289 To->startDefinition();
1290
1291 setTypedefNameForAnonDecl(From, To, Importer);
1292
1293 // Add base classes.
1294 if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1295 auto *FromCXX = cast<CXXRecordDecl>(From);
1296
1297 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1298 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1299 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
1300 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
1301 ToData.Aggregate = FromData.Aggregate;
1302 ToData.PlainOldData = FromData.PlainOldData;
1303 ToData.Empty = FromData.Empty;
1304 ToData.Polymorphic = FromData.Polymorphic;
1305 ToData.Abstract = FromData.Abstract;
1306 ToData.IsStandardLayout = FromData.IsStandardLayout;
1307 ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout;
1308 ToData.HasBasesWithFields = FromData.HasBasesWithFields;
1309 ToData.HasBasesWithNonStaticDataMembers =
1310 FromData.HasBasesWithNonStaticDataMembers;
1311 ToData.HasPrivateFields = FromData.HasPrivateFields;
1312 ToData.HasProtectedFields = FromData.HasProtectedFields;
1313 ToData.HasPublicFields = FromData.HasPublicFields;
1314 ToData.HasMutableFields = FromData.HasMutableFields;
1315 ToData.HasVariantMembers = FromData.HasVariantMembers;
1316 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
1317 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
1318 ToData.HasUninitializedReferenceMember
1319 = FromData.HasUninitializedReferenceMember;
1320 ToData.HasUninitializedFields = FromData.HasUninitializedFields;
1321 ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
1322 ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
1323 ToData.NeedOverloadResolutionForCopyConstructor
1324 = FromData.NeedOverloadResolutionForCopyConstructor;
1325 ToData.NeedOverloadResolutionForMoveConstructor
1326 = FromData.NeedOverloadResolutionForMoveConstructor;
1327 ToData.NeedOverloadResolutionForMoveAssignment
1328 = FromData.NeedOverloadResolutionForMoveAssignment;
1329 ToData.NeedOverloadResolutionForDestructor
1330 = FromData.NeedOverloadResolutionForDestructor;
1331 ToData.DefaultedCopyConstructorIsDeleted
1332 = FromData.DefaultedCopyConstructorIsDeleted;
1333 ToData.DefaultedMoveConstructorIsDeleted
1334 = FromData.DefaultedMoveConstructorIsDeleted;
1335 ToData.DefaultedMoveAssignmentIsDeleted
1336 = FromData.DefaultedMoveAssignmentIsDeleted;
1337 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1338 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1339 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1340 ToData.HasConstexprNonCopyMoveConstructor
1341 = FromData.HasConstexprNonCopyMoveConstructor;
1342 ToData.HasDefaultedDefaultConstructor
1343 = FromData.HasDefaultedDefaultConstructor;
1344 ToData.DefaultedDefaultConstructorIsConstexpr
1345 = FromData.DefaultedDefaultConstructorIsConstexpr;
1346 ToData.HasConstexprDefaultConstructor
1347 = FromData.HasConstexprDefaultConstructor;
1348 ToData.HasNonLiteralTypeFieldsOrBases
1349 = FromData.HasNonLiteralTypeFieldsOrBases;
1350 // ComputedVisibleConversions not imported.
1351 ToData.UserProvidedDefaultConstructor
1352 = FromData.UserProvidedDefaultConstructor;
1353 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1354 ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
1355 = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
1356 ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
1357 = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
1358 ToData.ImplicitCopyAssignmentHasConstParam
1359 = FromData.ImplicitCopyAssignmentHasConstParam;
1360 ToData.HasDeclaredCopyConstructorWithConstParam
1361 = FromData.HasDeclaredCopyConstructorWithConstParam;
1362 ToData.HasDeclaredCopyAssignmentWithConstParam
1363 = FromData.HasDeclaredCopyAssignmentWithConstParam;
1364
1365 SmallVector<CXXBaseSpecifier *, 4> Bases;
1366 for (const auto &Base1 : FromCXX->bases()) {
1367 QualType T = Importer.Import(Base1.getType());
1368 if (T.isNull())
1369 return true;
1370
1371 SourceLocation EllipsisLoc;
1372 if (Base1.isPackExpansion())
1373 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
1374
1375 // Ensure that we have a definition for the base.
1376 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
1377
1378 Bases.push_back(
1379 new (Importer.getToContext())
1380 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
1381 Base1.isVirtual(),
1382 Base1.isBaseOfClass(),
1383 Base1.getAccessSpecifierAsWritten(),
1384 Importer.Import(Base1.getTypeSourceInfo()),
1385 EllipsisLoc));
1386 }
1387 if (!Bases.empty())
1388 ToCXX->setBases(Bases.data(), Bases.size());
1389 }
1390
1391 if (shouldForceImportDeclContext(Kind))
1392 ImportDeclContext(From, /*ForceImport=*/true);
1393
1394 To->completeDefinition();
1395 return false;
1396}
1397
1398bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
1399 ImportDefinitionKind Kind) {
1400 if (To->getAnyInitializer())
1401 return false;
1402
1403 // FIXME: Can we really import any initializer? Alternatively, we could force
1404 // ourselves to import every declaration of a variable and then only use
1405 // getInit() here.
1406 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
1407
1408 // FIXME: Other bits to merge?
1409
1410 return false;
1411}
1412
1413bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
1414 ImportDefinitionKind Kind) {
1415 if (To->getDefinition() || To->isBeingDefined()) {
1416 if (Kind == IDK_Everything)
1417 ImportDeclContext(From, /*ForceImport=*/true);
1418 return false;
1419 }
1420
1421 To->startDefinition();
1422
1423 setTypedefNameForAnonDecl(From, To, Importer);
1424
1425 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
1426 if (T.isNull())
1427 return true;
1428
1429 QualType ToPromotionType = Importer.Import(From->getPromotionType());
1430 if (ToPromotionType.isNull())
1431 return true;
1432
1433 if (shouldForceImportDeclContext(Kind))
1434 ImportDeclContext(From, /*ForceImport=*/true);
1435
1436 // FIXME: we might need to merge the number of positive or negative bits
1437 // if the enumerator lists don't match.
1438 To->completeDefinition(T, ToPromotionType,
1439 From->getNumPositiveBits(),
1440 From->getNumNegativeBits());
1441 return false;
1442}
1443
1444TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
1445 TemplateParameterList *Params) {
1446 SmallVector<NamedDecl *, 4> ToParams(Params->size());
1447 if (ImportContainerChecked(*Params, ToParams))
1448 return nullptr;
1449
1450 Expr *ToRequiresClause;
1451 if (Expr *const R = Params->getRequiresClause()) {
1452 ToRequiresClause = Importer.Import(R);
1453 if (!ToRequiresClause)
1454 return nullptr;
1455 } else {
1456 ToRequiresClause = nullptr;
1457 }
1458
1459 return TemplateParameterList::Create(Importer.getToContext(),
1460 Importer.Import(Params->getTemplateLoc()),
1461 Importer.Import(Params->getLAngleLoc()),
1462 ToParams,
1463 Importer.Import(Params->getRAngleLoc()),
1464 ToRequiresClause);
1465}
1466
1467TemplateArgument
1468ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
1469 switch (From.getKind()) {
1470 case TemplateArgument::Null:
1471 return TemplateArgument();
1472
1473 case TemplateArgument::Type: {
1474 QualType ToType = Importer.Import(From.getAsType());
1475 if (ToType.isNull())
1476 return {};
1477 return TemplateArgument(ToType);
1478 }
1479
1480 case TemplateArgument::Integral: {
1481 QualType ToType = Importer.Import(From.getIntegralType());
1482 if (ToType.isNull())
1483 return {};
1484 return TemplateArgument(From, ToType);
1485 }
1486
1487 case TemplateArgument::Declaration: {
1488 auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
1489 QualType ToType = Importer.Import(From.getParamTypeForDecl());
1490 if (!To || ToType.isNull())
1491 return {};
1492 return TemplateArgument(To, ToType);
1493 }
1494
1495 case TemplateArgument::NullPtr: {
1496 QualType ToType = Importer.Import(From.getNullPtrType());
1497 if (ToType.isNull())
1498 return {};
1499 return TemplateArgument(ToType, /*isNullPtr*/true);
1500 }
1501
1502 case TemplateArgument::Template: {
1503 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
1504 if (ToTemplate.isNull())
1505 return {};
1506
1507 return TemplateArgument(ToTemplate);
1508 }
1509
1510 case TemplateArgument::TemplateExpansion: {
1511 TemplateName ToTemplate
1512 = Importer.Import(From.getAsTemplateOrTemplatePattern());
1513 if (ToTemplate.isNull())
1514 return {};
1515
1516 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
1517 }
1518
1519 case TemplateArgument::Expression:
1520 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
1521 return TemplateArgument(ToExpr);
1522 return TemplateArgument();
1523
1524 case TemplateArgument::Pack: {
1525 SmallVector<TemplateArgument, 2> ToPack;
1526 ToPack.reserve(From.pack_size());
1527 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
1528 return {};
1529
1530 return TemplateArgument(
1531 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
1532 }
1533 }
1534
1535 llvm_unreachable("Invalid template argument kind")::llvm::llvm_unreachable_internal("Invalid template argument kind"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1535)
;
1536}
1537
1538Optional<TemplateArgumentLoc>
1539ASTNodeImporter::ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc) {
1540 TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
1541 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
1542 TemplateArgumentLocInfo ToInfo;
1543 if (Arg.getKind() == TemplateArgument::Expression) {
1544 Expr *E = Importer.Import(FromInfo.getAsExpr());
1545 ToInfo = TemplateArgumentLocInfo(E);
1546 if (!E)
1547 return None;
1548 } else if (Arg.getKind() == TemplateArgument::Type) {
1549 if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
1550 ToInfo = TemplateArgumentLocInfo(TSI);
1551 else
1552 return None;
1553 } else {
1554 ToInfo = TemplateArgumentLocInfo(
1555 Importer.Import(FromInfo.getTemplateQualifierLoc()),
1556 Importer.Import(FromInfo.getTemplateNameLoc()),
1557 Importer.Import(FromInfo.getTemplateEllipsisLoc()));
1558 }
1559 return TemplateArgumentLoc(Arg, ToInfo);
1560}
1561
1562bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
1563 unsigned NumFromArgs,
1564 SmallVectorImpl<TemplateArgument> &ToArgs) {
1565 for (unsigned I = 0; I != NumFromArgs; ++I) {
1566 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
1567 if (To.isNull() && !FromArgs[I].isNull())
1568 return true;
1569
1570 ToArgs.push_back(To);
1571 }
1572
1573 return false;
1574}
1575
1576// We cannot use Optional<> pattern here and below because
1577// TemplateArgumentListInfo's operator new is declared as deleted so it cannot
1578// be stored in Optional.
1579template <typename InContainerTy>
1580bool ASTNodeImporter::ImportTemplateArgumentListInfo(
1581 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
1582 for (const auto &FromLoc : Container) {
1583 if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc))
1584 ToTAInfo.addArgument(*ToLoc);
1585 else
1586 return true;
1587 }
1588 return false;
1589}
1590
1591static StructuralEquivalenceKind
1592getStructuralEquivalenceKind(const ASTImporter &Importer) {
1593 return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
1594 : StructuralEquivalenceKind::Default;
1595}
1596
1597bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
1598 StructuralEquivalenceContext Ctx(
1599 Importer.getFromContext(), Importer.getToContext(),
1600 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1601 false, Complain);
1602 return Ctx.IsEquivalent(From, To);
1603}
1604
1605bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
1606 RecordDecl *ToRecord, bool Complain) {
1607 // Eliminate a potential failure point where we attempt to re-import
1608 // something we're trying to import while completing ToRecord.
1609 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
1610 if (ToOrigin) {
1611 auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
1612 if (ToOriginRecord)
1613 ToRecord = ToOriginRecord;
1614 }
1615
1616 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1617 ToRecord->getASTContext(),
1618 Importer.getNonEquivalentDecls(),
1619 getStructuralEquivalenceKind(Importer),
1620 false, Complain);
1621 return Ctx.IsEquivalent(FromRecord, ToRecord);
1622}
1623
1624bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
1625 bool Complain) {
1626 StructuralEquivalenceContext Ctx(
1627 Importer.getFromContext(), Importer.getToContext(),
1628 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1629 false, Complain);
1630 return Ctx.IsEquivalent(FromVar, ToVar);
1631}
1632
1633bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
1634 StructuralEquivalenceContext Ctx(
1635 Importer.getFromContext(), Importer.getToContext(),
1636 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
1637 return Ctx.IsEquivalent(FromEnum, ToEnum);
1638}
1639
1640bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
1641 FunctionTemplateDecl *To) {
1642 StructuralEquivalenceContext Ctx(
1643 Importer.getFromContext(), Importer.getToContext(),
1644 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1645 false, false);
1646 return Ctx.IsEquivalent(From, To);
1647}
1648
1649bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) {
1650 StructuralEquivalenceContext Ctx(
1651 Importer.getFromContext(), Importer.getToContext(),
1652 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1653 false, false);
1654 return Ctx.IsEquivalent(From, To);
1655}
1656
1657bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
1658 EnumConstantDecl *ToEC) {
1659 const llvm::APSInt &FromVal = FromEC->getInitVal();
1660 const llvm::APSInt &ToVal = ToEC->getInitVal();
1661
1662 return FromVal.isSigned() == ToVal.isSigned() &&
1663 FromVal.getBitWidth() == ToVal.getBitWidth() &&
1664 FromVal == ToVal;
1665}
1666
1667bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
1668 ClassTemplateDecl *To) {
1669 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1670 Importer.getToContext(),
1671 Importer.getNonEquivalentDecls(),
1672 getStructuralEquivalenceKind(Importer));
1673 return Ctx.IsEquivalent(From, To);
1674}
1675
1676bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
1677 VarTemplateDecl *To) {
1678 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1679 Importer.getToContext(),
1680 Importer.getNonEquivalentDecls(),
1681 getStructuralEquivalenceKind(Importer));
1682 return Ctx.IsEquivalent(From, To);
1683}
1684
1685Decl *ASTNodeImporter::VisitDecl(Decl *D) {
1686 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1687 << D->getDeclKindName();
1688 return nullptr;
1689}
1690
1691Decl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
1692 // Import the context of this declaration.
1693 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1694 if (!DC)
1695 return nullptr;
1696
1697 DeclContext *LexicalDC = DC;
1698 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1699 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1700 if (!LexicalDC)
1701 return nullptr;
1702 }
1703
1704 // Import the location of this declaration.
1705 SourceLocation Loc = Importer.Import(D->getLocation());
1706
1707 EmptyDecl *ToD;
1708 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc))
1709 return ToD;
1710
1711 ToD->setLexicalDeclContext(LexicalDC);
1712 LexicalDC->addDeclInternal(ToD);
1713 return ToD;
1714}
1715
1716Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
1717 TranslationUnitDecl *ToD =
1718 Importer.getToContext().getTranslationUnitDecl();
1719
1720 Importer.MapImported(D, ToD);
1721
1722 return ToD;
1723}
1724
1725Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1726 SourceLocation Loc = Importer.Import(D->getLocation());
1727 SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
1728
1729 // Import the context of this declaration.
1730 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1731 if (!DC)
1732 return nullptr;
1733
1734 AccessSpecDecl *ToD;
1735 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
1736 DC, Loc, ColonLoc))
1737 return ToD;
1738
1739 // Lexical DeclContext and Semantic DeclContext
1740 // is always the same for the accessSpec.
1741 ToD->setLexicalDeclContext(DC);
1742 DC->addDeclInternal(ToD);
1743
1744 return ToD;
1745}
1746
1747Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1748 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1749 if (!DC)
1750 return nullptr;
1751
1752 DeclContext *LexicalDC = DC;
1753
1754 // Import the location of this declaration.
1755 SourceLocation Loc = Importer.Import(D->getLocation());
1756
1757 Expr *AssertExpr = Importer.Import(D->getAssertExpr());
1758 if (!AssertExpr)
1759 return nullptr;
1760
1761 StringLiteral *FromMsg = D->getMessage();
1762 auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
1763 if (!ToMsg && FromMsg)
1764 return nullptr;
1765
1766 StaticAssertDecl *ToD;
1767 if (GetImportedOrCreateDecl(
1768 ToD, D, Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
1769 Importer.Import(D->getRParenLoc()), D->isFailed()))
1770 return ToD;
1771
1772 ToD->setLexicalDeclContext(LexicalDC);
1773 LexicalDC->addDeclInternal(ToD);
1774 return ToD;
1775}
1776
1777Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
1778 // Import the major distinguishing characteristics of this namespace.
1779 DeclContext *DC, *LexicalDC;
1780 DeclarationName Name;
1781 SourceLocation Loc;
1782 NamedDecl *ToD;
1783 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1784 return nullptr;
1785 if (ToD)
1786 return ToD;
1787
1788 NamespaceDecl *MergeWithNamespace = nullptr;
1789 if (!Name) {
1790 // This is an anonymous namespace. Adopt an existing anonymous
1791 // namespace if we can.
1792 // FIXME: Not testable.
1793 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
1794 MergeWithNamespace = TU->getAnonymousNamespace();
1795 else
1796 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
1797 } else {
1798 SmallVector<NamedDecl *, 4> ConflictingDecls;
1799 SmallVector<NamedDecl *, 2> FoundDecls;
1800 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1801 for (auto *FoundDecl : FoundDecls) {
1802 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
1803 continue;
1804
1805 if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
1806 MergeWithNamespace = FoundNS;
1807 ConflictingDecls.clear();
1808 break;
1809 }
1810
1811 ConflictingDecls.push_back(FoundDecl);
1812 }
1813
1814 if (!ConflictingDecls.empty()) {
1815 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
1816 ConflictingDecls.data(),
1817 ConflictingDecls.size());
1818 }
1819 }
1820
1821 // Create the "to" namespace, if needed.
1822 NamespaceDecl *ToNamespace = MergeWithNamespace;
1823 if (!ToNamespace) {
1824 if (GetImportedOrCreateDecl(
1825 ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
1826 Importer.Import(D->getLocStart()), Loc, Name.getAsIdentifierInfo(),
1827 /*PrevDecl=*/nullptr))
1828 return ToNamespace;
1829 ToNamespace->setLexicalDeclContext(LexicalDC);
1830 LexicalDC->addDeclInternal(ToNamespace);
1831
1832 // If this is an anonymous namespace, register it as the anonymous
1833 // namespace within its context.
1834 if (!Name) {
1835 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
1836 TU->setAnonymousNamespace(ToNamespace);
1837 else
1838 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
1839 }
1840 }
1841 Importer.MapImported(D, ToNamespace);
1842
1843 ImportDeclContext(D);
1844
1845 return ToNamespace;
1846}
1847
1848Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1849 // Import the major distinguishing characteristics of this namespace.
1850 DeclContext *DC, *LexicalDC;
1851 DeclarationName Name;
1852 SourceLocation Loc;
1853 NamedDecl *LookupD;
1854 if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
1855 return nullptr;
1856 if (LookupD)
1857 return LookupD;
1858
1859 // NOTE: No conflict resolution is done for namespace aliases now.
1860
1861 auto *TargetDecl = cast_or_null<NamespaceDecl>(
1862 Importer.Import(D->getNamespace()));
1863 if (!TargetDecl)
1864 return nullptr;
1865
1866 IdentifierInfo *ToII = Importer.Import(D->getIdentifier());
1867 if (!ToII)
1868 return nullptr;
1869
1870 NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc());
1871 if (D->getQualifierLoc() && !ToQLoc)
1872 return nullptr;
1873
1874 NamespaceAliasDecl *ToD;
1875 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC,
1876 Importer.Import(D->getNamespaceLoc()),
1877 Importer.Import(D->getAliasLoc()), ToII, ToQLoc,
1878 Importer.Import(D->getTargetNameLoc()),
1879 TargetDecl))
1880 return ToD;
1881
1882 ToD->setLexicalDeclContext(LexicalDC);
1883 LexicalDC->addDeclInternal(ToD);
1884
1885 return ToD;
1886}
1887
1888Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
1889 // Import the major distinguishing characteristics of this typedef.
1890 DeclContext *DC, *LexicalDC;
1891 DeclarationName Name;
1892 SourceLocation Loc;
1893 NamedDecl *ToD;
1894 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1895 return nullptr;
1896 if (ToD)
1897 return ToD;
1898
1899 // If this typedef is not in block scope, determine whether we've
1900 // seen a typedef with the same name (that we can merge with) or any
1901 // other entity by that name (which name lookup could conflict with).
1902 if (!DC->isFunctionOrMethod()) {
1903 SmallVector<NamedDecl *, 4> ConflictingDecls;
1904 unsigned IDNS = Decl::IDNS_Ordinary;
1905 SmallVector<NamedDecl *, 2> FoundDecls;
1906 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1907 for (auto *FoundDecl : FoundDecls) {
1908 if (!FoundDecl->isInIdentifierNamespace(IDNS))
1909 continue;
1910 if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
1911 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
1912 FoundTypedef->getUnderlyingType()))
1913 return Importer.MapImported(D, FoundTypedef);
1914 }
1915
1916 ConflictingDecls.push_back(FoundDecl);
1917 }
1918
1919 if (!ConflictingDecls.empty()) {
1920 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1921 ConflictingDecls.data(),
1922 ConflictingDecls.size());
1923 if (!Name)
1924 return nullptr;
1925 }
1926 }
1927
1928 // Import the underlying type of this typedef;
1929 QualType T = Importer.Import(D->getUnderlyingType());
1930 if (T.isNull())
1931 return nullptr;
1932
1933 // Create the new typedef node.
1934 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
1935 SourceLocation StartL = Importer.Import(D->getLocStart());
1936
1937 TypedefNameDecl *ToTypedef;
1938 if (IsAlias) {
1939 if (GetImportedOrCreateDecl<TypeAliasDecl>(
1940 ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1941 Name.getAsIdentifierInfo(), TInfo))
1942 return ToTypedef;
1943 } else if (GetImportedOrCreateDecl<TypedefDecl>(
1944 ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1945 Name.getAsIdentifierInfo(), TInfo))
1946 return ToTypedef;
1947
1948 ToTypedef->setAccess(D->getAccess());
1949 ToTypedef->setLexicalDeclContext(LexicalDC);
1950
1951 // Templated declarations should not appear in DeclContext.
1952 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
1953 if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
1954 LexicalDC->addDeclInternal(ToTypedef);
1955
1956 return ToTypedef;
1957}
1958
1959Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
1960 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
1961}
1962
1963Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
1964 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
1965}
1966
1967Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1968 // Import the major distinguishing characteristics of this typedef.
1969 DeclContext *DC, *LexicalDC;
1970 DeclarationName Name;
1971 SourceLocation Loc;
1972 NamedDecl *FoundD;
1973 if (ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
1974 return nullptr;
1975 if (FoundD)
1976 return FoundD;
1977
1978 // If this typedef is not in block scope, determine whether we've
1979 // seen a typedef with the same name (that we can merge with) or any
1980 // other entity by that name (which name lookup could conflict with).
1981 if (!DC->isFunctionOrMethod()) {
1982 SmallVector<NamedDecl *, 4> ConflictingDecls;
1983 unsigned IDNS = Decl::IDNS_Ordinary;
1984 SmallVector<NamedDecl *, 2> FoundDecls;
1985 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1986 for (auto *FoundDecl : FoundDecls) {
1987 if (!FoundDecl->isInIdentifierNamespace(IDNS))
1988 continue;
1989 if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
1990 return Importer.MapImported(D, FoundAlias);
1991 ConflictingDecls.push_back(FoundDecl);
1992 }
1993
1994 if (!ConflictingDecls.empty()) {
1995 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1996 ConflictingDecls.data(),
1997 ConflictingDecls.size());
1998 if (!Name)
1999 return nullptr;
2000 }
2001 }
2002
2003 TemplateParameterList *Params = ImportTemplateParameterList(
2004 D->getTemplateParameters());
2005 if (!Params)
2006 return nullptr;
2007
2008 auto *TemplDecl = cast_or_null<TypeAliasDecl>(
2009 Importer.Import(D->getTemplatedDecl()));
2010 if (!TemplDecl)
2011 return nullptr;
2012
2013 TypeAliasTemplateDecl *ToAlias;
2014 if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
2015 Name, Params, TemplDecl))
2016 return ToAlias;
2017
2018 TemplDecl->setDescribedAliasTemplate(ToAlias);
2019
2020 ToAlias->setAccess(D->getAccess());
2021 ToAlias->setLexicalDeclContext(LexicalDC);
2022 LexicalDC->addDeclInternal(ToAlias);
2023 return ToAlias;
2024}
2025
2026Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2027 // Import the major distinguishing characteristics of this label.
2028 DeclContext *DC, *LexicalDC;
2029 DeclarationName Name;
2030 SourceLocation Loc;
2031 NamedDecl *ToD;
2032 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2033 return nullptr;
2034 if (ToD)
2035 return ToD;
2036
2037 assert(LexicalDC->isFunctionOrMethod())(static_cast <bool> (LexicalDC->isFunctionOrMethod()
) ? void (0) : __assert_fail ("LexicalDC->isFunctionOrMethod()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2037, __extension__ __PRETTY_FUNCTION__))
;
2038
2039 LabelDecl *ToLabel;
2040 if (D->isGnuLocal()
2041 ? GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2042 Importer.Import(D->getLocation()),
2043 Name.getAsIdentifierInfo(),
2044 Importer.Import(D->getLocStart()))
2045 : GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2046 Importer.Import(D->getLocation()),
2047 Name.getAsIdentifierInfo()))
2048 return ToLabel;
2049
2050 auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2051 if (!Label)
2052 return nullptr;
2053
2054 ToLabel->setStmt(Label);
2055 ToLabel->setLexicalDeclContext(LexicalDC);
2056 LexicalDC->addDeclInternal(ToLabel);
2057 return ToLabel;
2058}
2059
2060Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2061 // Import the major distinguishing characteristics of this enum.
2062 DeclContext *DC, *LexicalDC;
2063 DeclarationName Name;
2064 SourceLocation Loc;
2065 NamedDecl *ToD;
2066 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2067 return nullptr;
2068 if (ToD)
2069 return ToD;
2070
2071 // Figure out what enum name we're looking for.
2072 unsigned IDNS = Decl::IDNS_Tag;
2073 DeclarationName SearchName = Name;
2074 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2075 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2076 IDNS = Decl::IDNS_Ordinary;
2077 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2078 IDNS |= Decl::IDNS_Ordinary;
2079
2080 // We may already have an enum of the same name; try to find and match it.
2081 if (!DC->isFunctionOrMethod() && SearchName) {
2082 SmallVector<NamedDecl *, 4> ConflictingDecls;
2083 SmallVector<NamedDecl *, 2> FoundDecls;
2084 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
2085 for (auto *FoundDecl : FoundDecls) {
2086 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2087 continue;
2088
2089 Decl *Found = FoundDecl;
2090 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2091 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2092 Found = Tag->getDecl();
2093 }
2094
2095 if (auto *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2096 if (IsStructuralMatch(D, FoundEnum))
2097 return Importer.MapImported(D, FoundEnum);
2098 }
2099
2100 ConflictingDecls.push_back(FoundDecl);
2101 }
2102
2103 if (!ConflictingDecls.empty()) {
2104 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2105 ConflictingDecls.data(),
2106 ConflictingDecls.size());
2107 }
2108 }
2109
2110 // Create the enum declaration.
2111 EnumDecl *D2;
2112 if (GetImportedOrCreateDecl(
2113 D2, D, Importer.getToContext(), DC, Importer.Import(D->getLocStart()),
2114 Loc, Name.getAsIdentifierInfo(), nullptr, D->isScoped(),
2115 D->isScopedUsingClassTag(), D->isFixed()))
2116 return D2;
2117
2118 // Import the qualifier, if any.
2119 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2120 D2->setAccess(D->getAccess());
2121 D2->setLexicalDeclContext(LexicalDC);
2122 LexicalDC->addDeclInternal(D2);
2123
2124 // Import the integer type.
2125 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2126 if (ToIntegerType.isNull())
2127 return nullptr;
2128 D2->setIntegerType(ToIntegerType);
2129
2130 // Import the definition
2131 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2132 return nullptr;
2133
2134 return D2;
2135}
2136
2137Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2138 // If this record has a definition in the translation unit we're coming from,
2139 // but this particular declaration is not that definition, import the
2140 // definition and map to that.
2141 TagDecl *Definition = D->getDefinition();
2142 if (Definition && Definition != D &&
2143 // In contrast to a normal CXXRecordDecl, the implicit
2144 // CXXRecordDecl of ClassTemplateSpecializationDecl is its redeclaration.
2145 // The definition of the implicit CXXRecordDecl in this case is the
2146 // ClassTemplateSpecializationDecl itself. Thus, we start with an extra
2147 // condition in order to be able to import the implict Decl.
2148 !D->isImplicit()) {
2149 Decl *ImportedDef = Importer.Import(Definition);
2150 if (!ImportedDef)
2151 return nullptr;
2152
2153 return Importer.MapImported(D, ImportedDef);
2154 }
2155
2156 // Import the major distinguishing characteristics of this record.
2157 DeclContext *DC, *LexicalDC;
2158 DeclarationName Name;
2159 SourceLocation Loc;
2160 NamedDecl *ToD;
2161 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2162 return nullptr;
2163 if (ToD)
2164 return ToD;
2165
2166 // Figure out what structure name we're looking for.
2167 unsigned IDNS = Decl::IDNS_Tag;
2168 DeclarationName SearchName = Name;
2169 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2170 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2171 IDNS = Decl::IDNS_Ordinary;
2172 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2173 IDNS |= Decl::IDNS_Ordinary;
2174
2175 // We may already have a record of the same name; try to find and match it.
2176 RecordDecl *AdoptDecl = nullptr;
2177 RecordDecl *PrevDecl = nullptr;
2178 if (!DC->isFunctionOrMethod()) {
2179 SmallVector<NamedDecl *, 4> ConflictingDecls;
2180 SmallVector<NamedDecl *, 2> FoundDecls;
2181 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
2182
2183 if (!FoundDecls.empty()) {
2184 // We're going to have to compare D against potentially conflicting Decls, so complete it.
2185 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
2186 D->getASTContext().getExternalSource()->CompleteType(D);
2187 }
2188
2189 for (auto *FoundDecl : FoundDecls) {
2190 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2191 continue;
2192
2193 Decl *Found = FoundDecl;
2194 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2195 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2196 Found = Tag->getDecl();
2197 }
2198
2199 if (D->getDescribedTemplate()) {
2200 if (auto *Template = dyn_cast<ClassTemplateDecl>(Found))
2201 Found = Template->getTemplatedDecl();
2202 else
2203 continue;
2204 }
2205
2206 if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2207 if (!SearchName) {
2208 if (!IsStructuralMatch(D, FoundRecord, false))
2209 continue;
2210 }
2211
2212 PrevDecl = FoundRecord;
2213
2214 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2215 if ((SearchName && !D->isCompleteDefinition())
2216 || (D->isCompleteDefinition() &&
2217 D->isAnonymousStructOrUnion()
2218 == FoundDef->isAnonymousStructOrUnion() &&
2219 IsStructuralMatch(D, FoundDef))) {
2220 // The record types structurally match, or the "from" translation
2221 // unit only had a forward declaration anyway; call it the same
2222 // function.
2223 // FIXME: Structural equivalence check should check for same
2224 // user-defined methods.
2225 Importer.MapImported(D, FoundDef);
2226 if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2227 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2228 assert(FoundCXX && "Record type mismatch")(static_cast <bool> (FoundCXX && "Record type mismatch"
) ? void (0) : __assert_fail ("FoundCXX && \"Record type mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2228, __extension__ __PRETTY_FUNCTION__))
;
2229
2230 if (D->isCompleteDefinition() && !Importer.isMinimalImport())
2231 // FoundDef may not have every implicit method that D has
2232 // because implicit methods are created only if they are used.
2233 ImportImplicitMethods(DCXX, FoundCXX);
2234 }
2235 return FoundDef;
2236 }
2237 } else if (!D->isCompleteDefinition()) {
2238 // We have a forward declaration of this type, so adopt that forward
2239 // declaration rather than building a new one.
2240
2241 // If one or both can be completed from external storage then try one
2242 // last time to complete and compare them before doing this.
2243
2244 if (FoundRecord->hasExternalLexicalStorage() &&
2245 !FoundRecord->isCompleteDefinition())
2246 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2247 if (D->hasExternalLexicalStorage())
2248 D->getASTContext().getExternalSource()->CompleteType(D);
2249
2250 if (FoundRecord->isCompleteDefinition() &&
2251 D->isCompleteDefinition() &&
2252 !IsStructuralMatch(D, FoundRecord))
2253 continue;
2254
2255 AdoptDecl = FoundRecord;
2256 continue;
2257 } else if (!SearchName) {
2258 continue;
2259 }
2260 }
2261
2262 ConflictingDecls.push_back(FoundDecl);
2263 }
2264
2265 if (!ConflictingDecls.empty() && SearchName) {
2266 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2267 ConflictingDecls.data(),
2268 ConflictingDecls.size());
2269 }
2270 }
2271
2272 // Create the record declaration.
2273 RecordDecl *D2 = AdoptDecl;
2274 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2275 if (!D2) {
2276 CXXRecordDecl *D2CXX = nullptr;
2277 if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2278 if (DCXX->isLambda()) {
2279 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
2280 if (GetImportedOrCreateSpecialDecl(
2281 D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
2282 DC, TInfo, Loc, DCXX->isDependentLambda(),
2283 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2284 return D2CXX;
2285 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
2286 if (DCXX->getLambdaContextDecl() && !CDecl)
2287 return nullptr;
2288 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
2289 } else if (DCXX->isInjectedClassName()) {
2290 // We have to be careful to do a similar dance to the one in
2291 // Sema::ActOnStartCXXMemberDeclarations
2292 CXXRecordDecl *const PrevDecl = nullptr;
2293 const bool DelayTypeCreation = true;
2294 if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2295 D->getTagKind(), DC, StartLoc, Loc,
2296 Name.getAsIdentifierInfo(), PrevDecl,
2297 DelayTypeCreation))
2298 return D2CXX;
2299 Importer.getToContext().getTypeDeclType(
2300 D2CXX, dyn_cast<CXXRecordDecl>(DC));
2301 } else {
2302 if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2303 D->getTagKind(), DC, StartLoc, Loc,
2304 Name.getAsIdentifierInfo(),
2305 cast_or_null<CXXRecordDecl>(PrevDecl)))
2306 return D2CXX;
2307 }
2308
2309 D2 = D2CXX;
2310 D2->setAccess(D->getAccess());
2311 D2->setLexicalDeclContext(LexicalDC);
2312 if (!DCXX->getDescribedClassTemplate() || DCXX->isImplicit())
2313 LexicalDC->addDeclInternal(D2);
2314
2315 if (ClassTemplateDecl *FromDescribed =
2316 DCXX->getDescribedClassTemplate()) {
2317 auto *ToDescribed = cast_or_null<ClassTemplateDecl>(
2318 Importer.Import(FromDescribed));
2319 if (!ToDescribed)
2320 return nullptr;
2321 D2CXX->setDescribedClassTemplate(ToDescribed);
2322 if (!DCXX->isInjectedClassName()) {
2323 // In a record describing a template the type should be an
2324 // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
2325 // previously set type to the correct value here (ToDescribed is not
2326 // available at record create).
2327 // FIXME: The previous type is cleared but not removed from
2328 // ASTContext's internal storage.
2329 CXXRecordDecl *Injected = nullptr;
2330 for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
2331 auto *Record = dyn_cast<CXXRecordDecl>(Found);
2332 if (Record && Record->isInjectedClassName()) {
2333 Injected = Record;
2334 break;
2335 }
2336 }
2337 D2CXX->setTypeForDecl(nullptr);
2338 Importer.getToContext().getInjectedClassNameType(D2CXX,
2339 ToDescribed->getInjectedClassNameSpecialization());
2340 if (Injected) {
2341 Injected->setTypeForDecl(nullptr);
2342 Importer.getToContext().getTypeDeclType(Injected, D2CXX);
2343 }
2344 }
2345 } else if (MemberSpecializationInfo *MemberInfo =
2346 DCXX->getMemberSpecializationInfo()) {
2347 TemplateSpecializationKind SK =
2348 MemberInfo->getTemplateSpecializationKind();
2349 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
2350 auto *ToInst =
2351 cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
2352 if (FromInst && !ToInst)
2353 return nullptr;
2354 D2CXX->setInstantiationOfMemberClass(ToInst, SK);
2355 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
2356 Importer.Import(MemberInfo->getPointOfInstantiation()));
2357 }
2358 } else {
2359 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
2360 D->getTagKind(), DC, StartLoc, Loc,
2361 Name.getAsIdentifierInfo(), PrevDecl))
2362 return D2;
2363 D2->setLexicalDeclContext(LexicalDC);
2364 LexicalDC->addDeclInternal(D2);
2365 }
2366
2367 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2368 if (D->isAnonymousStructOrUnion())
2369 D2->setAnonymousStructOrUnion(true);
2370 }
2371
2372 Importer.MapImported(D, D2);
2373
2374 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2375 return nullptr;
2376
2377 return D2;
2378}
2379
2380Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2381 // Import the major distinguishing characteristics of this enumerator.
2382 DeclContext *DC, *LexicalDC;
2383 DeclarationName Name;
2384 SourceLocation Loc;
2385 NamedDecl *ToD;
2386 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2387 return nullptr;
2388 if (ToD)
2389 return ToD;
2390
2391 QualType T = Importer.Import(D->getType());
2392 if (T.isNull())
2393 return nullptr;
2394
2395 // Determine whether there are any other declarations with the same name and
2396 // in the same context.
2397 if (!LexicalDC->isFunctionOrMethod()) {
2398 SmallVector<NamedDecl *, 4> ConflictingDecls;
2399 unsigned IDNS = Decl::IDNS_Ordinary;
2400 SmallVector<NamedDecl *, 2> FoundDecls;
2401 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2402 for (auto *FoundDecl : FoundDecls) {
2403 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2404 continue;
2405
2406 if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
2407 if (IsStructuralMatch(D, FoundEnumConstant))
2408 return Importer.MapImported(D, FoundEnumConstant);
2409 }
2410
2411 ConflictingDecls.push_back(FoundDecl);
2412 }
2413
2414 if (!ConflictingDecls.empty()) {
2415 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2416 ConflictingDecls.data(),
2417 ConflictingDecls.size());
2418 if (!Name)
2419 return nullptr;
2420 }
2421 }
2422
2423 Expr *Init = Importer.Import(D->getInitExpr());
2424 if (D->getInitExpr() && !Init)
2425 return nullptr;
2426
2427 EnumConstantDecl *ToEnumerator;
2428 if (GetImportedOrCreateDecl(
2429 ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2430 Name.getAsIdentifierInfo(), T, Init, D->getInitVal()))
2431 return ToEnumerator;
2432
2433 ToEnumerator->setAccess(D->getAccess());
2434 ToEnumerator->setLexicalDeclContext(LexicalDC);
2435 LexicalDC->addDeclInternal(ToEnumerator);
2436 return ToEnumerator;
2437}
2438
2439bool ASTNodeImporter::ImportTemplateInformation(FunctionDecl *FromFD,
2440 FunctionDecl *ToFD) {
2441 switch (FromFD->getTemplatedKind()) {
2442 case FunctionDecl::TK_NonTemplate:
2443 case FunctionDecl::TK_FunctionTemplate:
2444 return false;
2445
2446 case FunctionDecl::TK_MemberSpecialization: {
2447 auto *InstFD = cast_or_null<FunctionDecl>(
2448 Importer.Import(FromFD->getInstantiatedFromMemberFunction()));
2449 if (!InstFD)
2450 return true;
2451
2452 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
2453 SourceLocation POI = Importer.Import(
2454 FromFD->getMemberSpecializationInfo()->getPointOfInstantiation());
2455 ToFD->setInstantiationOfMemberFunction(InstFD, TSK);
2456 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
2457 return false;
2458 }
2459
2460 case FunctionDecl::TK_FunctionTemplateSpecialization: {
2461 FunctionTemplateDecl* Template;
2462 OptionalTemplateArgsTy ToTemplArgs;
2463 std::tie(Template, ToTemplArgs) =
2464 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
2465 if (!Template || !ToTemplArgs)
2466 return true;
2467
2468 TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
2469 Importer.getToContext(), *ToTemplArgs);
2470
2471 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
2472 TemplateArgumentListInfo ToTAInfo;
2473 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
2474 if (FromTAArgsAsWritten)
2475 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ToTAInfo))
2476 return true;
2477
2478 SourceLocation POI = Importer.Import(FTSInfo->getPointOfInstantiation());
2479
2480 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
2481 ToFD->setFunctionTemplateSpecialization(
2482 Template, ToTAList, /* InsertPos= */ nullptr,
2483 TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, POI);
2484 return false;
2485 }
2486
2487 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
2488 auto *FromInfo = FromFD->getDependentSpecializationInfo();
2489 UnresolvedSet<8> TemplDecls;
2490 unsigned NumTemplates = FromInfo->getNumTemplates();
2491 for (unsigned I = 0; I < NumTemplates; I++) {
2492 if (auto *ToFTD = cast_or_null<FunctionTemplateDecl>(
2493 Importer.Import(FromInfo->getTemplate(I))))
2494 TemplDecls.addDecl(ToFTD);
2495 else
2496 return true;
2497 }
2498
2499 // Import TemplateArgumentListInfo.
2500 TemplateArgumentListInfo ToTAInfo;
2501 if (ImportTemplateArgumentListInfo(
2502 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
2503 llvm::makeArrayRef(FromInfo->getTemplateArgs(),
2504 FromInfo->getNumTemplateArgs()),
2505 ToTAInfo))
2506 return true;
2507
2508 ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
2509 TemplDecls, ToTAInfo);
2510 return false;
2511 }
2512 }
2513 llvm_unreachable("All cases should be covered!")::llvm::llvm_unreachable_internal("All cases should be covered!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2513)
;
2514}
2515
2516FunctionDecl *
2517ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
2518 FunctionTemplateDecl* Template;
2519 OptionalTemplateArgsTy ToTemplArgs;
2520 std::tie(Template, ToTemplArgs) =
2521 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
2522 if (!Template || !ToTemplArgs)
2523 return nullptr;
2524
2525 void *InsertPos = nullptr;
2526 auto *FoundSpec = Template->findSpecialization(*ToTemplArgs, InsertPos);
2527 return FoundSpec;
2528}
2529
2530Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2531
2532 SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
2533 auto RedeclIt = Redecls.begin();
2534 // Import the first part of the decl chain. I.e. import all previous
2535 // declarations starting from the canonical decl.
2536 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt)
2537 if (!Importer.Import(*RedeclIt))
2538 return nullptr;
2539 assert(*RedeclIt == D)(static_cast <bool> (*RedeclIt == D) ? void (0) : __assert_fail
("*RedeclIt == D", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2539, __extension__ __PRETTY_FUNCTION__))
;
2540
2541 // Import the major distinguishing characteristics of this function.
2542 DeclContext *DC, *LexicalDC;
2543 DeclarationName Name;
2544 SourceLocation Loc;
2545 NamedDecl *ToD;
2546 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2547 return nullptr;
2548 if (ToD)
2549 return ToD;
2550
2551 const FunctionDecl *FoundByLookup = nullptr;
2552 FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
2553
2554 // If this is a function template specialization, then try to find the same
2555 // existing specialization in the "to" context. The localUncachedLookup
2556 // below will not find any specialization, but would find the primary
2557 // template; thus, we have to skip normal lookup in case of specializations.
2558 // FIXME handle member function templates (TK_MemberSpecialization) similarly?
2559 if (D->getTemplatedKind() ==
2560 FunctionDecl::TK_FunctionTemplateSpecialization) {
2561 if (FunctionDecl *FoundFunction = FindFunctionTemplateSpecialization(D)) {
2562 if (D->doesThisDeclarationHaveABody() &&
2563 FoundFunction->hasBody())
2564 return Importer.Imported(D, FoundFunction);
2565 FoundByLookup = FoundFunction;
2566 }
2567 }
2568 // Try to find a function in our own ("to") context with the same name, same
2569 // type, and in the same context as the function we're importing.
2570 else if (!LexicalDC->isFunctionOrMethod()) {
2571 SmallVector<NamedDecl *, 4> ConflictingDecls;
2572 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
2573 SmallVector<NamedDecl *, 2> FoundDecls;
2574 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2575 for (auto *FoundDecl : FoundDecls) {
2576 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2577 continue;
2578
2579 // If template was found, look at the templated function.
2580 if (FromFT) {
2581 if (auto *Template = dyn_cast<FunctionTemplateDecl>(FoundDecl))
2582 FoundDecl = Template->getTemplatedDecl();
2583 else
2584 continue;
2585 }
2586
2587 if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
2588 if (FoundFunction->hasExternalFormalLinkage() &&
2589 D->hasExternalFormalLinkage()) {
2590 if (IsStructuralMatch(D, FoundFunction)) {
2591 const FunctionDecl *Definition = nullptr;
2592 if (D->doesThisDeclarationHaveABody() &&
2593 FoundFunction->hasBody(Definition)) {
2594 return Importer.MapImported(
2595 D, const_cast<FunctionDecl *>(Definition));
2596 }
2597 FoundByLookup = FoundFunction;
2598 break;
2599 }
2600
2601 // FIXME: Check for overloading more carefully, e.g., by boosting
2602 // Sema::IsOverload out to the AST library.
2603
2604 // Function overloading is okay in C++.
2605 if (Importer.getToContext().getLangOpts().CPlusPlus)
2606 continue;
2607
2608 // Complain about inconsistent function types.
2609 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2610 << Name << D->getType() << FoundFunction->getType();
2611 Importer.ToDiag(FoundFunction->getLocation(),
2612 diag::note_odr_value_here)
2613 << FoundFunction->getType();
2614 }
2615 }
2616
2617 ConflictingDecls.push_back(FoundDecl);
2618 }
2619
2620 if (!ConflictingDecls.empty()) {
2621 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2622 ConflictingDecls.data(),
2623 ConflictingDecls.size());
2624 if (!Name)
2625 return nullptr;
2626 }
2627 }
2628
2629 DeclarationNameInfo NameInfo(Name, Loc);
2630 // Import additional name location/type info.
2631 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2632
2633 QualType FromTy = D->getType();
2634 bool usedDifferentExceptionSpec = false;
2635
2636 if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2637 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2638 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2639 // FunctionDecl that we are importing the FunctionProtoType for.
2640 // To avoid an infinite recursion when importing, create the FunctionDecl
2641 // with a simplified function type and update it afterwards.
2642 if (FromEPI.ExceptionSpec.SourceDecl ||
2643 FromEPI.ExceptionSpec.SourceTemplate ||
2644 FromEPI.ExceptionSpec.NoexceptExpr) {
2645 FunctionProtoType::ExtProtoInfo DefaultEPI;
2646 FromTy = Importer.getFromContext().getFunctionType(
2647 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2648 usedDifferentExceptionSpec = true;
2649 }
2650 }
2651
2652 // Import the type.
2653 QualType T = Importer.Import(FromTy);
2654 if (T.isNull())
2655 return nullptr;
2656
2657 // Import the function parameters.
2658 SmallVector<ParmVarDecl *, 8> Parameters;
2659 for (auto P : D->parameters()) {
2660 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2661 if (!ToP)
2662 return nullptr;
2663
2664 Parameters.push_back(ToP);
2665 }
2666
2667 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2668 if (D->getTypeSourceInfo() && !TInfo)
2669 return nullptr;
2670
2671 // Create the imported function.
2672 FunctionDecl *ToFunction = nullptr;
2673 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
2674 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2675 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
2676 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2677 InnerLocStart, NameInfo, T, TInfo, FromConstructor->isExplicit(),
2678 D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
2679 return ToFunction;
2680 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
2681 SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
2682 for (auto *I : FromConstructor->inits()) {
2683 auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I));
2684 if (!ToI && I)
2685 return nullptr;
2686 CtorInitializers.push_back(ToI);
2687 }
2688 auto **Memory =
2689 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
2690 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
2691 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
2692 ToCtor->setCtorInitializers(Memory);
2693 ToCtor->setNumCtorInitializers(NumInitializers);
2694 }
2695 } else if (isa<CXXDestructorDecl>(D)) {
2696 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
2697 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2698 InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2699 D->isImplicit()))
2700 return ToFunction;
2701 } else if (CXXConversionDecl *FromConversion =
2702 dyn_cast<CXXConversionDecl>(D)) {
2703 if (GetImportedOrCreateDecl<CXXConversionDecl>(
2704 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2705 InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2706 FromConversion->isExplicit(), D->isConstexpr(), SourceLocation()))
2707 return ToFunction;
2708 } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
2709 if (GetImportedOrCreateDecl<CXXMethodDecl>(
2710 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2711 InnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
2712 Method->isInlineSpecified(), D->isConstexpr(), SourceLocation()))
2713 return ToFunction;
2714 } else {
2715 if (GetImportedOrCreateDecl(ToFunction, D, Importer.getToContext(), DC,
2716 InnerLocStart, NameInfo, T, TInfo,
2717 D->getStorageClass(), D->isInlineSpecified(),
2718 D->hasWrittenPrototype(), D->isConstexpr()))
2719 return ToFunction;
2720 }
2721
2722 // Import the qualifier, if any.
2723 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2724 ToFunction->setAccess(D->getAccess());
2725 ToFunction->setLexicalDeclContext(LexicalDC);
2726 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2727 ToFunction->setTrivial(D->isTrivial());
2728 ToFunction->setPure(D->isPure());
2729 ToFunction->setRangeEnd(Importer.Import(D->getLocEnd()));
2730
2731 // Set the parameters.
2732 for (auto *Param : Parameters) {
2733 Param->setOwningFunction(ToFunction);
2734 ToFunction->addDeclInternal(Param);
2735 }
2736 ToFunction->setParams(Parameters);
2737
2738 if (FoundByLookup) {
2739 auto *Recent = const_cast<FunctionDecl *>(
2740 FoundByLookup->getMostRecentDecl());
2741 ToFunction->setPreviousDecl(Recent);
2742 }
2743
2744 // We need to complete creation of FunctionProtoTypeLoc manually with setting
2745 // params it refers to.
2746 if (TInfo) {
2747 if (auto ProtoLoc =
2748 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
2749 for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
2750 ProtoLoc.setParam(I, Parameters[I]);
2751 }
2752 }
2753
2754 if (usedDifferentExceptionSpec) {
2755 // Update FunctionProtoType::ExtProtoInfo.
2756 QualType T = Importer.Import(D->getType());
2757 if (T.isNull())
2758 return nullptr;
2759 ToFunction->setType(T);
2760 }
2761
2762 // Import the describing template function, if any.
2763 if (FromFT)
2764 if (!Importer.Import(FromFT))
2765 return nullptr;
2766
2767 if (D->doesThisDeclarationHaveABody()) {
2768 if (Stmt *FromBody = D->getBody()) {
2769 if (Stmt *ToBody = Importer.Import(FromBody)) {
2770 ToFunction->setBody(ToBody);
2771 }
2772 }
2773 }
2774
2775 // FIXME: Other bits to merge?
2776
2777 // If it is a template, import all related things.
2778 if (ImportTemplateInformation(D, ToFunction))
2779 return nullptr;
2780
2781 bool IsFriend = D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend);
2782
2783 // TODO Can we generalize this approach to other AST nodes as well?
2784 if (D->getDeclContext()->containsDeclAndLoad(D))
2785 DC->addDeclInternal(ToFunction);
2786 if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
2787 LexicalDC->addDeclInternal(ToFunction);
2788
2789 // Friend declaration's lexical context is the befriending class, but the
2790 // semantic context is the enclosing scope of the befriending class.
2791 // We want the friend functions to be found in the semantic context by lookup.
2792 // FIXME should we handle this generically in VisitFriendDecl?
2793 // In Other cases when LexicalDC != DC we don't want it to be added,
2794 // e.g out-of-class definitions like void B::f() {} .
2795 if (LexicalDC != DC && IsFriend) {
2796 DC->makeDeclVisibleInContext(ToFunction);
2797 }
2798
2799 // Import the rest of the chain. I.e. import all subsequent declarations.
2800 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt)
2801 if (!Importer.Import(*RedeclIt))
2802 return nullptr;
2803
2804 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
2805 ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod);
2806
2807 return ToFunction;
2808}
2809
2810Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2811 return VisitFunctionDecl(D);
2812}
2813
2814Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2815 return VisitCXXMethodDecl(D);
2816}
2817
2818Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2819 return VisitCXXMethodDecl(D);
2820}
2821
2822Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2823 return VisitCXXMethodDecl(D);
2824}
2825
2826static unsigned getFieldIndex(Decl *F) {
2827 auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2828 if (!Owner)
2829 return 0;
2830
2831 unsigned Index = 1;
2832 for (const auto *D : Owner->noload_decls()) {
2833 if (D == F)
2834 return Index;
2835
2836 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2837 ++Index;
2838 }
2839
2840 return Index;
2841}
2842
2843Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2844 // Import the major distinguishing characteristics of a variable.
2845 DeclContext *DC, *LexicalDC;
2846 DeclarationName Name;
2847 SourceLocation Loc;
2848 NamedDecl *ToD;
2849 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2850 return nullptr;
2851 if (ToD)
2852 return ToD;
2853
2854 // Determine whether we've already imported this field.
2855 SmallVector<NamedDecl *, 2> FoundDecls;
2856 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2857 for (auto *FoundDecl : FoundDecls) {
2858 if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
2859 // For anonymous fields, match up by index.
2860 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2861 continue;
2862
2863 if (Importer.IsStructurallyEquivalent(D->getType(),
2864 FoundField->getType())) {
2865 Importer.MapImported(D, FoundField);
2866 return FoundField;
2867 }
2868
2869 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2870 << Name << D->getType() << FoundField->getType();
2871 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2872 << FoundField->getType();
2873 return nullptr;
2874 }
2875 }
2876
2877 // Import the type.
2878 QualType T = Importer.Import(D->getType());
2879 if (T.isNull())
2880 return nullptr;
2881
2882 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2883 Expr *BitWidth = Importer.Import(D->getBitWidth());
2884 if (!BitWidth && D->getBitWidth())
2885 return nullptr;
2886
2887 FieldDecl *ToField;
2888 if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
2889 Importer.Import(D->getInnerLocStart()), Loc,
2890 Name.getAsIdentifierInfo(), T, TInfo, BitWidth,
2891 D->isMutable(), D->getInClassInitStyle()))
2892 return ToField;
2893
2894 ToField->setAccess(D->getAccess());
2895 ToField->setLexicalDeclContext(LexicalDC);
2896 if (Expr *FromInitializer = D->getInClassInitializer()) {
2897 Expr *ToInitializer = Importer.Import(FromInitializer);
2898 if (ToInitializer)
2899 ToField->setInClassInitializer(ToInitializer);
2900 else
2901 return nullptr;
2902 }
2903 ToField->setImplicit(D->isImplicit());
2904 LexicalDC->addDeclInternal(ToField);
2905 return ToField;
2906}
2907
2908Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2909 // Import the major distinguishing characteristics of a variable.
2910 DeclContext *DC, *LexicalDC;
2911 DeclarationName Name;
2912 SourceLocation Loc;
2913 NamedDecl *ToD;
2914 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2915 return nullptr;
2916 if (ToD)
2917 return ToD;
2918
2919 // Determine whether we've already imported this field.
2920 SmallVector<NamedDecl *, 2> FoundDecls;
2921 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2922 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2923 if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2924 // For anonymous indirect fields, match up by index.
2925 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2926 continue;
2927
2928 if (Importer.IsStructurallyEquivalent(D->getType(),
2929 FoundField->getType(),
2930 !Name.isEmpty())) {
2931 Importer.MapImported(D, FoundField);
2932 return FoundField;
2933 }
2934
2935 // If there are more anonymous fields to check, continue.
2936 if (!Name && I < N-1)
2937 continue;
2938
2939 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2940 << Name << D->getType() << FoundField->getType();
2941 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2942 << FoundField->getType();
2943 return nullptr;
2944 }
2945 }
2946
2947 // Import the type.
2948 QualType T = Importer.Import(D->getType());
2949 if (T.isNull())
2950 return nullptr;
2951
2952 auto **NamedChain =
2953 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
2954
2955 unsigned i = 0;
2956 for (auto *PI : D->chain()) {
2957 Decl *D = Importer.Import(PI);
2958 if (!D)
2959 return nullptr;
2960 NamedChain[i++] = cast<NamedDecl>(D);
2961 }
2962
2963 llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
2964 IndirectFieldDecl *ToIndirectField;
2965 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
2966 Loc, Name.getAsIdentifierInfo(), T, CH))
2967 // FIXME here we leak `NamedChain` which is allocated before
2968 return ToIndirectField;
2969
2970 for (const auto *A : D->attrs())
2971 ToIndirectField->addAttr(Importer.Import(A));
2972
2973 ToIndirectField->setAccess(D->getAccess());
2974 ToIndirectField->setLexicalDeclContext(LexicalDC);
2975 LexicalDC->addDeclInternal(ToIndirectField);
2976 return ToIndirectField;
2977}
2978
2979Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
2980 // Import the major distinguishing characteristics of a declaration.
2981 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2982 DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
2983 ? DC : Importer.ImportContext(D->getLexicalDeclContext());
2984 if (!DC || !LexicalDC)
2985 return nullptr;
2986
2987 // Determine whether we've already imported this decl.
2988 // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
2989 auto *RD = cast<CXXRecordDecl>(DC);
2990 FriendDecl *ImportedFriend = RD->getFirstFriend();
2991
2992 while (ImportedFriend) {
2993 if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
2994 if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
2995 /*Complain=*/false))
2996 return Importer.MapImported(D, ImportedFriend);
2997
2998 } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
2999 if (Importer.IsStructurallyEquivalent(
3000 D->getFriendType()->getType(),
3001 ImportedFriend->getFriendType()->getType(), true))
3002 return Importer.MapImported(D, ImportedFriend);
3003 }
3004 ImportedFriend = ImportedFriend->getNextFriend();
3005 }
3006
3007 // Not found. Create it.
3008 FriendDecl::FriendUnion ToFU;
3009 if (NamedDecl *FriendD = D->getFriendDecl()) {
3010 auto *ToFriendD = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3011 if (ToFriendD && FriendD->getFriendObjectKind() != Decl::FOK_None &&
3012 !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
3013 ToFriendD->setObjectOfFriendDecl(false);
3014
3015 ToFU = ToFriendD;
3016 } else // The friend is a type, not a decl.
3017 ToFU = Importer.Import(D->getFriendType());
3018 if (!ToFU)
3019 return nullptr;
3020
3021 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3022 auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
3023 for (unsigned I = 0; I < D->NumTPLists; I++) {
3024 TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3025 if (!List)
3026 return nullptr;
3027 ToTPLists[I] = List;
3028 }
3029
3030 FriendDecl *FrD;
3031 if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
3032 Importer.Import(D->getLocation()), ToFU,
3033 Importer.Import(D->getFriendLoc()), ToTPLists))
3034 return FrD;
3035
3036 FrD->setAccess(D->getAccess());
3037 FrD->setLexicalDeclContext(LexicalDC);
3038 LexicalDC->addDeclInternal(FrD);
3039 return FrD;
3040}
3041
3042Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3043 // Import the major distinguishing characteristics of an ivar.
3044 DeclContext *DC, *LexicalDC;
3045 DeclarationName Name;
3046 SourceLocation Loc;
3047 NamedDecl *ToD;
3048 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3049 return nullptr;
3050 if (ToD)
3051 return ToD;
3052
3053 // Determine whether we've already imported this ivar
3054 SmallVector<NamedDecl *, 2> FoundDecls;
3055 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3056 for (auto *FoundDecl : FoundDecls) {
3057 if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
3058 if (Importer.IsStructurallyEquivalent(D->getType(),
3059 FoundIvar->getType())) {
3060 Importer.MapImported(D, FoundIvar);
3061 return FoundIvar;
3062 }
3063
3064 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3065 << Name << D->getType() << FoundIvar->getType();
3066 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3067 << FoundIvar->getType();
3068 return nullptr;
3069 }
3070 }
3071
3072 // Import the type.
3073 QualType T = Importer.Import(D->getType());
3074 if (T.isNull())
3075 return nullptr;
3076
3077 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3078 Expr *BitWidth = Importer.Import(D->getBitWidth());
3079 if (!BitWidth && D->getBitWidth())
3080 return nullptr;
3081
3082 ObjCIvarDecl *ToIvar;
3083 if (GetImportedOrCreateDecl(
3084 ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
3085 Importer.Import(D->getInnerLocStart()), Loc,
3086 Name.getAsIdentifierInfo(), T, TInfo, D->getAccessControl(), BitWidth,
3087 D->getSynthesize()))
3088 return ToIvar;
3089
3090 ToIvar->setLexicalDeclContext(LexicalDC);
3091 LexicalDC->addDeclInternal(ToIvar);
3092 return ToIvar;
3093}
3094
3095Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3096 // Import the major distinguishing characteristics of a variable.
3097 DeclContext *DC, *LexicalDC;
3098 DeclarationName Name;
3099 SourceLocation Loc;
3100 NamedDecl *ToD;
3101 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3102 return nullptr;
3103 if (ToD)
3104 return ToD;
3105
3106 // Try to find a variable in our own ("to") context with the same name and
3107 // in the same context as the variable we're importing.
3108 if (D->isFileVarDecl()) {
3109 VarDecl *MergeWithVar = nullptr;
3110 SmallVector<NamedDecl *, 4> ConflictingDecls;
3111 unsigned IDNS = Decl::IDNS_Ordinary;
3112 SmallVector<NamedDecl *, 2> FoundDecls;
3113 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3114 for (auto *FoundDecl : FoundDecls) {
3115 if (!FoundDecl->isInIdentifierNamespace(IDNS))
3116 continue;
3117
3118 if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
3119 // We have found a variable that we may need to merge with. Check it.
3120 if (FoundVar->hasExternalFormalLinkage() &&
3121 D->hasExternalFormalLinkage()) {
3122 if (Importer.IsStructurallyEquivalent(D->getType(),
3123 FoundVar->getType())) {
3124 MergeWithVar = FoundVar;
3125 break;
3126 }
3127
3128 const ArrayType *FoundArray
3129 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3130 const ArrayType *TArray
3131 = Importer.getToContext().getAsArrayType(D->getType());
3132 if (FoundArray && TArray) {
3133 if (isa<IncompleteArrayType>(FoundArray) &&
3134 isa<ConstantArrayType>(TArray)) {
3135 // Import the type.
3136 QualType T = Importer.Import(D->getType());
3137 if (T.isNull())
3138 return nullptr;
3139
3140 FoundVar->setType(T);
3141 MergeWithVar = FoundVar;
3142 break;
3143 } else if (isa<IncompleteArrayType>(TArray) &&
3144 isa<ConstantArrayType>(FoundArray)) {
3145 MergeWithVar = FoundVar;
3146 break;
3147 }
3148 }
3149
3150 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3151 << Name << D->getType() << FoundVar->getType();
3152 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3153 << FoundVar->getType();
3154 }
3155 }
3156
3157 ConflictingDecls.push_back(FoundDecl);
3158 }
3159
3160 if (MergeWithVar) {
3161 // An equivalent variable with external linkage has been found. Link
3162 // the two declarations, then merge them.
3163 Importer.MapImported(D, MergeWithVar);
3164 updateFlags(D, MergeWithVar);
3165
3166 if (VarDecl *DDef = D->getDefinition()) {
3167 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3168 Importer.ToDiag(ExistingDef->getLocation(),
3169 diag::err_odr_variable_multiple_def)
3170 << Name;
3171 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3172 } else {
3173 Expr *Init = Importer.Import(DDef->getInit());
3174 MergeWithVar->setInit(Init);
3175 if (DDef->isInitKnownICE()) {
3176 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3177 Eval->CheckedICE = true;
3178 Eval->IsICE = DDef->isInitICE();
3179 }
3180 }
3181 }
3182
3183 return MergeWithVar;
3184 }
3185
3186 if (!ConflictingDecls.empty()) {
3187 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3188 ConflictingDecls.data(),
3189 ConflictingDecls.size());
3190 if (!Name)
3191 return nullptr;
3192 }
3193 }
3194
3195 // Import the type.
3196 QualType T = Importer.Import(D->getType());
3197 if (T.isNull())
3198 return nullptr;
3199
3200 // Create the imported variable.
3201 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3202 VarDecl *ToVar;
3203 if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
3204 Importer.Import(D->getInnerLocStart()), Loc,
3205 Name.getAsIdentifierInfo(), T, TInfo,
3206 D->getStorageClass()))
3207 return ToVar;
3208
3209 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3210 ToVar->setAccess(D->getAccess());
3211 ToVar->setLexicalDeclContext(LexicalDC);
3212
3213 // Templated declarations should never appear in the enclosing DeclContext.
3214 if (!D->getDescribedVarTemplate())
3215 LexicalDC->addDeclInternal(ToVar);
3216
3217 // Merge the initializer.
3218 if (ImportDefinition(D, ToVar))
3219 return nullptr;
3220
3221 if (D->isConstexpr())
3222 ToVar->setConstexpr(true);
3223
3224 return ToVar;
3225}
3226
3227Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3228 // Parameters are created in the translation unit's context, then moved
3229 // into the function declaration's context afterward.
3230 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3231
3232 // Import the name of this declaration.
3233 DeclarationName Name = Importer.Import(D->getDeclName());
3234 if (D->getDeclName() && !Name)
3235 return nullptr;
3236
3237 // Import the location of this declaration.
3238 SourceLocation Loc = Importer.Import(D->getLocation());
3239
3240 // Import the parameter's type.
3241 QualType T = Importer.Import(D->getType());
3242 if (T.isNull())
3243 return nullptr;
3244
3245 // Create the imported parameter.
3246 ImplicitParamDecl *ToParm = nullptr;
3247 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, Loc,
3248 Name.getAsIdentifierInfo(), T,
3249 D->getParameterKind()))
3250 return ToParm;
3251 return ToParm;
3252}
3253
3254Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3255 // Parameters are created in the translation unit's context, then moved
3256 // into the function declaration's context afterward.
3257 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3258
3259 // Import the name of this declaration.
3260 DeclarationName Name = Importer.Import(D->getDeclName());
3261 if (D->getDeclName() && !Name)
3262 return nullptr;
3263
3264 // Import the location of this declaration.
3265 SourceLocation Loc = Importer.Import(D->getLocation());
3266
3267 // Import the parameter's type.
3268 QualType T = Importer.Import(D->getType());
3269 if (T.isNull())
3270 return nullptr;
3271
3272 // Create the imported parameter.
3273 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3274 ParmVarDecl *ToParm;
3275 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
3276 Importer.Import(D->getInnerLocStart()), Loc,
3277 Name.getAsIdentifierInfo(), T, TInfo,
3278 D->getStorageClass(),
3279 /*DefaultArg*/ nullptr))
3280 return ToParm;
3281
3282 // Set the default argument.
3283 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3284 ToParm->setKNRPromoted(D->isKNRPromoted());
3285
3286 Expr *ToDefArg = nullptr;
3287 Expr *FromDefArg = nullptr;
3288 if (D->hasUninstantiatedDefaultArg()) {
3289 FromDefArg = D->getUninstantiatedDefaultArg();
3290 ToDefArg = Importer.Import(FromDefArg);
3291 ToParm->setUninstantiatedDefaultArg(ToDefArg);
3292 } else if (D->hasUnparsedDefaultArg()) {
3293 ToParm->setUnparsedDefaultArg();
3294 } else if (D->hasDefaultArg()) {
3295 FromDefArg = D->getDefaultArg();
3296 ToDefArg = Importer.Import(FromDefArg);
3297 ToParm->setDefaultArg(ToDefArg);
3298 }
3299 if (FromDefArg && !ToDefArg)
3300 return nullptr;
3301
3302 if (D->isObjCMethodParameter()) {
3303 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
3304 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
3305 } else {
3306 ToParm->setScopeInfo(D->getFunctionScopeDepth(),
3307 D->getFunctionScopeIndex());
3308 }
3309
3310 return ToParm;
3311}
3312
3313Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3314 // Import the major distinguishing characteristics of a method.
3315 DeclContext *DC, *LexicalDC;
3316 DeclarationName Name;
3317 SourceLocation Loc;
3318 NamedDecl *ToD;
3319 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3320 return nullptr;
3321 if (ToD)
3322 return ToD;
3323
3324 SmallVector<NamedDecl *, 2> FoundDecls;
3325 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3326 for (auto *FoundDecl : FoundDecls) {
3327 if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
3328 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3329 continue;
3330
3331 // Check return types.
3332 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3333 FoundMethod->getReturnType())) {
3334 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3335 << D->isInstanceMethod() << Name << D->getReturnType()
3336 << FoundMethod->getReturnType();
3337 Importer.ToDiag(FoundMethod->getLocation(),
3338 diag::note_odr_objc_method_here)
3339 << D->isInstanceMethod() << Name;
3340 return nullptr;
3341 }
3342
3343 // Check the number of parameters.
3344 if (D->param_size() != FoundMethod->param_size()) {
3345 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3346 << D->isInstanceMethod() << Name
3347 << D->param_size() << FoundMethod->param_size();
3348 Importer.ToDiag(FoundMethod->getLocation(),
3349 diag::note_odr_objc_method_here)
3350 << D->isInstanceMethod() << Name;
3351 return nullptr;
3352 }
3353
3354 // Check parameter types.
3355 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3356 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3357 P != PEnd; ++P, ++FoundP) {
3358 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3359 (*FoundP)->getType())) {
3360 Importer.FromDiag((*P)->getLocation(),
3361 diag::err_odr_objc_method_param_type_inconsistent)
3362 << D->isInstanceMethod() << Name
3363 << (*P)->getType() << (*FoundP)->getType();
3364 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3365 << (*FoundP)->getType();
3366 return nullptr;
3367 }
3368 }
3369
3370 // Check variadic/non-variadic.
3371 // Check the number of parameters.
3372 if (D->isVariadic() != FoundMethod->isVariadic()) {
3373 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3374 << D->isInstanceMethod() << Name;
3375 Importer.ToDiag(FoundMethod->getLocation(),
3376 diag::note_odr_objc_method_here)
3377 << D->isInstanceMethod() << Name;
3378 return nullptr;
3379 }
3380
3381 // FIXME: Any other bits we need to merge?
3382 return Importer.MapImported(D, FoundMethod);
3383 }
3384 }
3385
3386 // Import the result type.
3387 QualType ResultTy = Importer.Import(D->getReturnType());
3388 if (ResultTy.isNull())
3389 return nullptr;
3390
3391 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3392
3393 ObjCMethodDecl *ToMethod;
3394 if (GetImportedOrCreateDecl(
3395 ToMethod, D, Importer.getToContext(), Loc,
3396 Importer.Import(D->getLocEnd()), Name.getObjCSelector(), ResultTy,
3397 ReturnTInfo, DC, D->isInstanceMethod(), D->isVariadic(),
3398 D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3399 D->getImplementationControl(), D->hasRelatedResultType()))
3400 return ToMethod;
3401
3402 // FIXME: When we decide to merge method definitions, we'll need to
3403 // deal with implicit parameters.
3404
3405 // Import the parameters
3406 SmallVector<ParmVarDecl *, 5> ToParams;
3407 for (auto *FromP : D->parameters()) {
3408 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3409 if (!ToP)
3410 return nullptr;
3411
3412 ToParams.push_back(ToP);
3413 }
3414
3415 // Set the parameters.
3416 for (auto *ToParam : ToParams) {
3417 ToParam->setOwningFunction(ToMethod);
3418 ToMethod->addDeclInternal(ToParam);
3419 }
3420
3421 SmallVector<SourceLocation, 12> SelLocs;
3422 D->getSelectorLocs(SelLocs);
3423 for (auto &Loc : SelLocs)
3424 Loc = Importer.Import(Loc);
3425
3426 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3427
3428 ToMethod->setLexicalDeclContext(LexicalDC);
3429 LexicalDC->addDeclInternal(ToMethod);
3430 return ToMethod;
3431}
3432
3433Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
3434 // Import the major distinguishing characteristics of a category.
3435 DeclContext *DC, *LexicalDC;
3436 DeclarationName Name;
3437 SourceLocation Loc;
3438 NamedDecl *ToD;
3439 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3440 return nullptr;
3441 if (ToD)
3442 return ToD;
3443
3444 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3445 if (!BoundInfo)
3446 return nullptr;
3447
3448 ObjCTypeParamDecl *Result;
3449 if (GetImportedOrCreateDecl(
3450 Result, D, Importer.getToContext(), DC, D->getVariance(),
3451 Importer.Import(D->getVarianceLoc()), D->getIndex(),
3452 Importer.Import(D->getLocation()), Name.getAsIdentifierInfo(),
3453 Importer.Import(D->getColonLoc()), BoundInfo))
3454 return Result;
3455
3456 Result->setLexicalDeclContext(LexicalDC);
3457 return Result;
3458}
3459
3460Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3461 // Import the major distinguishing characteristics of a category.
3462 DeclContext *DC, *LexicalDC;
3463 DeclarationName Name;
3464 SourceLocation Loc;
3465 NamedDecl *ToD;
3466 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3467 return nullptr;
3468 if (ToD)
3469 return ToD;
3470
3471 auto *ToInterface =
3472 cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3473 if (!ToInterface)
3474 return nullptr;
3475
3476 // Determine if we've already encountered this category.
3477 ObjCCategoryDecl *MergeWithCategory
3478 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3479 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3480 if (!ToCategory) {
3481
3482 if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
3483 Importer.Import(D->getAtStartLoc()), Loc,
3484 Importer.Import(D->getCategoryNameLoc()),
3485 Name.getAsIdentifierInfo(), ToInterface,
3486 /*TypeParamList=*/nullptr,
3487 Importer.Import(D->getIvarLBraceLoc()),
3488 Importer.Import(D->getIvarRBraceLoc())))
3489 return ToCategory;
3490
3491 ToCategory->setLexicalDeclContext(LexicalDC);
3492 LexicalDC->addDeclInternal(ToCategory);
3493 // Import the type parameter list after calling Imported, to avoid
3494 // loops when bringing in their DeclContext.
3495 ToCategory->setTypeParamList(ImportObjCTypeParamList(
3496 D->getTypeParamList()));
3497
3498 // Import protocols
3499 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3500 SmallVector<SourceLocation, 4> ProtocolLocs;
3501 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3502 = D->protocol_loc_begin();
3503 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3504 FromProtoEnd = D->protocol_end();
3505 FromProto != FromProtoEnd;
3506 ++FromProto, ++FromProtoLoc) {
3507 auto *ToProto =
3508 cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3509 if (!ToProto)
3510 return nullptr;
3511 Protocols.push_back(ToProto);
3512 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3513 }
3514
3515 // FIXME: If we're merging, make sure that the protocol list is the same.
3516 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3517 ProtocolLocs.data(), Importer.getToContext());
3518 } else {
3519 Importer.MapImported(D, ToCategory);
3520 }
3521
3522 // Import all of the members of this category.
3523 ImportDeclContext(D);
3524
3525 // If we have an implementation, import it as well.
3526 if (D->getImplementation()) {
3527 auto *Impl =
3528 cast_or_null<ObjCCategoryImplDecl>(
3529 Importer.Import(D->getImplementation()));
3530 if (!Impl)
3531 return nullptr;
3532
3533 ToCategory->setImplementation(Impl);
3534 }
3535
3536 return ToCategory;
3537}
3538
3539bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3540 ObjCProtocolDecl *To,
3541 ImportDefinitionKind Kind) {
3542 if (To->getDefinition()) {
3543 if (shouldForceImportDeclContext(Kind))
3544 ImportDeclContext(From);
3545 return false;
3546 }
3547
3548 // Start the protocol definition
3549 To->startDefinition();
3550
3551 // Import protocols
3552 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3553 SmallVector<SourceLocation, 4> ProtocolLocs;
3554 ObjCProtocolDecl::protocol_loc_iterator
3555 FromProtoLoc = From->protocol_loc_begin();
3556 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3557 FromProtoEnd = From->protocol_end();
3558 FromProto != FromProtoEnd;
3559 ++FromProto, ++FromProtoLoc) {
3560 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3561 if (!ToProto)
3562 return true;
3563 Protocols.push_back(ToProto);
3564 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3565 }
3566
3567 // FIXME: If we're merging, make sure that the protocol list is the same.
3568 To->setProtocolList(Protocols.data(), Protocols.size(),
3569 ProtocolLocs.data(), Importer.getToContext());
3570
3571 if (shouldForceImportDeclContext(Kind)) {
3572 // Import all of the members of this protocol.
3573 ImportDeclContext(From, /*ForceImport=*/true);
3574 }
3575 return false;
3576}
3577
3578Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3579 // If this protocol has a definition in the translation unit we're coming
3580 // from, but this particular declaration is not that definition, import the
3581 // definition and map to that.
3582 ObjCProtocolDecl *Definition = D->getDefinition();
3583 if (Definition && Definition != D) {
3584 Decl *ImportedDef = Importer.Import(Definition);
3585 if (!ImportedDef)
3586 return nullptr;
3587
3588 return Importer.MapImported(D, ImportedDef);
3589 }
3590
3591 // Import the major distinguishing characteristics of a protocol.
3592 DeclContext *DC, *LexicalDC;
3593 DeclarationName Name;
3594 SourceLocation Loc;
3595 NamedDecl *ToD;
3596 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3597 return nullptr;
3598 if (ToD)
3599 return ToD;
3600
3601 ObjCProtocolDecl *MergeWithProtocol = nullptr;
3602 SmallVector<NamedDecl *, 2> FoundDecls;
3603 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3604 for (auto *FoundDecl : FoundDecls) {
3605 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3606 continue;
3607
3608 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
3609 break;
3610 }
3611
3612 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3613 if (!ToProto) {
3614 if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
3615 Name.getAsIdentifierInfo(), Loc,
3616 Importer.Import(D->getAtStartLoc()),
3617 /*PrevDecl=*/nullptr))
3618 return ToProto;
3619 ToProto->setLexicalDeclContext(LexicalDC);
3620 LexicalDC->addDeclInternal(ToProto);
3621 }
3622
3623 Importer.MapImported(D, ToProto);
3624
3625 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3626 return nullptr;
3627
3628 return ToProto;
3629}
3630
3631Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
3632 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3633 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3634
3635 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3636 SourceLocation LangLoc = Importer.Import(D->getLocation());
3637
3638 bool HasBraces = D->hasBraces();
3639
3640 LinkageSpecDecl *ToLinkageSpec;
3641 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
3642 ExternLoc, LangLoc, D->getLanguage(), HasBraces))
3643 return ToLinkageSpec;
3644
3645 if (HasBraces) {
3646 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3647 ToLinkageSpec->setRBraceLoc(RBraceLoc);
3648 }
3649
3650 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3651 LexicalDC->addDeclInternal(ToLinkageSpec);
3652
3653 return ToLinkageSpec;
3654}
3655
3656Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
3657 DeclContext *DC, *LexicalDC;
3658 DeclarationName Name;
3659 SourceLocation Loc;
3660 NamedDecl *ToD = nullptr;
3661 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3662 return nullptr;
3663 if (ToD)
3664 return ToD;
3665
3666 DeclarationNameInfo NameInfo(Name,
3667 Importer.Import(D->getNameInfo().getLoc()));
3668 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3669
3670 UsingDecl *ToUsing;
3671 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3672 Importer.Import(D->getUsingLoc()),
3673 Importer.Import(D->getQualifierLoc()), NameInfo,
3674 D->hasTypename()))
3675 return ToUsing;
3676
3677 ToUsing->setLexicalDeclContext(LexicalDC);
3678 LexicalDC->addDeclInternal(ToUsing);
3679
3680 if (NamedDecl *FromPattern =
3681 Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
3682 if (auto *ToPattern =
3683 dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
3684 Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
3685 else
3686 return nullptr;
3687 }
3688
3689 for (auto *FromShadow : D->shadows()) {
3690 if (auto *ToShadow =
3691 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
3692 ToUsing->addShadowDecl(ToShadow);
3693 else
3694 // FIXME: We return a nullptr here but the definition is already created
3695 // and available with lookups. How to fix this?..
3696 return nullptr;
3697 }
3698 return ToUsing;
3699}
3700
3701Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
3702 DeclContext *DC, *LexicalDC;
3703 DeclarationName Name;
3704 SourceLocation Loc;
3705 NamedDecl *ToD = nullptr;
3706 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3707 return nullptr;
3708 if (ToD)
3709 return ToD;
3710
3711 auto *ToUsing = dyn_cast_or_null<UsingDecl>(
3712 Importer.Import(D->getUsingDecl()));
3713 if (!ToUsing)
3714 return nullptr;
3715
3716 auto *ToTarget = dyn_cast_or_null<NamedDecl>(
3717 Importer.Import(D->getTargetDecl()));
3718 if (!ToTarget)
3719 return nullptr;
3720
3721 UsingShadowDecl *ToShadow;
3722 if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
3723 ToUsing, ToTarget))
3724 return ToShadow;
3725
3726 ToShadow->setLexicalDeclContext(LexicalDC);
3727 ToShadow->setAccess(D->getAccess());
3728
3729 if (UsingShadowDecl *FromPattern =
3730 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
3731 if (auto *ToPattern =
3732 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
3733 Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
3734 ToPattern);
3735 else
3736 // FIXME: We return a nullptr here but the definition is already created
3737 // and available with lookups. How to fix this?..
3738 return nullptr;
3739 }
3740
3741 LexicalDC->addDeclInternal(ToShadow);
3742
3743 return ToShadow;
3744}
3745
3746Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
3747 DeclContext *DC, *LexicalDC;
3748 DeclarationName Name;
3749 SourceLocation Loc;
3750 NamedDecl *ToD = nullptr;
3751 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3752 return nullptr;
3753 if (ToD)
3754 return ToD;
3755
3756 DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor());
3757 if (!ToComAncestor)
3758 return nullptr;
3759
3760 auto *ToNominated = cast_or_null<NamespaceDecl>(
3761 Importer.Import(D->getNominatedNamespace()));
3762 if (!ToNominated)
3763 return nullptr;
3764
3765 UsingDirectiveDecl *ToUsingDir;
3766 if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
3767 Importer.Import(D->getUsingLoc()),
3768 Importer.Import(D->getNamespaceKeyLocation()),
3769 Importer.Import(D->getQualifierLoc()),
3770 Importer.Import(D->getIdentLocation()),
3771 ToNominated, ToComAncestor))
3772 return ToUsingDir;
3773
3774 ToUsingDir->setLexicalDeclContext(LexicalDC);
3775 LexicalDC->addDeclInternal(ToUsingDir);
3776
3777 return ToUsingDir;
3778}
3779
3780Decl *ASTNodeImporter::VisitUnresolvedUsingValueDecl(
3781 UnresolvedUsingValueDecl *D) {
3782 DeclContext *DC, *LexicalDC;
3783 DeclarationName Name;
3784 SourceLocation Loc;
3785 NamedDecl *ToD = nullptr;
3786 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3787 return nullptr;
3788 if (ToD)
3789 return ToD;
3790
3791 DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
3792 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3793
3794 UnresolvedUsingValueDecl *ToUsingValue;
3795 if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
3796 Importer.Import(D->getUsingLoc()),
3797 Importer.Import(D->getQualifierLoc()), NameInfo,
3798 Importer.Import(D->getEllipsisLoc())))
3799 return ToUsingValue;
3800
3801 ToUsingValue->setAccess(D->getAccess());
3802 ToUsingValue->setLexicalDeclContext(LexicalDC);
3803 LexicalDC->addDeclInternal(ToUsingValue);
3804
3805 return ToUsingValue;
3806}
3807
3808Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
3809 UnresolvedUsingTypenameDecl *D) {
3810 DeclContext *DC, *LexicalDC;
3811 DeclarationName Name;
3812 SourceLocation Loc;
3813 NamedDecl *ToD = nullptr;
3814 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3815 return nullptr;
3816 if (ToD)
3817 return ToD;
3818
3819 UnresolvedUsingTypenameDecl *ToUsing;
3820 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3821 Importer.Import(D->getUsingLoc()),
3822 Importer.Import(D->getTypenameLoc()),
3823 Importer.Import(D->getQualifierLoc()), Loc, Name,
3824 Importer.Import(D->getEllipsisLoc())))
3825 return ToUsing;
3826
3827 ToUsing->setAccess(D->getAccess());
3828 ToUsing->setLexicalDeclContext(LexicalDC);
3829 LexicalDC->addDeclInternal(ToUsing);
3830
3831 return ToUsing;
3832}
3833
3834bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3835 ObjCInterfaceDecl *To,
3836 ImportDefinitionKind Kind) {
3837 if (To->getDefinition()) {
3838 // Check consistency of superclass.
3839 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3840 if (FromSuper) {
3841 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3842 if (!FromSuper)
3843 return true;
3844 }
3845
3846 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3847 if ((bool)FromSuper != (bool)ToSuper ||
3848 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3849 Importer.ToDiag(To->getLocation(),
3850 diag::err_odr_objc_superclass_inconsistent)
3851 << To->getDeclName();
3852 if (ToSuper)
3853 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3854 << To->getSuperClass()->getDeclName();
3855 else
3856 Importer.ToDiag(To->getLocation(),
3857 diag::note_odr_objc_missing_superclass);
3858 if (From->getSuperClass())
3859 Importer.FromDiag(From->getSuperClassLoc(),
3860 diag::note_odr_objc_superclass)
3861 << From->getSuperClass()->getDeclName();
3862 else
3863 Importer.FromDiag(From->getLocation(),
3864 diag::note_odr_objc_missing_superclass);
3865 }
3866
3867 if (shouldForceImportDeclContext(Kind))
3868 ImportDeclContext(From);
3869 return false;
3870 }
3871
3872 // Start the definition.
3873 To->startDefinition();
3874
3875 // If this class has a superclass, import it.
3876 if (From->getSuperClass()) {
3877 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3878 if (!SuperTInfo)
3879 return true;
3880
3881 To->setSuperClass(SuperTInfo);
3882 }
3883
3884 // Import protocols
3885 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3886 SmallVector<SourceLocation, 4> ProtocolLocs;
3887 ObjCInterfaceDecl::protocol_loc_iterator
3888 FromProtoLoc = From->protocol_loc_begin();
3889
3890 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3891 FromProtoEnd = From->protocol_end();
3892 FromProto != FromProtoEnd;
3893 ++FromProto, ++FromProtoLoc) {
3894 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3895 if (!ToProto)
3896 return true;
3897 Protocols.push_back(ToProto);
3898 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3899 }
3900
3901 // FIXME: If we're merging, make sure that the protocol list is the same.
3902 To->setProtocolList(Protocols.data(), Protocols.size(),
3903 ProtocolLocs.data(), Importer.getToContext());
3904
3905 // Import categories. When the categories themselves are imported, they'll
3906 // hook themselves into this interface.
3907 for (auto *Cat : From->known_categories())
3908 Importer.Import(Cat);
3909
3910 // If we have an @implementation, import it as well.
3911 if (From->getImplementation()) {
3912 auto *Impl = cast_or_null<ObjCImplementationDecl>(
3913 Importer.Import(From->getImplementation()));
3914 if (!Impl)
3915 return true;
3916
3917 To->setImplementation(Impl);
3918 }
3919
3920 if (shouldForceImportDeclContext(Kind)) {
3921 // Import all of the members of this class.
3922 ImportDeclContext(From, /*ForceImport=*/true);
3923 }
3924 return false;
3925}
3926
3927ObjCTypeParamList *
3928ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
3929 if (!list)
3930 return nullptr;
3931
3932 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
3933 for (auto fromTypeParam : *list) {
3934 auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>(
3935 Importer.Import(fromTypeParam));
3936 if (!toTypeParam)
3937 return nullptr;
3938
3939 toTypeParams.push_back(toTypeParam);
3940 }
3941
3942 return ObjCTypeParamList::create(Importer.getToContext(),
3943 Importer.Import(list->getLAngleLoc()),
3944 toTypeParams,
3945 Importer.Import(list->getRAngleLoc()));
3946}
3947
3948Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3949 // If this class has a definition in the translation unit we're coming from,
3950 // but this particular declaration is not that definition, import the
3951 // definition and map to that.
3952 ObjCInterfaceDecl *Definition = D->getDefinition();
3953 if (Definition && Definition != D) {
3954 Decl *ImportedDef = Importer.Import(Definition);
3955 if (!ImportedDef)
3956 return nullptr;
3957
3958 return Importer.MapImported(D, ImportedDef);
3959 }
3960
3961 // Import the major distinguishing characteristics of an @interface.
3962 DeclContext *DC, *LexicalDC;
3963 DeclarationName Name;
3964 SourceLocation Loc;
3965 NamedDecl *ToD;
3966 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3967 return nullptr;
3968 if (ToD)
3969 return ToD;
3970
3971 // Look for an existing interface with the same name.
3972 ObjCInterfaceDecl *MergeWithIface = nullptr;
3973 SmallVector<NamedDecl *, 2> FoundDecls;
3974 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3975 for (auto *FoundDecl : FoundDecls) {
3976 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3977 continue;
3978
3979 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
3980 break;
3981 }
3982
3983 // Create an interface declaration, if one does not already exist.
3984 ObjCInterfaceDecl *ToIface = MergeWithIface;
3985 if (!ToIface) {
3986 if (GetImportedOrCreateDecl(
3987 ToIface, D, Importer.getToContext(), DC,
3988 Importer.Import(D->getAtStartLoc()), Name.getAsIdentifierInfo(),
3989 /*TypeParamList=*/nullptr,
3990 /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
3991 return ToIface;
3992 ToIface->setLexicalDeclContext(LexicalDC);
3993 LexicalDC->addDeclInternal(ToIface);
3994 }
3995 Importer.MapImported(D, ToIface);
3996 // Import the type parameter list after calling Imported, to avoid
3997 // loops when bringing in their DeclContext.
3998 ToIface->setTypeParamList(ImportObjCTypeParamList(
3999 D->getTypeParamListAsWritten()));
4000
4001 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4002 return nullptr;
4003
4004 return ToIface;
4005}
4006
4007Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4008 auto *Category = cast_or_null<ObjCCategoryDecl>(
4009 Importer.Import(D->getCategoryDecl()));
4010 if (!Category)
4011 return nullptr;
4012
4013 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4014 if (!ToImpl) {
4015 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4016 if (!DC)
4017 return nullptr;
4018
4019 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4020 if (GetImportedOrCreateDecl(
4021 ToImpl, D, Importer.getToContext(), DC,
4022 Importer.Import(D->getIdentifier()), Category->getClassInterface(),
4023 Importer.Import(D->getLocation()),
4024 Importer.Import(D->getAtStartLoc()), CategoryNameLoc))
4025 return ToImpl;
4026
4027 DeclContext *LexicalDC = DC;
4028 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4029 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4030 if (!LexicalDC)
4031 return nullptr;
4032
4033 ToImpl->setLexicalDeclContext(LexicalDC);
4034 }
4035
4036 LexicalDC->addDeclInternal(ToImpl);
4037 Category->setImplementation(ToImpl);
4038 }
4039
4040 Importer.MapImported(D, ToImpl);
4041 ImportDeclContext(D);
4042 return ToImpl;
4043}
4044
4045Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4046 // Find the corresponding interface.
4047 auto *Iface = cast_or_null<ObjCInterfaceDecl>(
4048 Importer.Import(D->getClassInterface()));
4049 if (!Iface)
4050 return nullptr;
4051
4052 // Import the superclass, if any.
4053 ObjCInterfaceDecl *Super = nullptr;
4054 if (D->getSuperClass()) {
4055 Super = cast_or_null<ObjCInterfaceDecl>(
4056 Importer.Import(D->getSuperClass()));
4057 if (!Super)
4058 return nullptr;
4059 }
4060
4061 ObjCImplementationDecl *Impl = Iface->getImplementation();
4062 if (!Impl) {
4063 // We haven't imported an implementation yet. Create a new @implementation
4064 // now.
4065 if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
4066 Importer.ImportContext(D->getDeclContext()),
4067 Iface, Super, Importer.Import(D->getLocation()),
4068 Importer.Import(D->getAtStartLoc()),
4069 Importer.Import(D->getSuperClassLoc()),
4070 Importer.Import(D->getIvarLBraceLoc()),
4071 Importer.Import(D->getIvarRBraceLoc())))
4072 return Impl;
4073
4074 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4075 DeclContext *LexicalDC
4076 = Importer.ImportContext(D->getLexicalDeclContext());
4077 if (!LexicalDC)
4078 return nullptr;
4079 Impl->setLexicalDeclContext(LexicalDC);
4080 }
4081
4082 // Associate the implementation with the class it implements.
4083 Iface->setImplementation(Impl);
4084 Importer.MapImported(D, Iface->getImplementation());
4085 } else {
4086 Importer.MapImported(D, Iface->getImplementation());
4087
4088 // Verify that the existing @implementation has the same superclass.
4089 if ((Super && !Impl->getSuperClass()) ||
4090 (!Super && Impl->getSuperClass()) ||
4091 (Super && Impl->getSuperClass() &&
4092 !declaresSameEntity(Super->getCanonicalDecl(),
4093 Impl->getSuperClass()))) {
4094 Importer.ToDiag(Impl->getLocation(),
4095 diag::err_odr_objc_superclass_inconsistent)
4096 << Iface->getDeclName();
4097 // FIXME: It would be nice to have the location of the superclass
4098 // below.
4099 if (Impl->getSuperClass())
4100 Importer.ToDiag(Impl->getLocation(),
4101 diag::note_odr_objc_superclass)
4102 << Impl->getSuperClass()->getDeclName();
4103 else
4104 Importer.ToDiag(Impl->getLocation(),
4105 diag::note_odr_objc_missing_superclass);
4106 if (D->getSuperClass())
4107 Importer.FromDiag(D->getLocation(),
4108 diag::note_odr_objc_superclass)
4109 << D->getSuperClass()->getDeclName();
4110 else
4111 Importer.FromDiag(D->getLocation(),
4112 diag::note_odr_objc_missing_superclass);
4113 return nullptr;
4114 }
4115 }
4116
4117 // Import all of the members of this @implementation.
4118 ImportDeclContext(D);
4119
4120 return Impl;
4121}
4122
4123Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4124 // Import the major distinguishing characteristics of an @property.
4125 DeclContext *DC, *LexicalDC;
4126 DeclarationName Name;
4127 SourceLocation Loc;
4128 NamedDecl *ToD;
4129 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4130 return nullptr;
4131 if (ToD)
4132 return ToD;
4133
4134 // Check whether we have already imported this property.
4135 SmallVector<NamedDecl *, 2> FoundDecls;
4136 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4137 for (auto *FoundDecl : FoundDecls) {
4138 if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
4139 // Check property types.
4140 if (!Importer.IsStructurallyEquivalent(D->getType(),
4141 FoundProp->getType())) {
4142 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4143 << Name << D->getType() << FoundProp->getType();
4144 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4145 << FoundProp->getType();
4146 return nullptr;
4147 }
4148
4149 // FIXME: Check property attributes, getters, setters, etc.?
4150
4151 // Consider these properties to be equivalent.
4152 Importer.MapImported(D, FoundProp);
4153 return FoundProp;
4154 }
4155 }
4156
4157 // Import the type.
4158 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4159 if (!TSI)
4160 return nullptr;
4161
4162 // Create the new property.
4163 ObjCPropertyDecl *ToProperty;
4164 if (GetImportedOrCreateDecl(
4165 ToProperty, D, Importer.getToContext(), DC, Loc,
4166 Name.getAsIdentifierInfo(), Importer.Import(D->getAtLoc()),
4167 Importer.Import(D->getLParenLoc()), Importer.Import(D->getType()),
4168 TSI, D->getPropertyImplementation()))
4169 return ToProperty;
4170
4171 ToProperty->setLexicalDeclContext(LexicalDC);
4172 LexicalDC->addDeclInternal(ToProperty);
4173
4174 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4175 ToProperty->setPropertyAttributesAsWritten(
4176 D->getPropertyAttributesAsWritten());
4177 ToProperty->setGetterName(Importer.Import(D->getGetterName()),
4178 Importer.Import(D->getGetterNameLoc()));
4179 ToProperty->setSetterName(Importer.Import(D->getSetterName()),
4180 Importer.Import(D->getSetterNameLoc()));
4181 ToProperty->setGetterMethodDecl(
4182 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4183 ToProperty->setSetterMethodDecl(
4184 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4185 ToProperty->setPropertyIvarDecl(
4186 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4187 return ToProperty;
4188}
4189
4190Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4191 auto *Property = cast_or_null<ObjCPropertyDecl>(
4192 Importer.Import(D->getPropertyDecl()));
4193 if (!Property)
4194 return nullptr;
4195
4196 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4197 if (!DC)
4198 return nullptr;
4199
4200 // Import the lexical declaration context.
4201 DeclContext *LexicalDC = DC;
4202 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4203 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4204 if (!LexicalDC)
4205 return nullptr;
4206 }
4207
4208 auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4209 if (!InImpl)
4210 return nullptr;
4211
4212 // Import the ivar (for an @synthesize).
4213 ObjCIvarDecl *Ivar = nullptr;
4214 if (D->getPropertyIvarDecl()) {
4215 Ivar = cast_or_null<ObjCIvarDecl>(
4216 Importer.Import(D->getPropertyIvarDecl()));
4217 if (!Ivar)
4218 return nullptr;
4219 }
4220
4221 ObjCPropertyImplDecl *ToImpl
4222 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4223 Property->getQueryKind());
4224 if (!ToImpl) {
4225 if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
4226 Importer.Import(D->getLocStart()),
4227 Importer.Import(D->getLocation()), Property,
4228 D->getPropertyImplementation(), Ivar,
4229 Importer.Import(D->getPropertyIvarDeclLoc())))
4230 return ToImpl;
4231
4232 ToImpl->setLexicalDeclContext(LexicalDC);
4233 LexicalDC->addDeclInternal(ToImpl);
4234 } else {
4235 // Check that we have the same kind of property implementation (@synthesize
4236 // vs. @dynamic).
4237 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4238 Importer.ToDiag(ToImpl->getLocation(),
4239 diag::err_odr_objc_property_impl_kind_inconsistent)
4240 << Property->getDeclName()
4241 << (ToImpl->getPropertyImplementation()
4242 == ObjCPropertyImplDecl::Dynamic);
4243 Importer.FromDiag(D->getLocation(),
4244 diag::note_odr_objc_property_impl_kind)
4245 << D->getPropertyDecl()->getDeclName()
4246 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4247 return nullptr;
4248 }
4249
4250 // For @synthesize, check that we have the same
4251 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4252 Ivar != ToImpl->getPropertyIvarDecl()) {
4253 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4254 diag::err_odr_objc_synthesize_ivar_inconsistent)
4255 << Property->getDeclName()
4256 << ToImpl->getPropertyIvarDecl()->getDeclName()
4257 << Ivar->getDeclName();
4258 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4259 diag::note_odr_objc_synthesize_ivar_here)
4260 << D->getPropertyIvarDecl()->getDeclName();
4261 return nullptr;
4262 }
4263
4264 // Merge the existing implementation with the new implementation.
4265 Importer.MapImported(D, ToImpl);
4266 }
4267
4268 return ToImpl;
4269}
4270
4271Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4272 // For template arguments, we adopt the translation unit as our declaration
4273 // context. This context will be fixed when the actual template declaration
4274 // is created.
4275
4276 // FIXME: Import default argument.
4277 TemplateTypeParmDecl *ToD = nullptr;
4278 (void)GetImportedOrCreateDecl(
4279 ToD, D, Importer.getToContext(),
4280 Importer.getToContext().getTranslationUnitDecl(),
4281 Importer.Import(D->getLocStart()), Importer.Import(D->getLocation()),
4282 D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
4283 D->wasDeclaredWithTypename(), D->isParameterPack());
4284 return ToD;
4285}
4286
4287Decl *
4288ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4289 // Import the name of this declaration.
4290 DeclarationName Name = Importer.Import(D->getDeclName());
4291 if (D->getDeclName() && !Name)
4292 return nullptr;
4293
4294 // Import the location of this declaration.
4295 SourceLocation Loc = Importer.Import(D->getLocation());
4296
4297 // Import the type of this declaration.
4298 QualType T = Importer.Import(D->getType());
4299 if (T.isNull())
4300 return nullptr;
4301
4302 // Import type-source information.
4303 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4304 if (D->getTypeSourceInfo() && !TInfo)
4305 return nullptr;
4306
4307 // FIXME: Import default argument.
4308
4309 NonTypeTemplateParmDecl *ToD = nullptr;
4310 (void)GetImportedOrCreateDecl(
4311 ToD, D, Importer.getToContext(),
4312 Importer.getToContext().getTranslationUnitDecl(),
4313 Importer.Import(D->getInnerLocStart()), Loc, D->getDepth(),
4314 D->getPosition(), Name.getAsIdentifierInfo(), T, D->isParameterPack(),
4315 TInfo);
4316 return ToD;
4317}
4318
4319Decl *
4320ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4321 // Import the name of this declaration.
4322 DeclarationName Name = Importer.Import(D->getDeclName());
4323 if (D->getDeclName() && !Name)
4324 return nullptr;
4325
4326 // Import the location of this declaration.
4327 SourceLocation Loc = Importer.Import(D->getLocation());
4328
4329 // Import template parameters.
4330 TemplateParameterList *TemplateParams
4331 = ImportTemplateParameterList(D->getTemplateParameters());
4332 if (!TemplateParams)
4333 return nullptr;
4334
4335 // FIXME: Import default argument.
4336
4337 TemplateTemplateParmDecl *ToD = nullptr;
4338 (void)GetImportedOrCreateDecl(
4339 ToD, D, Importer.getToContext(),
4340 Importer.getToContext().getTranslationUnitDecl(), Loc, D->getDepth(),
4341 D->getPosition(), D->isParameterPack(), Name.getAsIdentifierInfo(),
4342 TemplateParams);
4343 return ToD;
4344}
4345
4346// Returns the definition for a (forward) declaration of a ClassTemplateDecl, if
4347// it has any definition in the redecl chain.
4348static ClassTemplateDecl *getDefinition(ClassTemplateDecl *D) {
4349 CXXRecordDecl *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
4350 if (!ToTemplatedDef)
4351 return nullptr;
4352 ClassTemplateDecl *TemplateWithDef =
4353 ToTemplatedDef->getDescribedClassTemplate();
4354 return TemplateWithDef;
4355}
4356
4357Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4358 // If this record has a definition in the translation unit we're coming from,
4359 // but this particular declaration is not that definition, import the
4360 // definition and map to that.
4361 auto *Definition =
4362 cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4363 if (Definition && Definition != D->getTemplatedDecl()) {
4364 Decl *ImportedDef
4365 = Importer.Import(Definition->getDescribedClassTemplate());
4366 if (!ImportedDef)
4367 return nullptr;
4368
4369 return Importer.MapImported(D, ImportedDef);
4370 }
4371
4372 // Import the major distinguishing characteristics of this class template.
4373 DeclContext *DC, *LexicalDC;
4374 DeclarationName Name;
4375 SourceLocation Loc;
4376 NamedDecl *ToD;
4377 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4378 return nullptr;
4379 if (ToD)
4380 return ToD;
4381
4382 // We may already have a template of the same name; try to find and match it.
4383 if (!DC->isFunctionOrMethod()) {
4384 SmallVector<NamedDecl *, 4> ConflictingDecls;
4385 SmallVector<NamedDecl *, 2> FoundDecls;
4386 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4387 for (auto *FoundDecl : FoundDecls) {
4388 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4389 continue;
4390
4391 Decl *Found = FoundDecl;
4392 if (auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found)) {
4393
4394 // The class to be imported is a definition.
4395 if (D->isThisDeclarationADefinition()) {
4396 // Lookup will find the fwd decl only if that is more recent than the
4397 // definition. So, try to get the definition if that is available in
4398 // the redecl chain.
4399 ClassTemplateDecl *TemplateWithDef = getDefinition(FoundTemplate);
4400 if (!TemplateWithDef)
4401 continue;
4402 FoundTemplate = TemplateWithDef; // Continue with the definition.
4403 }
4404
4405 if (IsStructuralMatch(D, FoundTemplate)) {
4406 // The class templates structurally match; call it the same template.
4407
4408 Importer.MapImported(D->getTemplatedDecl(),
4409 FoundTemplate->getTemplatedDecl());
4410 return Importer.MapImported(D, FoundTemplate);
4411 }
4412 }
4413
4414 ConflictingDecls.push_back(FoundDecl);
4415 }
4416
4417 if (!ConflictingDecls.empty()) {
4418 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4419 ConflictingDecls.data(),
4420 ConflictingDecls.size());
4421 }
4422
4423 if (!Name)
4424 return nullptr;
4425 }
4426
4427 CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
4428
4429 // Create the declaration that is being templated.
4430 auto *ToTemplated = cast_or_null<CXXRecordDecl>(
4431 Importer.Import(FromTemplated));
4432 if (!ToTemplated)
4433 return nullptr;
4434
4435 // Create the class template declaration itself.
4436 TemplateParameterList *TemplateParams =
4437 ImportTemplateParameterList(D->getTemplateParameters());
4438 if (!TemplateParams)
4439 return nullptr;
4440
4441 ClassTemplateDecl *D2;
4442 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
4443 TemplateParams, ToTemplated))
4444 return D2;
4445
4446 ToTemplated->setDescribedClassTemplate(D2);
4447
4448 D2->setAccess(D->getAccess());
4449 D2->setLexicalDeclContext(LexicalDC);
4450 LexicalDC->addDeclInternal(D2);
4451
4452 if (FromTemplated->isCompleteDefinition() &&
4453 !ToTemplated->isCompleteDefinition()) {
4454 // FIXME: Import definition!
4455 }
4456
4457 return D2;
4458}
4459
4460Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4461 ClassTemplateSpecializationDecl *D) {
4462 // If this record has a definition in the translation unit we're coming from,
4463 // but this particular declaration is not that definition, import the
4464 // definition and map to that.
4465 TagDecl *Definition = D->getDefinition();
4466 if (Definition && Definition != D) {
4467 Decl *ImportedDef = Importer.Import(Definition);
4468 if (!ImportedDef)
4469 return nullptr;
4470
4471 return Importer.MapImported(D, ImportedDef);
4472 }
4473
4474 auto *ClassTemplate =
4475 cast_or_null<ClassTemplateDecl>(Importer.Import(
4476 D->getSpecializedTemplate()));
4477 if (!ClassTemplate)
4478 return nullptr;
4479
4480 // Import the context of this declaration.
4481 DeclContext *DC = ClassTemplate->getDeclContext();
4482 if (!DC)
4483 return nullptr;
4484
4485 DeclContext *LexicalDC = DC;
4486 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4487 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4488 if (!LexicalDC)
4489 return nullptr;
4490 }
4491
4492 // Import the location of this declaration.
4493 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4494 SourceLocation IdLoc = Importer.Import(D->getLocation());
4495
4496 // Import template arguments.
4497 SmallVector<TemplateArgument, 2> TemplateArgs;
4498 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4499 D->getTemplateArgs().size(),
4500 TemplateArgs))
4501 return nullptr;
4502
4503 // Try to find an existing specialization with these template arguments.
4504 void *InsertPos = nullptr;
4505 ClassTemplateSpecializationDecl *D2
4506 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4507 if (D2) {
4508 // We already have a class template specialization with these template
4509 // arguments.
4510
4511 // FIXME: Check for specialization vs. instantiation errors.
4512
4513 if (RecordDecl *FoundDef = D2->getDefinition()) {
4514 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4515 // The record types structurally match, or the "from" translation
4516 // unit only had a forward declaration anyway; call it the same
4517 // function.
4518 return Importer.MapImported(D, FoundDef);
4519 }
4520 }
4521 } else {
4522 // Create a new specialization.
4523 if (auto *PartialSpec =
4524 dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
4525 // Import TemplateArgumentListInfo
4526 TemplateArgumentListInfo ToTAInfo;
4527 const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4528 if (ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
4529 return nullptr;
4530
4531 QualType CanonInjType = Importer.Import(
4532 PartialSpec->getInjectedSpecializationType());
4533 if (CanonInjType.isNull())
4534 return nullptr;
4535 CanonInjType = CanonInjType.getCanonicalType();
4536
4537 TemplateParameterList *ToTPList = ImportTemplateParameterList(
4538 PartialSpec->getTemplateParameters());
4539 if (!ToTPList && PartialSpec->getTemplateParameters())
4540 return nullptr;
4541
4542 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
4543 D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
4544 IdLoc, ToTPList, ClassTemplate,
4545 llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
4546 ToTAInfo, CanonInjType, nullptr))
4547 return D2;
4548
4549 } else {
4550 if (GetImportedOrCreateDecl(
4551 D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
4552 IdLoc, ClassTemplate, TemplateArgs, /*PrevDecl=*/nullptr))
4553 return D2;
4554 }
4555
4556 D2->setSpecializationKind(D->getSpecializationKind());
4557
4558 // Add this specialization to the class template.
4559 ClassTemplate->AddSpecialization(D2, InsertPos);
4560
4561 // Import the qualifier, if any.
4562 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4563
4564 if (auto *TSI = D->getTypeAsWritten()) {
4565 TypeSourceInfo *TInfo = Importer.Import(TSI);
4566 if (!TInfo)
4567 return nullptr;
4568 D2->setTypeAsWritten(TInfo);
4569 D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4570 D2->setExternLoc(Importer.Import(D->getExternLoc()));
4571 }
4572
4573 SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4574 if (POI.isValid())
4575 D2->setPointOfInstantiation(POI);
4576 else if (D->getPointOfInstantiation().isValid())
4577 return nullptr;
4578
4579 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4580
4581 // Set the context of this specialization/instantiation.
4582 D2->setLexicalDeclContext(LexicalDC);
4583
4584 // Add to the DC only if it was an explicit specialization/instantiation.
4585 if (D2->isExplicitInstantiationOrSpecialization()) {
4586 LexicalDC->addDeclInternal(D2);
4587 }
4588 }
4589 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4590 return nullptr;
4591
4592 return D2;
4593}
4594
4595Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4596 // If this variable has a definition in the translation unit we're coming
4597 // from,
4598 // but this particular declaration is not that definition, import the
4599 // definition and map to that.
4600 auto *Definition =
4601 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4602 if (Definition && Definition != D->getTemplatedDecl()) {
4603 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4604 if (!ImportedDef)
4605 return nullptr;
4606
4607 return Importer.MapImported(D, ImportedDef);
4608 }
4609
4610 // Import the major distinguishing characteristics of this variable template.
4611 DeclContext *DC, *LexicalDC;
4612 DeclarationName Name;
4613 SourceLocation Loc;
4614 NamedDecl *ToD;
4615 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4616 return nullptr;
4617 if (ToD)
4618 return ToD;
4619
4620 // We may already have a template of the same name; try to find and match it.
4621 assert(!DC->isFunctionOrMethod() &&(static_cast <bool> (!DC->isFunctionOrMethod() &&
"Variable templates cannot be declared at function scope") ?
void (0) : __assert_fail ("!DC->isFunctionOrMethod() && \"Variable templates cannot be declared at function scope\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 4622, __extension__ __PRETTY_FUNCTION__))
4622 "Variable templates cannot be declared at function scope")(static_cast <bool> (!DC->isFunctionOrMethod() &&
"Variable templates cannot be declared at function scope") ?
void (0) : __assert_fail ("!DC->isFunctionOrMethod() && \"Variable templates cannot be declared at function scope\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 4622, __extension__ __PRETTY_FUNCTION__))
;
4623 SmallVector<NamedDecl *, 4> ConflictingDecls;
4624 SmallVector<NamedDecl *, 2> FoundDecls;
4625 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4626 for (auto *FoundDecl : FoundDecls) {
4627 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4628 continue;
4629
4630 Decl *Found = FoundDecl;
4631 if (auto *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4632 if (IsStructuralMatch(D, FoundTemplate)) {
4633 // The variable templates structurally match; call it the same template.
4634 Importer.MapImported(D->getTemplatedDecl(),
4635 FoundTemplate->getTemplatedDecl());
4636 return Importer.MapImported(D, FoundTemplate);
4637 }
4638 }
4639
4640 ConflictingDecls.push_back(FoundDecl);
4641 }
4642
4643 if (!ConflictingDecls.empty()) {
4644 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4645 ConflictingDecls.data(),
4646 ConflictingDecls.size());
4647 }
4648
4649 if (!Name)
4650 return nullptr;
4651
4652 VarDecl *DTemplated = D->getTemplatedDecl();
4653
4654 // Import the type.
4655 QualType T = Importer.Import(DTemplated->getType());
4656 if (T.isNull())
4657 return nullptr;
4658
4659 // Create the declaration that is being templated.
4660 auto *ToTemplated = dyn_cast_or_null<VarDecl>(Importer.Import(DTemplated));
4661 if (!ToTemplated)
4662 return nullptr;
4663
4664 // Create the variable template declaration itself.
4665 TemplateParameterList *TemplateParams =
4666 ImportTemplateParameterList(D->getTemplateParameters());
4667 if (!TemplateParams)
4668 return nullptr;
4669
4670 VarTemplateDecl *ToVarTD;
4671 if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
4672 Name, TemplateParams, ToTemplated))
4673 return ToVarTD;
4674
4675 ToTemplated->setDescribedVarTemplate(ToVarTD);
4676
4677 ToVarTD->setAccess(D->getAccess());
4678 ToVarTD->setLexicalDeclContext(LexicalDC);
4679 LexicalDC->addDeclInternal(ToVarTD);
4680
4681 if (DTemplated->isThisDeclarationADefinition() &&
4682 !ToTemplated->isThisDeclarationADefinition()) {
4683 // FIXME: Import definition!
4684 }
4685
4686 return ToVarTD;
4687}
4688
4689Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4690 VarTemplateSpecializationDecl *D) {
4691 // If this record has a definition in the translation unit we're coming from,
4692 // but this particular declaration is not that definition, import the
4693 // definition and map to that.
4694 VarDecl *Definition = D->getDefinition();
4695 if (Definition && Definition != D) {
4696 Decl *ImportedDef = Importer.Import(Definition);
4697 if (!ImportedDef)
4698 return nullptr;
4699
4700 return Importer.MapImported(D, ImportedDef);
4701 }
4702
4703 auto *VarTemplate = cast_or_null<VarTemplateDecl>(
4704 Importer.Import(D->getSpecializedTemplate()));
4705 if (!VarTemplate)
4706 return nullptr;
4707
4708 // Import the context of this declaration.
4709 DeclContext *DC = VarTemplate->getDeclContext();
4710 if (!DC)
4711 return nullptr;
4712
4713 DeclContext *LexicalDC = DC;
4714 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4715 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4716 if (!LexicalDC)
4717 return nullptr;
4718 }
4719
4720 // Import the location of this declaration.
4721 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4722 SourceLocation IdLoc = Importer.Import(D->getLocation());
4723
4724 // Import template arguments.
4725 SmallVector<TemplateArgument, 2> TemplateArgs;
4726 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4727 D->getTemplateArgs().size(), TemplateArgs))
4728 return nullptr;
4729
4730 // Try to find an existing specialization with these template arguments.
4731 void *InsertPos = nullptr;
4732 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4733 TemplateArgs, InsertPos);
4734 if (D2) {
4735 // We already have a variable template specialization with these template
4736 // arguments.
4737
4738 // FIXME: Check for specialization vs. instantiation errors.
4739
4740 if (VarDecl *FoundDef = D2->getDefinition()) {
4741 if (!D->isThisDeclarationADefinition() ||
4742 IsStructuralMatch(D, FoundDef)) {
4743 // The record types structurally match, or the "from" translation
4744 // unit only had a forward declaration anyway; call it the same
4745 // variable.
4746 return Importer.MapImported(D, FoundDef);
4747 }
4748 }
4749 } else {
4750 // Import the type.
4751 QualType T = Importer.Import(D->getType());
4752 if (T.isNull())
4753 return nullptr;
4754
4755 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4756 if (D->getTypeSourceInfo() && !TInfo)
4757 return nullptr;
4758
4759 TemplateArgumentListInfo ToTAInfo;
4760 if (ImportTemplateArgumentListInfo(D->getTemplateArgsInfo(), ToTAInfo))
4761 return nullptr;
4762
4763 using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
4764 // Create a new specialization.
4765 if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
4766 // Import TemplateArgumentListInfo
4767 TemplateArgumentListInfo ArgInfos;
4768 const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
4769 // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
4770 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos))
4771 return nullptr;
4772
4773 TemplateParameterList *ToTPList = ImportTemplateParameterList(
4774 FromPartial->getTemplateParameters());
4775 if (!ToTPList)
4776 return nullptr;
4777
4778 PartVarSpecDecl *ToPartial;
4779 if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
4780 StartLoc, IdLoc, ToTPList, VarTemplate, T,
4781 TInfo, D->getStorageClass(), TemplateArgs,
4782 ArgInfos))
4783 return ToPartial;
4784
4785 auto *FromInst = FromPartial->getInstantiatedFromMember();
4786 auto *ToInst = cast_or_null<PartVarSpecDecl>(Importer.Import(FromInst));
4787 if (FromInst && !ToInst)
4788 return nullptr;
4789
4790 ToPartial->setInstantiatedFromMember(ToInst);
4791 if (FromPartial->isMemberSpecialization())
4792 ToPartial->setMemberSpecialization();
4793
4794 D2 = ToPartial;
4795 } else { // Full specialization
4796 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, StartLoc,
4797 IdLoc, VarTemplate, T, TInfo,
4798 D->getStorageClass(), TemplateArgs))
4799 return D2;
4800 }
4801
4802 SourceLocation POI = D->getPointOfInstantiation();
4803 if (POI.isValid())
4804 D2->setPointOfInstantiation(Importer.Import(POI));
4805
4806 D2->setSpecializationKind(D->getSpecializationKind());
4807 D2->setTemplateArgsInfo(ToTAInfo);
4808
4809 // Add this specialization to the class template.
4810 VarTemplate->AddSpecialization(D2, InsertPos);
4811
4812 // Import the qualifier, if any.
4813 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4814
4815 if (D->isConstexpr())
4816 D2->setConstexpr(true);
4817
4818 // Add the specialization to this context.
4819 D2->setLexicalDeclContext(LexicalDC);
4820 LexicalDC->addDeclInternal(D2);
4821
4822 D2->setAccess(D->getAccess());
4823 }
4824
4825 // NOTE: isThisDeclarationADefinition() can return DeclarationOnly even if
4826 // declaration has initializer. Should this be fixed in the AST?.. Anyway,
4827 // we have to check the declaration for initializer - otherwise, it won't be
4828 // imported.
4829 if ((D->isThisDeclarationADefinition() || D->hasInit()) &&
4830 ImportDefinition(D, D2))
4831 return nullptr;
4832
4833 return D2;
4834}
4835
4836Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
4837 DeclContext *DC, *LexicalDC;
4838 DeclarationName Name;
4839 SourceLocation Loc;
4840 NamedDecl *ToD;
4841
4842 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4843 return nullptr;
4844
4845 if (ToD)
4846 return ToD;
4847
4848 // Try to find a function in our own ("to") context with the same name, same
4849 // type, and in the same context as the function we're importing.
4850 if (!LexicalDC->isFunctionOrMethod()) {
4851 unsigned IDNS = Decl::IDNS_Ordinary;
4852 SmallVector<NamedDecl *, 2> FoundDecls;
4853 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4854 for (auto *FoundDecl : FoundDecls) {
4855 if (!FoundDecl->isInIdentifierNamespace(IDNS))
4856 continue;
4857
4858 if (auto *FoundFunction = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
4859 if (FoundFunction->hasExternalFormalLinkage() &&
4860 D->hasExternalFormalLinkage()) {
4861 if (IsStructuralMatch(D, FoundFunction)) {
4862 Importer.MapImported(D, FoundFunction);
4863 // FIXME: Actually try to merge the body and other attributes.
4864 return FoundFunction;
4865 }
4866 }
4867 }
4868 }
4869 }
4870
4871 TemplateParameterList *Params =
4872 ImportTemplateParameterList(D->getTemplateParameters());
4873 if (!Params)
4874 return nullptr;
4875
4876 auto *TemplatedFD =
4877 cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
4878 if (!TemplatedFD)
4879 return nullptr;
4880
4881 FunctionTemplateDecl *ToFunc;
4882 if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
4883 Params, TemplatedFD))
4884 return ToFunc;
4885
4886 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
4887 ToFunc->setAccess(D->getAccess());
4888 ToFunc->setLexicalDeclContext(LexicalDC);
4889
4890 LexicalDC->addDeclInternal(ToFunc);
4891 return ToFunc;
4892}
4893
4894//----------------------------------------------------------------------------
4895// Import Statements
4896//----------------------------------------------------------------------------
4897
4898DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
4899 if (DG.isNull())
4900 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4901 size_t NumDecls = DG.end() - DG.begin();
4902 SmallVector<Decl *, 1> ToDecls(NumDecls);
4903 auto &_Importer = this->Importer;
4904 std::transform(DG.begin(), DG.end(), ToDecls.begin(),
4905 [&_Importer](Decl *D) -> Decl * {
4906 return _Importer.Import(D);
4907 });
4908 return DeclGroupRef::Create(Importer.getToContext(),
4909 ToDecls.begin(),
4910 NumDecls);
4911}
4912
4913Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4914 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4915 << S->getStmtClassName();
4916 return nullptr;
4917}
4918
4919Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
4920 SmallVector<IdentifierInfo *, 4> Names;
4921 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4922 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
4923 // ToII is nullptr when no symbolic name is given for output operand
4924 // see ParseStmtAsm::ParseAsmOperandsOpt
4925 if (!ToII && S->getOutputIdentifier(I))
4926 return nullptr;
4927 Names.push_back(ToII);
4928 }
4929 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4930 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
4931 // ToII is nullptr when no symbolic name is given for input operand
4932 // see ParseStmtAsm::ParseAsmOperandsOpt
4933 if (!ToII && S->getInputIdentifier(I))
4934 return nullptr;
4935 Names.push_back(ToII);
4936 }
4937
4938 SmallVector<StringLiteral *, 4> Clobbers;
4939 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
4940 auto *Clobber = cast_or_null<StringLiteral>(
4941 Importer.Import(S->getClobberStringLiteral(I)));
4942 if (!Clobber)
4943 return nullptr;
4944 Clobbers.push_back(Clobber);
4945 }
4946
4947 SmallVector<StringLiteral *, 4> Constraints;
4948 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4949 auto *Output = cast_or_null<StringLiteral>(
4950 Importer.Import(S->getOutputConstraintLiteral(I)));
4951 if (!Output)
4952 return nullptr;
4953 Constraints.push_back(Output);
4954 }
4955
4956 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4957 auto *Input = cast_or_null<StringLiteral>(
4958 Importer.Import(S->getInputConstraintLiteral(I)));
4959 if (!Input)
4960 return nullptr;
4961 Constraints.push_back(Input);
4962 }
4963
4964 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
4965 if (ImportContainerChecked(S->outputs(), Exprs))
4966 return nullptr;
4967
4968 if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
4969 return nullptr;
4970
4971 auto *AsmStr = cast_or_null<StringLiteral>(
4972 Importer.Import(S->getAsmString()));
4973 if (!AsmStr)
4974 return nullptr;
4975
4976 return new (Importer.getToContext()) GCCAsmStmt(
4977 Importer.getToContext(),
4978 Importer.Import(S->getAsmLoc()),
4979 S->isSimple(),
4980 S->isVolatile(),
4981 S->getNumOutputs(),
4982 S->getNumInputs(),
4983 Names.data(),
4984 Constraints.data(),
4985 Exprs.data(),
4986 AsmStr,
4987 S->getNumClobbers(),
4988 Clobbers.data(),
4989 Importer.Import(S->getRParenLoc()));
4990}
4991
4992Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
4993 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
4994 for (auto *ToD : ToDG) {
4995 if (!ToD)
4996 return nullptr;
4997 }
4998 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4999 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5000 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5001}
5002
5003Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
5004 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5005 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5006 S->hasLeadingEmptyMacro());
5007}
5008
5009Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
5010 SmallVector<Stmt *, 8> ToStmts(S->size());
5011
5012 if (ImportContainerChecked(S->body(), ToStmts))
5013 return nullptr;
5014
5015 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5016 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
5017 return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc,
5018 ToRBraceLoc);
5019}
5020
5021Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
5022 Expr *ToLHS = Importer.Import(S->getLHS());
5023 if (!ToLHS)
5024 return nullptr;
5025 Expr *ToRHS = Importer.Import(S->getRHS());
5026 if (!ToRHS && S->getRHS())
5027 return nullptr;
5028 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5029 if (!ToSubStmt && S->getSubStmt())
5030 return nullptr;
5031 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5032 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5033 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5034 auto *ToStmt = new (Importer.getToContext())
5035 CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc);
5036 ToStmt->setSubStmt(ToSubStmt);
5037 return ToStmt;
5038}
5039
5040Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
5041 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5042 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5043 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5044 if (!ToSubStmt && S->getSubStmt())
5045 return nullptr;
5046 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5047 ToSubStmt);
5048}
5049
5050Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
5051 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
5052 auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
5053 if (!ToLabelDecl && S->getDecl())
5054 return nullptr;
5055 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5056 if (!ToSubStmt && S->getSubStmt())
5057 return nullptr;
5058 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5059 ToSubStmt);
5060}
5061
5062Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
5063 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5064 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5065 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
5066 if (ImportContainerChecked(FromAttrs, ToAttrs))
5067 return nullptr;
5068 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5069 if (!ToSubStmt && S->getSubStmt())
5070 return nullptr;
5071 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5072 ToAttrs, ToSubStmt);
5073}
5074
5075Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
5076 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
5077 Stmt *ToInit = Importer.Import(S->getInit());
5078 if (!ToInit && S->getInit())
5079 return nullptr;
5080 VarDecl *ToConditionVariable = nullptr;
5081 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5082 ToConditionVariable =
5083 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5084 if (!ToConditionVariable)
5085 return nullptr;
5086 }
5087 Expr *ToCondition = Importer.Import(S->getCond());
5088 if (!ToCondition && S->getCond())
5089 return nullptr;
5090 Stmt *ToThenStmt = Importer.Import(S->getThen());
5091 if (!ToThenStmt && S->getThen())
5092 return nullptr;
5093 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5094 Stmt *ToElseStmt = Importer.Import(S->getElse());
5095 if (!ToElseStmt && S->getElse())
5096 return nullptr;
5097 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5098 ToIfLoc, S->isConstexpr(),
5099 ToInit,
5100 ToConditionVariable,
5101 ToCondition, ToThenStmt,
5102 ToElseLoc, ToElseStmt);
5103}
5104
5105Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
5106 Stmt *ToInit = Importer.Import(S->getInit());
5107 if (!ToInit && S->getInit())
5108 return nullptr;
5109 VarDecl *ToConditionVariable = nullptr;
5110 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5111 ToConditionVariable =
5112 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5113 if (!ToConditionVariable)
5114 return nullptr;
5115 }
5116 Expr *ToCondition = Importer.Import(S->getCond());
5117 if (!ToCondition && S->getCond())
5118 return nullptr;
5119 auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
5120 Importer.getToContext(), ToInit,
5121 ToConditionVariable, ToCondition);
5122 Stmt *ToBody = Importer.Import(S->getBody());
5123 if (!ToBody && S->getBody())
5124 return nullptr;
5125 ToStmt->setBody(ToBody);
5126 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5127 // Now we have to re-chain the cases.
5128 SwitchCase *LastChainedSwitchCase = nullptr;
5129 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5130 SC = SC->getNextSwitchCase()) {
5131 auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5132 if (!ToSC)
5133 return nullptr;
5134 if (LastChainedSwitchCase)
5135 LastChainedSwitchCase->setNextSwitchCase(ToSC);
5136 else
5137 ToStmt->setSwitchCaseList(ToSC);
5138 LastChainedSwitchCase = ToSC;
5139 }
5140 return ToStmt;
5141}
5142
5143Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5144 VarDecl *ToConditionVariable = nullptr;
5145 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5146 ToConditionVariable =
5147 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5148 if (!ToConditionVariable)
5149 return nullptr;
5150 }
5151 Expr *ToCondition = Importer.Import(S->getCond());
5152 if (!ToCondition && S->getCond())
5153 return nullptr;
5154 Stmt *ToBody = Importer.Import(S->getBody());
5155 if (!ToBody && S->getBody())
5156 return nullptr;
5157 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5158 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5159 ToConditionVariable,
5160 ToCondition, ToBody,
5161 ToWhileLoc);
5162}
5163
5164Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5165 Stmt *ToBody = Importer.Import(S->getBody());
5166 if (!ToBody && S->getBody())
5167 return nullptr;
5168 Expr *ToCondition = Importer.Import(S->getCond());
5169 if (!ToCondition && S->getCond())
5170 return nullptr;
5171 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5172 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5173 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5174 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5175 ToDoLoc, ToWhileLoc,
5176 ToRParenLoc);
5177}
5178
5179Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5180 Stmt *ToInit = Importer.Import(S->getInit());
5181 if (!ToInit && S->getInit())
5182 return nullptr;
5183 Expr *ToCondition = Importer.Import(S->getCond());
5184 if (!ToCondition && S->getCond())
5185 return nullptr;
5186 VarDecl *ToConditionVariable = nullptr;
5187 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5188 ToConditionVariable =
5189 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5190 if (!ToConditionVariable)
5191 return nullptr;
5192 }
5193 Expr *ToInc = Importer.Import(S->getInc());
5194 if (!ToInc && S->getInc())
5195 return nullptr;
5196 Stmt *ToBody = Importer.Import(S->getBody());
5197 if (!ToBody && S->getBody())
5198 return nullptr;
5199 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5200 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5201 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5202 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5203 ToInit, ToCondition,
5204 ToConditionVariable,
5205 ToInc, ToBody,
5206 ToForLoc, ToLParenLoc,
5207 ToRParenLoc);
5208}
5209
5210Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5211 LabelDecl *ToLabel = nullptr;
5212 if (LabelDecl *FromLabel = S->getLabel()) {
5213 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5214 if (!ToLabel)
5215 return nullptr;
5216 }
5217 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5218 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5219 return new (Importer.getToContext()) GotoStmt(ToLabel,
5220 ToGotoLoc, ToLabelLoc);
5221}
5222
5223Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5224 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5225 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5226 Expr *ToTarget = Importer.Import(S->getTarget());
5227 if (!ToTarget && S->getTarget())
5228 return nullptr;
5229 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5230 ToTarget);
5231}
5232
5233Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5234 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5235 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5236}
5237
5238Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5239 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5240 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5241}
5242
5243Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5244 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5245 Expr *ToRetExpr = Importer.Import(S->getRetValue());
5246 if (!ToRetExpr && S->getRetValue())
5247 return nullptr;
5248 auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate());
5249 auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5250 if (!ToNRVOCandidate && NRVOCandidate)
5251 return nullptr;
5252 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5253 ToNRVOCandidate);
5254}
5255
5256Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5257 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5258 VarDecl *ToExceptionDecl = nullptr;
5259 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5260 ToExceptionDecl =
5261 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5262 if (!ToExceptionDecl)
5263 return nullptr;
5264 }
5265 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5266 if (!ToHandlerBlock && S->getHandlerBlock())
5267 return nullptr;
5268 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5269 ToExceptionDecl,
5270 ToHandlerBlock);
5271}
5272
5273Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5274 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5275 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5276 if (!ToTryBlock && S->getTryBlock())
5277 return nullptr;
5278 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5279 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5280 CXXCatchStmt *FromHandler = S->getHandler(HI);
5281 if (Stmt *ToHandler = Importer.Import(FromHandler))
5282 ToHandlers[HI] = ToHandler;
5283 else
5284 return nullptr;
5285 }
5286 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5287 ToHandlers);
5288}
5289
5290Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
5291 auto *ToRange =
5292 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5293 if (!ToRange && S->getRangeStmt())
5294 return nullptr;
5295 auto *ToBegin =
5296 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5297 if (!ToBegin && S->getBeginStmt())
5298 return nullptr;
5299 auto *ToEnd =
5300 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5301 if (!ToEnd && S->getEndStmt())
5302 return nullptr;
5303 Expr *ToCond = Importer.Import(S->getCond());
5304 if (!ToCond && S->getCond())
5305 return nullptr;
5306 Expr *ToInc = Importer.Import(S->getInc());
5307 if (!ToInc && S->getInc())
5308 return nullptr;
5309 auto *ToLoopVar =
5310 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5311 if (!ToLoopVar && S->getLoopVarStmt())
5312 return nullptr;
5313 Stmt *ToBody = Importer.Import(S->getBody());
5314 if (!ToBody && S->getBody())
5315 return nullptr;
5316 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5317 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5318 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5319 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5320 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5321 ToCond, ToInc,
5322 ToLoopVar, ToBody,
5323 ToForLoc, ToCoawaitLoc,
5324 ToColonLoc, ToRParenLoc);
5325}
5326
5327Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5328 Stmt *ToElem = Importer.Import(S->getElement());
5329 if (!ToElem && S->getElement())
5330 return nullptr;
5331 Expr *ToCollect = Importer.Import(S->getCollection());
5332 if (!ToCollect && S->getCollection())
5333 return nullptr;
5334 Stmt *ToBody = Importer.Import(S->getBody());
5335 if (!ToBody && S->getBody())
5336 return nullptr;
5337 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5338 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5339 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5340 ToCollect,
5341 ToBody, ToForLoc,
5342 ToRParenLoc);
5343}
5344
5345Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5346 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5347 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5348 VarDecl *ToExceptionDecl = nullptr;
5349 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5350 ToExceptionDecl =
5351 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5352 if (!ToExceptionDecl)
5353 return nullptr;
5354 }
5355 Stmt *ToBody = Importer.Import(S->getCatchBody());
5356 if (!ToBody && S->getCatchBody())
5357 return nullptr;
5358 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5359 ToRParenLoc,
5360 ToExceptionDecl,
5361 ToBody);
5362}
5363
5364Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5365 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5366 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5367 if (!ToAtFinallyStmt && S->getFinallyBody())
5368 return nullptr;
5369 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5370 ToAtFinallyStmt);
5371}
5372
5373Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5374 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5375 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5376 if (!ToAtTryStmt && S->getTryBody())
5377 return nullptr;
5378 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5379 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5380 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5381 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5382 ToCatchStmts[CI] = ToCatchStmt;
5383 else
5384 return nullptr;
5385 }
5386 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5387 if (!ToAtFinallyStmt && S->getFinallyStmt())
5388 return nullptr;
5389 return ObjCAtTryStmt::Create(Importer.getToContext(),
5390 ToAtTryLoc, ToAtTryStmt,
5391 ToCatchStmts.begin(), ToCatchStmts.size(),
5392 ToAtFinallyStmt);
5393}
5394
5395Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5396 (ObjCAtSynchronizedStmt *S) {
5397 SourceLocation ToAtSynchronizedLoc =
5398 Importer.Import(S->getAtSynchronizedLoc());
5399 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5400 if (!ToSynchExpr && S->getSynchExpr())
5401 return nullptr;
5402 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5403 if (!ToSynchBody && S->getSynchBody())
5404 return nullptr;
5405 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5406 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5407}
5408
5409Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5410 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5411 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5412 if (!ToThrow && S->getThrowExpr())
5413 return nullptr;
5414 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5415}
5416
5417Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5418 (ObjCAutoreleasePoolStmt *S) {
5419 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5420 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5421 if (!ToSubStmt && S->getSubStmt())
5422 return nullptr;
5423 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5424 ToSubStmt);
5425}
5426
5427//----------------------------------------------------------------------------
5428// Import Expressions
5429//----------------------------------------------------------------------------
5430Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5431 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5432 << E->getStmtClassName();
5433 return nullptr;
5434}
5435
5436Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5437 QualType T = Importer.Import(E->getType());
5438 if (T.isNull())
5439 return nullptr;
5440
5441 Expr *SubExpr = Importer.Import(E->getSubExpr());
5442 if (!SubExpr && E->getSubExpr())
5443 return nullptr;
5444
5445 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5446 if (!TInfo)
5447 return nullptr;
5448
5449 return new (Importer.getToContext()) VAArgExpr(
5450 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5451 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5452}
5453
5454Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5455 QualType T = Importer.Import(E->getType());
5456 if (T.isNull())
5457 return nullptr;
5458
5459 return new (Importer.getToContext()) GNUNullExpr(
5460 T, Importer.Import(E->getLocStart()));
5461}
5462
5463Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5464 QualType T = Importer.Import(E->getType());
5465 if (T.isNull())
5466 return nullptr;
5467
5468 auto *SL = cast_or_null<StringLiteral>(Importer.Import(E->getFunctionName()));
5469 if (!SL && E->getFunctionName())
5470 return nullptr;
5471
5472 return new (Importer.getToContext()) PredefinedExpr(
5473 Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5474}
5475
5476Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5477 auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5478 if (!ToD)
5479 return nullptr;
5480
5481 NamedDecl *FoundD = nullptr;
5482 if (E->getDecl() != E->getFoundDecl()) {
5483 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5484 if (!FoundD)
5485 return nullptr;
5486 }
5487
5488 QualType T = Importer.Import(E->getType());
5489 if (T.isNull())
5490 return nullptr;
5491
5492 TemplateArgumentListInfo ToTAInfo;
5493 TemplateArgumentListInfo *ResInfo = nullptr;
5494 if (E->hasExplicitTemplateArgs()) {
5495 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
5496 return nullptr;
5497 ResInfo = &ToTAInfo;
5498 }
5499
5500 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5501 Importer.Import(E->getQualifierLoc()),
5502 Importer.Import(E->getTemplateKeywordLoc()),
5503 ToD,
5504 E->refersToEnclosingVariableOrCapture(),
5505 Importer.Import(E->getLocation()),
5506 T, E->getValueKind(),
5507 FoundD, ResInfo);
5508 if (E->hadMultipleCandidates())
5509 DRE->setHadMultipleCandidates(true);
5510 return DRE;
5511}
5512
5513Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5514 QualType T = Importer.Import(E->getType());
5515 if (T.isNull())
5516 return nullptr;
5517
5518 return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5519}
5520
5521ASTNodeImporter::Designator
5522ASTNodeImporter::ImportDesignator(const Designator &D) {
5523 if (D.isFieldDesignator()) {
5524 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5525 // Caller checks for import error
5526 return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5527 Importer.Import(D.getFieldLoc()));
5528 }
5529 if (D.isArrayDesignator())
5530 return Designator(D.getFirstExprIndex(),
5531 Importer.Import(D.getLBracketLoc()),
5532 Importer.Import(D.getRBracketLoc()));
5533
5534 assert(D.isArrayRangeDesignator())(static_cast <bool> (D.isArrayRangeDesignator()) ? void
(0) : __assert_fail ("D.isArrayRangeDesignator()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 5534, __extension__ __PRETTY_FUNCTION__))
;
5535 return Designator(D.getFirstExprIndex(),
5536 Importer.Import(D.getLBracketLoc()),
5537 Importer.Import(D.getEllipsisLoc()),
5538 Importer.Import(D.getRBracketLoc()));
5539}
5540
5541
5542Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
5543 auto *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5544 if (!Init)
5545 return nullptr;
5546
5547 SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5548 // List elements from the second, the first is Init itself
5549 for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5550 if (auto *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5551 IndexExprs[I - 1] = Arg;
5552 else
5553 return nullptr;
5554 }
5555
5556 SmallVector<Designator, 4> Designators(DIE->size());
5557 llvm::transform(DIE->designators(), Designators.begin(),
5558 [this](const Designator &D) -> Designator {
5559 return ImportDesignator(D);
5560 });
5561
5562 for (const auto &D : DIE->designators())
5563 if (D.isFieldDesignator() && !D.getFieldName())
5564 return nullptr;
5565
5566 return DesignatedInitExpr::Create(
5567 Importer.getToContext(), Designators,
5568 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5569 DIE->usesGNUSyntax(), Init);
5570}
5571
5572Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5573 QualType T = Importer.Import(E->getType());
5574 if (T.isNull())
5575 return nullptr;
5576
5577 return new (Importer.getToContext())
5578 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5579}
5580
5581Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5582 QualType T = Importer.Import(E->getType());
5583 if (T.isNull())
5584 return nullptr;
5585
5586 return IntegerLiteral::Create(Importer.getToContext(),
5587 E->getValue(), T,
5588 Importer.Import(E->getLocation()));
5589}
5590
5591Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5592 QualType T = Importer.Import(E->getType());
5593 if (T.isNull())
5594 return nullptr;
5595
5596 return FloatingLiteral::Create(Importer.getToContext(),
5597 E->getValue(), E->isExact(), T,
5598 Importer.Import(E->getLocation()));
5599}
5600
5601Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5602 QualType T = Importer.Import(E->getType());
5603 if (T.isNull())
5604 return nullptr;
5605
5606 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5607 E->getKind(), T,
5608 Importer.Import(E->getLocation()));
5609}
5610
5611Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5612 QualType T = Importer.Import(E->getType());
5613 if (T.isNull())
5614 return nullptr;
5615
5616 SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5617 ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5618
5619 return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5620 E->getKind(), E->isPascal(), T,
5621 Locations.data(), Locations.size());
5622}
5623
5624Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5625 QualType T = Importer.Import(E->getType());
5626 if (T.isNull())
5627 return nullptr;
5628
5629 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5630 if (!TInfo)
5631 return nullptr;
5632
5633 Expr *Init = Importer.Import(E->getInitializer());
5634 if (!Init)
5635 return nullptr;
5636
5637 return new (Importer.getToContext()) CompoundLiteralExpr(
5638 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5639 Init, E->isFileScope());
5640}
5641
5642Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5643 QualType T = Importer.Import(E->getType());
5644 if (T.isNull())
5645 return nullptr;
5646
5647 SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5648 if (ImportArrayChecked(
5649 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5650 Exprs.begin()))
5651 return nullptr;
5652
5653 return new (Importer.getToContext()) AtomicExpr(
5654 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5655 Importer.Import(E->getRParenLoc()));
5656}
5657
5658Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5659 QualType T = Importer.Import(E->getType());
5660 if (T.isNull())
5661 return nullptr;
5662
5663 auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5664 if (!ToLabel)
5665 return nullptr;
5666
5667 return new (Importer.getToContext()) AddrLabelExpr(
5668 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5669 ToLabel, T);
5670}
5671
5672Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5673 Expr *SubExpr = Importer.Import(E->getSubExpr());
5674 if (!SubExpr)
5675 return nullptr;
5676
5677 return new (Importer.getToContext())
5678 ParenExpr(Importer.Import(E->getLParen()),
5679 Importer.Import(E->getRParen()),
5680 SubExpr);
5681}
5682
5683Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5684 SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5685 if (ImportContainerChecked(E->exprs(), Exprs))
5686 return nullptr;
5687
5688 return new (Importer.getToContext()) ParenListExpr(
5689 Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5690 Exprs, Importer.Import(E->getLParenLoc()));
5691}
5692
5693Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
5694 QualType T = Importer.Import(E->getType());
5695 if (T.isNull())
5696 return nullptr;
5697
5698 auto *ToSubStmt = cast_or_null<CompoundStmt>(
5699 Importer.Import(E->getSubStmt()));
5700 if (!ToSubStmt && E->getSubStmt())
5701 return nullptr;
5702
5703 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5704 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5705}
5706
5707Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
5708 QualType T = Importer.Import(E->getType());
5709 if (T.isNull())
5710 return nullptr;
5711
5712 Expr *SubExpr = Importer.Import(E->getSubExpr());
5713 if (!SubExpr)
5714 return nullptr;
5715
5716 return new (Importer.getToContext()) UnaryOperator(
5717 SubExpr, E->getOpcode(), T, E->getValueKind(), E->getObjectKind(),
5718 Importer.Import(E->getOperatorLoc()), E->canOverflow());
5719}
5720
5721Expr *
5722ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
5723 QualType ResultType = Importer.Import(E->getType());
5724
5725 if (E->isArgumentType()) {
5726 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5727 if (!TInfo)
5728 return nullptr;
5729
5730 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5731 TInfo, ResultType,
5732 Importer.Import(E->getOperatorLoc()),
5733 Importer.Import(E->getRParenLoc()));
5734 }
5735
5736 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5737 if (!SubExpr)
5738 return nullptr;
5739
5740 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5741 SubExpr, ResultType,
5742 Importer.Import(E->getOperatorLoc()),
5743 Importer.Import(E->getRParenLoc()));
5744}
5745
5746Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
5747 QualType T = Importer.Import(E->getType());
5748 if (T.isNull())
5749 return nullptr;
5750
5751 Expr *LHS = Importer.Import(E->getLHS());
5752 if (!LHS)
5753 return nullptr;
5754
5755 Expr *RHS = Importer.Import(E->getRHS());
5756 if (!RHS)
5757 return nullptr;
5758
5759 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5760 T, E->getValueKind(),
5761 E->getObjectKind(),
5762 Importer.Import(E->getOperatorLoc()),
5763 E->getFPFeatures());
5764}
5765
5766Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
5767 QualType T = Importer.Import(E->getType());
5768 if (T.isNull())
5769 return nullptr;
5770
5771 Expr *ToLHS = Importer.Import(E->getLHS());
5772 if (!ToLHS)
5773 return nullptr;
5774
5775 Expr *ToRHS = Importer.Import(E->getRHS());
5776 if (!ToRHS)
5777 return nullptr;
5778
5779 Expr *ToCond = Importer.Import(E->getCond());
5780 if (!ToCond)
5781 return nullptr;
5782
5783 return new (Importer.getToContext()) ConditionalOperator(
5784 ToCond, Importer.Import(E->getQuestionLoc()),
5785 ToLHS, Importer.Import(E->getColonLoc()),
5786 ToRHS, T, E->getValueKind(), E->getObjectKind());
5787}
5788
5789Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
5790 BinaryConditionalOperator *E) {
5791 QualType T = Importer.Import(E->getType());
5792 if (T.isNull())
5793 return nullptr;
5794
5795 Expr *Common = Importer.Import(E->getCommon());
5796 if (!Common)
5797 return nullptr;
5798
5799 Expr *Cond = Importer.Import(E->getCond());
5800 if (!Cond)
5801 return nullptr;
5802
5803 auto *OpaqueValue = cast_or_null<OpaqueValueExpr>(
5804 Importer.Import(E->getOpaqueValue()));
5805 if (!OpaqueValue)
5806 return nullptr;
5807
5808 Expr *TrueExpr = Importer.Import(E->getTrueExpr());
5809 if (!TrueExpr)
5810 return nullptr;
5811
5812 Expr *FalseExpr = Importer.Import(E->getFalseExpr());
5813 if (!FalseExpr)
5814 return nullptr;
5815
5816 return new (Importer.getToContext()) BinaryConditionalOperator(
5817 Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
5818 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
5819 T, E->getValueKind(), E->getObjectKind());
5820}
5821
5822Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
5823 QualType T = Importer.Import(E->getType());
5824 if (T.isNull())
5825 return nullptr;
5826
5827 TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
5828 if (!ToQueried)
5829 return nullptr;
5830
5831 Expr *Dim = Importer.Import(E->getDimensionExpression());
5832 if (!Dim && E->getDimensionExpression())
5833 return nullptr;
5834
5835 return new (Importer.getToContext()) ArrayTypeTraitExpr(
5836 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5837 E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
5838}
5839
5840Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
5841 QualType T = Importer.Import(E->getType());
5842 if (T.isNull())
5843 return nullptr;
5844
5845 Expr *ToQueried = Importer.Import(E->getQueriedExpression());
5846 if (!ToQueried)
5847 return nullptr;
5848
5849 return new (Importer.getToContext()) ExpressionTraitExpr(
5850 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5851 E->getValue(), Importer.Import(E->getLocEnd()), T);
5852}
5853
5854Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
5855 QualType T = Importer.Import(E->getType());
5856 if (T.isNull())
5857 return nullptr;
5858
5859 Expr *SourceExpr = Importer.Import(E->getSourceExpr());
5860 if (!SourceExpr && E->getSourceExpr())
5861 return nullptr;
5862
5863 return new (Importer.getToContext()) OpaqueValueExpr(
5864 Importer.Import(E->getLocation()), T, E->getValueKind(),
5865 E->getObjectKind(), SourceExpr);
5866}
5867
5868Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
5869 QualType T = Importer.Import(E->getType());
5870 if (T.isNull())
5871 return nullptr;
5872
5873 Expr *ToLHS = Importer.Import(E->getLHS());
5874 if (!ToLHS)
5875 return nullptr;
5876
5877 Expr *ToRHS = Importer.Import(E->getRHS());
5878 if (!ToRHS)
5879 return nullptr;
5880
5881 return new (Importer.getToContext()) ArraySubscriptExpr(
5882 ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
5883 Importer.Import(E->getRBracketLoc()));
5884}
5885
5886Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
5887 QualType T = Importer.Import(E->getType());
5888 if (T.isNull())
5889 return nullptr;
5890
5891 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5892 if (CompLHSType.isNull())
5893 return nullptr;
5894
5895 QualType CompResultType = Importer.Import(E->getComputationResultType());
5896 if (CompResultType.isNull())
5897 return nullptr;
5898
5899 Expr *LHS = Importer.Import(E->getLHS());
5900 if (!LHS)
5901 return nullptr;
5902
5903 Expr *RHS = Importer.Import(E->getRHS());
5904 if (!RHS)
5905 return nullptr;
5906
5907 return new (Importer.getToContext())
5908 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
5909 T, E->getValueKind(),
5910 E->getObjectKind(),
5911 CompLHSType, CompResultType,
5912 Importer.Import(E->getOperatorLoc()),
5913 E->getFPFeatures());
5914}
5915
5916bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
5917 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
5918 if (CXXBaseSpecifier *Spec = Importer.Import(*I))
5919 Path.push_back(Spec);
5920 else
5921 return true;
5922 }
5923 return false;
5924}
5925
5926Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
5927 QualType T = Importer.Import(E->getType());
5928 if (T.isNull())
5929 return nullptr;
5930
5931 Expr *SubExpr = Importer.Import(E->getSubExpr());
5932 if (!SubExpr)
5933 return nullptr;
5934
5935 CXXCastPath BasePath;
5936 if (ImportCastPath(E, BasePath))
5937 return nullptr;
5938
5939 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5940 SubExpr, &BasePath, E->getValueKind());
5941}
5942
5943Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
5944 QualType T = Importer.Import(E->getType());
5945 if (T.isNull())
5946 return nullptr;
5947
5948 Expr *SubExpr = Importer.Import(E->getSubExpr());
5949 if (!SubExpr)
5950 return nullptr;
5951
5952 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5953 if (!TInfo && E->getTypeInfoAsWritten())
5954 return nullptr;
5955
5956 CXXCastPath BasePath;
5957 if (ImportCastPath(E, BasePath))
5958 return nullptr;
5959
5960 switch (E->getStmtClass()) {
5961 case Stmt::CStyleCastExprClass: {
5962 auto *CCE = cast<CStyleCastExpr>(E);
5963 return CStyleCastExpr::Create(Importer.getToContext(), T,
5964 E->getValueKind(), E->getCastKind(),
5965 SubExpr, &BasePath, TInfo,
5966 Importer.Import(CCE->getLParenLoc()),
5967 Importer.Import(CCE->getRParenLoc()));
5968 }
5969
5970 case Stmt::CXXFunctionalCastExprClass: {
5971 auto *FCE = cast<CXXFunctionalCastExpr>(E);
5972 return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
5973 E->getValueKind(), TInfo,
5974 E->getCastKind(), SubExpr, &BasePath,
5975 Importer.Import(FCE->getLParenLoc()),
5976 Importer.Import(FCE->getRParenLoc()));
5977 }
5978
5979 case Stmt::ObjCBridgedCastExprClass: {
5980 auto *OCE = cast<ObjCBridgedCastExpr>(E);
5981 return new (Importer.getToContext()) ObjCBridgedCastExpr(
5982 Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
5983 E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
5984 TInfo, SubExpr);
5985 }
5986 default:
5987 break; // just fall through
5988 }
5989
5990 auto *Named = cast<CXXNamedCastExpr>(E);
5991 SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
5992 RParenLoc = Importer.Import(Named->getRParenLoc());
5993 SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
5994
5995 switch (E->getStmtClass()) {
5996 case Stmt::CXXStaticCastExprClass:
5997 return CXXStaticCastExpr::Create(Importer.getToContext(), T,
5998 E->getValueKind(), E->getCastKind(),
5999 SubExpr, &BasePath, TInfo,
6000 ExprLoc, RParenLoc, Brackets);
6001
6002 case Stmt::CXXDynamicCastExprClass:
6003 return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6004 E->getValueKind(), E->getCastKind(),
6005 SubExpr, &BasePath, TInfo,
6006 ExprLoc, RParenLoc, Brackets);
6007
6008 case Stmt::CXXReinterpretCastExprClass:
6009 return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6010 E->getValueKind(), E->getCastKind(),
6011 SubExpr, &BasePath, TInfo,
6012 ExprLoc, RParenLoc, Brackets);
6013
6014 case Stmt::CXXConstCastExprClass:
6015 return CXXConstCastExpr::Create(Importer.getToContext(), T,
6016 E->getValueKind(), SubExpr, TInfo, ExprLoc,
6017 RParenLoc, Brackets);
6018 default:
6019 llvm_unreachable("Cast expression of unsupported type!")::llvm::llvm_unreachable_internal("Cast expression of unsupported type!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 6019)
;
6020 return nullptr;
6021 }
6022}
6023
6024Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
6025 QualType T = Importer.Import(OE->getType());
6026 if (T.isNull())
6027 return nullptr;
6028
6029 SmallVector<OffsetOfNode, 4> Nodes;
6030 for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6031 const OffsetOfNode &Node = OE->getComponent(I);
6032
6033 switch (Node.getKind()) {
6034 case OffsetOfNode::Array:
6035 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
6036 Node.getArrayExprIndex(),
6037 Importer.Import(Node.getLocEnd())));
6038 break;
6039
6040 case OffsetOfNode::Base: {
6041 CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6042 if (!BS && Node.getBase())
6043 return nullptr;
6044 Nodes.push_back(OffsetOfNode(BS));
6045 break;
6046 }
6047 case OffsetOfNode::Field: {
6048 auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
6049 if (!FD)
6050 return nullptr;
6051 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
6052 Importer.Import(Node.getLocEnd())));
6053 break;
6054 }
6055 case OffsetOfNode::Identifier: {
6056 IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6057 if (!ToII)
6058 return nullptr;
6059 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
6060 Importer.Import(Node.getLocEnd())));
6061 break;
6062 }
6063 }
6064 }
6065
6066 SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
6067 for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6068 Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6069 if (!ToIndexExpr)
6070 return nullptr;
6071 Exprs[I] = ToIndexExpr;
6072 }
6073
6074 TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6075 if (!TInfo && OE->getTypeSourceInfo())
6076 return nullptr;
6077
6078 return OffsetOfExpr::Create(Importer.getToContext(), T,
6079 Importer.Import(OE->getOperatorLoc()),
6080 TInfo, Nodes, Exprs,
6081 Importer.Import(OE->getRParenLoc()));
6082}
6083
6084Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
6085 QualType T = Importer.Import(E->getType());
6086 if (T.isNull())
6087 return nullptr;
6088
6089 Expr *Operand = Importer.Import(E->getOperand());
6090 if (!Operand)
6091 return nullptr;
6092
6093 CanThrowResult CanThrow;
6094 if (E->isValueDependent())
6095 CanThrow = CT_Dependent;
6096 else
6097 CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6098
6099 return new (Importer.getToContext()) CXXNoexceptExpr(
6100 T, Operand, CanThrow,
6101 Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6102}
6103
6104Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
6105 QualType T = Importer.Import(E->getType());
6106 if (T.isNull())
6107 return nullptr;
6108
6109 Expr *SubExpr = Importer.Import(E->getSubExpr());
6110 if (!SubExpr && E->getSubExpr())
6111 return nullptr;
6112
6113 return new (Importer.getToContext()) CXXThrowExpr(
6114 SubExpr, T, Importer.Import(E->getThrowLoc()),
6115 E->isThrownVariableInScope());
6116}
6117
6118Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
6119 auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
6120 if (!Param)
6121 return nullptr;
6122
6123 return CXXDefaultArgExpr::Create(
6124 Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6125}
6126
6127Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
6128 QualType T = Importer.Import(E->getType());
6129 if (T.isNull())
6130 return nullptr;
6131
6132 TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6133 if (!TypeInfo)
6134 return nullptr;
6135
6136 return new (Importer.getToContext()) CXXScalarValueInitExpr(
6137 T, TypeInfo, Importer.Import(E->getRParenLoc()));
6138}
6139
6140Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
6141 Expr *SubExpr = Importer.Import(E->getSubExpr());
6142 if (!SubExpr)
6143 return nullptr;
6144
6145 auto *Dtor = cast_or_null<CXXDestructorDecl>(
6146 Importer.Import(const_cast<CXXDestructorDecl *>(
6147 E->getTemporary()->getDestructor())));
6148 if (!Dtor)
6149 return nullptr;
6150
6151 ASTContext &ToCtx = Importer.getToContext();
6152 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6153 return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6154}
6155
6156Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
6157 QualType T = Importer.Import(CE->getType());
6158 if (T.isNull())
6159 return nullptr;
6160
6161 TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo());
6162 if (!TInfo)
6163 return nullptr;
6164
6165 SmallVector<Expr *, 8> Args(CE->getNumArgs());
6166 if (ImportContainerChecked(CE->arguments(), Args))
6167 return nullptr;
6168
6169 auto *Ctor = cast_or_null<CXXConstructorDecl>(
6170 Importer.Import(CE->getConstructor()));
6171 if (!Ctor)
6172 return nullptr;
6173
6174 return new (Importer.getToContext()) CXXTemporaryObjectExpr(
6175 Importer.getToContext(), Ctor, T, TInfo, Args,
6176 Importer.Import(CE->getParenOrBraceRange()), CE->hadMultipleCandidates(),
6177 CE->isListInitialization(), CE->isStdInitListInitialization(),
6178 CE->requiresZeroInitialization());
6179}
6180
6181Expr *
6182ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
6183 QualType T = Importer.Import(E->getType());
6184 if (T.isNull())
6185 return nullptr;
6186
6187 Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6188 if (!TempE)
6189 return nullptr;
6190
6191 auto *ExtendedBy = cast_or_null<ValueDecl>(
6192 Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6193 if (!ExtendedBy && E->getExtendingDecl())
6194 return nullptr;
6195
6196 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
6197 T, TempE, E->isBoundToLvalueReference());
6198
6199 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6200 ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6201 return ToMTE;
6202}
6203
6204Expr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
6205 QualType T = Importer.Import(E->getType());
6206 if (T.isNull())
6207 return nullptr;
6208
6209 Expr *Pattern = Importer.Import(E->getPattern());
6210 if (!Pattern)
6211 return nullptr;
6212
6213 return new (Importer.getToContext()) PackExpansionExpr(
6214 T, Pattern, Importer.Import(E->getEllipsisLoc()),
6215 E->getNumExpansions());
6216}
6217
6218Expr *ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
6219 auto *Pack = cast_or_null<NamedDecl>(Importer.Import(E->getPack()));
6220 if (!Pack)
6221 return nullptr;
6222
6223 Optional<unsigned> Length;
6224
6225 if (!E->isValueDependent())
6226 Length = E->getPackLength();
6227
6228 SmallVector<TemplateArgument, 8> PartialArguments;
6229 if (E->isPartiallySubstituted()) {
6230 if (ImportTemplateArguments(E->getPartialArguments().data(),
6231 E->getPartialArguments().size(),
6232 PartialArguments))
6233 return nullptr;
6234 }
6235
6236 return SizeOfPackExpr::Create(
6237 Importer.getToContext(), Importer.Import(E->getOperatorLoc()), Pack,
6238 Importer.Import(E->getPackLoc()), Importer.Import(E->getRParenLoc()),
6239 Length, PartialArguments);
6240}
6241
6242Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
6243 QualType T = Importer.Import(CE->getType());
6244 if (T.isNull())
6245 return nullptr;
6246
6247 SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6248 if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6249 return nullptr;
6250
6251 auto *OperatorNewDecl = cast_or_null<FunctionDecl>(
6252 Importer.Import(CE->getOperatorNew()));
6253 if (!OperatorNewDecl && CE->getOperatorNew())
6254 return nullptr;
6255
6256 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6257 Importer.Import(CE->getOperatorDelete()));
6258 if (!OperatorDeleteDecl && CE->getOperatorDelete())
6259 return nullptr;
6260
6261 Expr *ToInit = Importer.Import(CE->getInitializer());
6262 if (!ToInit && CE->getInitializer())
6263 return nullptr;
6264
6265 TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6266 if (!TInfo)
6267 return nullptr;
6268
6269 Expr *ToArrSize = Importer.Import(CE->getArraySize());
6270 if (!ToArrSize && CE->getArraySize())
6271 return nullptr;
6272
6273 return new (Importer.getToContext()) CXXNewExpr(
6274 Importer.getToContext(),
6275 CE->isGlobalNew(),
6276 OperatorNewDecl, OperatorDeleteDecl,
6277 CE->passAlignment(),
6278 CE->doesUsualArrayDeleteWantSize(),
6279 PlacementArgs,
6280 Importer.Import(CE->getTypeIdParens()),
6281 ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6282 Importer.Import(CE->getSourceRange()),
6283 Importer.Import(CE->getDirectInitRange()));
6284}
6285
6286Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
6287 QualType T = Importer.Import(E->getType());
6288 if (T.isNull())
6289 return nullptr;
6290
6291 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6292 Importer.Import(E->getOperatorDelete()));
6293 if (!OperatorDeleteDecl && E->getOperatorDelete())
6294 return nullptr;
6295
6296 Expr *ToArg = Importer.Import(E->getArgument());
6297 if (!ToArg && E->getArgument())
6298 return nullptr;
6299
6300 return new (Importer.getToContext()) CXXDeleteExpr(
6301 T, E->isGlobalDelete(),
6302 E->isArrayForm(),
6303 E->isArrayFormAsWritten(),
6304 E->doesUsualArrayDeleteWantSize(),
6305 OperatorDeleteDecl,
6306 ToArg,
6307 Importer.Import(E->getLocStart()));
6308}
6309
6310Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
6311 QualType T = Importer.Import(E->getType());
6312 if (T.isNull())
6313 return nullptr;
6314
6315 auto *ToCCD =
6316 dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
6317 if (!ToCCD)
6318 return nullptr;
6319
6320 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
6321 if (ImportContainerChecked(E->arguments(), ToArgs))
6322 return nullptr;
6323
6324 return CXXConstructExpr::Create(Importer.getToContext(), T,
6325 Importer.Import(E->getLocation()),
6326 ToCCD, E->isElidable(),
6327 ToArgs, E->hadMultipleCandidates(),
6328 E->isListInitialization(),
6329 E->isStdInitListInitialization(),
6330 E->requiresZeroInitialization(),
6331 E->getConstructionKind(),
6332 Importer.Import(E->getParenOrBraceRange()));
6333}
6334
6335Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
6336 Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6337 if (!SubExpr && EWC->getSubExpr())
6338 return nullptr;
6339
6340 SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
6341 for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6342 if (ExprWithCleanups::CleanupObject Obj =
6343 cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6344 Objs[I] = Obj;
6345 else
6346 return nullptr;
6347
6348 return ExprWithCleanups::Create(Importer.getToContext(),
6349 SubExpr, EWC->cleanupsHaveSideEffects(),
6350 Objs);
6351}
6352
6353Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
6354 QualType T = Importer.Import(E->getType());
6355 if (T.isNull())
6356 return nullptr;
6357
6358 Expr *ToFn = Importer.Import(E->getCallee());
6359 if (!ToFn)
6360 return nullptr;
6361
6362 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
6363 if (ImportContainerChecked(E->arguments(), ToArgs))
6364 return nullptr;
6365
6366 return new (Importer.getToContext()) CXXMemberCallExpr(
6367 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6368 Importer.Import(E->getRParenLoc()));
6369}
6370
6371Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
6372 QualType T = Importer.Import(E->getType());
6373 if (T.isNull())
6374 return nullptr;
6375
6376 return new (Importer.getToContext())
6377 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6378}
6379
6380Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
6381 QualType T = Importer.Import(E->getType());
6382 if (T.isNull())
6383 return nullptr;
6384
6385 return new (Importer.getToContext())
6386 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6387}
6388
6389
6390Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
6391 QualType T = Importer.Import(E->getType());
6392 if (T.isNull())
6393 return nullptr;
6394
6395 Expr *ToBase = Importer.Import(E->getBase());
6396