File: | tools/clang/lib/AST/DeclBase.cpp |
Warning: | line 962, column 10 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- DeclBase.cpp - Declaration AST Node Implementation -----------------===// | ||||
2 | // | ||||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||||
4 | // See https://llvm.org/LICENSE.txt for license information. | ||||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||||
6 | // | ||||
7 | //===----------------------------------------------------------------------===// | ||||
8 | // | ||||
9 | // This file implements the Decl and DeclContext classes. | ||||
10 | // | ||||
11 | //===----------------------------------------------------------------------===// | ||||
12 | |||||
13 | #include "clang/AST/DeclBase.h" | ||||
14 | #include "clang/AST/ASTContext.h" | ||||
15 | #include "clang/AST/ASTLambda.h" | ||||
16 | #include "clang/AST/ASTMutationListener.h" | ||||
17 | #include "clang/AST/Attr.h" | ||||
18 | #include "clang/AST/AttrIterator.h" | ||||
19 | #include "clang/AST/Decl.h" | ||||
20 | #include "clang/AST/DeclCXX.h" | ||||
21 | #include "clang/AST/DeclContextInternals.h" | ||||
22 | #include "clang/AST/DeclFriend.h" | ||||
23 | #include "clang/AST/DeclObjC.h" | ||||
24 | #include "clang/AST/DeclOpenMP.h" | ||||
25 | #include "clang/AST/DeclTemplate.h" | ||||
26 | #include "clang/AST/DependentDiagnostic.h" | ||||
27 | #include "clang/AST/ExternalASTSource.h" | ||||
28 | #include "clang/AST/Stmt.h" | ||||
29 | #include "clang/AST/Type.h" | ||||
30 | #include "clang/Basic/IdentifierTable.h" | ||||
31 | #include "clang/Basic/LLVM.h" | ||||
32 | #include "clang/Basic/LangOptions.h" | ||||
33 | #include "clang/Basic/ObjCRuntime.h" | ||||
34 | #include "clang/Basic/PartialDiagnostic.h" | ||||
35 | #include "clang/Basic/SourceLocation.h" | ||||
36 | #include "clang/Basic/TargetInfo.h" | ||||
37 | #include "llvm/ADT/ArrayRef.h" | ||||
38 | #include "llvm/ADT/PointerIntPair.h" | ||||
39 | #include "llvm/ADT/SmallVector.h" | ||||
40 | #include "llvm/ADT/StringRef.h" | ||||
41 | #include "llvm/Support/Casting.h" | ||||
42 | #include "llvm/Support/ErrorHandling.h" | ||||
43 | #include "llvm/Support/MathExtras.h" | ||||
44 | #include "llvm/Support/VersionTuple.h" | ||||
45 | #include "llvm/Support/raw_ostream.h" | ||||
46 | #include <algorithm> | ||||
47 | #include <cassert> | ||||
48 | #include <cstddef> | ||||
49 | #include <string> | ||||
50 | #include <tuple> | ||||
51 | #include <utility> | ||||
52 | |||||
53 | using namespace clang; | ||||
54 | |||||
55 | //===----------------------------------------------------------------------===// | ||||
56 | // Statistics | ||||
57 | //===----------------------------------------------------------------------===// | ||||
58 | |||||
59 | #define DECL(DERIVED, BASE) static int n##DERIVED##s = 0; | ||||
60 | #define ABSTRACT_DECL(DECL) | ||||
61 | #include "clang/AST/DeclNodes.inc" | ||||
62 | |||||
63 | void Decl::updateOutOfDate(IdentifierInfo &II) const { | ||||
64 | getASTContext().getExternalSource()->updateOutOfDateIdentifier(II); | ||||
65 | } | ||||
66 | |||||
67 | #define DECL(DERIVED, BASE) \ | ||||
68 | static_assert(alignof(Decl) >= alignof(DERIVED##Decl), \ | ||||
69 | "Alignment sufficient after objects prepended to " #DERIVED); | ||||
70 | #define ABSTRACT_DECL(DECL) | ||||
71 | #include "clang/AST/DeclNodes.inc" | ||||
72 | |||||
73 | void *Decl::operator new(std::size_t Size, const ASTContext &Context, | ||||
74 | unsigned ID, std::size_t Extra) { | ||||
75 | // Allocate an extra 8 bytes worth of storage, which ensures that the | ||||
76 | // resulting pointer will still be 8-byte aligned. | ||||
77 | static_assert(sizeof(unsigned) * 2 >= alignof(Decl), | ||||
78 | "Decl won't be misaligned"); | ||||
79 | void *Start = Context.Allocate(Size + Extra + 8); | ||||
80 | void *Result = (char*)Start + 8; | ||||
81 | |||||
82 | unsigned *PrefixPtr = (unsigned *)Result - 2; | ||||
83 | |||||
84 | // Zero out the first 4 bytes; this is used to store the owning module ID. | ||||
85 | PrefixPtr[0] = 0; | ||||
86 | |||||
87 | // Store the global declaration ID in the second 4 bytes. | ||||
88 | PrefixPtr[1] = ID; | ||||
89 | |||||
90 | return Result; | ||||
91 | } | ||||
92 | |||||
93 | void *Decl::operator new(std::size_t Size, const ASTContext &Ctx, | ||||
94 | DeclContext *Parent, std::size_t Extra) { | ||||
95 | assert(!Parent || &Parent->getParentASTContext() == &Ctx)((!Parent || &Parent->getParentASTContext() == &Ctx ) ? static_cast<void> (0) : __assert_fail ("!Parent || &Parent->getParentASTContext() == &Ctx" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 95, __PRETTY_FUNCTION__)); | ||||
96 | // With local visibility enabled, we track the owning module even for local | ||||
97 | // declarations. We create the TU decl early and may not yet know what the | ||||
98 | // LangOpts are, so conservatively allocate the storage. | ||||
99 | if (Ctx.getLangOpts().trackLocalOwningModule() || !Parent) { | ||||
100 | // Ensure required alignment of the resulting object by adding extra | ||||
101 | // padding at the start if required. | ||||
102 | size_t ExtraAlign = | ||||
103 | llvm::offsetToAlignment(sizeof(Module *), llvm::Align(alignof(Decl))); | ||||
104 | auto *Buffer = reinterpret_cast<char *>( | ||||
105 | ::operator new(ExtraAlign + sizeof(Module *) + Size + Extra, Ctx)); | ||||
106 | Buffer += ExtraAlign; | ||||
107 | auto *ParentModule = | ||||
108 | Parent ? cast<Decl>(Parent)->getOwningModule() : nullptr; | ||||
109 | return new (Buffer) Module*(ParentModule) + 1; | ||||
110 | } | ||||
111 | return ::operator new(Size + Extra, Ctx); | ||||
112 | } | ||||
113 | |||||
114 | Module *Decl::getOwningModuleSlow() const { | ||||
115 | assert(isFromASTFile() && "Not from AST file?")((isFromASTFile() && "Not from AST file?") ? static_cast <void> (0) : __assert_fail ("isFromASTFile() && \"Not from AST file?\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 115, __PRETTY_FUNCTION__)); | ||||
116 | return getASTContext().getExternalSource()->getModule(getOwningModuleID()); | ||||
117 | } | ||||
118 | |||||
119 | bool Decl::hasLocalOwningModuleStorage() const { | ||||
120 | return getASTContext().getLangOpts().trackLocalOwningModule(); | ||||
121 | } | ||||
122 | |||||
123 | const char *Decl::getDeclKindName() const { | ||||
124 | switch (DeclKind) { | ||||
125 | default: llvm_unreachable("Declaration not in DeclNodes.inc!")::llvm::llvm_unreachable_internal("Declaration not in DeclNodes.inc!" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 125); | ||||
126 | #define DECL(DERIVED, BASE) case DERIVED: return #DERIVED; | ||||
127 | #define ABSTRACT_DECL(DECL) | ||||
128 | #include "clang/AST/DeclNodes.inc" | ||||
129 | } | ||||
130 | } | ||||
131 | |||||
132 | void Decl::setInvalidDecl(bool Invalid) { | ||||
133 | InvalidDecl = Invalid; | ||||
134 | assert(!isa<TagDecl>(this) || !cast<TagDecl>(this)->isCompleteDefinition())((!isa<TagDecl>(this) || !cast<TagDecl>(this)-> isCompleteDefinition()) ? static_cast<void> (0) : __assert_fail ("!isa<TagDecl>(this) || !cast<TagDecl>(this)->isCompleteDefinition()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 134, __PRETTY_FUNCTION__)); | ||||
135 | if (!Invalid) { | ||||
136 | return; | ||||
137 | } | ||||
138 | |||||
139 | if (!isa<ParmVarDecl>(this)) { | ||||
140 | // Defensive maneuver for ill-formed code: we're likely not to make it to | ||||
141 | // a point where we set the access specifier, so default it to "public" | ||||
142 | // to avoid triggering asserts elsewhere in the front end. | ||||
143 | setAccess(AS_public); | ||||
144 | } | ||||
145 | |||||
146 | // Marking a DecompositionDecl as invalid implies all the child BindingDecl's | ||||
147 | // are invalid too. | ||||
148 | if (auto *DD = dyn_cast<DecompositionDecl>(this)) { | ||||
149 | for (auto *Binding : DD->bindings()) { | ||||
150 | Binding->setInvalidDecl(); | ||||
151 | } | ||||
152 | } | ||||
153 | } | ||||
154 | |||||
155 | const char *DeclContext::getDeclKindName() const { | ||||
156 | switch (getDeclKind()) { | ||||
157 | #define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED; | ||||
158 | #define ABSTRACT_DECL(DECL) | ||||
159 | #include "clang/AST/DeclNodes.inc" | ||||
160 | } | ||||
161 | llvm_unreachable("Declaration context not in DeclNodes.inc!")::llvm::llvm_unreachable_internal("Declaration context not in DeclNodes.inc!" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 161); | ||||
162 | } | ||||
163 | |||||
164 | bool Decl::StatisticsEnabled = false; | ||||
165 | void Decl::EnableStatistics() { | ||||
166 | StatisticsEnabled = true; | ||||
167 | } | ||||
168 | |||||
169 | void Decl::PrintStats() { | ||||
170 | llvm::errs() << "\n*** Decl Stats:\n"; | ||||
171 | |||||
172 | int totalDecls = 0; | ||||
173 | #define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s; | ||||
174 | #define ABSTRACT_DECL(DECL) | ||||
175 | #include "clang/AST/DeclNodes.inc" | ||||
176 | llvm::errs() << " " << totalDecls << " decls total.\n"; | ||||
177 | |||||
178 | int totalBytes = 0; | ||||
179 | #define DECL(DERIVED, BASE) \ | ||||
180 | if (n##DERIVED##s > 0) { \ | ||||
181 | totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \ | ||||
182 | llvm::errs() << " " << n##DERIVED##s << " " #DERIVED " decls, " \ | ||||
183 | << sizeof(DERIVED##Decl) << " each (" \ | ||||
184 | << n##DERIVED##s * sizeof(DERIVED##Decl) \ | ||||
185 | << " bytes)\n"; \ | ||||
186 | } | ||||
187 | #define ABSTRACT_DECL(DECL) | ||||
188 | #include "clang/AST/DeclNodes.inc" | ||||
189 | |||||
190 | llvm::errs() << "Total bytes = " << totalBytes << "\n"; | ||||
191 | } | ||||
192 | |||||
193 | void Decl::add(Kind k) { | ||||
194 | switch (k) { | ||||
195 | #define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break; | ||||
196 | #define ABSTRACT_DECL(DECL) | ||||
197 | #include "clang/AST/DeclNodes.inc" | ||||
198 | } | ||||
199 | } | ||||
200 | |||||
201 | bool Decl::isTemplateParameterPack() const { | ||||
202 | if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(this)) | ||||
203 | return TTP->isParameterPack(); | ||||
204 | if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(this)) | ||||
205 | return NTTP->isParameterPack(); | ||||
206 | if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(this)) | ||||
207 | return TTP->isParameterPack(); | ||||
208 | return false; | ||||
209 | } | ||||
210 | |||||
211 | bool Decl::isParameterPack() const { | ||||
212 | if (const auto *Var = dyn_cast<VarDecl>(this)) | ||||
213 | return Var->isParameterPack(); | ||||
214 | |||||
215 | return isTemplateParameterPack(); | ||||
216 | } | ||||
217 | |||||
218 | FunctionDecl *Decl::getAsFunction() { | ||||
219 | if (auto *FD = dyn_cast<FunctionDecl>(this)) | ||||
220 | return FD; | ||||
221 | if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(this)) | ||||
222 | return FTD->getTemplatedDecl(); | ||||
223 | return nullptr; | ||||
224 | } | ||||
225 | |||||
226 | bool Decl::isTemplateDecl() const { | ||||
227 | return isa<TemplateDecl>(this); | ||||
228 | } | ||||
229 | |||||
230 | TemplateDecl *Decl::getDescribedTemplate() const { | ||||
231 | if (auto *FD = dyn_cast<FunctionDecl>(this)) | ||||
232 | return FD->getDescribedFunctionTemplate(); | ||||
233 | else if (auto *RD = dyn_cast<CXXRecordDecl>(this)) | ||||
234 | return RD->getDescribedClassTemplate(); | ||||
235 | else if (auto *VD = dyn_cast<VarDecl>(this)) | ||||
236 | return VD->getDescribedVarTemplate(); | ||||
237 | else if (auto *AD = dyn_cast<TypeAliasDecl>(this)) | ||||
238 | return AD->getDescribedAliasTemplate(); | ||||
239 | |||||
240 | return nullptr; | ||||
241 | } | ||||
242 | |||||
243 | bool Decl::isTemplated() const { | ||||
244 | // A declaration is dependent if it is a template or a template pattern, or | ||||
245 | // is within (lexcially for a friend, semantically otherwise) a dependent | ||||
246 | // context. | ||||
247 | // FIXME: Should local extern declarations be treated like friends? | ||||
248 | if (auto *AsDC = dyn_cast<DeclContext>(this)) | ||||
249 | return AsDC->isDependentContext(); | ||||
250 | auto *DC = getFriendObjectKind() ? getLexicalDeclContext() : getDeclContext(); | ||||
251 | return DC->isDependentContext() || isTemplateDecl() || getDescribedTemplate(); | ||||
252 | } | ||||
253 | |||||
254 | const DeclContext *Decl::getParentFunctionOrMethod() const { | ||||
255 | for (const DeclContext *DC = getDeclContext(); | ||||
256 | DC && !DC->isTranslationUnit() && !DC->isNamespace(); | ||||
257 | DC = DC->getParent()) | ||||
258 | if (DC->isFunctionOrMethod()) | ||||
259 | return DC; | ||||
260 | |||||
261 | return nullptr; | ||||
262 | } | ||||
263 | |||||
264 | //===----------------------------------------------------------------------===// | ||||
265 | // PrettyStackTraceDecl Implementation | ||||
266 | //===----------------------------------------------------------------------===// | ||||
267 | |||||
268 | void PrettyStackTraceDecl::print(raw_ostream &OS) const { | ||||
269 | SourceLocation TheLoc = Loc; | ||||
270 | if (TheLoc.isInvalid() && TheDecl) | ||||
271 | TheLoc = TheDecl->getLocation(); | ||||
272 | |||||
273 | if (TheLoc.isValid()) { | ||||
274 | TheLoc.print(OS, SM); | ||||
275 | OS << ": "; | ||||
276 | } | ||||
277 | |||||
278 | OS << Message; | ||||
279 | |||||
280 | if (const auto *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) { | ||||
281 | OS << " '"; | ||||
282 | DN->printQualifiedName(OS); | ||||
283 | OS << '\''; | ||||
284 | } | ||||
285 | OS << '\n'; | ||||
286 | } | ||||
287 | |||||
288 | //===----------------------------------------------------------------------===// | ||||
289 | // Decl Implementation | ||||
290 | //===----------------------------------------------------------------------===// | ||||
291 | |||||
292 | // Out-of-line virtual method providing a home for Decl. | ||||
293 | Decl::~Decl() = default; | ||||
294 | |||||
295 | void Decl::setDeclContext(DeclContext *DC) { | ||||
296 | DeclCtx = DC; | ||||
297 | } | ||||
298 | |||||
299 | void Decl::setLexicalDeclContext(DeclContext *DC) { | ||||
300 | if (DC == getLexicalDeclContext()) | ||||
301 | return; | ||||
302 | |||||
303 | if (isInSemaDC()) { | ||||
304 | setDeclContextsImpl(getDeclContext(), DC, getASTContext()); | ||||
305 | } else { | ||||
306 | getMultipleDC()->LexicalDC = DC; | ||||
307 | } | ||||
308 | |||||
309 | // FIXME: We shouldn't be changing the lexical context of declarations | ||||
310 | // imported from AST files. | ||||
311 | if (!isFromASTFile()) { | ||||
312 | setModuleOwnershipKind(getModuleOwnershipKindForChildOf(DC)); | ||||
313 | if (hasOwningModule()) | ||||
314 | setLocalOwningModule(cast<Decl>(DC)->getOwningModule()); | ||||
315 | } | ||||
316 | |||||
317 | assert((((getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && "hidden declaration has no owning module" ) ? static_cast<void> (0) : __assert_fail ("(getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && \"hidden declaration has no owning module\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 320, __PRETTY_FUNCTION__)) | ||||
318 | (getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported ||(((getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && "hidden declaration has no owning module" ) ? static_cast<void> (0) : __assert_fail ("(getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && \"hidden declaration has no owning module\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 320, __PRETTY_FUNCTION__)) | ||||
319 | getOwningModule()) &&(((getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && "hidden declaration has no owning module" ) ? static_cast<void> (0) : __assert_fail ("(getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && \"hidden declaration has no owning module\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 320, __PRETTY_FUNCTION__)) | ||||
320 | "hidden declaration has no owning module")(((getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && "hidden declaration has no owning module" ) ? static_cast<void> (0) : __assert_fail ("(getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported || getOwningModule()) && \"hidden declaration has no owning module\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 320, __PRETTY_FUNCTION__)); | ||||
321 | } | ||||
322 | |||||
323 | void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC, | ||||
324 | ASTContext &Ctx) { | ||||
325 | if (SemaDC == LexicalDC) { | ||||
326 | DeclCtx = SemaDC; | ||||
327 | } else { | ||||
328 | auto *MDC = new (Ctx) Decl::MultipleDC(); | ||||
329 | MDC->SemanticDC = SemaDC; | ||||
330 | MDC->LexicalDC = LexicalDC; | ||||
331 | DeclCtx = MDC; | ||||
332 | } | ||||
333 | } | ||||
334 | |||||
335 | bool Decl::isLexicallyWithinFunctionOrMethod() const { | ||||
336 | const DeclContext *LDC = getLexicalDeclContext(); | ||||
337 | while (true) { | ||||
338 | if (LDC->isFunctionOrMethod()) | ||||
339 | return true; | ||||
340 | if (!isa<TagDecl>(LDC)) | ||||
341 | return false; | ||||
342 | LDC = LDC->getLexicalParent(); | ||||
343 | } | ||||
344 | return false; | ||||
345 | } | ||||
346 | |||||
347 | bool Decl::isInAnonymousNamespace() const { | ||||
348 | for (const DeclContext *DC = getDeclContext(); DC; DC = DC->getParent()) { | ||||
349 | if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) | ||||
350 | if (ND->isAnonymousNamespace()) | ||||
351 | return true; | ||||
352 | } | ||||
353 | |||||
354 | return false; | ||||
355 | } | ||||
356 | |||||
357 | bool Decl::isInStdNamespace() const { | ||||
358 | const DeclContext *DC = getDeclContext(); | ||||
359 | return DC && DC->isStdNamespace(); | ||||
360 | } | ||||
361 | |||||
362 | TranslationUnitDecl *Decl::getTranslationUnitDecl() { | ||||
363 | if (auto *TUD = dyn_cast<TranslationUnitDecl>(this)) | ||||
364 | return TUD; | ||||
365 | |||||
366 | DeclContext *DC = getDeclContext(); | ||||
367 | assert(DC && "This decl is not contained in a translation unit!")((DC && "This decl is not contained in a translation unit!" ) ? static_cast<void> (0) : __assert_fail ("DC && \"This decl is not contained in a translation unit!\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 367, __PRETTY_FUNCTION__)); | ||||
368 | |||||
369 | while (!DC->isTranslationUnit()) { | ||||
370 | DC = DC->getParent(); | ||||
371 | assert(DC && "This decl is not contained in a translation unit!")((DC && "This decl is not contained in a translation unit!" ) ? static_cast<void> (0) : __assert_fail ("DC && \"This decl is not contained in a translation unit!\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 371, __PRETTY_FUNCTION__)); | ||||
372 | } | ||||
373 | |||||
374 | return cast<TranslationUnitDecl>(DC); | ||||
375 | } | ||||
376 | |||||
377 | ASTContext &Decl::getASTContext() const { | ||||
378 | return getTranslationUnitDecl()->getASTContext(); | ||||
379 | } | ||||
380 | |||||
381 | ASTMutationListener *Decl::getASTMutationListener() const { | ||||
382 | return getASTContext().getASTMutationListener(); | ||||
383 | } | ||||
384 | |||||
385 | unsigned Decl::getMaxAlignment() const { | ||||
386 | if (!hasAttrs()) | ||||
387 | return 0; | ||||
388 | |||||
389 | unsigned Align = 0; | ||||
390 | const AttrVec &V = getAttrs(); | ||||
391 | ASTContext &Ctx = getASTContext(); | ||||
392 | specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end()); | ||||
393 | for (; I != E; ++I) | ||||
394 | Align = std::max(Align, I->getAlignment(Ctx)); | ||||
395 | return Align; | ||||
396 | } | ||||
397 | |||||
398 | bool Decl::isUsed(bool CheckUsedAttr) const { | ||||
399 | const Decl *CanonD = getCanonicalDecl(); | ||||
400 | if (CanonD->Used) | ||||
401 | return true; | ||||
402 | |||||
403 | // Check for used attribute. | ||||
404 | // Ask the most recent decl, since attributes accumulate in the redecl chain. | ||||
405 | if (CheckUsedAttr && getMostRecentDecl()->hasAttr<UsedAttr>()) | ||||
406 | return true; | ||||
407 | |||||
408 | // The information may have not been deserialized yet. Force deserialization | ||||
409 | // to complete the needed information. | ||||
410 | return getMostRecentDecl()->getCanonicalDecl()->Used; | ||||
411 | } | ||||
412 | |||||
413 | void Decl::markUsed(ASTContext &C) { | ||||
414 | if (isUsed(false)) | ||||
415 | return; | ||||
416 | |||||
417 | if (C.getASTMutationListener()) | ||||
418 | C.getASTMutationListener()->DeclarationMarkedUsed(this); | ||||
419 | |||||
420 | setIsUsed(); | ||||
421 | } | ||||
422 | |||||
423 | bool Decl::isReferenced() const { | ||||
424 | if (Referenced) | ||||
425 | return true; | ||||
426 | |||||
427 | // Check redeclarations. | ||||
428 | for (const auto *I : redecls()) | ||||
429 | if (I->Referenced) | ||||
430 | return true; | ||||
431 | |||||
432 | return false; | ||||
433 | } | ||||
434 | |||||
435 | ExternalSourceSymbolAttr *Decl::getExternalSourceSymbolAttr() const { | ||||
436 | const Decl *Definition = nullptr; | ||||
437 | if (auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) { | ||||
438 | Definition = ID->getDefinition(); | ||||
439 | } else if (auto *PD = dyn_cast<ObjCProtocolDecl>(this)) { | ||||
440 | Definition = PD->getDefinition(); | ||||
441 | } else if (auto *TD = dyn_cast<TagDecl>(this)) { | ||||
442 | Definition = TD->getDefinition(); | ||||
443 | } | ||||
444 | if (!Definition) | ||||
445 | Definition = this; | ||||
446 | |||||
447 | if (auto *attr = Definition->getAttr<ExternalSourceSymbolAttr>()) | ||||
448 | return attr; | ||||
449 | if (auto *dcd = dyn_cast<Decl>(getDeclContext())) { | ||||
450 | return dcd->getAttr<ExternalSourceSymbolAttr>(); | ||||
451 | } | ||||
452 | |||||
453 | return nullptr; | ||||
454 | } | ||||
455 | |||||
456 | bool Decl::hasDefiningAttr() const { | ||||
457 | return hasAttr<AliasAttr>() || hasAttr<IFuncAttr>(); | ||||
458 | } | ||||
459 | |||||
460 | const Attr *Decl::getDefiningAttr() const { | ||||
461 | if (auto *AA = getAttr<AliasAttr>()) | ||||
462 | return AA; | ||||
463 | if (auto *IFA = getAttr<IFuncAttr>()) | ||||
464 | return IFA; | ||||
465 | return nullptr; | ||||
466 | } | ||||
467 | |||||
468 | static StringRef getRealizedPlatform(const AvailabilityAttr *A, | ||||
469 | const ASTContext &Context) { | ||||
470 | // Check if this is an App Extension "platform", and if so chop off | ||||
471 | // the suffix for matching with the actual platform. | ||||
472 | StringRef RealizedPlatform = A->getPlatform()->getName(); | ||||
473 | if (!Context.getLangOpts().AppExt) | ||||
474 | return RealizedPlatform; | ||||
475 | size_t suffix = RealizedPlatform.rfind("_app_extension"); | ||||
476 | if (suffix != StringRef::npos) | ||||
477 | return RealizedPlatform.slice(0, suffix); | ||||
478 | return RealizedPlatform; | ||||
479 | } | ||||
480 | |||||
481 | /// Determine the availability of the given declaration based on | ||||
482 | /// the target platform. | ||||
483 | /// | ||||
484 | /// When it returns an availability result other than \c AR_Available, | ||||
485 | /// if the \p Message parameter is non-NULL, it will be set to a | ||||
486 | /// string describing why the entity is unavailable. | ||||
487 | /// | ||||
488 | /// FIXME: Make these strings localizable, since they end up in | ||||
489 | /// diagnostics. | ||||
490 | static AvailabilityResult CheckAvailability(ASTContext &Context, | ||||
491 | const AvailabilityAttr *A, | ||||
492 | std::string *Message, | ||||
493 | VersionTuple EnclosingVersion) { | ||||
494 | if (EnclosingVersion.empty()) | ||||
495 | EnclosingVersion = Context.getTargetInfo().getPlatformMinVersion(); | ||||
496 | |||||
497 | if (EnclosingVersion.empty()) | ||||
498 | return AR_Available; | ||||
499 | |||||
500 | StringRef ActualPlatform = A->getPlatform()->getName(); | ||||
501 | StringRef TargetPlatform = Context.getTargetInfo().getPlatformName(); | ||||
502 | |||||
503 | // Match the platform name. | ||||
504 | if (getRealizedPlatform(A, Context) != TargetPlatform) | ||||
505 | return AR_Available; | ||||
506 | |||||
507 | StringRef PrettyPlatformName | ||||
508 | = AvailabilityAttr::getPrettyPlatformName(ActualPlatform); | ||||
509 | |||||
510 | if (PrettyPlatformName.empty()) | ||||
511 | PrettyPlatformName = ActualPlatform; | ||||
512 | |||||
513 | std::string HintMessage; | ||||
514 | if (!A->getMessage().empty()) { | ||||
515 | HintMessage = " - "; | ||||
516 | HintMessage += A->getMessage(); | ||||
517 | } | ||||
518 | |||||
519 | // Make sure that this declaration has not been marked 'unavailable'. | ||||
520 | if (A->getUnavailable()) { | ||||
521 | if (Message) { | ||||
522 | Message->clear(); | ||||
523 | llvm::raw_string_ostream Out(*Message); | ||||
524 | Out << "not available on " << PrettyPlatformName | ||||
525 | << HintMessage; | ||||
526 | } | ||||
527 | |||||
528 | return AR_Unavailable; | ||||
529 | } | ||||
530 | |||||
531 | // Make sure that this declaration has already been introduced. | ||||
532 | if (!A->getIntroduced().empty() && | ||||
533 | EnclosingVersion < A->getIntroduced()) { | ||||
534 | if (Message) { | ||||
535 | Message->clear(); | ||||
536 | llvm::raw_string_ostream Out(*Message); | ||||
537 | VersionTuple VTI(A->getIntroduced()); | ||||
538 | Out << "introduced in " << PrettyPlatformName << ' ' | ||||
539 | << VTI << HintMessage; | ||||
540 | } | ||||
541 | |||||
542 | return A->getStrict() ? AR_Unavailable : AR_NotYetIntroduced; | ||||
543 | } | ||||
544 | |||||
545 | // Make sure that this declaration hasn't been obsoleted. | ||||
546 | if (!A->getObsoleted().empty() && EnclosingVersion >= A->getObsoleted()) { | ||||
547 | if (Message) { | ||||
548 | Message->clear(); | ||||
549 | llvm::raw_string_ostream Out(*Message); | ||||
550 | VersionTuple VTO(A->getObsoleted()); | ||||
551 | Out << "obsoleted in " << PrettyPlatformName << ' ' | ||||
552 | << VTO << HintMessage; | ||||
553 | } | ||||
554 | |||||
555 | return AR_Unavailable; | ||||
556 | } | ||||
557 | |||||
558 | // Make sure that this declaration hasn't been deprecated. | ||||
559 | if (!A->getDeprecated().empty() && EnclosingVersion >= A->getDeprecated()) { | ||||
560 | if (Message) { | ||||
561 | Message->clear(); | ||||
562 | llvm::raw_string_ostream Out(*Message); | ||||
563 | VersionTuple VTD(A->getDeprecated()); | ||||
564 | Out << "first deprecated in " << PrettyPlatformName << ' ' | ||||
565 | << VTD << HintMessage; | ||||
566 | } | ||||
567 | |||||
568 | return AR_Deprecated; | ||||
569 | } | ||||
570 | |||||
571 | return AR_Available; | ||||
572 | } | ||||
573 | |||||
574 | AvailabilityResult Decl::getAvailability(std::string *Message, | ||||
575 | VersionTuple EnclosingVersion, | ||||
576 | StringRef *RealizedPlatform) const { | ||||
577 | if (auto *FTD = dyn_cast<FunctionTemplateDecl>(this)) | ||||
578 | return FTD->getTemplatedDecl()->getAvailability(Message, EnclosingVersion, | ||||
579 | RealizedPlatform); | ||||
580 | |||||
581 | AvailabilityResult Result = AR_Available; | ||||
582 | std::string ResultMessage; | ||||
583 | |||||
584 | for (const auto *A : attrs()) { | ||||
585 | if (const auto *Deprecated = dyn_cast<DeprecatedAttr>(A)) { | ||||
586 | if (Result >= AR_Deprecated) | ||||
587 | continue; | ||||
588 | |||||
589 | if (Message) | ||||
590 | ResultMessage = Deprecated->getMessage(); | ||||
591 | |||||
592 | Result = AR_Deprecated; | ||||
593 | continue; | ||||
594 | } | ||||
595 | |||||
596 | if (const auto *Unavailable = dyn_cast<UnavailableAttr>(A)) { | ||||
597 | if (Message) | ||||
598 | *Message = Unavailable->getMessage(); | ||||
599 | return AR_Unavailable; | ||||
600 | } | ||||
601 | |||||
602 | if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) { | ||||
603 | AvailabilityResult AR = CheckAvailability(getASTContext(), Availability, | ||||
604 | Message, EnclosingVersion); | ||||
605 | |||||
606 | if (AR == AR_Unavailable) { | ||||
607 | if (RealizedPlatform) | ||||
608 | *RealizedPlatform = Availability->getPlatform()->getName(); | ||||
609 | return AR_Unavailable; | ||||
610 | } | ||||
611 | |||||
612 | if (AR > Result) { | ||||
613 | Result = AR; | ||||
614 | if (Message) | ||||
615 | ResultMessage.swap(*Message); | ||||
616 | } | ||||
617 | continue; | ||||
618 | } | ||||
619 | } | ||||
620 | |||||
621 | if (Message) | ||||
622 | Message->swap(ResultMessage); | ||||
623 | return Result; | ||||
624 | } | ||||
625 | |||||
626 | VersionTuple Decl::getVersionIntroduced() const { | ||||
627 | const ASTContext &Context = getASTContext(); | ||||
628 | StringRef TargetPlatform = Context.getTargetInfo().getPlatformName(); | ||||
629 | for (const auto *A : attrs()) { | ||||
630 | if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) { | ||||
631 | if (getRealizedPlatform(Availability, Context) != TargetPlatform) | ||||
632 | continue; | ||||
633 | if (!Availability->getIntroduced().empty()) | ||||
634 | return Availability->getIntroduced(); | ||||
635 | } | ||||
636 | } | ||||
637 | return {}; | ||||
638 | } | ||||
639 | |||||
640 | bool Decl::canBeWeakImported(bool &IsDefinition) const { | ||||
641 | IsDefinition = false; | ||||
642 | |||||
643 | // Variables, if they aren't definitions. | ||||
644 | if (const auto *Var = dyn_cast<VarDecl>(this)) { | ||||
645 | if (Var->isThisDeclarationADefinition()) { | ||||
646 | IsDefinition = true; | ||||
647 | return false; | ||||
648 | } | ||||
649 | return true; | ||||
650 | |||||
651 | // Functions, if they aren't definitions. | ||||
652 | } else if (const auto *FD = dyn_cast<FunctionDecl>(this)) { | ||||
653 | if (FD->hasBody()) { | ||||
654 | IsDefinition = true; | ||||
655 | return false; | ||||
656 | } | ||||
657 | return true; | ||||
658 | |||||
659 | // Objective-C classes, if this is the non-fragile runtime. | ||||
660 | } else if (isa<ObjCInterfaceDecl>(this) && | ||||
661 | getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) { | ||||
662 | return true; | ||||
663 | |||||
664 | // Nothing else. | ||||
665 | } else { | ||||
666 | return false; | ||||
667 | } | ||||
668 | } | ||||
669 | |||||
670 | bool Decl::isWeakImported() const { | ||||
671 | bool IsDefinition; | ||||
672 | if (!canBeWeakImported(IsDefinition)) | ||||
673 | return false; | ||||
674 | |||||
675 | for (const auto *A : attrs()) { | ||||
676 | if (isa<WeakImportAttr>(A)) | ||||
677 | return true; | ||||
678 | |||||
679 | if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) { | ||||
680 | if (CheckAvailability(getASTContext(), Availability, nullptr, | ||||
681 | VersionTuple()) == AR_NotYetIntroduced) | ||||
682 | return true; | ||||
683 | } | ||||
684 | } | ||||
685 | |||||
686 | return false; | ||||
687 | } | ||||
688 | |||||
689 | unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) { | ||||
690 | switch (DeclKind) { | ||||
691 | case Function: | ||||
692 | case CXXDeductionGuide: | ||||
693 | case CXXMethod: | ||||
694 | case CXXConstructor: | ||||
695 | case ConstructorUsingShadow: | ||||
696 | case CXXDestructor: | ||||
697 | case CXXConversion: | ||||
698 | case EnumConstant: | ||||
699 | case Var: | ||||
700 | case ImplicitParam: | ||||
701 | case ParmVar: | ||||
702 | case ObjCMethod: | ||||
703 | case ObjCProperty: | ||||
704 | case MSProperty: | ||||
705 | return IDNS_Ordinary; | ||||
706 | case Label: | ||||
707 | return IDNS_Label; | ||||
708 | case IndirectField: | ||||
709 | return IDNS_Ordinary | IDNS_Member; | ||||
710 | |||||
711 | case Binding: | ||||
712 | case NonTypeTemplateParm: | ||||
713 | case VarTemplate: | ||||
714 | case Concept: | ||||
715 | // These (C++-only) declarations are found by redeclaration lookup for | ||||
716 | // tag types, so we include them in the tag namespace. | ||||
717 | return IDNS_Ordinary | IDNS_Tag; | ||||
718 | |||||
719 | case ObjCCompatibleAlias: | ||||
720 | case ObjCInterface: | ||||
721 | return IDNS_Ordinary | IDNS_Type; | ||||
722 | |||||
723 | case Typedef: | ||||
724 | case TypeAlias: | ||||
725 | case TemplateTypeParm: | ||||
726 | case ObjCTypeParam: | ||||
727 | return IDNS_Ordinary | IDNS_Type; | ||||
728 | |||||
729 | case UnresolvedUsingTypename: | ||||
730 | return IDNS_Ordinary | IDNS_Type | IDNS_Using; | ||||
731 | |||||
732 | case UsingShadow: | ||||
733 | return 0; // we'll actually overwrite this later | ||||
734 | |||||
735 | case UnresolvedUsingValue: | ||||
736 | return IDNS_Ordinary | IDNS_Using; | ||||
737 | |||||
738 | case Using: | ||||
739 | case UsingPack: | ||||
740 | return IDNS_Using; | ||||
741 | |||||
742 | case ObjCProtocol: | ||||
743 | return IDNS_ObjCProtocol; | ||||
744 | |||||
745 | case Field: | ||||
746 | case ObjCAtDefsField: | ||||
747 | case ObjCIvar: | ||||
748 | return IDNS_Member; | ||||
749 | |||||
750 | case Record: | ||||
751 | case CXXRecord: | ||||
752 | case Enum: | ||||
753 | return IDNS_Tag | IDNS_Type; | ||||
754 | |||||
755 | case Namespace: | ||||
756 | case NamespaceAlias: | ||||
757 | return IDNS_Namespace; | ||||
758 | |||||
759 | case FunctionTemplate: | ||||
760 | return IDNS_Ordinary; | ||||
761 | |||||
762 | case ClassTemplate: | ||||
763 | case TemplateTemplateParm: | ||||
764 | case TypeAliasTemplate: | ||||
765 | return IDNS_Ordinary | IDNS_Tag | IDNS_Type; | ||||
766 | |||||
767 | case OMPDeclareReduction: | ||||
768 | return IDNS_OMPReduction; | ||||
769 | |||||
770 | case OMPDeclareMapper: | ||||
771 | return IDNS_OMPMapper; | ||||
772 | |||||
773 | // Never have names. | ||||
774 | case Friend: | ||||
775 | case FriendTemplate: | ||||
776 | case AccessSpec: | ||||
777 | case LinkageSpec: | ||||
778 | case Export: | ||||
779 | case FileScopeAsm: | ||||
780 | case StaticAssert: | ||||
781 | case ObjCPropertyImpl: | ||||
782 | case PragmaComment: | ||||
783 | case PragmaDetectMismatch: | ||||
784 | case Block: | ||||
785 | case Captured: | ||||
786 | case TranslationUnit: | ||||
787 | case ExternCContext: | ||||
788 | case Decomposition: | ||||
789 | |||||
790 | case UsingDirective: | ||||
791 | case BuiltinTemplate: | ||||
792 | case ClassTemplateSpecialization: | ||||
793 | case ClassTemplatePartialSpecialization: | ||||
794 | case ClassScopeFunctionSpecialization: | ||||
795 | case VarTemplateSpecialization: | ||||
796 | case VarTemplatePartialSpecialization: | ||||
797 | case ObjCImplementation: | ||||
798 | case ObjCCategory: | ||||
799 | case ObjCCategoryImpl: | ||||
800 | case Import: | ||||
801 | case OMPThreadPrivate: | ||||
802 | case OMPAllocate: | ||||
803 | case OMPRequires: | ||||
804 | case OMPCapturedExpr: | ||||
805 | case Empty: | ||||
806 | // Never looked up by name. | ||||
807 | return 0; | ||||
808 | } | ||||
809 | |||||
810 | llvm_unreachable("Invalid DeclKind!")::llvm::llvm_unreachable_internal("Invalid DeclKind!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 810); | ||||
811 | } | ||||
812 | |||||
813 | void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) { | ||||
814 | assert(!HasAttrs && "Decl already contains attrs.")((!HasAttrs && "Decl already contains attrs.") ? static_cast <void> (0) : __assert_fail ("!HasAttrs && \"Decl already contains attrs.\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 814, __PRETTY_FUNCTION__)); | ||||
815 | |||||
816 | AttrVec &AttrBlank = Ctx.getDeclAttrs(this); | ||||
817 | assert(AttrBlank.empty() && "HasAttrs was wrong?")((AttrBlank.empty() && "HasAttrs was wrong?") ? static_cast <void> (0) : __assert_fail ("AttrBlank.empty() && \"HasAttrs was wrong?\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 817, __PRETTY_FUNCTION__)); | ||||
818 | |||||
819 | AttrBlank = attrs; | ||||
820 | HasAttrs = true; | ||||
821 | } | ||||
822 | |||||
823 | void Decl::dropAttrs() { | ||||
824 | if (!HasAttrs) return; | ||||
825 | |||||
826 | HasAttrs = false; | ||||
827 | getASTContext().eraseDeclAttrs(this); | ||||
828 | } | ||||
829 | |||||
830 | void Decl::addAttr(Attr *A) { | ||||
831 | if (!hasAttrs()) { | ||||
832 | setAttrs(AttrVec(1, A)); | ||||
833 | return; | ||||
834 | } | ||||
835 | |||||
836 | AttrVec &Attrs = getAttrs(); | ||||
837 | if (!A->isInherited()) { | ||||
838 | Attrs.push_back(A); | ||||
839 | return; | ||||
840 | } | ||||
841 | |||||
842 | // Attribute inheritance is processed after attribute parsing. To keep the | ||||
843 | // order as in the source code, add inherited attributes before non-inherited | ||||
844 | // ones. | ||||
845 | auto I = Attrs.begin(), E = Attrs.end(); | ||||
846 | for (; I != E; ++I) { | ||||
847 | if (!(*I)->isInherited()) | ||||
848 | break; | ||||
849 | } | ||||
850 | Attrs.insert(I, A); | ||||
851 | } | ||||
852 | |||||
853 | const AttrVec &Decl::getAttrs() const { | ||||
854 | assert(HasAttrs && "No attrs to get!")((HasAttrs && "No attrs to get!") ? static_cast<void > (0) : __assert_fail ("HasAttrs && \"No attrs to get!\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 854, __PRETTY_FUNCTION__)); | ||||
855 | return getASTContext().getDeclAttrs(this); | ||||
856 | } | ||||
857 | |||||
858 | Decl *Decl::castFromDeclContext (const DeclContext *D) { | ||||
859 | Decl::Kind DK = D->getDeclKind(); | ||||
860 | switch(DK) { | ||||
861 | #define DECL(NAME, BASE) | ||||
862 | #define DECL_CONTEXT(NAME) \ | ||||
863 | case Decl::NAME: \ | ||||
864 | return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D)); | ||||
865 | #define DECL_CONTEXT_BASE(NAME) | ||||
866 | #include "clang/AST/DeclNodes.inc" | ||||
867 | default: | ||||
868 | #define DECL(NAME, BASE) | ||||
869 | #define DECL_CONTEXT_BASE(NAME) \ | ||||
870 | if (DK >= first##NAME && DK <= last##NAME) \ | ||||
871 | return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D)); | ||||
872 | #include "clang/AST/DeclNodes.inc" | ||||
873 | llvm_unreachable("a decl that inherits DeclContext isn't handled")::llvm::llvm_unreachable_internal("a decl that inherits DeclContext isn't handled" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 873); | ||||
874 | } | ||||
875 | } | ||||
876 | |||||
877 | DeclContext *Decl::castToDeclContext(const Decl *D) { | ||||
878 | Decl::Kind DK = D->getKind(); | ||||
879 | switch(DK) { | ||||
880 | #define DECL(NAME, BASE) | ||||
881 | #define DECL_CONTEXT(NAME) \ | ||||
882 | case Decl::NAME: \ | ||||
883 | return static_cast<NAME##Decl *>(const_cast<Decl *>(D)); | ||||
884 | #define DECL_CONTEXT_BASE(NAME) | ||||
885 | #include "clang/AST/DeclNodes.inc" | ||||
886 | default: | ||||
887 | #define DECL(NAME, BASE) | ||||
888 | #define DECL_CONTEXT_BASE(NAME) \ | ||||
889 | if (DK >= first##NAME && DK <= last##NAME) \ | ||||
890 | return static_cast<NAME##Decl *>(const_cast<Decl *>(D)); | ||||
891 | #include "clang/AST/DeclNodes.inc" | ||||
892 | llvm_unreachable("a decl that inherits DeclContext isn't handled")::llvm::llvm_unreachable_internal("a decl that inherits DeclContext isn't handled" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 892); | ||||
893 | } | ||||
894 | } | ||||
895 | |||||
896 | SourceLocation Decl::getBodyRBrace() const { | ||||
897 | // Special handling of FunctionDecl to avoid de-serializing the body from PCH. | ||||
898 | // FunctionDecl stores EndRangeLoc for this purpose. | ||||
899 | if (const auto *FD = dyn_cast<FunctionDecl>(this)) { | ||||
900 | const FunctionDecl *Definition; | ||||
901 | if (FD->hasBody(Definition)) | ||||
902 | return Definition->getSourceRange().getEnd(); | ||||
903 | return {}; | ||||
904 | } | ||||
905 | |||||
906 | if (Stmt *Body = getBody()) | ||||
907 | return Body->getSourceRange().getEnd(); | ||||
908 | |||||
909 | return {}; | ||||
910 | } | ||||
911 | |||||
912 | bool Decl::AccessDeclContextSanity() const { | ||||
913 | #ifndef NDEBUG | ||||
914 | // Suppress this check if any of the following hold: | ||||
915 | // 1. this is the translation unit (and thus has no parent) | ||||
916 | // 2. this is a template parameter (and thus doesn't belong to its context) | ||||
917 | // 3. this is a non-type template parameter | ||||
918 | // 4. the context is not a record | ||||
919 | // 5. it's invalid | ||||
920 | // 6. it's a C++0x static_assert. | ||||
921 | // 7. it's a block literal declaration | ||||
922 | if (isa<TranslationUnitDecl>(this) || | ||||
923 | isa<TemplateTypeParmDecl>(this) || | ||||
924 | isa<NonTypeTemplateParmDecl>(this) || | ||||
925 | !getDeclContext() || | ||||
926 | !isa<CXXRecordDecl>(getDeclContext()) || | ||||
927 | isInvalidDecl() || | ||||
928 | isa<StaticAssertDecl>(this) || | ||||
929 | isa<BlockDecl>(this) || | ||||
930 | // FIXME: a ParmVarDecl can have ClassTemplateSpecialization | ||||
931 | // as DeclContext (?). | ||||
932 | isa<ParmVarDecl>(this) || | ||||
933 | // FIXME: a ClassTemplateSpecialization or CXXRecordDecl can have | ||||
934 | // AS_none as access specifier. | ||||
935 | isa<CXXRecordDecl>(this) || | ||||
936 | isa<ClassScopeFunctionSpecializationDecl>(this)) | ||||
937 | return true; | ||||
938 | |||||
939 | assert(Access != AS_none &&((Access != AS_none && "Access specifier is AS_none inside a record decl" ) ? static_cast<void> (0) : __assert_fail ("Access != AS_none && \"Access specifier is AS_none inside a record decl\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 940, __PRETTY_FUNCTION__)) | ||||
940 | "Access specifier is AS_none inside a record decl")((Access != AS_none && "Access specifier is AS_none inside a record decl" ) ? static_cast<void> (0) : __assert_fail ("Access != AS_none && \"Access specifier is AS_none inside a record decl\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 940, __PRETTY_FUNCTION__)); | ||||
941 | #endif | ||||
942 | return true; | ||||
943 | } | ||||
944 | |||||
945 | static Decl::Kind getKind(const Decl *D) { return D->getKind(); } | ||||
946 | static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); } | ||||
947 | |||||
948 | int64_t Decl::getID() const { | ||||
949 | return getASTContext().getAllocator().identifyKnownAlignedObject<Decl>(this); | ||||
950 | } | ||||
951 | |||||
952 | const FunctionType *Decl::getFunctionType(bool BlocksToo) const { | ||||
953 | QualType Ty; | ||||
954 | if (const auto *D
| ||||
| |||||
955 | Ty = D->getType(); | ||||
956 | else if (const auto *D = dyn_cast<TypedefNameDecl>(this)) | ||||
957 | Ty = D->getUnderlyingType(); | ||||
958 | else | ||||
959 | return nullptr; | ||||
960 | |||||
961 | if (Ty->isFunctionPointerType()) | ||||
962 | Ty = Ty->getAs<PointerType>()->getPointeeType(); | ||||
| |||||
963 | else if (Ty->isFunctionReferenceType()) | ||||
964 | Ty = Ty->getAs<ReferenceType>()->getPointeeType(); | ||||
965 | else if (BlocksToo && Ty->isBlockPointerType()) | ||||
966 | Ty = Ty->getAs<BlockPointerType>()->getPointeeType(); | ||||
967 | |||||
968 | return Ty->getAs<FunctionType>(); | ||||
969 | } | ||||
970 | |||||
971 | /// Starting at a given context (a Decl or DeclContext), look for a | ||||
972 | /// code context that is not a closure (a lambda, block, etc.). | ||||
973 | template <class T> static Decl *getNonClosureContext(T *D) { | ||||
974 | if (getKind(D) == Decl::CXXMethod) { | ||||
975 | auto *MD = cast<CXXMethodDecl>(D); | ||||
976 | if (MD->getOverloadedOperator() == OO_Call && | ||||
977 | MD->getParent()->isLambda()) | ||||
978 | return getNonClosureContext(MD->getParent()->getParent()); | ||||
979 | return MD; | ||||
980 | } else if (auto *FD = dyn_cast<FunctionDecl>(D)) | ||||
981 | return FD; | ||||
982 | else if (auto *MD = dyn_cast<ObjCMethodDecl>(D)) | ||||
983 | return MD; | ||||
984 | else if (auto *BD = dyn_cast<BlockDecl>(D)) | ||||
985 | return getNonClosureContext(BD->getParent()); | ||||
986 | else if (auto *CD = dyn_cast<CapturedDecl>(D)) | ||||
987 | return getNonClosureContext(CD->getParent()); | ||||
988 | else | ||||
989 | return nullptr; | ||||
990 | } | ||||
991 | |||||
992 | Decl *Decl::getNonClosureContext() { | ||||
993 | return ::getNonClosureContext(this); | ||||
994 | } | ||||
995 | |||||
996 | Decl *DeclContext::getNonClosureAncestor() { | ||||
997 | return ::getNonClosureContext(this); | ||||
998 | } | ||||
999 | |||||
1000 | //===----------------------------------------------------------------------===// | ||||
1001 | // DeclContext Implementation | ||||
1002 | //===----------------------------------------------------------------------===// | ||||
1003 | |||||
1004 | DeclContext::DeclContext(Decl::Kind K) { | ||||
1005 | DeclContextBits.DeclKind = K; | ||||
1006 | setHasExternalLexicalStorage(false); | ||||
1007 | setHasExternalVisibleStorage(false); | ||||
1008 | setNeedToReconcileExternalVisibleStorage(false); | ||||
1009 | setHasLazyLocalLexicalLookups(false); | ||||
1010 | setHasLazyExternalLexicalLookups(false); | ||||
1011 | setUseQualifiedLookup(false); | ||||
1012 | } | ||||
1013 | |||||
1014 | bool DeclContext::classof(const Decl *D) { | ||||
1015 | switch (D->getKind()) { | ||||
1016 | #define DECL(NAME, BASE) | ||||
1017 | #define DECL_CONTEXT(NAME) case Decl::NAME: | ||||
1018 | #define DECL_CONTEXT_BASE(NAME) | ||||
1019 | #include "clang/AST/DeclNodes.inc" | ||||
1020 | return true; | ||||
1021 | default: | ||||
1022 | #define DECL(NAME, BASE) | ||||
1023 | #define DECL_CONTEXT_BASE(NAME) \ | ||||
1024 | if (D->getKind() >= Decl::first##NAME && \ | ||||
1025 | D->getKind() <= Decl::last##NAME) \ | ||||
1026 | return true; | ||||
1027 | #include "clang/AST/DeclNodes.inc" | ||||
1028 | return false; | ||||
1029 | } | ||||
1030 | } | ||||
1031 | |||||
1032 | DeclContext::~DeclContext() = default; | ||||
1033 | |||||
1034 | /// Find the parent context of this context that will be | ||||
1035 | /// used for unqualified name lookup. | ||||
1036 | /// | ||||
1037 | /// Generally, the parent lookup context is the semantic context. However, for | ||||
1038 | /// a friend function the parent lookup context is the lexical context, which | ||||
1039 | /// is the class in which the friend is declared. | ||||
1040 | DeclContext *DeclContext::getLookupParent() { | ||||
1041 | // FIXME: Find a better way to identify friends. | ||||
1042 | if (isa<FunctionDecl>(this)) | ||||
1043 | if (getParent()->getRedeclContext()->isFileContext() && | ||||
1044 | getLexicalParent()->getRedeclContext()->isRecord()) | ||||
1045 | return getLexicalParent(); | ||||
1046 | |||||
1047 | // A lookup within the call operator of a lambda never looks in the lambda | ||||
1048 | // class; instead, skip to the context in which that closure type is | ||||
1049 | // declared. | ||||
1050 | if (isLambdaCallOperator(this)) | ||||
1051 | return getParent()->getParent(); | ||||
1052 | |||||
1053 | return getParent(); | ||||
1054 | } | ||||
1055 | |||||
1056 | const BlockDecl *DeclContext::getInnermostBlockDecl() const { | ||||
1057 | const DeclContext *Ctx = this; | ||||
1058 | |||||
1059 | do { | ||||
1060 | if (Ctx->isClosure()) | ||||
1061 | return cast<BlockDecl>(Ctx); | ||||
1062 | Ctx = Ctx->getParent(); | ||||
1063 | } while (Ctx); | ||||
1064 | |||||
1065 | return nullptr; | ||||
1066 | } | ||||
1067 | |||||
1068 | bool DeclContext::isInlineNamespace() const { | ||||
1069 | return isNamespace() && | ||||
1070 | cast<NamespaceDecl>(this)->isInline(); | ||||
1071 | } | ||||
1072 | |||||
1073 | bool DeclContext::isStdNamespace() const { | ||||
1074 | if (!isNamespace()) | ||||
1075 | return false; | ||||
1076 | |||||
1077 | const auto *ND = cast<NamespaceDecl>(this); | ||||
1078 | if (ND->isInline()) { | ||||
1079 | return ND->getParent()->isStdNamespace(); | ||||
1080 | } | ||||
1081 | |||||
1082 | if (!getParent()->getRedeclContext()->isTranslationUnit()) | ||||
1083 | return false; | ||||
1084 | |||||
1085 | const IdentifierInfo *II = ND->getIdentifier(); | ||||
1086 | return II && II->isStr("std"); | ||||
1087 | } | ||||
1088 | |||||
1089 | bool DeclContext::isDependentContext() const { | ||||
1090 | if (isFileContext()) | ||||
1091 | return false; | ||||
1092 | |||||
1093 | if (isa<ClassTemplatePartialSpecializationDecl>(this)) | ||||
1094 | return true; | ||||
1095 | |||||
1096 | if (const auto *Record = dyn_cast<CXXRecordDecl>(this)) { | ||||
1097 | if (Record->getDescribedClassTemplate()) | ||||
1098 | return true; | ||||
1099 | |||||
1100 | if (Record->isDependentLambda()) | ||||
1101 | return true; | ||||
1102 | } | ||||
1103 | |||||
1104 | if (const auto *Function = dyn_cast<FunctionDecl>(this)) { | ||||
1105 | if (Function->getDescribedFunctionTemplate()) | ||||
1106 | return true; | ||||
1107 | |||||
1108 | // Friend function declarations are dependent if their *lexical* | ||||
1109 | // context is dependent. | ||||
1110 | if (cast<Decl>(this)->getFriendObjectKind()) | ||||
1111 | return getLexicalParent()->isDependentContext(); | ||||
1112 | } | ||||
1113 | |||||
1114 | // FIXME: A variable template is a dependent context, but is not a | ||||
1115 | // DeclContext. A context within it (such as a lambda-expression) | ||||
1116 | // should be considered dependent. | ||||
1117 | |||||
1118 | return getParent() && getParent()->isDependentContext(); | ||||
1119 | } | ||||
1120 | |||||
1121 | bool DeclContext::isTransparentContext() const { | ||||
1122 | if (getDeclKind() == Decl::Enum) | ||||
1123 | return !cast<EnumDecl>(this)->isScoped(); | ||||
1124 | else if (getDeclKind() == Decl::LinkageSpec || getDeclKind() == Decl::Export) | ||||
1125 | return true; | ||||
1126 | |||||
1127 | return false; | ||||
1128 | } | ||||
1129 | |||||
1130 | static bool isLinkageSpecContext(const DeclContext *DC, | ||||
1131 | LinkageSpecDecl::LanguageIDs ID) { | ||||
1132 | while (DC->getDeclKind() != Decl::TranslationUnit) { | ||||
1133 | if (DC->getDeclKind() == Decl::LinkageSpec) | ||||
1134 | return cast<LinkageSpecDecl>(DC)->getLanguage() == ID; | ||||
1135 | DC = DC->getLexicalParent(); | ||||
1136 | } | ||||
1137 | return false; | ||||
1138 | } | ||||
1139 | |||||
1140 | bool DeclContext::isExternCContext() const { | ||||
1141 | return isLinkageSpecContext(this, LinkageSpecDecl::lang_c); | ||||
1142 | } | ||||
1143 | |||||
1144 | const LinkageSpecDecl *DeclContext::getExternCContext() const { | ||||
1145 | const DeclContext *DC = this; | ||||
1146 | while (DC->getDeclKind() != Decl::TranslationUnit) { | ||||
1147 | if (DC->getDeclKind() == Decl::LinkageSpec && | ||||
1148 | cast<LinkageSpecDecl>(DC)->getLanguage() == LinkageSpecDecl::lang_c) | ||||
1149 | return cast<LinkageSpecDecl>(DC); | ||||
1150 | DC = DC->getLexicalParent(); | ||||
1151 | } | ||||
1152 | return nullptr; | ||||
1153 | } | ||||
1154 | |||||
1155 | bool DeclContext::isExternCXXContext() const { | ||||
1156 | return isLinkageSpecContext(this, LinkageSpecDecl::lang_cxx); | ||||
1157 | } | ||||
1158 | |||||
1159 | bool DeclContext::Encloses(const DeclContext *DC) const { | ||||
1160 | if (getPrimaryContext() != this) | ||||
1161 | return getPrimaryContext()->Encloses(DC); | ||||
1162 | |||||
1163 | for (; DC; DC = DC->getParent()) | ||||
1164 | if (DC->getPrimaryContext() == this) | ||||
1165 | return true; | ||||
1166 | return false; | ||||
1167 | } | ||||
1168 | |||||
1169 | DeclContext *DeclContext::getPrimaryContext() { | ||||
1170 | switch (getDeclKind()) { | ||||
1171 | case Decl::TranslationUnit: | ||||
1172 | case Decl::ExternCContext: | ||||
1173 | case Decl::LinkageSpec: | ||||
1174 | case Decl::Export: | ||||
1175 | case Decl::Block: | ||||
1176 | case Decl::Captured: | ||||
1177 | case Decl::OMPDeclareReduction: | ||||
1178 | case Decl::OMPDeclareMapper: | ||||
1179 | // There is only one DeclContext for these entities. | ||||
1180 | return this; | ||||
1181 | |||||
1182 | case Decl::Namespace: | ||||
1183 | // The original namespace is our primary context. | ||||
1184 | return static_cast<NamespaceDecl *>(this)->getOriginalNamespace(); | ||||
1185 | |||||
1186 | case Decl::ObjCMethod: | ||||
1187 | return this; | ||||
1188 | |||||
1189 | case Decl::ObjCInterface: | ||||
1190 | if (auto *OID = dyn_cast<ObjCInterfaceDecl>(this)) | ||||
1191 | if (auto *Def = OID->getDefinition()) | ||||
1192 | return Def; | ||||
1193 | return this; | ||||
1194 | |||||
1195 | case Decl::ObjCProtocol: | ||||
1196 | if (auto *OPD = dyn_cast<ObjCProtocolDecl>(this)) | ||||
1197 | if (auto *Def = OPD->getDefinition()) | ||||
1198 | return Def; | ||||
1199 | return this; | ||||
1200 | |||||
1201 | case Decl::ObjCCategory: | ||||
1202 | return this; | ||||
1203 | |||||
1204 | case Decl::ObjCImplementation: | ||||
1205 | case Decl::ObjCCategoryImpl: | ||||
1206 | return this; | ||||
1207 | |||||
1208 | default: | ||||
1209 | if (getDeclKind() >= Decl::firstTag && getDeclKind() <= Decl::lastTag) { | ||||
1210 | // If this is a tag type that has a definition or is currently | ||||
1211 | // being defined, that definition is our primary context. | ||||
1212 | auto *Tag = cast<TagDecl>(this); | ||||
1213 | |||||
1214 | if (TagDecl *Def = Tag->getDefinition()) | ||||
1215 | return Def; | ||||
1216 | |||||
1217 | if (const auto *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) { | ||||
1218 | // Note, TagType::getDecl returns the (partial) definition one exists. | ||||
1219 | TagDecl *PossiblePartialDef = TagTy->getDecl(); | ||||
1220 | if (PossiblePartialDef->isBeingDefined()) | ||||
1221 | return PossiblePartialDef; | ||||
1222 | } else { | ||||
1223 | assert(isa<InjectedClassNameType>(Tag->getTypeForDecl()))((isa<InjectedClassNameType>(Tag->getTypeForDecl())) ? static_cast<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Tag->getTypeForDecl())" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1223, __PRETTY_FUNCTION__)); | ||||
1224 | } | ||||
1225 | |||||
1226 | return Tag; | ||||
1227 | } | ||||
1228 | |||||
1229 | assert(getDeclKind() >= Decl::firstFunction &&((getDeclKind() >= Decl::firstFunction && getDeclKind () <= Decl::lastFunction && "Unknown DeclContext kind" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() >= Decl::firstFunction && getDeclKind() <= Decl::lastFunction && \"Unknown DeclContext kind\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1231, __PRETTY_FUNCTION__)) | ||||
1230 | getDeclKind() <= Decl::lastFunction &&((getDeclKind() >= Decl::firstFunction && getDeclKind () <= Decl::lastFunction && "Unknown DeclContext kind" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() >= Decl::firstFunction && getDeclKind() <= Decl::lastFunction && \"Unknown DeclContext kind\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1231, __PRETTY_FUNCTION__)) | ||||
1231 | "Unknown DeclContext kind")((getDeclKind() >= Decl::firstFunction && getDeclKind () <= Decl::lastFunction && "Unknown DeclContext kind" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() >= Decl::firstFunction && getDeclKind() <= Decl::lastFunction && \"Unknown DeclContext kind\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1231, __PRETTY_FUNCTION__)); | ||||
1232 | return this; | ||||
1233 | } | ||||
1234 | } | ||||
1235 | |||||
1236 | void | ||||
1237 | DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts){ | ||||
1238 | Contexts.clear(); | ||||
1239 | |||||
1240 | if (getDeclKind() != Decl::Namespace) { | ||||
1241 | Contexts.push_back(this); | ||||
1242 | return; | ||||
1243 | } | ||||
1244 | |||||
1245 | auto *Self = static_cast<NamespaceDecl *>(this); | ||||
1246 | for (NamespaceDecl *N = Self->getMostRecentDecl(); N; | ||||
1247 | N = N->getPreviousDecl()) | ||||
1248 | Contexts.push_back(N); | ||||
1249 | |||||
1250 | std::reverse(Contexts.begin(), Contexts.end()); | ||||
1251 | } | ||||
1252 | |||||
1253 | std::pair<Decl *, Decl *> | ||||
1254 | DeclContext::BuildDeclChain(ArrayRef<Decl *> Decls, | ||||
1255 | bool FieldsAlreadyLoaded) { | ||||
1256 | // Build up a chain of declarations via the Decl::NextInContextAndBits field. | ||||
1257 | Decl *FirstNewDecl = nullptr; | ||||
1258 | Decl *PrevDecl = nullptr; | ||||
1259 | for (auto *D : Decls) { | ||||
1260 | if (FieldsAlreadyLoaded && isa<FieldDecl>(D)) | ||||
1261 | continue; | ||||
1262 | |||||
1263 | if (PrevDecl) | ||||
1264 | PrevDecl->NextInContextAndBits.setPointer(D); | ||||
1265 | else | ||||
1266 | FirstNewDecl = D; | ||||
1267 | |||||
1268 | PrevDecl = D; | ||||
1269 | } | ||||
1270 | |||||
1271 | return std::make_pair(FirstNewDecl, PrevDecl); | ||||
1272 | } | ||||
1273 | |||||
1274 | /// We have just acquired external visible storage, and we already have | ||||
1275 | /// built a lookup map. For every name in the map, pull in the new names from | ||||
1276 | /// the external storage. | ||||
1277 | void DeclContext::reconcileExternalVisibleStorage() const { | ||||
1278 | assert(hasNeedToReconcileExternalVisibleStorage() && LookupPtr)((hasNeedToReconcileExternalVisibleStorage() && LookupPtr ) ? static_cast<void> (0) : __assert_fail ("hasNeedToReconcileExternalVisibleStorage() && LookupPtr" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1278, __PRETTY_FUNCTION__)); | ||||
1279 | setNeedToReconcileExternalVisibleStorage(false); | ||||
1280 | |||||
1281 | for (auto &Lookup : *LookupPtr) | ||||
1282 | Lookup.second.setHasExternalDecls(); | ||||
1283 | } | ||||
1284 | |||||
1285 | /// Load the declarations within this lexical storage from an | ||||
1286 | /// external source. | ||||
1287 | /// \return \c true if any declarations were added. | ||||
1288 | bool | ||||
1289 | DeclContext::LoadLexicalDeclsFromExternalStorage() const { | ||||
1290 | ExternalASTSource *Source = getParentASTContext().getExternalSource(); | ||||
1291 | assert(hasExternalLexicalStorage() && Source && "No external storage?")((hasExternalLexicalStorage() && Source && "No external storage?" ) ? static_cast<void> (0) : __assert_fail ("hasExternalLexicalStorage() && Source && \"No external storage?\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1291, __PRETTY_FUNCTION__)); | ||||
1292 | |||||
1293 | // Notify that we have a DeclContext that is initializing. | ||||
1294 | ExternalASTSource::Deserializing ADeclContext(Source); | ||||
1295 | |||||
1296 | // Load the external declarations, if any. | ||||
1297 | SmallVector<Decl*, 64> Decls; | ||||
1298 | setHasExternalLexicalStorage(false); | ||||
1299 | Source->FindExternalLexicalDecls(this, Decls); | ||||
1300 | |||||
1301 | if (Decls.empty()) | ||||
1302 | return false; | ||||
1303 | |||||
1304 | // We may have already loaded just the fields of this record, in which case | ||||
1305 | // we need to ignore them. | ||||
1306 | bool FieldsAlreadyLoaded = false; | ||||
1307 | if (const auto *RD = dyn_cast<RecordDecl>(this)) | ||||
1308 | FieldsAlreadyLoaded = RD->hasLoadedFieldsFromExternalStorage(); | ||||
1309 | |||||
1310 | // Splice the newly-read declarations into the beginning of the list | ||||
1311 | // of declarations. | ||||
1312 | Decl *ExternalFirst, *ExternalLast; | ||||
1313 | std::tie(ExternalFirst, ExternalLast) = | ||||
1314 | BuildDeclChain(Decls, FieldsAlreadyLoaded); | ||||
1315 | ExternalLast->NextInContextAndBits.setPointer(FirstDecl); | ||||
1316 | FirstDecl = ExternalFirst; | ||||
1317 | if (!LastDecl) | ||||
1318 | LastDecl = ExternalLast; | ||||
1319 | return true; | ||||
1320 | } | ||||
1321 | |||||
1322 | DeclContext::lookup_result | ||||
1323 | ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC, | ||||
1324 | DeclarationName Name) { | ||||
1325 | ASTContext &Context = DC->getParentASTContext(); | ||||
1326 | StoredDeclsMap *Map; | ||||
1327 | if (!(Map = DC->LookupPtr)) | ||||
1328 | Map = DC->CreateStoredDeclsMap(Context); | ||||
1329 | if (DC->hasNeedToReconcileExternalVisibleStorage()) | ||||
1330 | DC->reconcileExternalVisibleStorage(); | ||||
1331 | |||||
1332 | (*Map)[Name].removeExternalDecls(); | ||||
1333 | |||||
1334 | return DeclContext::lookup_result(); | ||||
1335 | } | ||||
1336 | |||||
1337 | DeclContext::lookup_result | ||||
1338 | ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC, | ||||
1339 | DeclarationName Name, | ||||
1340 | ArrayRef<NamedDecl*> Decls) { | ||||
1341 | ASTContext &Context = DC->getParentASTContext(); | ||||
1342 | StoredDeclsMap *Map; | ||||
1343 | if (!(Map = DC->LookupPtr)) | ||||
1344 | Map = DC->CreateStoredDeclsMap(Context); | ||||
1345 | if (DC->hasNeedToReconcileExternalVisibleStorage()) | ||||
1346 | DC->reconcileExternalVisibleStorage(); | ||||
1347 | |||||
1348 | StoredDeclsList &List = (*Map)[Name]; | ||||
1349 | |||||
1350 | // Clear out any old external visible declarations, to avoid quadratic | ||||
1351 | // performance in the redeclaration checks below. | ||||
1352 | List.removeExternalDecls(); | ||||
1353 | |||||
1354 | if (!List.isNull()) { | ||||
1355 | // We have both existing declarations and new declarations for this name. | ||||
1356 | // Some of the declarations may simply replace existing ones. Handle those | ||||
1357 | // first. | ||||
1358 | llvm::SmallVector<unsigned, 8> Skip; | ||||
1359 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) | ||||
1360 | if (List.HandleRedeclaration(Decls[I], /*IsKnownNewer*/false)) | ||||
1361 | Skip.push_back(I); | ||||
1362 | Skip.push_back(Decls.size()); | ||||
1363 | |||||
1364 | // Add in any new declarations. | ||||
1365 | unsigned SkipPos = 0; | ||||
1366 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) { | ||||
1367 | if (I == Skip[SkipPos]) | ||||
1368 | ++SkipPos; | ||||
1369 | else | ||||
1370 | List.AddSubsequentDecl(Decls[I]); | ||||
1371 | } | ||||
1372 | } else { | ||||
1373 | // Convert the array to a StoredDeclsList. | ||||
1374 | for (auto *D : Decls) { | ||||
1375 | if (List.isNull()) | ||||
1376 | List.setOnlyValue(D); | ||||
1377 | else | ||||
1378 | List.AddSubsequentDecl(D); | ||||
1379 | } | ||||
1380 | } | ||||
1381 | |||||
1382 | return List.getLookupResult(); | ||||
1383 | } | ||||
1384 | |||||
1385 | DeclContext::decl_iterator DeclContext::decls_begin() const { | ||||
1386 | if (hasExternalLexicalStorage()) | ||||
1387 | LoadLexicalDeclsFromExternalStorage(); | ||||
1388 | return decl_iterator(FirstDecl); | ||||
1389 | } | ||||
1390 | |||||
1391 | bool DeclContext::decls_empty() const { | ||||
1392 | if (hasExternalLexicalStorage()) | ||||
1393 | LoadLexicalDeclsFromExternalStorage(); | ||||
1394 | |||||
1395 | return !FirstDecl; | ||||
1396 | } | ||||
1397 | |||||
1398 | bool DeclContext::containsDecl(Decl *D) const { | ||||
1399 | return (D->getLexicalDeclContext() == this && | ||||
1400 | (D->NextInContextAndBits.getPointer() || D == LastDecl)); | ||||
1401 | } | ||||
1402 | |||||
1403 | bool DeclContext::containsDeclAndLoad(Decl *D) const { | ||||
1404 | if (hasExternalLexicalStorage()) | ||||
1405 | LoadLexicalDeclsFromExternalStorage(); | ||||
1406 | return containsDecl(D); | ||||
1407 | } | ||||
1408 | |||||
1409 | /// shouldBeHidden - Determine whether a declaration which was declared | ||||
1410 | /// within its semantic context should be invisible to qualified name lookup. | ||||
1411 | static bool shouldBeHidden(NamedDecl *D) { | ||||
1412 | // Skip unnamed declarations. | ||||
1413 | if (!D->getDeclName()) | ||||
1414 | return true; | ||||
1415 | |||||
1416 | // Skip entities that can't be found by name lookup into a particular | ||||
1417 | // context. | ||||
1418 | if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) || | ||||
1419 | D->isTemplateParameter()) | ||||
1420 | return true; | ||||
1421 | |||||
1422 | // Skip friends and local extern declarations unless they're the first | ||||
1423 | // declaration of the entity. | ||||
1424 | if ((D->isLocalExternDecl() || D->getFriendObjectKind()) && | ||||
1425 | D != D->getCanonicalDecl()) | ||||
1426 | return true; | ||||
1427 | |||||
1428 | // Skip template specializations. | ||||
1429 | // FIXME: This feels like a hack. Should DeclarationName support | ||||
1430 | // template-ids, or is there a better way to keep specializations | ||||
1431 | // from being visible? | ||||
1432 | if (isa<ClassTemplateSpecializationDecl>(D)) | ||||
1433 | return true; | ||||
1434 | if (auto *FD = dyn_cast<FunctionDecl>(D)) | ||||
1435 | if (FD->isFunctionTemplateSpecialization()) | ||||
1436 | return true; | ||||
1437 | |||||
1438 | return false; | ||||
1439 | } | ||||
1440 | |||||
1441 | void DeclContext::removeDecl(Decl *D) { | ||||
1442 | assert(D->getLexicalDeclContext() == this &&((D->getLexicalDeclContext() == this && "decl being removed from non-lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"decl being removed from non-lexical context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1443, __PRETTY_FUNCTION__)) | ||||
1443 | "decl being removed from non-lexical context")((D->getLexicalDeclContext() == this && "decl being removed from non-lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"decl being removed from non-lexical context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1443, __PRETTY_FUNCTION__)); | ||||
1444 | assert((D->NextInContextAndBits.getPointer() || D == LastDecl) &&(((D->NextInContextAndBits.getPointer() || D == LastDecl) && "decl is not in decls list") ? static_cast<void> (0) : __assert_fail ("(D->NextInContextAndBits.getPointer() || D == LastDecl) && \"decl is not in decls list\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1445, __PRETTY_FUNCTION__)) | ||||
1445 | "decl is not in decls list")(((D->NextInContextAndBits.getPointer() || D == LastDecl) && "decl is not in decls list") ? static_cast<void> (0) : __assert_fail ("(D->NextInContextAndBits.getPointer() || D == LastDecl) && \"decl is not in decls list\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1445, __PRETTY_FUNCTION__)); | ||||
1446 | |||||
1447 | // Remove D from the decl chain. This is O(n) but hopefully rare. | ||||
1448 | if (D == FirstDecl) { | ||||
1449 | if (D == LastDecl) | ||||
1450 | FirstDecl = LastDecl = nullptr; | ||||
1451 | else | ||||
1452 | FirstDecl = D->NextInContextAndBits.getPointer(); | ||||
1453 | } else { | ||||
1454 | for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) { | ||||
1455 | assert(I && "decl not found in linked list")((I && "decl not found in linked list") ? static_cast <void> (0) : __assert_fail ("I && \"decl not found in linked list\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1455, __PRETTY_FUNCTION__)); | ||||
1456 | if (I->NextInContextAndBits.getPointer() == D) { | ||||
1457 | I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer()); | ||||
1458 | if (D == LastDecl) LastDecl = I; | ||||
1459 | break; | ||||
1460 | } | ||||
1461 | } | ||||
1462 | } | ||||
1463 | |||||
1464 | // Mark that D is no longer in the decl chain. | ||||
1465 | D->NextInContextAndBits.setPointer(nullptr); | ||||
1466 | |||||
1467 | // Remove D from the lookup table if necessary. | ||||
1468 | if (isa<NamedDecl>(D)) { | ||||
1469 | auto *ND = cast<NamedDecl>(D); | ||||
1470 | |||||
1471 | // Do not try to remove the declaration if that is invisible to qualified | ||||
1472 | // lookup. E.g. template specializations are skipped. | ||||
1473 | if (shouldBeHidden(ND)) | ||||
1474 | return; | ||||
1475 | |||||
1476 | // Remove only decls that have a name | ||||
1477 | if (!ND->getDeclName()) | ||||
1478 | return; | ||||
1479 | |||||
1480 | auto *DC = D->getDeclContext(); | ||||
1481 | do { | ||||
1482 | StoredDeclsMap *Map = DC->getPrimaryContext()->LookupPtr; | ||||
1483 | if (Map) { | ||||
1484 | StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName()); | ||||
1485 | assert(Pos != Map->end() && "no lookup entry for decl")((Pos != Map->end() && "no lookup entry for decl") ? static_cast<void> (0) : __assert_fail ("Pos != Map->end() && \"no lookup entry for decl\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1485, __PRETTY_FUNCTION__)); | ||||
1486 | // Remove the decl only if it is contained. | ||||
1487 | StoredDeclsList::DeclsTy *Vec = Pos->second.getAsVector(); | ||||
1488 | if ((Vec && is_contained(*Vec, ND)) || Pos->second.getAsDecl() == ND) | ||||
1489 | Pos->second.remove(ND); | ||||
1490 | } | ||||
1491 | } while (DC->isTransparentContext() && (DC = DC->getParent())); | ||||
1492 | } | ||||
1493 | } | ||||
1494 | |||||
1495 | void DeclContext::addHiddenDecl(Decl *D) { | ||||
1496 | assert(D->getLexicalDeclContext() == this &&((D->getLexicalDeclContext() == this && "Decl inserted into wrong lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"Decl inserted into wrong lexical context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1497, __PRETTY_FUNCTION__)) | ||||
1497 | "Decl inserted into wrong lexical context")((D->getLexicalDeclContext() == this && "Decl inserted into wrong lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"Decl inserted into wrong lexical context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1497, __PRETTY_FUNCTION__)); | ||||
1498 | assert(!D->getNextDeclInContext() && D != LastDecl &&((!D->getNextDeclInContext() && D != LastDecl && "Decl already inserted into a DeclContext") ? static_cast< void> (0) : __assert_fail ("!D->getNextDeclInContext() && D != LastDecl && \"Decl already inserted into a DeclContext\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1499, __PRETTY_FUNCTION__)) | ||||
1499 | "Decl already inserted into a DeclContext")((!D->getNextDeclInContext() && D != LastDecl && "Decl already inserted into a DeclContext") ? static_cast< void> (0) : __assert_fail ("!D->getNextDeclInContext() && D != LastDecl && \"Decl already inserted into a DeclContext\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1499, __PRETTY_FUNCTION__)); | ||||
1500 | |||||
1501 | if (FirstDecl) { | ||||
1502 | LastDecl->NextInContextAndBits.setPointer(D); | ||||
1503 | LastDecl = D; | ||||
1504 | } else { | ||||
1505 | FirstDecl = LastDecl = D; | ||||
1506 | } | ||||
1507 | |||||
1508 | // Notify a C++ record declaration that we've added a member, so it can | ||||
1509 | // update its class-specific state. | ||||
1510 | if (auto *Record = dyn_cast<CXXRecordDecl>(this)) | ||||
1511 | Record->addedMember(D); | ||||
1512 | |||||
1513 | // If this is a newly-created (not de-serialized) import declaration, wire | ||||
1514 | // it in to the list of local import declarations. | ||||
1515 | if (!D->isFromASTFile()) { | ||||
1516 | if (auto *Import = dyn_cast<ImportDecl>(D)) | ||||
1517 | D->getASTContext().addedLocalImportDecl(Import); | ||||
1518 | } | ||||
1519 | } | ||||
1520 | |||||
1521 | void DeclContext::addDecl(Decl *D) { | ||||
1522 | addHiddenDecl(D); | ||||
1523 | |||||
1524 | if (auto *ND = dyn_cast<NamedDecl>(D)) | ||||
1525 | ND->getDeclContext()->getPrimaryContext()-> | ||||
1526 | makeDeclVisibleInContextWithFlags(ND, false, true); | ||||
1527 | } | ||||
1528 | |||||
1529 | void DeclContext::addDeclInternal(Decl *D) { | ||||
1530 | addHiddenDecl(D); | ||||
1531 | |||||
1532 | if (auto *ND = dyn_cast<NamedDecl>(D)) | ||||
1533 | ND->getDeclContext()->getPrimaryContext()-> | ||||
1534 | makeDeclVisibleInContextWithFlags(ND, true, true); | ||||
1535 | } | ||||
1536 | |||||
1537 | /// buildLookup - Build the lookup data structure with all of the | ||||
1538 | /// declarations in this DeclContext (and any other contexts linked | ||||
1539 | /// to it or transparent contexts nested within it) and return it. | ||||
1540 | /// | ||||
1541 | /// Note that the produced map may miss out declarations from an | ||||
1542 | /// external source. If it does, those entries will be marked with | ||||
1543 | /// the 'hasExternalDecls' flag. | ||||
1544 | StoredDeclsMap *DeclContext::buildLookup() { | ||||
1545 | assert(this == getPrimaryContext() && "buildLookup called on non-primary DC")((this == getPrimaryContext() && "buildLookup called on non-primary DC" ) ? static_cast<void> (0) : __assert_fail ("this == getPrimaryContext() && \"buildLookup called on non-primary DC\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1545, __PRETTY_FUNCTION__)); | ||||
1546 | |||||
1547 | if (!hasLazyLocalLexicalLookups() && | ||||
1548 | !hasLazyExternalLexicalLookups()) | ||||
1549 | return LookupPtr; | ||||
1550 | |||||
1551 | SmallVector<DeclContext *, 2> Contexts; | ||||
1552 | collectAllContexts(Contexts); | ||||
1553 | |||||
1554 | if (hasLazyExternalLexicalLookups()) { | ||||
1555 | setHasLazyExternalLexicalLookups(false); | ||||
1556 | for (auto *DC : Contexts) { | ||||
1557 | if (DC->hasExternalLexicalStorage()) { | ||||
1558 | bool LoadedDecls = DC->LoadLexicalDeclsFromExternalStorage(); | ||||
1559 | setHasLazyLocalLexicalLookups( | ||||
1560 | hasLazyLocalLexicalLookups() | LoadedDecls ); | ||||
1561 | } | ||||
1562 | } | ||||
1563 | |||||
1564 | if (!hasLazyLocalLexicalLookups()) | ||||
1565 | return LookupPtr; | ||||
1566 | } | ||||
1567 | |||||
1568 | for (auto *DC : Contexts) | ||||
1569 | buildLookupImpl(DC, hasExternalVisibleStorage()); | ||||
1570 | |||||
1571 | // We no longer have any lazy decls. | ||||
1572 | setHasLazyLocalLexicalLookups(false); | ||||
1573 | return LookupPtr; | ||||
1574 | } | ||||
1575 | |||||
1576 | /// buildLookupImpl - Build part of the lookup data structure for the | ||||
1577 | /// declarations contained within DCtx, which will either be this | ||||
1578 | /// DeclContext, a DeclContext linked to it, or a transparent context | ||||
1579 | /// nested within it. | ||||
1580 | void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) { | ||||
1581 | for (auto *D : DCtx->noload_decls()) { | ||||
1582 | // Insert this declaration into the lookup structure, but only if | ||||
1583 | // it's semantically within its decl context. Any other decls which | ||||
1584 | // should be found in this context are added eagerly. | ||||
1585 | // | ||||
1586 | // If it's from an AST file, don't add it now. It'll get handled by | ||||
1587 | // FindExternalVisibleDeclsByName if needed. Exception: if we're not | ||||
1588 | // in C++, we do not track external visible decls for the TU, so in | ||||
1589 | // that case we need to collect them all here. | ||||
1590 | if (auto *ND = dyn_cast<NamedDecl>(D)) | ||||
1591 | if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) && | ||||
1592 | (!ND->isFromASTFile() || | ||||
1593 | (isTranslationUnit() && | ||||
1594 | !getParentASTContext().getLangOpts().CPlusPlus))) | ||||
1595 | makeDeclVisibleInContextImpl(ND, Internal); | ||||
1596 | |||||
1597 | // If this declaration is itself a transparent declaration context | ||||
1598 | // or inline namespace, add the members of this declaration of that | ||||
1599 | // context (recursively). | ||||
1600 | if (auto *InnerCtx = dyn_cast<DeclContext>(D)) | ||||
1601 | if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace()) | ||||
1602 | buildLookupImpl(InnerCtx, Internal); | ||||
1603 | } | ||||
1604 | } | ||||
1605 | |||||
1606 | NamedDecl *const DeclContextLookupResult::SingleElementDummyList = nullptr; | ||||
1607 | |||||
1608 | DeclContext::lookup_result | ||||
1609 | DeclContext::lookup(DeclarationName Name) const { | ||||
1610 | assert(getDeclKind() != Decl::LinkageSpec &&((getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && "should not perform lookups into transparent contexts" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && \"should not perform lookups into transparent contexts\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1612, __PRETTY_FUNCTION__)) | ||||
1611 | getDeclKind() != Decl::Export &&((getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && "should not perform lookups into transparent contexts" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && \"should not perform lookups into transparent contexts\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1612, __PRETTY_FUNCTION__)) | ||||
1612 | "should not perform lookups into transparent contexts")((getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && "should not perform lookups into transparent contexts" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && \"should not perform lookups into transparent contexts\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1612, __PRETTY_FUNCTION__)); | ||||
1613 | |||||
1614 | const DeclContext *PrimaryContext = getPrimaryContext(); | ||||
1615 | if (PrimaryContext != this) | ||||
1616 | return PrimaryContext->lookup(Name); | ||||
1617 | |||||
1618 | // If we have an external source, ensure that any later redeclarations of this | ||||
1619 | // context have been loaded, since they may add names to the result of this | ||||
1620 | // lookup (or add external visible storage). | ||||
1621 | ExternalASTSource *Source = getParentASTContext().getExternalSource(); | ||||
1622 | if (Source) | ||||
1623 | (void)cast<Decl>(this)->getMostRecentDecl(); | ||||
1624 | |||||
1625 | if (hasExternalVisibleStorage()) { | ||||
1626 | assert(Source && "external visible storage but no external source?")((Source && "external visible storage but no external source?" ) ? static_cast<void> (0) : __assert_fail ("Source && \"external visible storage but no external source?\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1626, __PRETTY_FUNCTION__)); | ||||
1627 | |||||
1628 | if (hasNeedToReconcileExternalVisibleStorage()) | ||||
1629 | reconcileExternalVisibleStorage(); | ||||
1630 | |||||
1631 | StoredDeclsMap *Map = LookupPtr; | ||||
1632 | |||||
1633 | if (hasLazyLocalLexicalLookups() || | ||||
1634 | hasLazyExternalLexicalLookups()) | ||||
1635 | // FIXME: Make buildLookup const? | ||||
1636 | Map = const_cast<DeclContext*>(this)->buildLookup(); | ||||
1637 | |||||
1638 | if (!Map) | ||||
1639 | Map = CreateStoredDeclsMap(getParentASTContext()); | ||||
1640 | |||||
1641 | // If we have a lookup result with no external decls, we are done. | ||||
1642 | std::pair<StoredDeclsMap::iterator, bool> R = | ||||
1643 | Map->insert(std::make_pair(Name, StoredDeclsList())); | ||||
1644 | if (!R.second && !R.first->second.hasExternalDecls()) | ||||
1645 | return R.first->second.getLookupResult(); | ||||
1646 | |||||
1647 | if (Source->FindExternalVisibleDeclsByName(this, Name) || !R.second) { | ||||
1648 | if (StoredDeclsMap *Map = LookupPtr) { | ||||
1649 | StoredDeclsMap::iterator I = Map->find(Name); | ||||
1650 | if (I != Map->end()) | ||||
1651 | return I->second.getLookupResult(); | ||||
1652 | } | ||||
1653 | } | ||||
1654 | |||||
1655 | return {}; | ||||
1656 | } | ||||
1657 | |||||
1658 | StoredDeclsMap *Map = LookupPtr; | ||||
1659 | if (hasLazyLocalLexicalLookups() || | ||||
1660 | hasLazyExternalLexicalLookups()) | ||||
1661 | Map = const_cast<DeclContext*>(this)->buildLookup(); | ||||
1662 | |||||
1663 | if (!Map) | ||||
1664 | return {}; | ||||
1665 | |||||
1666 | StoredDeclsMap::iterator I = Map->find(Name); | ||||
1667 | if (I == Map->end()) | ||||
1668 | return {}; | ||||
1669 | |||||
1670 | return I->second.getLookupResult(); | ||||
1671 | } | ||||
1672 | |||||
1673 | DeclContext::lookup_result | ||||
1674 | DeclContext::noload_lookup(DeclarationName Name) { | ||||
1675 | assert(getDeclKind() != Decl::LinkageSpec &&((getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && "should not perform lookups into transparent contexts" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && \"should not perform lookups into transparent contexts\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1677, __PRETTY_FUNCTION__)) | ||||
1676 | getDeclKind() != Decl::Export &&((getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && "should not perform lookups into transparent contexts" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && \"should not perform lookups into transparent contexts\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1677, __PRETTY_FUNCTION__)) | ||||
1677 | "should not perform lookups into transparent contexts")((getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && "should not perform lookups into transparent contexts" ) ? static_cast<void> (0) : __assert_fail ("getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export && \"should not perform lookups into transparent contexts\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1677, __PRETTY_FUNCTION__)); | ||||
1678 | |||||
1679 | DeclContext *PrimaryContext = getPrimaryContext(); | ||||
1680 | if (PrimaryContext != this) | ||||
1681 | return PrimaryContext->noload_lookup(Name); | ||||
1682 | |||||
1683 | loadLazyLocalLexicalLookups(); | ||||
1684 | StoredDeclsMap *Map = LookupPtr; | ||||
1685 | if (!Map) | ||||
1686 | return {}; | ||||
1687 | |||||
1688 | StoredDeclsMap::iterator I = Map->find(Name); | ||||
1689 | return I != Map->end() ? I->second.getLookupResult() | ||||
1690 | : lookup_result(); | ||||
1691 | } | ||||
1692 | |||||
1693 | // If we have any lazy lexical declarations not in our lookup map, add them | ||||
1694 | // now. Don't import any external declarations, not even if we know we have | ||||
1695 | // some missing from the external visible lookups. | ||||
1696 | void DeclContext::loadLazyLocalLexicalLookups() { | ||||
1697 | if (hasLazyLocalLexicalLookups()) { | ||||
1698 | SmallVector<DeclContext *, 2> Contexts; | ||||
1699 | collectAllContexts(Contexts); | ||||
1700 | for (auto *Context : Contexts) | ||||
1701 | buildLookupImpl(Context, hasExternalVisibleStorage()); | ||||
1702 | setHasLazyLocalLexicalLookups(false); | ||||
1703 | } | ||||
1704 | } | ||||
1705 | |||||
1706 | void DeclContext::localUncachedLookup(DeclarationName Name, | ||||
1707 | SmallVectorImpl<NamedDecl *> &Results) { | ||||
1708 | Results.clear(); | ||||
1709 | |||||
1710 | // If there's no external storage, just perform a normal lookup and copy | ||||
1711 | // the results. | ||||
1712 | if (!hasExternalVisibleStorage() && !hasExternalLexicalStorage() && Name) { | ||||
1713 | lookup_result LookupResults = lookup(Name); | ||||
1714 | Results.insert(Results.end(), LookupResults.begin(), LookupResults.end()); | ||||
1715 | return; | ||||
1716 | } | ||||
1717 | |||||
1718 | // If we have a lookup table, check there first. Maybe we'll get lucky. | ||||
1719 | // FIXME: Should we be checking these flags on the primary context? | ||||
1720 | if (Name && !hasLazyLocalLexicalLookups() && | ||||
1721 | !hasLazyExternalLexicalLookups()) { | ||||
1722 | if (StoredDeclsMap *Map = LookupPtr) { | ||||
1723 | StoredDeclsMap::iterator Pos = Map->find(Name); | ||||
1724 | if (Pos != Map->end()) { | ||||
1725 | Results.insert(Results.end(), | ||||
1726 | Pos->second.getLookupResult().begin(), | ||||
1727 | Pos->second.getLookupResult().end()); | ||||
1728 | return; | ||||
1729 | } | ||||
1730 | } | ||||
1731 | } | ||||
1732 | |||||
1733 | // Slow case: grovel through the declarations in our chain looking for | ||||
1734 | // matches. | ||||
1735 | // FIXME: If we have lazy external declarations, this will not find them! | ||||
1736 | // FIXME: Should we CollectAllContexts and walk them all here? | ||||
1737 | for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) { | ||||
1738 | if (auto *ND = dyn_cast<NamedDecl>(D)) | ||||
1739 | if (ND->getDeclName() == Name) | ||||
1740 | Results.push_back(ND); | ||||
1741 | } | ||||
1742 | } | ||||
1743 | |||||
1744 | DeclContext *DeclContext::getRedeclContext() { | ||||
1745 | DeclContext *Ctx = this; | ||||
1746 | |||||
1747 | // In C, a record type is the redeclaration context for its fields only. If | ||||
1748 | // we arrive at a record context after skipping anything else, we should skip | ||||
1749 | // the record as well. Currently, this means skipping enumerations because | ||||
1750 | // they're the only transparent context that can exist within a struct or | ||||
1751 | // union. | ||||
1752 | bool SkipRecords = getDeclKind() == Decl::Kind::Enum && | ||||
1753 | !getParentASTContext().getLangOpts().CPlusPlus; | ||||
1754 | |||||
1755 | // Skip through contexts to get to the redeclaration context. Transparent | ||||
1756 | // contexts are always skipped. | ||||
1757 | while ((SkipRecords && Ctx->isRecord()) || Ctx->isTransparentContext()) | ||||
1758 | Ctx = Ctx->getParent(); | ||||
1759 | return Ctx; | ||||
1760 | } | ||||
1761 | |||||
1762 | DeclContext *DeclContext::getEnclosingNamespaceContext() { | ||||
1763 | DeclContext *Ctx = this; | ||||
1764 | // Skip through non-namespace, non-translation-unit contexts. | ||||
1765 | while (!Ctx->isFileContext()) | ||||
1766 | Ctx = Ctx->getParent(); | ||||
1767 | return Ctx->getPrimaryContext(); | ||||
1768 | } | ||||
1769 | |||||
1770 | RecordDecl *DeclContext::getOuterLexicalRecordContext() { | ||||
1771 | // Loop until we find a non-record context. | ||||
1772 | RecordDecl *OutermostRD = nullptr; | ||||
1773 | DeclContext *DC = this; | ||||
1774 | while (DC->isRecord()) { | ||||
1775 | OutermostRD = cast<RecordDecl>(DC); | ||||
1776 | DC = DC->getLexicalParent(); | ||||
1777 | } | ||||
1778 | return OutermostRD; | ||||
1779 | } | ||||
1780 | |||||
1781 | bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const { | ||||
1782 | // For non-file contexts, this is equivalent to Equals. | ||||
1783 | if (!isFileContext()) | ||||
1784 | return O->Equals(this); | ||||
1785 | |||||
1786 | do { | ||||
1787 | if (O->Equals(this)) | ||||
1788 | return true; | ||||
1789 | |||||
1790 | const auto *NS = dyn_cast<NamespaceDecl>(O); | ||||
1791 | if (!NS || !NS->isInline()) | ||||
1792 | break; | ||||
1793 | O = NS->getParent(); | ||||
1794 | } while (O); | ||||
1795 | |||||
1796 | return false; | ||||
1797 | } | ||||
1798 | |||||
1799 | void DeclContext::makeDeclVisibleInContext(NamedDecl *D) { | ||||
1800 | DeclContext *PrimaryDC = this->getPrimaryContext(); | ||||
1801 | DeclContext *DeclDC = D->getDeclContext()->getPrimaryContext(); | ||||
1802 | // If the decl is being added outside of its semantic decl context, we | ||||
1803 | // need to ensure that we eagerly build the lookup information for it. | ||||
1804 | PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC); | ||||
1805 | } | ||||
1806 | |||||
1807 | void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal, | ||||
1808 | bool Recoverable) { | ||||
1809 | assert(this == getPrimaryContext() && "expected a primary DC")((this == getPrimaryContext() && "expected a primary DC" ) ? static_cast<void> (0) : __assert_fail ("this == getPrimaryContext() && \"expected a primary DC\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1809, __PRETTY_FUNCTION__)); | ||||
1810 | |||||
1811 | if (!isLookupContext()) { | ||||
1812 | if (isTransparentContext()) | ||||
1813 | getParent()->getPrimaryContext() | ||||
1814 | ->makeDeclVisibleInContextWithFlags(D, Internal, Recoverable); | ||||
1815 | return; | ||||
1816 | } | ||||
1817 | |||||
1818 | // Skip declarations which should be invisible to name lookup. | ||||
1819 | if (shouldBeHidden(D)) | ||||
1820 | return; | ||||
1821 | |||||
1822 | // If we already have a lookup data structure, perform the insertion into | ||||
1823 | // it. If we might have externally-stored decls with this name, look them | ||||
1824 | // up and perform the insertion. If this decl was declared outside its | ||||
1825 | // semantic context, buildLookup won't add it, so add it now. | ||||
1826 | // | ||||
1827 | // FIXME: As a performance hack, don't add such decls into the translation | ||||
1828 | // unit unless we're in C++, since qualified lookup into the TU is never | ||||
1829 | // performed. | ||||
1830 | if (LookupPtr || hasExternalVisibleStorage() || | ||||
1831 | ((!Recoverable || D->getDeclContext() != D->getLexicalDeclContext()) && | ||||
1832 | (getParentASTContext().getLangOpts().CPlusPlus || | ||||
1833 | !isTranslationUnit()))) { | ||||
1834 | // If we have lazily omitted any decls, they might have the same name as | ||||
1835 | // the decl which we are adding, so build a full lookup table before adding | ||||
1836 | // this decl. | ||||
1837 | buildLookup(); | ||||
1838 | makeDeclVisibleInContextImpl(D, Internal); | ||||
1839 | } else { | ||||
1840 | setHasLazyLocalLexicalLookups(true); | ||||
1841 | } | ||||
1842 | |||||
1843 | // If we are a transparent context or inline namespace, insert into our | ||||
1844 | // parent context, too. This operation is recursive. | ||||
1845 | if (isTransparentContext() || isInlineNamespace()) | ||||
1846 | getParent()->getPrimaryContext()-> | ||||
1847 | makeDeclVisibleInContextWithFlags(D, Internal, Recoverable); | ||||
1848 | |||||
1849 | auto *DCAsDecl = cast<Decl>(this); | ||||
1850 | // Notify that a decl was made visible unless we are a Tag being defined. | ||||
1851 | if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined())) | ||||
1852 | if (ASTMutationListener *L = DCAsDecl->getASTMutationListener()) | ||||
1853 | L->AddedVisibleDecl(this, D); | ||||
1854 | } | ||||
1855 | |||||
1856 | void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) { | ||||
1857 | // Find or create the stored declaration map. | ||||
1858 | StoredDeclsMap *Map = LookupPtr; | ||||
1859 | if (!Map) { | ||||
1860 | ASTContext *C = &getParentASTContext(); | ||||
1861 | Map = CreateStoredDeclsMap(*C); | ||||
1862 | } | ||||
1863 | |||||
1864 | // If there is an external AST source, load any declarations it knows about | ||||
1865 | // with this declaration's name. | ||||
1866 | // If the lookup table contains an entry about this name it means that we | ||||
1867 | // have already checked the external source. | ||||
1868 | if (!Internal) | ||||
1869 | if (ExternalASTSource *Source = getParentASTContext().getExternalSource()) | ||||
1870 | if (hasExternalVisibleStorage() && | ||||
1871 | Map->find(D->getDeclName()) == Map->end()) | ||||
1872 | Source->FindExternalVisibleDeclsByName(this, D->getDeclName()); | ||||
1873 | |||||
1874 | // Insert this declaration into the map. | ||||
1875 | StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()]; | ||||
1876 | |||||
1877 | if (Internal) { | ||||
1878 | // If this is being added as part of loading an external declaration, | ||||
1879 | // this may not be the only external declaration with this name. | ||||
1880 | // In this case, we never try to replace an existing declaration; we'll | ||||
1881 | // handle that when we finalize the list of declarations for this name. | ||||
1882 | DeclNameEntries.setHasExternalDecls(); | ||||
1883 | DeclNameEntries.AddSubsequentDecl(D); | ||||
1884 | return; | ||||
1885 | } | ||||
1886 | |||||
1887 | if (DeclNameEntries.isNull()) { | ||||
1888 | DeclNameEntries.setOnlyValue(D); | ||||
1889 | return; | ||||
1890 | } | ||||
1891 | |||||
1892 | if (DeclNameEntries.HandleRedeclaration(D, /*IsKnownNewer*/!Internal)) { | ||||
1893 | // This declaration has replaced an existing one for which | ||||
1894 | // declarationReplaces returns true. | ||||
1895 | return; | ||||
1896 | } | ||||
1897 | |||||
1898 | // Put this declaration into the appropriate slot. | ||||
1899 | DeclNameEntries.AddSubsequentDecl(D); | ||||
1900 | } | ||||
1901 | |||||
1902 | UsingDirectiveDecl *DeclContext::udir_iterator::operator*() const { | ||||
1903 | return cast<UsingDirectiveDecl>(*I); | ||||
1904 | } | ||||
1905 | |||||
1906 | /// Returns iterator range [First, Last) of UsingDirectiveDecls stored within | ||||
1907 | /// this context. | ||||
1908 | DeclContext::udir_range DeclContext::using_directives() const { | ||||
1909 | // FIXME: Use something more efficient than normal lookup for using | ||||
1910 | // directives. In C++, using directives are looked up more than anything else. | ||||
1911 | lookup_result Result = lookup(UsingDirectiveDecl::getName()); | ||||
1912 | return udir_range(Result.begin(), Result.end()); | ||||
1913 | } | ||||
1914 | |||||
1915 | //===----------------------------------------------------------------------===// | ||||
1916 | // Creation and Destruction of StoredDeclsMaps. // | ||||
1917 | //===----------------------------------------------------------------------===// | ||||
1918 | |||||
1919 | StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const { | ||||
1920 | assert(!LookupPtr && "context already has a decls map")((!LookupPtr && "context already has a decls map") ? static_cast <void> (0) : __assert_fail ("!LookupPtr && \"context already has a decls map\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1920, __PRETTY_FUNCTION__)); | ||||
1921 | assert(getPrimaryContext() == this &&((getPrimaryContext() == this && "creating decls map on non-primary context" ) ? static_cast<void> (0) : __assert_fail ("getPrimaryContext() == this && \"creating decls map on non-primary context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1922, __PRETTY_FUNCTION__)) | ||||
1922 | "creating decls map on non-primary context")((getPrimaryContext() == this && "creating decls map on non-primary context" ) ? static_cast<void> (0) : __assert_fail ("getPrimaryContext() == this && \"creating decls map on non-primary context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1922, __PRETTY_FUNCTION__)); | ||||
1923 | |||||
1924 | StoredDeclsMap *M; | ||||
1925 | bool Dependent = isDependentContext(); | ||||
1926 | if (Dependent) | ||||
1927 | M = new DependentStoredDeclsMap(); | ||||
1928 | else | ||||
1929 | M = new StoredDeclsMap(); | ||||
1930 | M->Previous = C.LastSDM; | ||||
1931 | C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent); | ||||
1932 | LookupPtr = M; | ||||
1933 | return M; | ||||
1934 | } | ||||
1935 | |||||
1936 | void ASTContext::ReleaseDeclContextMaps() { | ||||
1937 | // It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap | ||||
1938 | // pointer because the subclass doesn't add anything that needs to | ||||
1939 | // be deleted. | ||||
1940 | StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt()); | ||||
1941 | } | ||||
1942 | |||||
1943 | void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) { | ||||
1944 | while (Map) { | ||||
1945 | // Advance the iteration before we invalidate memory. | ||||
1946 | llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous; | ||||
1947 | |||||
1948 | if (Dependent) | ||||
1949 | delete static_cast<DependentStoredDeclsMap*>(Map); | ||||
1950 | else | ||||
1951 | delete Map; | ||||
1952 | |||||
1953 | Map = Next.getPointer(); | ||||
1954 | Dependent = Next.getInt(); | ||||
1955 | } | ||||
1956 | } | ||||
1957 | |||||
1958 | DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C, | ||||
1959 | DeclContext *Parent, | ||||
1960 | const PartialDiagnostic &PDiag) { | ||||
1961 | assert(Parent->isDependentContext()((Parent->isDependentContext() && "cannot iterate dependent diagnostics of non-dependent context" ) ? static_cast<void> (0) : __assert_fail ("Parent->isDependentContext() && \"cannot iterate dependent diagnostics of non-dependent context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1962, __PRETTY_FUNCTION__)) | ||||
1962 | && "cannot iterate dependent diagnostics of non-dependent context")((Parent->isDependentContext() && "cannot iterate dependent diagnostics of non-dependent context" ) ? static_cast<void> (0) : __assert_fail ("Parent->isDependentContext() && \"cannot iterate dependent diagnostics of non-dependent context\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/DeclBase.cpp" , 1962, __PRETTY_FUNCTION__)); | ||||
1963 | Parent = Parent->getPrimaryContext(); | ||||
1964 | if (!Parent->LookupPtr) | ||||
1965 | Parent->CreateStoredDeclsMap(C); | ||||
1966 | |||||
1967 | auto *Map = static_cast<DependentStoredDeclsMap *>(Parent->LookupPtr); | ||||
1968 | |||||
1969 | // Allocate the copy of the PartialDiagnostic via the ASTContext's | ||||
1970 | // BumpPtrAllocator, rather than the ASTContext itself. | ||||
1971 | PartialDiagnostic::Storage *DiagStorage = nullptr; | ||||
1972 | if (PDiag.hasStorage()) | ||||
1973 | DiagStorage = new (C) PartialDiagnostic::Storage; | ||||
1974 | |||||
1975 | auto *DD = new (C) DependentDiagnostic(PDiag, DiagStorage); | ||||
1976 | |||||
1977 | // TODO: Maybe we shouldn't reverse the order during insertion. | ||||
1978 | DD->NextDiagnostic = Map->FirstDiagnostic; | ||||
1979 | Map->FirstDiagnostic = DD; | ||||
1980 | |||||
1981 | return DD; | ||||
1982 | } |
1 | //===- Type.h - C Language Family Type Representation -----------*- C++ -*-===// | ||||
2 | // | ||||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||||
4 | // See https://llvm.org/LICENSE.txt for license information. | ||||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||||
6 | // | ||||
7 | //===----------------------------------------------------------------------===// | ||||
8 | // | ||||
9 | /// \file | ||||
10 | /// C Language Family Type Representation | ||||
11 | /// | ||||
12 | /// This file defines the clang::Type interface and subclasses, used to | ||||
13 | /// represent types for languages in the C family. | ||||
14 | // | ||||
15 | //===----------------------------------------------------------------------===// | ||||
16 | |||||
17 | #ifndef LLVM_CLANG_AST_TYPE_H | ||||
18 | #define LLVM_CLANG_AST_TYPE_H | ||||
19 | |||||
20 | #include "clang/AST/NestedNameSpecifier.h" | ||||
21 | #include "clang/AST/TemplateName.h" | ||||
22 | #include "clang/Basic/AddressSpaces.h" | ||||
23 | #include "clang/Basic/AttrKinds.h" | ||||
24 | #include "clang/Basic/Diagnostic.h" | ||||
25 | #include "clang/Basic/ExceptionSpecificationType.h" | ||||
26 | #include "clang/Basic/LLVM.h" | ||||
27 | #include "clang/Basic/Linkage.h" | ||||
28 | #include "clang/Basic/PartialDiagnostic.h" | ||||
29 | #include "clang/Basic/SourceLocation.h" | ||||
30 | #include "clang/Basic/Specifiers.h" | ||||
31 | #include "clang/Basic/Visibility.h" | ||||
32 | #include "llvm/ADT/APInt.h" | ||||
33 | #include "llvm/ADT/APSInt.h" | ||||
34 | #include "llvm/ADT/ArrayRef.h" | ||||
35 | #include "llvm/ADT/FoldingSet.h" | ||||
36 | #include "llvm/ADT/None.h" | ||||
37 | #include "llvm/ADT/Optional.h" | ||||
38 | #include "llvm/ADT/PointerIntPair.h" | ||||
39 | #include "llvm/ADT/PointerUnion.h" | ||||
40 | #include "llvm/ADT/StringRef.h" | ||||
41 | #include "llvm/ADT/Twine.h" | ||||
42 | #include "llvm/ADT/iterator_range.h" | ||||
43 | #include "llvm/Support/Casting.h" | ||||
44 | #include "llvm/Support/Compiler.h" | ||||
45 | #include "llvm/Support/ErrorHandling.h" | ||||
46 | #include "llvm/Support/PointerLikeTypeTraits.h" | ||||
47 | #include "llvm/Support/type_traits.h" | ||||
48 | #include "llvm/Support/TrailingObjects.h" | ||||
49 | #include <cassert> | ||||
50 | #include <cstddef> | ||||
51 | #include <cstdint> | ||||
52 | #include <cstring> | ||||
53 | #include <string> | ||||
54 | #include <type_traits> | ||||
55 | #include <utility> | ||||
56 | |||||
57 | namespace clang { | ||||
58 | |||||
59 | class ExtQuals; | ||||
60 | class QualType; | ||||
61 | class TagDecl; | ||||
62 | class Type; | ||||
63 | |||||
64 | enum { | ||||
65 | TypeAlignmentInBits = 4, | ||||
66 | TypeAlignment = 1 << TypeAlignmentInBits | ||||
67 | }; | ||||
68 | |||||
69 | } // namespace clang | ||||
70 | |||||
71 | namespace llvm { | ||||
72 | |||||
73 | template <typename T> | ||||
74 | struct PointerLikeTypeTraits; | ||||
75 | template<> | ||||
76 | struct PointerLikeTypeTraits< ::clang::Type*> { | ||||
77 | static inline void *getAsVoidPointer(::clang::Type *P) { return P; } | ||||
78 | |||||
79 | static inline ::clang::Type *getFromVoidPointer(void *P) { | ||||
80 | return static_cast< ::clang::Type*>(P); | ||||
81 | } | ||||
82 | |||||
83 | enum { NumLowBitsAvailable = clang::TypeAlignmentInBits }; | ||||
84 | }; | ||||
85 | |||||
86 | template<> | ||||
87 | struct PointerLikeTypeTraits< ::clang::ExtQuals*> { | ||||
88 | static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; } | ||||
89 | |||||
90 | static inline ::clang::ExtQuals *getFromVoidPointer(void *P) { | ||||
91 | return static_cast< ::clang::ExtQuals*>(P); | ||||
92 | } | ||||
93 | |||||
94 | enum { NumLowBitsAvailable = clang::TypeAlignmentInBits }; | ||||
95 | }; | ||||
96 | |||||
97 | } // namespace llvm | ||||
98 | |||||
99 | namespace clang { | ||||
100 | |||||
101 | class ASTContext; | ||||
102 | template <typename> class CanQual; | ||||
103 | class CXXRecordDecl; | ||||
104 | class DeclContext; | ||||
105 | class EnumDecl; | ||||
106 | class Expr; | ||||
107 | class ExtQualsTypeCommonBase; | ||||
108 | class FunctionDecl; | ||||
109 | class IdentifierInfo; | ||||
110 | class NamedDecl; | ||||
111 | class ObjCInterfaceDecl; | ||||
112 | class ObjCProtocolDecl; | ||||
113 | class ObjCTypeParamDecl; | ||||
114 | struct PrintingPolicy; | ||||
115 | class RecordDecl; | ||||
116 | class Stmt; | ||||
117 | class TagDecl; | ||||
118 | class TemplateArgument; | ||||
119 | class TemplateArgumentListInfo; | ||||
120 | class TemplateArgumentLoc; | ||||
121 | class TemplateTypeParmDecl; | ||||
122 | class TypedefNameDecl; | ||||
123 | class UnresolvedUsingTypenameDecl; | ||||
124 | |||||
125 | using CanQualType = CanQual<Type>; | ||||
126 | |||||
127 | // Provide forward declarations for all of the *Type classes. | ||||
128 | #define TYPE(Class, Base) class Class##Type; | ||||
129 | #include "clang/AST/TypeNodes.inc" | ||||
130 | |||||
131 | /// The collection of all-type qualifiers we support. | ||||
132 | /// Clang supports five independent qualifiers: | ||||
133 | /// * C99: const, volatile, and restrict | ||||
134 | /// * MS: __unaligned | ||||
135 | /// * Embedded C (TR18037): address spaces | ||||
136 | /// * Objective C: the GC attributes (none, weak, or strong) | ||||
137 | class Qualifiers { | ||||
138 | public: | ||||
139 | enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ. | ||||
140 | Const = 0x1, | ||||
141 | Restrict = 0x2, | ||||
142 | Volatile = 0x4, | ||||
143 | CVRMask = Const | Volatile | Restrict | ||||
144 | }; | ||||
145 | |||||
146 | enum GC { | ||||
147 | GCNone = 0, | ||||
148 | Weak, | ||||
149 | Strong | ||||
150 | }; | ||||
151 | |||||
152 | enum ObjCLifetime { | ||||
153 | /// There is no lifetime qualification on this type. | ||||
154 | OCL_None, | ||||
155 | |||||
156 | /// This object can be modified without requiring retains or | ||||
157 | /// releases. | ||||
158 | OCL_ExplicitNone, | ||||
159 | |||||
160 | /// Assigning into this object requires the old value to be | ||||
161 | /// released and the new value to be retained. The timing of the | ||||
162 | /// release of the old value is inexact: it may be moved to | ||||
163 | /// immediately after the last known point where the value is | ||||
164 | /// live. | ||||
165 | OCL_Strong, | ||||
166 | |||||
167 | /// Reading or writing from this object requires a barrier call. | ||||
168 | OCL_Weak, | ||||
169 | |||||
170 | /// Assigning into this object requires a lifetime extension. | ||||
171 | OCL_Autoreleasing | ||||
172 | }; | ||||
173 | |||||
174 | enum { | ||||
175 | /// The maximum supported address space number. | ||||
176 | /// 23 bits should be enough for anyone. | ||||
177 | MaxAddressSpace = 0x7fffffu, | ||||
178 | |||||
179 | /// The width of the "fast" qualifier mask. | ||||
180 | FastWidth = 3, | ||||
181 | |||||
182 | /// The fast qualifier mask. | ||||
183 | FastMask = (1 << FastWidth) - 1 | ||||
184 | }; | ||||
185 | |||||
186 | /// Returns the common set of qualifiers while removing them from | ||||
187 | /// the given sets. | ||||
188 | static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) { | ||||
189 | // If both are only CVR-qualified, bit operations are sufficient. | ||||
190 | if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) { | ||||
191 | Qualifiers Q; | ||||
192 | Q.Mask = L.Mask & R.Mask; | ||||
193 | L.Mask &= ~Q.Mask; | ||||
194 | R.Mask &= ~Q.Mask; | ||||
195 | return Q; | ||||
196 | } | ||||
197 | |||||
198 | Qualifiers Q; | ||||
199 | unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers(); | ||||
200 | Q.addCVRQualifiers(CommonCRV); | ||||
201 | L.removeCVRQualifiers(CommonCRV); | ||||
202 | R.removeCVRQualifiers(CommonCRV); | ||||
203 | |||||
204 | if (L.getObjCGCAttr() == R.getObjCGCAttr()) { | ||||
205 | Q.setObjCGCAttr(L.getObjCGCAttr()); | ||||
206 | L.removeObjCGCAttr(); | ||||
207 | R.removeObjCGCAttr(); | ||||
208 | } | ||||
209 | |||||
210 | if (L.getObjCLifetime() == R.getObjCLifetime()) { | ||||
211 | Q.setObjCLifetime(L.getObjCLifetime()); | ||||
212 | L.removeObjCLifetime(); | ||||
213 | R.removeObjCLifetime(); | ||||
214 | } | ||||
215 | |||||
216 | if (L.getAddressSpace() == R.getAddressSpace()) { | ||||
217 | Q.setAddressSpace(L.getAddressSpace()); | ||||
218 | L.removeAddressSpace(); | ||||
219 | R.removeAddressSpace(); | ||||
220 | } | ||||
221 | return Q; | ||||
222 | } | ||||
223 | |||||
224 | static Qualifiers fromFastMask(unsigned Mask) { | ||||
225 | Qualifiers Qs; | ||||
226 | Qs.addFastQualifiers(Mask); | ||||
227 | return Qs; | ||||
228 | } | ||||
229 | |||||
230 | static Qualifiers fromCVRMask(unsigned CVR) { | ||||
231 | Qualifiers Qs; | ||||
232 | Qs.addCVRQualifiers(CVR); | ||||
233 | return Qs; | ||||
234 | } | ||||
235 | |||||
236 | static Qualifiers fromCVRUMask(unsigned CVRU) { | ||||
237 | Qualifiers Qs; | ||||
238 | Qs.addCVRUQualifiers(CVRU); | ||||
239 | return Qs; | ||||
240 | } | ||||
241 | |||||
242 | // Deserialize qualifiers from an opaque representation. | ||||
243 | static Qualifiers fromOpaqueValue(unsigned opaque) { | ||||
244 | Qualifiers Qs; | ||||
245 | Qs.Mask = opaque; | ||||
246 | return Qs; | ||||
247 | } | ||||
248 | |||||
249 | // Serialize these qualifiers into an opaque representation. | ||||
250 | unsigned getAsOpaqueValue() const { | ||||
251 | return Mask; | ||||
252 | } | ||||
253 | |||||
254 | bool hasConst() const { return Mask & Const; } | ||||
255 | bool hasOnlyConst() const { return Mask == Const; } | ||||
256 | void removeConst() { Mask &= ~Const; } | ||||
257 | void addConst() { Mask |= Const; } | ||||
258 | |||||
259 | bool hasVolatile() const { return Mask & Volatile; } | ||||
260 | bool hasOnlyVolatile() const { return Mask == Volatile; } | ||||
261 | void removeVolatile() { Mask &= ~Volatile; } | ||||
262 | void addVolatile() { Mask |= Volatile; } | ||||
263 | |||||
264 | bool hasRestrict() const { return Mask & Restrict; } | ||||
265 | bool hasOnlyRestrict() const { return Mask == Restrict; } | ||||
266 | void removeRestrict() { Mask &= ~Restrict; } | ||||
267 | void addRestrict() { Mask |= Restrict; } | ||||
268 | |||||
269 | bool hasCVRQualifiers() const { return getCVRQualifiers(); } | ||||
270 | unsigned getCVRQualifiers() const { return Mask & CVRMask; } | ||||
271 | unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); } | ||||
272 | |||||
273 | void setCVRQualifiers(unsigned mask) { | ||||
274 | assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits" ) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 274, __PRETTY_FUNCTION__)); | ||||
275 | Mask = (Mask & ~CVRMask) | mask; | ||||
276 | } | ||||
277 | void removeCVRQualifiers(unsigned mask) { | ||||
278 | assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits" ) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 278, __PRETTY_FUNCTION__)); | ||||
279 | Mask &= ~mask; | ||||
280 | } | ||||
281 | void removeCVRQualifiers() { | ||||
282 | removeCVRQualifiers(CVRMask); | ||||
283 | } | ||||
284 | void addCVRQualifiers(unsigned mask) { | ||||
285 | assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits" ) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 285, __PRETTY_FUNCTION__)); | ||||
286 | Mask |= mask; | ||||
287 | } | ||||
288 | void addCVRUQualifiers(unsigned mask) { | ||||
289 | assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits" ) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 289, __PRETTY_FUNCTION__)); | ||||
290 | Mask |= mask; | ||||
291 | } | ||||
292 | |||||
293 | bool hasUnaligned() const { return Mask & UMask; } | ||||
294 | void setUnaligned(bool flag) { | ||||
295 | Mask = (Mask & ~UMask) | (flag ? UMask : 0); | ||||
296 | } | ||||
297 | void removeUnaligned() { Mask &= ~UMask; } | ||||
298 | void addUnaligned() { Mask |= UMask; } | ||||
299 | |||||
300 | bool hasObjCGCAttr() const { return Mask & GCAttrMask; } | ||||
301 | GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); } | ||||
302 | void setObjCGCAttr(GC type) { | ||||
303 | Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift); | ||||
304 | } | ||||
305 | void removeObjCGCAttr() { setObjCGCAttr(GCNone); } | ||||
306 | void addObjCGCAttr(GC type) { | ||||
307 | assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 307, __PRETTY_FUNCTION__)); | ||||
308 | setObjCGCAttr(type); | ||||
309 | } | ||||
310 | Qualifiers withoutObjCGCAttr() const { | ||||
311 | Qualifiers qs = *this; | ||||
312 | qs.removeObjCGCAttr(); | ||||
313 | return qs; | ||||
314 | } | ||||
315 | Qualifiers withoutObjCLifetime() const { | ||||
316 | Qualifiers qs = *this; | ||||
317 | qs.removeObjCLifetime(); | ||||
318 | return qs; | ||||
319 | } | ||||
320 | Qualifiers withoutAddressSpace() const { | ||||
321 | Qualifiers qs = *this; | ||||
322 | qs.removeAddressSpace(); | ||||
323 | return qs; | ||||
324 | } | ||||
325 | |||||
326 | bool hasObjCLifetime() const { return Mask & LifetimeMask; } | ||||
327 | ObjCLifetime getObjCLifetime() const { | ||||
328 | return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift); | ||||
329 | } | ||||
330 | void setObjCLifetime(ObjCLifetime type) { | ||||
331 | Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift); | ||||
332 | } | ||||
333 | void removeObjCLifetime() { setObjCLifetime(OCL_None); } | ||||
334 | void addObjCLifetime(ObjCLifetime type) { | ||||
335 | assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 335, __PRETTY_FUNCTION__)); | ||||
336 | assert(!hasObjCLifetime())((!hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail ("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 336, __PRETTY_FUNCTION__)); | ||||
337 | Mask |= (type << LifetimeShift); | ||||
338 | } | ||||
339 | |||||
340 | /// True if the lifetime is neither None or ExplicitNone. | ||||
341 | bool hasNonTrivialObjCLifetime() const { | ||||
342 | ObjCLifetime lifetime = getObjCLifetime(); | ||||
343 | return (lifetime > OCL_ExplicitNone); | ||||
344 | } | ||||
345 | |||||
346 | /// True if the lifetime is either strong or weak. | ||||
347 | bool hasStrongOrWeakObjCLifetime() const { | ||||
348 | ObjCLifetime lifetime = getObjCLifetime(); | ||||
349 | return (lifetime == OCL_Strong || lifetime == OCL_Weak); | ||||
350 | } | ||||
351 | |||||
352 | bool hasAddressSpace() const { return Mask & AddressSpaceMask; } | ||||
353 | LangAS getAddressSpace() const { | ||||
354 | return static_cast<LangAS>(Mask >> AddressSpaceShift); | ||||
355 | } | ||||
356 | bool hasTargetSpecificAddressSpace() const { | ||||
357 | return isTargetAddressSpace(getAddressSpace()); | ||||
358 | } | ||||
359 | /// Get the address space attribute value to be printed by diagnostics. | ||||
360 | unsigned getAddressSpaceAttributePrintValue() const { | ||||
361 | auto Addr = getAddressSpace(); | ||||
362 | // This function is not supposed to be used with language specific | ||||
363 | // address spaces. If that happens, the diagnostic message should consider | ||||
364 | // printing the QualType instead of the address space value. | ||||
365 | assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((Addr == LangAS::Default || hasTargetSpecificAddressSpace()) ? static_cast<void> (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 365, __PRETTY_FUNCTION__)); | ||||
366 | if (Addr != LangAS::Default) | ||||
367 | return toTargetAddressSpace(Addr); | ||||
368 | // TODO: The diagnostic messages where Addr may be 0 should be fixed | ||||
369 | // since it cannot differentiate the situation where 0 denotes the default | ||||
370 | // address space or user specified __attribute__((address_space(0))). | ||||
371 | return 0; | ||||
372 | } | ||||
373 | void setAddressSpace(LangAS space) { | ||||
374 | assert((unsigned)space <= MaxAddressSpace)(((unsigned)space <= MaxAddressSpace) ? static_cast<void > (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 374, __PRETTY_FUNCTION__)); | ||||
375 | Mask = (Mask & ~AddressSpaceMask) | ||||
376 | | (((uint32_t) space) << AddressSpaceShift); | ||||
377 | } | ||||
378 | void removeAddressSpace() { setAddressSpace(LangAS::Default); } | ||||
379 | void addAddressSpace(LangAS space) { | ||||
380 | assert(space != LangAS::Default)((space != LangAS::Default) ? static_cast<void> (0) : __assert_fail ("space != LangAS::Default", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 380, __PRETTY_FUNCTION__)); | ||||
381 | setAddressSpace(space); | ||||
382 | } | ||||
383 | |||||
384 | // Fast qualifiers are those that can be allocated directly | ||||
385 | // on a QualType object. | ||||
386 | bool hasFastQualifiers() const { return getFastQualifiers(); } | ||||
387 | unsigned getFastQualifiers() const { return Mask & FastMask; } | ||||
388 | void setFastQualifiers(unsigned mask) { | ||||
389 | assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits" ) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 389, __PRETTY_FUNCTION__)); | ||||
390 | Mask = (Mask & ~FastMask) | mask; | ||||
391 | } | ||||
392 | void removeFastQualifiers(unsigned mask) { | ||||
393 | assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits" ) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 393, __PRETTY_FUNCTION__)); | ||||
394 | Mask &= ~mask; | ||||
395 | } | ||||
396 | void removeFastQualifiers() { | ||||
397 | removeFastQualifiers(FastMask); | ||||
398 | } | ||||
399 | void addFastQualifiers(unsigned mask) { | ||||
400 | assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits" ) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 400, __PRETTY_FUNCTION__)); | ||||
401 | Mask |= mask; | ||||
402 | } | ||||
403 | |||||
404 | /// Return true if the set contains any qualifiers which require an ExtQuals | ||||
405 | /// node to be allocated. | ||||
406 | bool hasNonFastQualifiers() const { return Mask & ~FastMask; } | ||||
407 | Qualifiers getNonFastQualifiers() const { | ||||
408 | Qualifiers Quals = *this; | ||||
409 | Quals.setFastQualifiers(0); | ||||
410 | return Quals; | ||||
411 | } | ||||
412 | |||||
413 | /// Return true if the set contains any qualifiers. | ||||
414 | bool hasQualifiers() const { return Mask; } | ||||
415 | bool empty() const { return !Mask; } | ||||
416 | |||||
417 | /// Add the qualifiers from the given set to this set. | ||||
418 | void addQualifiers(Qualifiers Q) { | ||||
419 | // If the other set doesn't have any non-boolean qualifiers, just | ||||
420 | // bit-or it in. | ||||
421 | if (!(Q.Mask & ~CVRMask)) | ||||
422 | Mask |= Q.Mask; | ||||
423 | else { | ||||
424 | Mask |= (Q.Mask & CVRMask); | ||||
425 | if (Q.hasAddressSpace()) | ||||
426 | addAddressSpace(Q.getAddressSpace()); | ||||
427 | if (Q.hasObjCGCAttr()) | ||||
428 | addObjCGCAttr(Q.getObjCGCAttr()); | ||||
429 | if (Q.hasObjCLifetime()) | ||||
430 | addObjCLifetime(Q.getObjCLifetime()); | ||||
431 | } | ||||
432 | } | ||||
433 | |||||
434 | /// Remove the qualifiers from the given set from this set. | ||||
435 | void removeQualifiers(Qualifiers Q) { | ||||
436 | // If the other set doesn't have any non-boolean qualifiers, just | ||||
437 | // bit-and the inverse in. | ||||
438 | if (!(Q.Mask & ~CVRMask)) | ||||
439 | Mask &= ~Q.Mask; | ||||
440 | else { | ||||
441 | Mask &= ~(Q.Mask & CVRMask); | ||||
442 | if (getObjCGCAttr() == Q.getObjCGCAttr()) | ||||
443 | removeObjCGCAttr(); | ||||
444 | if (getObjCLifetime() == Q.getObjCLifetime()) | ||||
445 | removeObjCLifetime(); | ||||
446 | if (getAddressSpace() == Q.getAddressSpace()) | ||||
447 | removeAddressSpace(); | ||||
448 | } | ||||
449 | } | ||||
450 | |||||
451 | /// Add the qualifiers from the given set to this set, given that | ||||
452 | /// they don't conflict. | ||||
453 | void addConsistentQualifiers(Qualifiers qs) { | ||||
454 | assert(getAddressSpace() == qs.getAddressSpace() ||((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace () || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 455, __PRETTY_FUNCTION__)) | ||||
455 | !hasAddressSpace() || !qs.hasAddressSpace())((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace () || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 455, __PRETTY_FUNCTION__)); | ||||
456 | assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 457, __PRETTY_FUNCTION__)) | ||||
457 | !hasObjCGCAttr() || !qs.hasObjCGCAttr())((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 457, __PRETTY_FUNCTION__)); | ||||
458 | assert(getObjCLifetime() == qs.getObjCLifetime() ||((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime () || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 459, __PRETTY_FUNCTION__)) | ||||
459 | !hasObjCLifetime() || !qs.hasObjCLifetime())((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime () || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 459, __PRETTY_FUNCTION__)); | ||||
460 | Mask |= qs.Mask; | ||||
461 | } | ||||
462 | |||||
463 | /// Returns true if address space A is equal to or a superset of B. | ||||
464 | /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of | ||||
465 | /// overlapping address spaces. | ||||
466 | /// CL1.1 or CL1.2: | ||||
467 | /// every address space is a superset of itself. | ||||
468 | /// CL2.0 adds: | ||||
469 | /// __generic is a superset of any address space except for __constant. | ||||
470 | static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) { | ||||
471 | // Address spaces must match exactly. | ||||
472 | return A == B || | ||||
473 | // Otherwise in OpenCLC v2.0 s6.5.5: every address space except | ||||
474 | // for __constant can be used as __generic. | ||||
475 | (A == LangAS::opencl_generic && B != LangAS::opencl_constant); | ||||
476 | } | ||||
477 | |||||
478 | /// Returns true if the address space in these qualifiers is equal to or | ||||
479 | /// a superset of the address space in the argument qualifiers. | ||||
480 | bool isAddressSpaceSupersetOf(Qualifiers other) const { | ||||
481 | return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace()); | ||||
482 | } | ||||
483 | |||||
484 | /// Determines if these qualifiers compatibly include another set. | ||||
485 | /// Generally this answers the question of whether an object with the other | ||||
486 | /// qualifiers can be safely used as an object with these qualifiers. | ||||
487 | bool compatiblyIncludes(Qualifiers other) const { | ||||
488 | return isAddressSpaceSupersetOf(other) && | ||||
489 | // ObjC GC qualifiers can match, be added, or be removed, but can't | ||||
490 | // be changed. | ||||
491 | (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() || | ||||
492 | !other.hasObjCGCAttr()) && | ||||
493 | // ObjC lifetime qualifiers must match exactly. | ||||
494 | getObjCLifetime() == other.getObjCLifetime() && | ||||
495 | // CVR qualifiers may subset. | ||||
496 | (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) && | ||||
497 | // U qualifier may superset. | ||||
498 | (!other.hasUnaligned() || hasUnaligned()); | ||||
499 | } | ||||
500 | |||||
501 | /// Determines if these qualifiers compatibly include another set of | ||||
502 | /// qualifiers from the narrow perspective of Objective-C ARC lifetime. | ||||
503 | /// | ||||
504 | /// One set of Objective-C lifetime qualifiers compatibly includes the other | ||||
505 | /// if the lifetime qualifiers match, or if both are non-__weak and the | ||||
506 | /// including set also contains the 'const' qualifier, or both are non-__weak | ||||
507 | /// and one is None (which can only happen in non-ARC modes). | ||||
508 | bool compatiblyIncludesObjCLifetime(Qualifiers other) const { | ||||
509 | if (getObjCLifetime() == other.getObjCLifetime()) | ||||
510 | return true; | ||||
511 | |||||
512 | if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak) | ||||
513 | return false; | ||||
514 | |||||
515 | if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None) | ||||
516 | return true; | ||||
517 | |||||
518 | return hasConst(); | ||||
519 | } | ||||
520 | |||||
521 | /// Determine whether this set of qualifiers is a strict superset of | ||||
522 | /// another set of qualifiers, not considering qualifier compatibility. | ||||
523 | bool isStrictSupersetOf(Qualifiers Other) const; | ||||
524 | |||||
525 | bool operator==(Qualifiers Other) const { return Mask == Other.Mask; } | ||||
526 | bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; } | ||||
527 | |||||
528 | explicit operator bool() const { return hasQualifiers(); } | ||||
529 | |||||
530 | Qualifiers &operator+=(Qualifiers R) { | ||||
531 | addQualifiers(R); | ||||
532 | return *this; | ||||
533 | } | ||||
534 | |||||
535 | // Union two qualifier sets. If an enumerated qualifier appears | ||||
536 | // in both sets, use the one from the right. | ||||
537 | friend Qualifiers operator+(Qualifiers L, Qualifiers R) { | ||||
538 | L += R; | ||||
539 | return L; | ||||
540 | } | ||||
541 | |||||
542 | Qualifiers &operator-=(Qualifiers R) { | ||||
543 | removeQualifiers(R); | ||||
544 | return *this; | ||||
545 | } | ||||
546 | |||||
547 | /// Compute the difference between two qualifier sets. | ||||
548 | friend Qualifiers operator-(Qualifiers L, Qualifiers R) { | ||||
549 | L -= R; | ||||
550 | return L; | ||||
551 | } | ||||
552 | |||||
553 | std::string getAsString() const; | ||||
554 | std::string getAsString(const PrintingPolicy &Policy) const; | ||||
555 | |||||
556 | bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const; | ||||
557 | void print(raw_ostream &OS, const PrintingPolicy &Policy, | ||||
558 | bool appendSpaceIfNonEmpty = false) const; | ||||
559 | |||||
560 | void Profile(llvm::FoldingSetNodeID &ID) const { | ||||
561 | ID.AddInteger(Mask); | ||||
562 | } | ||||
563 | |||||
564 | private: | ||||
565 | // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31| | ||||
566 | // |C R V|U|GCAttr|Lifetime|AddressSpace| | ||||
567 | uint32_t Mask = 0; | ||||
568 | |||||
569 | static const uint32_t UMask = 0x8; | ||||
570 | static const uint32_t UShift = 3; | ||||
571 | static const uint32_t GCAttrMask = 0x30; | ||||
572 | static const uint32_t GCAttrShift = 4; | ||||
573 | static const uint32_t LifetimeMask = 0x1C0; | ||||
574 | static const uint32_t LifetimeShift = 6; | ||||
575 | static const uint32_t AddressSpaceMask = | ||||
576 | ~(CVRMask | UMask | GCAttrMask | LifetimeMask); | ||||
577 | static const uint32_t AddressSpaceShift = 9; | ||||
578 | }; | ||||
579 | |||||
580 | /// A std::pair-like structure for storing a qualified type split | ||||
581 | /// into its local qualifiers and its locally-unqualified type. | ||||
582 | struct SplitQualType { | ||||
583 | /// The locally-unqualified type. | ||||
584 | const Type *Ty = nullptr; | ||||
585 | |||||
586 | /// The local qualifiers. | ||||
587 | Qualifiers Quals; | ||||
588 | |||||
589 | SplitQualType() = default; | ||||
590 | SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {} | ||||
591 | |||||
592 | SplitQualType getSingleStepDesugaredType() const; // end of this file | ||||
593 | |||||
594 | // Make std::tie work. | ||||
595 | std::pair<const Type *,Qualifiers> asPair() const { | ||||
596 | return std::pair<const Type *, Qualifiers>(Ty, Quals); | ||||
597 | } | ||||
598 | |||||
599 | friend bool operator==(SplitQualType a, SplitQualType b) { | ||||
600 | return a.Ty == b.Ty && a.Quals == b.Quals; | ||||
601 | } | ||||
602 | friend bool operator!=(SplitQualType a, SplitQualType b) { | ||||
603 | return a.Ty != b.Ty || a.Quals != b.Quals; | ||||
604 | } | ||||
605 | }; | ||||
606 | |||||
607 | /// The kind of type we are substituting Objective-C type arguments into. | ||||
608 | /// | ||||
609 | /// The kind of substitution affects the replacement of type parameters when | ||||
610 | /// no concrete type information is provided, e.g., when dealing with an | ||||
611 | /// unspecialized type. | ||||
612 | enum class ObjCSubstitutionContext { | ||||
613 | /// An ordinary type. | ||||
614 | Ordinary, | ||||
615 | |||||
616 | /// The result type of a method or function. | ||||
617 | Result, | ||||
618 | |||||
619 | /// The parameter type of a method or function. | ||||
620 | Parameter, | ||||
621 | |||||
622 | /// The type of a property. | ||||
623 | Property, | ||||
624 | |||||
625 | /// The superclass of a type. | ||||
626 | Superclass, | ||||
627 | }; | ||||
628 | |||||
629 | /// A (possibly-)qualified type. | ||||
630 | /// | ||||
631 | /// For efficiency, we don't store CV-qualified types as nodes on their | ||||
632 | /// own: instead each reference to a type stores the qualifiers. This | ||||
633 | /// greatly reduces the number of nodes we need to allocate for types (for | ||||
634 | /// example we only need one for 'int', 'const int', 'volatile int', | ||||
635 | /// 'const volatile int', etc). | ||||
636 | /// | ||||
637 | /// As an added efficiency bonus, instead of making this a pair, we | ||||
638 | /// just store the two bits we care about in the low bits of the | ||||
639 | /// pointer. To handle the packing/unpacking, we make QualType be a | ||||
640 | /// simple wrapper class that acts like a smart pointer. A third bit | ||||
641 | /// indicates whether there are extended qualifiers present, in which | ||||
642 | /// case the pointer points to a special structure. | ||||
643 | class QualType { | ||||
644 | friend class QualifierCollector; | ||||
645 | |||||
646 | // Thankfully, these are efficiently composable. | ||||
647 | llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>, | ||||
648 | Qualifiers::FastWidth> Value; | ||||
649 | |||||
650 | const ExtQuals *getExtQualsUnsafe() const { | ||||
651 | return Value.getPointer().get<const ExtQuals*>(); | ||||
652 | } | ||||
653 | |||||
654 | const Type *getTypePtrUnsafe() const { | ||||
655 | return Value.getPointer().get<const Type*>(); | ||||
656 | } | ||||
657 | |||||
658 | const ExtQualsTypeCommonBase *getCommonPtr() const { | ||||
659 | assert(!isNull() && "Cannot retrieve a NULL type pointer")((!isNull() && "Cannot retrieve a NULL type pointer") ? static_cast<void> (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 659, __PRETTY_FUNCTION__)); | ||||
660 | auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue()); | ||||
661 | CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1); | ||||
662 | return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal); | ||||
663 | } | ||||
664 | |||||
665 | public: | ||||
666 | QualType() = default; | ||||
667 | QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {} | ||||
668 | QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {} | ||||
669 | |||||
670 | unsigned getLocalFastQualifiers() const { return Value.getInt(); } | ||||
671 | void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); } | ||||
672 | |||||
673 | /// Retrieves a pointer to the underlying (unqualified) type. | ||||
674 | /// | ||||
675 | /// This function requires that the type not be NULL. If the type might be | ||||
676 | /// NULL, use the (slightly less efficient) \c getTypePtrOrNull(). | ||||
677 | const Type *getTypePtr() const; | ||||
678 | |||||
679 | const Type *getTypePtrOrNull() const; | ||||
680 | |||||
681 | /// Retrieves a pointer to the name of the base type. | ||||
682 | const IdentifierInfo *getBaseTypeIdentifier() const; | ||||
683 | |||||
684 | /// Divides a QualType into its unqualified type and a set of local | ||||
685 | /// qualifiers. | ||||
686 | SplitQualType split() const; | ||||
687 | |||||
688 | void *getAsOpaquePtr() const { return Value.getOpaqueValue(); } | ||||
689 | |||||
690 | static QualType getFromOpaquePtr(const void *Ptr) { | ||||
691 | QualType T; | ||||
692 | T.Value.setFromOpaqueValue(const_cast<void*>(Ptr)); | ||||
693 | return T; | ||||
694 | } | ||||
695 | |||||
696 | const Type &operator*() const { | ||||
697 | return *getTypePtr(); | ||||
698 | } | ||||
699 | |||||
700 | const Type *operator->() const { | ||||
701 | return getTypePtr(); | ||||
702 | } | ||||
703 | |||||
704 | bool isCanonical() const; | ||||
705 | bool isCanonicalAsParam() const; | ||||
706 | |||||
707 | /// Return true if this QualType doesn't point to a type yet. | ||||
708 | bool isNull() const { | ||||
709 | return Value.getPointer().isNull(); | ||||
710 | } | ||||
711 | |||||
712 | /// Determine whether this particular QualType instance has the | ||||
713 | /// "const" qualifier set, without looking through typedefs that may have | ||||
714 | /// added "const" at a different level. | ||||
715 | bool isLocalConstQualified() const { | ||||
716 | return (getLocalFastQualifiers() & Qualifiers::Const); | ||||
717 | } | ||||
718 | |||||
719 | /// Determine whether this type is const-qualified. | ||||
720 | bool isConstQualified() const; | ||||
721 | |||||
722 | /// Determine whether this particular QualType instance has the | ||||
723 | /// "restrict" qualifier set, without looking through typedefs that may have | ||||
724 | /// added "restrict" at a different level. | ||||
725 | bool isLocalRestrictQualified() const { | ||||
726 | return (getLocalFastQualifiers() & Qualifiers::Restrict); | ||||
727 | } | ||||
728 | |||||
729 | /// Determine whether this type is restrict-qualified. | ||||
730 | bool isRestrictQualified() const; | ||||
731 | |||||
732 | /// Determine whether this particular QualType instance has the | ||||
733 | /// "volatile" qualifier set, without looking through typedefs that may have | ||||
734 | /// added "volatile" at a different level. | ||||
735 | bool isLocalVolatileQualified() const { | ||||
736 | return (getLocalFastQualifiers() & Qualifiers::Volatile); | ||||
737 | } | ||||
738 | |||||
739 | /// Determine whether this type is volatile-qualified. | ||||
740 | bool isVolatileQualified() const; | ||||
741 | |||||
742 | /// Determine whether this particular QualType instance has any | ||||
743 | /// qualifiers, without looking through any typedefs that might add | ||||
744 | /// qualifiers at a different level. | ||||
745 | bool hasLocalQualifiers() const { | ||||
746 | return getLocalFastQualifiers() || hasLocalNonFastQualifiers(); | ||||
747 | } | ||||
748 | |||||
749 | /// Determine whether this type has any qualifiers. | ||||
750 | bool hasQualifiers() const; | ||||
751 | |||||
752 | /// Determine whether this particular QualType instance has any | ||||
753 | /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType | ||||
754 | /// instance. | ||||
755 | bool hasLocalNonFastQualifiers() const { | ||||
756 | return Value.getPointer().is<const ExtQuals*>(); | ||||
757 | } | ||||
758 | |||||
759 | /// Retrieve the set of qualifiers local to this particular QualType | ||||
760 | /// instance, not including any qualifiers acquired through typedefs or | ||||
761 | /// other sugar. | ||||
762 | Qualifiers getLocalQualifiers() const; | ||||
763 | |||||
764 | /// Retrieve the set of qualifiers applied to this type. | ||||
765 | Qualifiers getQualifiers() const; | ||||
766 | |||||
767 | /// Retrieve the set of CVR (const-volatile-restrict) qualifiers | ||||
768 | /// local to this particular QualType instance, not including any qualifiers | ||||
769 | /// acquired through typedefs or other sugar. | ||||
770 | unsigned getLocalCVRQualifiers() const { | ||||
771 | return getLocalFastQualifiers(); | ||||
772 | } | ||||
773 | |||||
774 | /// Retrieve the set of CVR (const-volatile-restrict) qualifiers | ||||
775 | /// applied to this type. | ||||
776 | unsigned getCVRQualifiers() const; | ||||
777 | |||||
778 | bool isConstant(const ASTContext& Ctx) const { | ||||
779 | return QualType::isConstant(*this, Ctx); | ||||
780 | } | ||||
781 | |||||
782 | /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10). | ||||
783 | bool isPODType(const ASTContext &Context) const; | ||||
784 | |||||
785 | /// Return true if this is a POD type according to the rules of the C++98 | ||||
786 | /// standard, regardless of the current compilation's language. | ||||
787 | bool isCXX98PODType(const ASTContext &Context) const; | ||||
788 | |||||
789 | /// Return true if this is a POD type according to the more relaxed rules | ||||
790 | /// of the C++11 standard, regardless of the current compilation's language. | ||||
791 | /// (C++0x [basic.types]p9). Note that, unlike | ||||
792 | /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account. | ||||
793 | bool isCXX11PODType(const ASTContext &Context) const; | ||||
794 | |||||
795 | /// Return true if this is a trivial type per (C++0x [basic.types]p9) | ||||
796 | bool isTrivialType(const ASTContext &Context) const; | ||||
797 | |||||
798 | /// Return true if this is a trivially copyable type (C++0x [basic.types]p9) | ||||
799 | bool isTriviallyCopyableType(const ASTContext &Context) const; | ||||
800 | |||||
801 | |||||
802 | /// Returns true if it is a class and it might be dynamic. | ||||
803 | bool mayBeDynamicClass() const; | ||||
804 | |||||
805 | /// Returns true if it is not a class or if the class might not be dynamic. | ||||
806 | bool mayBeNotDynamicClass() const; | ||||
807 | |||||
808 | // Don't promise in the API that anything besides 'const' can be | ||||
809 | // easily added. | ||||
810 | |||||
811 | /// Add the `const` type qualifier to this QualType. | ||||
812 | void addConst() { | ||||
813 | addFastQualifiers(Qualifiers::Const); | ||||
814 | } | ||||
815 | QualType withConst() const { | ||||
816 | return withFastQualifiers(Qualifiers::Const); | ||||
817 | } | ||||
818 | |||||
819 | /// Add the `volatile` type qualifier to this QualType. | ||||
820 | void addVolatile() { | ||||
821 | addFastQualifiers(Qualifiers::Volatile); | ||||
822 | } | ||||
823 | QualType withVolatile() const { | ||||
824 | return withFastQualifiers(Qualifiers::Volatile); | ||||
825 | } | ||||
826 | |||||
827 | /// Add the `restrict` qualifier to this QualType. | ||||
828 | void addRestrict() { | ||||
829 | addFastQualifiers(Qualifiers::Restrict); | ||||
830 | } | ||||
831 | QualType withRestrict() const { | ||||
832 | return withFastQualifiers(Qualifiers::Restrict); | ||||
833 | } | ||||
834 | |||||
835 | QualType withCVRQualifiers(unsigned CVR) const { | ||||
836 | return withFastQualifiers(CVR); | ||||
837 | } | ||||
838 | |||||
839 | void addFastQualifiers(unsigned TQs) { | ||||
840 | assert(!(TQs & ~Qualifiers::FastMask)((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!" ) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 841, __PRETTY_FUNCTION__)) | ||||
841 | && "non-fast qualifier bits set in mask!")((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!" ) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 841, __PRETTY_FUNCTION__)); | ||||
842 | Value.setInt(Value.getInt() | TQs); | ||||
843 | } | ||||
844 | |||||
845 | void removeLocalConst(); | ||||
846 | void removeLocalVolatile(); | ||||
847 | void removeLocalRestrict(); | ||||
848 | void removeLocalCVRQualifiers(unsigned Mask); | ||||
849 | |||||
850 | void removeLocalFastQualifiers() { Value.setInt(0); } | ||||
851 | void removeLocalFastQualifiers(unsigned Mask) { | ||||
852 | assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers" ) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 852, __PRETTY_FUNCTION__)); | ||||
853 | Value.setInt(Value.getInt() & ~Mask); | ||||
854 | } | ||||
855 | |||||
856 | // Creates a type with the given qualifiers in addition to any | ||||
857 | // qualifiers already on this type. | ||||
858 | QualType withFastQualifiers(unsigned TQs) const { | ||||
859 | QualType T = *this; | ||||
860 | T.addFastQualifiers(TQs); | ||||
861 | return T; | ||||
862 | } | ||||
863 | |||||
864 | // Creates a type with exactly the given fast qualifiers, removing | ||||
865 | // any existing fast qualifiers. | ||||
866 | QualType withExactLocalFastQualifiers(unsigned TQs) const { | ||||
867 | return withoutLocalFastQualifiers().withFastQualifiers(TQs); | ||||
868 | } | ||||
869 | |||||
870 | // Removes fast qualifiers, but leaves any extended qualifiers in place. | ||||
871 | QualType withoutLocalFastQualifiers() const { | ||||
872 | QualType T = *this; | ||||
873 | T.removeLocalFastQualifiers(); | ||||
874 | return T; | ||||
875 | } | ||||
876 | |||||
877 | QualType getCanonicalType() const; | ||||
878 | |||||
879 | /// Return this type with all of the instance-specific qualifiers | ||||
880 | /// removed, but without removing any qualifiers that may have been applied | ||||
881 | /// through typedefs. | ||||
882 | QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); } | ||||
883 | |||||
884 | /// Retrieve the unqualified variant of the given type, | ||||
885 | /// removing as little sugar as possible. | ||||
886 | /// | ||||
887 | /// This routine looks through various kinds of sugar to find the | ||||
888 | /// least-desugared type that is unqualified. For example, given: | ||||
889 | /// | ||||
890 | /// \code | ||||
891 | /// typedef int Integer; | ||||
892 | /// typedef const Integer CInteger; | ||||
893 | /// typedef CInteger DifferenceType; | ||||
894 | /// \endcode | ||||
895 | /// | ||||
896 | /// Executing \c getUnqualifiedType() on the type \c DifferenceType will | ||||
897 | /// desugar until we hit the type \c Integer, which has no qualifiers on it. | ||||
898 | /// | ||||
899 | /// The resulting type might still be qualified if it's sugar for an array | ||||
900 | /// type. To strip qualifiers even from within a sugared array type, use | ||||
901 | /// ASTContext::getUnqualifiedArrayType. | ||||
902 | inline QualType getUnqualifiedType() const; | ||||
903 | |||||
904 | /// Retrieve the unqualified variant of the given type, removing as little | ||||
905 | /// sugar as possible. | ||||
906 | /// | ||||
907 | /// Like getUnqualifiedType(), but also returns the set of | ||||
908 | /// qualifiers that were built up. | ||||
909 | /// | ||||
910 | /// The resulting type might still be qualified if it's sugar for an array | ||||
911 | /// type. To strip qualifiers even from within a sugared array type, use | ||||
912 | /// ASTContext::getUnqualifiedArrayType. | ||||
913 | inline SplitQualType getSplitUnqualifiedType() const; | ||||
914 | |||||
915 | /// Determine whether this type is more qualified than the other | ||||
916 | /// given type, requiring exact equality for non-CVR qualifiers. | ||||
917 | bool isMoreQualifiedThan(QualType Other) const; | ||||
918 | |||||
919 | /// Determine whether this type is at least as qualified as the other | ||||
920 | /// given type, requiring exact equality for non-CVR qualifiers. | ||||
921 | bool isAtLeastAsQualifiedAs(QualType Other) const; | ||||
922 | |||||
923 | QualType getNonReferenceType() const; | ||||
924 | |||||
925 | /// Determine the type of a (typically non-lvalue) expression with the | ||||
926 | /// specified result type. | ||||
927 | /// | ||||
928 | /// This routine should be used for expressions for which the return type is | ||||
929 | /// explicitly specified (e.g., in a cast or call) and isn't necessarily | ||||
930 | /// an lvalue. It removes a top-level reference (since there are no | ||||
931 | /// expressions of reference type) and deletes top-level cvr-qualifiers | ||||
932 | /// from non-class types (in C++) or all types (in C). | ||||
933 | QualType getNonLValueExprType(const ASTContext &Context) const; | ||||
934 | |||||
935 | /// Return the specified type with any "sugar" removed from | ||||
936 | /// the type. This takes off typedefs, typeof's etc. If the outer level of | ||||
937 | /// the type is already concrete, it returns it unmodified. This is similar | ||||
938 | /// to getting the canonical type, but it doesn't remove *all* typedefs. For | ||||
939 | /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is | ||||
940 | /// concrete. | ||||
941 | /// | ||||
942 | /// Qualifiers are left in place. | ||||
943 | QualType getDesugaredType(const ASTContext &Context) const { | ||||
944 | return getDesugaredType(*this, Context); | ||||
945 | } | ||||
946 | |||||
947 | SplitQualType getSplitDesugaredType() const { | ||||
948 | return getSplitDesugaredType(*this); | ||||
949 | } | ||||
950 | |||||
951 | /// Return the specified type with one level of "sugar" removed from | ||||
952 | /// the type. | ||||
953 | /// | ||||
954 | /// This routine takes off the first typedef, typeof, etc. If the outer level | ||||
955 | /// of the type is already concrete, it returns it unmodified. | ||||
956 | QualType getSingleStepDesugaredType(const ASTContext &Context) const { | ||||
957 | return getSingleStepDesugaredTypeImpl(*this, Context); | ||||
958 | } | ||||
959 | |||||
960 | /// Returns the specified type after dropping any | ||||
961 | /// outer-level parentheses. | ||||
962 | QualType IgnoreParens() const { | ||||
963 | if (isa<ParenType>(*this)) | ||||
964 | return QualType::IgnoreParens(*this); | ||||
965 | return *this; | ||||
966 | } | ||||
967 | |||||
968 | /// Indicate whether the specified types and qualifiers are identical. | ||||
969 | friend bool operator==(const QualType &LHS, const QualType &RHS) { | ||||
970 | return LHS.Value == RHS.Value; | ||||
971 | } | ||||
972 | friend bool operator!=(const QualType &LHS, const QualType &RHS) { | ||||
973 | return LHS.Value != RHS.Value; | ||||
974 | } | ||||
975 | friend bool operator<(const QualType &LHS, const QualType &RHS) { | ||||
976 | return LHS.Value < RHS.Value; | ||||
977 | } | ||||
978 | |||||
979 | static std::string getAsString(SplitQualType split, | ||||
980 | const PrintingPolicy &Policy) { | ||||
981 | return getAsString(split.Ty, split.Quals, Policy); | ||||
982 | } | ||||
983 | static std::string getAsString(const Type *ty, Qualifiers qs, | ||||
984 | const PrintingPolicy &Policy); | ||||
985 | |||||
986 | std::string getAsString() const; | ||||
987 | std::string getAsString(const PrintingPolicy &Policy) const; | ||||
988 | |||||
989 | void print(raw_ostream &OS, const PrintingPolicy &Policy, | ||||
990 | const Twine &PlaceHolder = Twine(), | ||||
991 | unsigned Indentation = 0) const; | ||||
992 | |||||
993 | static void print(SplitQualType split, raw_ostream &OS, | ||||
994 | const PrintingPolicy &policy, const Twine &PlaceHolder, | ||||
995 | unsigned Indentation = 0) { | ||||
996 | return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation); | ||||
997 | } | ||||
998 | |||||
999 | static void print(const Type *ty, Qualifiers qs, | ||||
1000 | raw_ostream &OS, const PrintingPolicy &policy, | ||||
1001 | const Twine &PlaceHolder, | ||||
1002 | unsigned Indentation = 0); | ||||
1003 | |||||
1004 | void getAsStringInternal(std::string &Str, | ||||
1005 | const PrintingPolicy &Policy) const; | ||||
1006 | |||||
1007 | static void getAsStringInternal(SplitQualType split, std::string &out, | ||||
1008 | const PrintingPolicy &policy) { | ||||
1009 | return getAsStringInternal(split.Ty, split.Quals, out, policy); | ||||
1010 | } | ||||
1011 | |||||
1012 | static void getAsStringInternal(const Type *ty, Qualifiers qs, | ||||
1013 | std::string &out, | ||||
1014 | const PrintingPolicy &policy); | ||||
1015 | |||||
1016 | class StreamedQualTypeHelper { | ||||
1017 | const QualType &T; | ||||
1018 | const PrintingPolicy &Policy; | ||||
1019 | const Twine &PlaceHolder; | ||||
1020 | unsigned Indentation; | ||||
1021 | |||||
1022 | public: | ||||
1023 | StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy, | ||||
1024 | const Twine &PlaceHolder, unsigned Indentation) | ||||
1025 | : T(T), Policy(Policy), PlaceHolder(PlaceHolder), | ||||
1026 | Indentation(Indentation) {} | ||||
1027 | |||||
1028 | friend raw_ostream &operator<<(raw_ostream &OS, | ||||
1029 | const StreamedQualTypeHelper &SQT) { | ||||
1030 | SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation); | ||||
1031 | return OS; | ||||
1032 | } | ||||
1033 | }; | ||||
1034 | |||||
1035 | StreamedQualTypeHelper stream(const PrintingPolicy &Policy, | ||||
1036 | const Twine &PlaceHolder = Twine(), | ||||
1037 | unsigned Indentation = 0) const { | ||||
1038 | return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation); | ||||
1039 | } | ||||
1040 | |||||
1041 | void dump(const char *s) const; | ||||
1042 | void dump() const; | ||||
1043 | void dump(llvm::raw_ostream &OS) const; | ||||
1044 | |||||
1045 | void Profile(llvm::FoldingSetNodeID &ID) const { | ||||
1046 | ID.AddPointer(getAsOpaquePtr()); | ||||
1047 | } | ||||
1048 | |||||
1049 | /// Return the address space of this type. | ||||
1050 | inline LangAS getAddressSpace() const; | ||||
1051 | |||||
1052 | /// Returns gc attribute of this type. | ||||
1053 | inline Qualifiers::GC getObjCGCAttr() const; | ||||
1054 | |||||
1055 | /// true when Type is objc's weak. | ||||
1056 | bool isObjCGCWeak() const { | ||||
1057 | return getObjCGCAttr() == Qualifiers::Weak; | ||||
1058 | } | ||||
1059 | |||||
1060 | /// true when Type is objc's strong. | ||||
1061 | bool isObjCGCStrong() const { | ||||
1062 | return getObjCGCAttr() == Qualifiers::Strong; | ||||
1063 | } | ||||
1064 | |||||
1065 | /// Returns lifetime attribute of this type. | ||||
1066 | Qualifiers::ObjCLifetime getObjCLifetime() const { | ||||
1067 | return getQualifiers().getObjCLifetime(); | ||||
1068 | } | ||||
1069 | |||||
1070 | bool hasNonTrivialObjCLifetime() const { | ||||
1071 | return getQualifiers().hasNonTrivialObjCLifetime(); | ||||
1072 | } | ||||
1073 | |||||
1074 | bool hasStrongOrWeakObjCLifetime() const { | ||||
1075 | return getQualifiers().hasStrongOrWeakObjCLifetime(); | ||||
1076 | } | ||||
1077 | |||||
1078 | // true when Type is objc's weak and weak is enabled but ARC isn't. | ||||
1079 | bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const; | ||||
1080 | |||||
1081 | enum PrimitiveDefaultInitializeKind { | ||||
1082 | /// The type does not fall into any of the following categories. Note that | ||||
1083 | /// this case is zero-valued so that values of this enum can be used as a | ||||
1084 | /// boolean condition for non-triviality. | ||||
1085 | PDIK_Trivial, | ||||
1086 | |||||
1087 | /// The type is an Objective-C retainable pointer type that is qualified | ||||
1088 | /// with the ARC __strong qualifier. | ||||
1089 | PDIK_ARCStrong, | ||||
1090 | |||||
1091 | /// The type is an Objective-C retainable pointer type that is qualified | ||||
1092 | /// with the ARC __weak qualifier. | ||||
1093 | PDIK_ARCWeak, | ||||
1094 | |||||
1095 | /// The type is a struct containing a field whose type is not PCK_Trivial. | ||||
1096 | PDIK_Struct | ||||
1097 | }; | ||||
1098 | |||||
1099 | /// Functions to query basic properties of non-trivial C struct types. | ||||
1100 | |||||
1101 | /// Check if this is a non-trivial type that would cause a C struct | ||||
1102 | /// transitively containing this type to be non-trivial to default initialize | ||||
1103 | /// and return the kind. | ||||
1104 | PrimitiveDefaultInitializeKind | ||||
1105 | isNonTrivialToPrimitiveDefaultInitialize() const; | ||||
1106 | |||||
1107 | enum PrimitiveCopyKind { | ||||
1108 | /// The type does not fall into any of the following categories. Note that | ||||
1109 | /// this case is zero-valued so that values of this enum can be used as a | ||||
1110 | /// boolean condition for non-triviality. | ||||
1111 | PCK_Trivial, | ||||
1112 | |||||
1113 | /// The type would be trivial except that it is volatile-qualified. Types | ||||
1114 | /// that fall into one of the other non-trivial cases may additionally be | ||||
1115 | /// volatile-qualified. | ||||
1116 | PCK_VolatileTrivial, | ||||
1117 | |||||
1118 | /// The type is an Objective-C retainable pointer type that is qualified | ||||
1119 | /// with the ARC __strong qualifier. | ||||
1120 | PCK_ARCStrong, | ||||
1121 | |||||
1122 | /// The type is an Objective-C retainable pointer type that is qualified | ||||
1123 | /// with the ARC __weak qualifier. | ||||
1124 | PCK_ARCWeak, | ||||
1125 | |||||
1126 | /// The type is a struct containing a field whose type is neither | ||||
1127 | /// PCK_Trivial nor PCK_VolatileTrivial. | ||||
1128 | /// Note that a C++ struct type does not necessarily match this; C++ copying | ||||
1129 | /// semantics are too complex to express here, in part because they depend | ||||
1130 | /// on the exact constructor or assignment operator that is chosen by | ||||
1131 | /// overload resolution to do the copy. | ||||
1132 | PCK_Struct | ||||
1133 | }; | ||||
1134 | |||||
1135 | /// Check if this is a non-trivial type that would cause a C struct | ||||
1136 | /// transitively containing this type to be non-trivial to copy and return the | ||||
1137 | /// kind. | ||||
1138 | PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const; | ||||
1139 | |||||
1140 | /// Check if this is a non-trivial type that would cause a C struct | ||||
1141 | /// transitively containing this type to be non-trivial to destructively | ||||
1142 | /// move and return the kind. Destructive move in this context is a C++-style | ||||
1143 | /// move in which the source object is placed in a valid but unspecified state | ||||
1144 | /// after it is moved, as opposed to a truly destructive move in which the | ||||
1145 | /// source object is placed in an uninitialized state. | ||||
1146 | PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const; | ||||
1147 | |||||
1148 | enum DestructionKind { | ||||
1149 | DK_none, | ||||
1150 | DK_cxx_destructor, | ||||
1151 | DK_objc_strong_lifetime, | ||||
1152 | DK_objc_weak_lifetime, | ||||
1153 | DK_nontrivial_c_struct | ||||
1154 | }; | ||||
1155 | |||||
1156 | /// Returns a nonzero value if objects of this type require | ||||
1157 | /// non-trivial work to clean up after. Non-zero because it's | ||||
1158 | /// conceivable that qualifiers (objc_gc(weak)?) could make | ||||
1159 | /// something require destruction. | ||||
1160 | DestructionKind isDestructedType() const { | ||||
1161 | return isDestructedTypeImpl(*this); | ||||
1162 | } | ||||
1163 | |||||
1164 | /// Check if this is or contains a C union that is non-trivial to | ||||
1165 | /// default-initialize, which is a union that has a member that is non-trivial | ||||
1166 | /// to default-initialize. If this returns true, | ||||
1167 | /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct. | ||||
1168 | bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const; | ||||
1169 | |||||
1170 | /// Check if this is or contains a C union that is non-trivial to destruct, | ||||
1171 | /// which is a union that has a member that is non-trivial to destruct. If | ||||
1172 | /// this returns true, isDestructedType returns DK_nontrivial_c_struct. | ||||
1173 | bool hasNonTrivialToPrimitiveDestructCUnion() const; | ||||
1174 | |||||
1175 | /// Check if this is or contains a C union that is non-trivial to copy, which | ||||
1176 | /// is a union that has a member that is non-trivial to copy. If this returns | ||||
1177 | /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct. | ||||
1178 | bool hasNonTrivialToPrimitiveCopyCUnion() const; | ||||
1179 | |||||
1180 | /// Determine whether expressions of the given type are forbidden | ||||
1181 | /// from being lvalues in C. | ||||
1182 | /// | ||||
1183 | /// The expression types that are forbidden to be lvalues are: | ||||
1184 | /// - 'void', but not qualified void | ||||
1185 | /// - function types | ||||
1186 | /// | ||||
1187 | /// The exact rule here is C99 6.3.2.1: | ||||
1188 | /// An lvalue is an expression with an object type or an incomplete | ||||
1189 | /// type other than void. | ||||
1190 | bool isCForbiddenLValueType() const; | ||||
1191 | |||||
1192 | /// Substitute type arguments for the Objective-C type parameters used in the | ||||
1193 | /// subject type. | ||||
1194 | /// | ||||
1195 | /// \param ctx ASTContext in which the type exists. | ||||
1196 | /// | ||||
1197 | /// \param typeArgs The type arguments that will be substituted for the | ||||
1198 | /// Objective-C type parameters in the subject type, which are generally | ||||
1199 | /// computed via \c Type::getObjCSubstitutions. If empty, the type | ||||
1200 | /// parameters will be replaced with their bounds or id/Class, as appropriate | ||||
1201 | /// for the context. | ||||
1202 | /// | ||||
1203 | /// \param context The context in which the subject type was written. | ||||
1204 | /// | ||||
1205 | /// \returns the resulting type. | ||||
1206 | QualType substObjCTypeArgs(ASTContext &ctx, | ||||
1207 | ArrayRef<QualType> typeArgs, | ||||
1208 | ObjCSubstitutionContext context) const; | ||||
1209 | |||||
1210 | /// Substitute type arguments from an object type for the Objective-C type | ||||
1211 | /// parameters used in the subject type. | ||||
1212 | /// | ||||
1213 | /// This operation combines the computation of type arguments for | ||||
1214 | /// substitution (\c Type::getObjCSubstitutions) with the actual process of | ||||
1215 | /// substitution (\c QualType::substObjCTypeArgs) for the convenience of | ||||
1216 | /// callers that need to perform a single substitution in isolation. | ||||
1217 | /// | ||||
1218 | /// \param objectType The type of the object whose member type we're | ||||
1219 | /// substituting into. For example, this might be the receiver of a message | ||||
1220 | /// or the base of a property access. | ||||
1221 | /// | ||||
1222 | /// \param dc The declaration context from which the subject type was | ||||
1223 | /// retrieved, which indicates (for example) which type parameters should | ||||
1224 | /// be substituted. | ||||
1225 | /// | ||||
1226 | /// \param context The context in which the subject type was written. | ||||
1227 | /// | ||||
1228 | /// \returns the subject type after replacing all of the Objective-C type | ||||
1229 | /// parameters with their corresponding arguments. | ||||
1230 | QualType substObjCMemberType(QualType objectType, | ||||
1231 | const DeclContext *dc, | ||||
1232 | ObjCSubstitutionContext context) const; | ||||
1233 | |||||
1234 | /// Strip Objective-C "__kindof" types from the given type. | ||||
1235 | QualType stripObjCKindOfType(const ASTContext &ctx) const; | ||||
1236 | |||||
1237 | /// Remove all qualifiers including _Atomic. | ||||
1238 | QualType getAtomicUnqualifiedType() const; | ||||
1239 | |||||
1240 | private: | ||||
1241 | // These methods are implemented in a separate translation unit; | ||||
1242 | // "static"-ize them to avoid creating temporary QualTypes in the | ||||
1243 | // caller. | ||||
1244 | static bool isConstant(QualType T, const ASTContext& Ctx); | ||||
1245 | static QualType getDesugaredType(QualType T, const ASTContext &Context); | ||||
1246 | static SplitQualType getSplitDesugaredType(QualType T); | ||||
1247 | static SplitQualType getSplitUnqualifiedTypeImpl(QualType type); | ||||
1248 | static QualType getSingleStepDesugaredTypeImpl(QualType type, | ||||
1249 | const ASTContext &C); | ||||
1250 | static QualType IgnoreParens(QualType T); | ||||
1251 | static DestructionKind isDestructedTypeImpl(QualType type); | ||||
1252 | |||||
1253 | /// Check if \param RD is or contains a non-trivial C union. | ||||
1254 | static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD); | ||||
1255 | static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD); | ||||
1256 | static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD); | ||||
1257 | }; | ||||
1258 | |||||
1259 | } // namespace clang | ||||
1260 | |||||
1261 | namespace llvm { | ||||
1262 | |||||
1263 | /// Implement simplify_type for QualType, so that we can dyn_cast from QualType | ||||
1264 | /// to a specific Type class. | ||||
1265 | template<> struct simplify_type< ::clang::QualType> { | ||||
1266 | using SimpleType = const ::clang::Type *; | ||||
1267 | |||||
1268 | static SimpleType getSimplifiedValue(::clang::QualType Val) { | ||||
1269 | return Val.getTypePtr(); | ||||
1270 | } | ||||
1271 | }; | ||||
1272 | |||||
1273 | // Teach SmallPtrSet that QualType is "basically a pointer". | ||||
1274 | template<> | ||||
1275 | struct PointerLikeTypeTraits<clang::QualType> { | ||||
1276 | static inline void *getAsVoidPointer(clang::QualType P) { | ||||
1277 | return P.getAsOpaquePtr(); | ||||
1278 | } | ||||
1279 | |||||
1280 | static inline clang::QualType getFromVoidPointer(void *P) { | ||||
1281 | return clang::QualType::getFromOpaquePtr(P); | ||||
1282 | } | ||||
1283 | |||||
1284 | // Various qualifiers go in low bits. | ||||
1285 | enum { NumLowBitsAvailable = 0 }; | ||||
1286 | }; | ||||
1287 | |||||
1288 | } // namespace llvm | ||||
1289 | |||||
1290 | namespace clang { | ||||
1291 | |||||
1292 | /// Base class that is common to both the \c ExtQuals and \c Type | ||||
1293 | /// classes, which allows \c QualType to access the common fields between the | ||||
1294 | /// two. | ||||
1295 | class ExtQualsTypeCommonBase { | ||||
1296 | friend class ExtQuals; | ||||
1297 | friend class QualType; | ||||
1298 | friend class Type; | ||||
1299 | |||||
1300 | /// The "base" type of an extended qualifiers type (\c ExtQuals) or | ||||
1301 | /// a self-referential pointer (for \c Type). | ||||
1302 | /// | ||||
1303 | /// This pointer allows an efficient mapping from a QualType to its | ||||
1304 | /// underlying type pointer. | ||||
1305 | const Type *const BaseType; | ||||
1306 | |||||
1307 | /// The canonical type of this type. A QualType. | ||||
1308 | QualType CanonicalType; | ||||
1309 | |||||
1310 | ExtQualsTypeCommonBase(const Type *baseType, QualType canon) | ||||
1311 | : BaseType(baseType), CanonicalType(canon) {} | ||||
1312 | }; | ||||
1313 | |||||
1314 | /// We can encode up to four bits in the low bits of a | ||||
1315 | /// type pointer, but there are many more type qualifiers that we want | ||||
1316 | /// to be able to apply to an arbitrary type. Therefore we have this | ||||
1317 | /// struct, intended to be heap-allocated and used by QualType to | ||||
1318 | /// store qualifiers. | ||||
1319 | /// | ||||
1320 | /// The current design tags the 'const', 'restrict', and 'volatile' qualifiers | ||||
1321 | /// in three low bits on the QualType pointer; a fourth bit records whether | ||||
1322 | /// the pointer is an ExtQuals node. The extended qualifiers (address spaces, | ||||
1323 | /// Objective-C GC attributes) are much more rare. | ||||
1324 | class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode { | ||||
1325 | // NOTE: changing the fast qualifiers should be straightforward as | ||||
1326 | // long as you don't make 'const' non-fast. | ||||
1327 | // 1. Qualifiers: | ||||
1328 | // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ). | ||||
1329 | // Fast qualifiers must occupy the low-order bits. | ||||
1330 | // b) Update Qualifiers::FastWidth and FastMask. | ||||
1331 | // 2. QualType: | ||||
1332 | // a) Update is{Volatile,Restrict}Qualified(), defined inline. | ||||
1333 | // b) Update remove{Volatile,Restrict}, defined near the end of | ||||
1334 | // this header. | ||||
1335 | // 3. ASTContext: | ||||
1336 | // a) Update get{Volatile,Restrict}Type. | ||||
1337 | |||||
1338 | /// The immutable set of qualifiers applied by this node. Always contains | ||||
1339 | /// extended qualifiers. | ||||
1340 | Qualifiers Quals; | ||||
1341 | |||||
1342 | ExtQuals *this_() { return this; } | ||||
1343 | |||||
1344 | public: | ||||
1345 | ExtQuals(const Type *baseType, QualType canon, Qualifiers quals) | ||||
1346 | : ExtQualsTypeCommonBase(baseType, | ||||
1347 | canon.isNull() ? QualType(this_(), 0) : canon), | ||||
1348 | Quals(quals) { | ||||
1349 | assert(Quals.hasNonFastQualifiers()((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers" ) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 1350, __PRETTY_FUNCTION__)) | ||||
1350 | && "ExtQuals created with no fast qualifiers")((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers" ) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 1350, __PRETTY_FUNCTION__)); | ||||
1351 | assert(!Quals.hasFastQualifiers()((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers" ) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 1352, __PRETTY_FUNCTION__)) | ||||
1352 | && "ExtQuals created with fast qualifiers")((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers" ) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 1352, __PRETTY_FUNCTION__)); | ||||
1353 | } | ||||
1354 | |||||
1355 | Qualifiers getQualifiers() const { return Quals; } | ||||
1356 | |||||
1357 | bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); } | ||||
1358 | Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); } | ||||
1359 | |||||
1360 | bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); } | ||||
1361 | Qualifiers::ObjCLifetime getObjCLifetime() const { | ||||
1362 | return Quals.getObjCLifetime(); | ||||
1363 | } | ||||
1364 | |||||
1365 | bool hasAddressSpace() const { return Quals.hasAddressSpace(); } | ||||
1366 | LangAS getAddressSpace() const { return Quals.getAddressSpace(); } | ||||
1367 | |||||
1368 | const Type *getBaseType() const { return BaseType; } | ||||
1369 | |||||
1370 | public: | ||||
1371 | void Profile(llvm::FoldingSetNodeID &ID) const { | ||||
1372 | Profile(ID, getBaseType(), Quals); | ||||
1373 | } | ||||
1374 | |||||
1375 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
1376 | const Type *BaseType, | ||||
1377 | Qualifiers Quals) { | ||||
1378 | assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!" ) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"fast qualifiers in ExtQuals hash!\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 1378, __PRETTY_FUNCTION__)); | ||||
1379 | ID.AddPointer(BaseType); | ||||
1380 | Quals.Profile(ID); | ||||
1381 | } | ||||
1382 | }; | ||||
1383 | |||||
1384 | /// The kind of C++11 ref-qualifier associated with a function type. | ||||
1385 | /// This determines whether a member function's "this" object can be an | ||||
1386 | /// lvalue, rvalue, or neither. | ||||
1387 | enum RefQualifierKind { | ||||
1388 | /// No ref-qualifier was provided. | ||||
1389 | RQ_None = 0, | ||||
1390 | |||||
1391 | /// An lvalue ref-qualifier was provided (\c &). | ||||
1392 | RQ_LValue, | ||||
1393 | |||||
1394 | /// An rvalue ref-qualifier was provided (\c &&). | ||||
1395 | RQ_RValue | ||||
1396 | }; | ||||
1397 | |||||
1398 | /// Which keyword(s) were used to create an AutoType. | ||||
1399 | enum class AutoTypeKeyword { | ||||
1400 | /// auto | ||||
1401 | Auto, | ||||
1402 | |||||
1403 | /// decltype(auto) | ||||
1404 | DecltypeAuto, | ||||
1405 | |||||
1406 | /// __auto_type (GNU extension) | ||||
1407 | GNUAutoType | ||||
1408 | }; | ||||
1409 | |||||
1410 | /// The base class of the type hierarchy. | ||||
1411 | /// | ||||
1412 | /// A central concept with types is that each type always has a canonical | ||||
1413 | /// type. A canonical type is the type with any typedef names stripped out | ||||
1414 | /// of it or the types it references. For example, consider: | ||||
1415 | /// | ||||
1416 | /// typedef int foo; | ||||
1417 | /// typedef foo* bar; | ||||
1418 | /// 'int *' 'foo *' 'bar' | ||||
1419 | /// | ||||
1420 | /// There will be a Type object created for 'int'. Since int is canonical, its | ||||
1421 | /// CanonicalType pointer points to itself. There is also a Type for 'foo' (a | ||||
1422 | /// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next | ||||
1423 | /// there is a PointerType that represents 'int*', which, like 'int', is | ||||
1424 | /// canonical. Finally, there is a PointerType type for 'foo*' whose canonical | ||||
1425 | /// type is 'int*', and there is a TypedefType for 'bar', whose canonical type | ||||
1426 | /// is also 'int*'. | ||||
1427 | /// | ||||
1428 | /// Non-canonical types are useful for emitting diagnostics, without losing | ||||
1429 | /// information about typedefs being used. Canonical types are useful for type | ||||
1430 | /// comparisons (they allow by-pointer equality tests) and useful for reasoning | ||||
1431 | /// about whether something has a particular form (e.g. is a function type), | ||||
1432 | /// because they implicitly, recursively, strip all typedefs out of a type. | ||||
1433 | /// | ||||
1434 | /// Types, once created, are immutable. | ||||
1435 | /// | ||||
1436 | class alignas(8) Type : public ExtQualsTypeCommonBase { | ||||
1437 | public: | ||||
1438 | enum TypeClass { | ||||
1439 | #define TYPE(Class, Base) Class, | ||||
1440 | #define LAST_TYPE(Class) TypeLast = Class | ||||
1441 | #define ABSTRACT_TYPE(Class, Base) | ||||
1442 | #include "clang/AST/TypeNodes.inc" | ||||
1443 | }; | ||||
1444 | |||||
1445 | private: | ||||
1446 | /// Bitfields required by the Type class. | ||||
1447 | class TypeBitfields { | ||||
1448 | friend class Type; | ||||
1449 | template <class T> friend class TypePropertyCache; | ||||
1450 | |||||
1451 | /// TypeClass bitfield - Enum that specifies what subclass this belongs to. | ||||
1452 | unsigned TC : 8; | ||||
1453 | |||||
1454 | /// Whether this type is a dependent type (C++ [temp.dep.type]). | ||||
1455 | unsigned Dependent : 1; | ||||
1456 | |||||
1457 | /// Whether this type somehow involves a template parameter, even | ||||
1458 | /// if the resolution of the type does not depend on a template parameter. | ||||
1459 | unsigned InstantiationDependent : 1; | ||||
1460 | |||||
1461 | /// Whether this type is a variably-modified type (C99 6.7.5). | ||||
1462 | unsigned VariablyModified : 1; | ||||
1463 | |||||
1464 | /// Whether this type contains an unexpanded parameter pack | ||||
1465 | /// (for C++11 variadic templates). | ||||
1466 | unsigned ContainsUnexpandedParameterPack : 1; | ||||
1467 | |||||
1468 | /// True if the cache (i.e. the bitfields here starting with | ||||
1469 | /// 'Cache') is valid. | ||||
1470 | mutable unsigned CacheValid : 1; | ||||
1471 | |||||
1472 | /// Linkage of this type. | ||||
1473 | mutable unsigned CachedLinkage : 3; | ||||
1474 | |||||
1475 | /// Whether this type involves and local or unnamed types. | ||||
1476 | mutable unsigned CachedLocalOrUnnamed : 1; | ||||
1477 | |||||
1478 | /// Whether this type comes from an AST file. | ||||
1479 | mutable unsigned FromAST : 1; | ||||
1480 | |||||
1481 | bool isCacheValid() const { | ||||
1482 | return CacheValid; | ||||
1483 | } | ||||
1484 | |||||
1485 | Linkage getLinkage() const { | ||||
1486 | assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache" ) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 1486, __PRETTY_FUNCTION__)); | ||||
1487 | return static_cast<Linkage>(CachedLinkage); | ||||
1488 | } | ||||
1489 | |||||
1490 | bool hasLocalOrUnnamedType() const { | ||||
1491 | assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache" ) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 1491, __PRETTY_FUNCTION__)); | ||||
1492 | return CachedLocalOrUnnamed; | ||||
1493 | } | ||||
1494 | }; | ||||
1495 | enum { NumTypeBits = 18 }; | ||||
1496 | |||||
1497 | protected: | ||||
1498 | // These classes allow subclasses to somewhat cleanly pack bitfields | ||||
1499 | // into Type. | ||||
1500 | |||||
1501 | class ArrayTypeBitfields { | ||||
1502 | friend class ArrayType; | ||||
1503 | |||||
1504 | unsigned : NumTypeBits; | ||||
1505 | |||||
1506 | /// CVR qualifiers from declarations like | ||||
1507 | /// 'int X[static restrict 4]'. For function parameters only. | ||||
1508 | unsigned IndexTypeQuals : 3; | ||||
1509 | |||||
1510 | /// Storage class qualifiers from declarations like | ||||
1511 | /// 'int X[static restrict 4]'. For function parameters only. | ||||
1512 | /// Actually an ArrayType::ArraySizeModifier. | ||||
1513 | unsigned SizeModifier : 3; | ||||
1514 | }; | ||||
1515 | |||||
1516 | class BuiltinTypeBitfields { | ||||
1517 | friend class BuiltinType; | ||||
1518 | |||||
1519 | unsigned : NumTypeBits; | ||||
1520 | |||||
1521 | /// The kind (BuiltinType::Kind) of builtin type this is. | ||||
1522 | unsigned Kind : 8; | ||||
1523 | }; | ||||
1524 | |||||
1525 | /// FunctionTypeBitfields store various bits belonging to FunctionProtoType. | ||||
1526 | /// Only common bits are stored here. Additional uncommon bits are stored | ||||
1527 | /// in a trailing object after FunctionProtoType. | ||||
1528 | class FunctionTypeBitfields { | ||||
1529 | friend class FunctionProtoType; | ||||
1530 | friend class FunctionType; | ||||
1531 | |||||
1532 | unsigned : NumTypeBits; | ||||
1533 | |||||
1534 | /// Extra information which affects how the function is called, like | ||||
1535 | /// regparm and the calling convention. | ||||
1536 | unsigned ExtInfo : 12; | ||||
1537 | |||||
1538 | /// The ref-qualifier associated with a \c FunctionProtoType. | ||||
1539 | /// | ||||
1540 | /// This is a value of type \c RefQualifierKind. | ||||
1541 | unsigned RefQualifier : 2; | ||||
1542 | |||||
1543 | /// Used only by FunctionProtoType, put here to pack with the | ||||
1544 | /// other bitfields. | ||||
1545 | /// The qualifiers are part of FunctionProtoType because... | ||||
1546 | /// | ||||
1547 | /// C++ 8.3.5p4: The return type, the parameter type list and the | ||||
1548 | /// cv-qualifier-seq, [...], are part of the function type. | ||||
1549 | unsigned FastTypeQuals : Qualifiers::FastWidth; | ||||
1550 | /// Whether this function has extended Qualifiers. | ||||
1551 | unsigned HasExtQuals : 1; | ||||
1552 | |||||
1553 | /// The number of parameters this function has, not counting '...'. | ||||
1554 | /// According to [implimits] 8 bits should be enough here but this is | ||||
1555 | /// somewhat easy to exceed with metaprogramming and so we would like to | ||||
1556 | /// keep NumParams as wide as reasonably possible. | ||||
1557 | unsigned NumParams : 16; | ||||
1558 | |||||
1559 | /// The type of exception specification this function has. | ||||
1560 | unsigned ExceptionSpecType : 4; | ||||
1561 | |||||
1562 | /// Whether this function has extended parameter information. | ||||
1563 | unsigned HasExtParameterInfos : 1; | ||||
1564 | |||||
1565 | /// Whether the function is variadic. | ||||
1566 | unsigned Variadic : 1; | ||||
1567 | |||||
1568 | /// Whether this function has a trailing return type. | ||||
1569 | unsigned HasTrailingReturn : 1; | ||||
1570 | }; | ||||
1571 | |||||
1572 | class ObjCObjectTypeBitfields { | ||||
1573 | friend class ObjCObjectType; | ||||
1574 | |||||
1575 | unsigned : NumTypeBits; | ||||
1576 | |||||
1577 | /// The number of type arguments stored directly on this object type. | ||||
1578 | unsigned NumTypeArgs : 7; | ||||
1579 | |||||
1580 | /// The number of protocols stored directly on this object type. | ||||
1581 | unsigned NumProtocols : 6; | ||||
1582 | |||||
1583 | /// Whether this is a "kindof" type. | ||||
1584 | unsigned IsKindOf : 1; | ||||
1585 | }; | ||||
1586 | |||||
1587 | class ReferenceTypeBitfields { | ||||
1588 | friend class ReferenceType; | ||||
1589 | |||||
1590 | unsigned : NumTypeBits; | ||||
1591 | |||||
1592 | /// True if the type was originally spelled with an lvalue sigil. | ||||
1593 | /// This is never true of rvalue references but can also be false | ||||
1594 | /// on lvalue references because of C++0x [dcl.typedef]p9, | ||||
1595 | /// as follows: | ||||
1596 | /// | ||||
1597 | /// typedef int &ref; // lvalue, spelled lvalue | ||||
1598 | /// typedef int &&rvref; // rvalue | ||||
1599 | /// ref &a; // lvalue, inner ref, spelled lvalue | ||||
1600 | /// ref &&a; // lvalue, inner ref | ||||
1601 | /// rvref &a; // lvalue, inner ref, spelled lvalue | ||||
1602 | /// rvref &&a; // rvalue, inner ref | ||||
1603 | unsigned SpelledAsLValue : 1; | ||||
1604 | |||||
1605 | /// True if the inner type is a reference type. This only happens | ||||
1606 | /// in non-canonical forms. | ||||
1607 | unsigned InnerRef : 1; | ||||
1608 | }; | ||||
1609 | |||||
1610 | class TypeWithKeywordBitfields { | ||||
1611 | friend class TypeWithKeyword; | ||||
1612 | |||||
1613 | unsigned : NumTypeBits; | ||||
1614 | |||||
1615 | /// An ElaboratedTypeKeyword. 8 bits for efficient access. | ||||
1616 | unsigned Keyword : 8; | ||||
1617 | }; | ||||
1618 | |||||
1619 | enum { NumTypeWithKeywordBits = 8 }; | ||||
1620 | |||||
1621 | class ElaboratedTypeBitfields { | ||||
1622 | friend class ElaboratedType; | ||||
1623 | |||||
1624 | unsigned : NumTypeBits; | ||||
1625 | unsigned : NumTypeWithKeywordBits; | ||||
1626 | |||||
1627 | /// Whether the ElaboratedType has a trailing OwnedTagDecl. | ||||
1628 | unsigned HasOwnedTagDecl : 1; | ||||
1629 | }; | ||||
1630 | |||||
1631 | class VectorTypeBitfields { | ||||
1632 | friend class VectorType; | ||||
1633 | friend class DependentVectorType; | ||||
1634 | |||||
1635 | unsigned : NumTypeBits; | ||||
1636 | |||||
1637 | /// The kind of vector, either a generic vector type or some | ||||
1638 | /// target-specific vector type such as for AltiVec or Neon. | ||||
1639 | unsigned VecKind : 3; | ||||
1640 | |||||
1641 | /// The number of elements in the vector. | ||||
1642 | unsigned NumElements : 29 - NumTypeBits; | ||||
1643 | |||||
1644 | enum { MaxNumElements = (1 << (29 - NumTypeBits)) - 1 }; | ||||
1645 | }; | ||||
1646 | |||||
1647 | class AttributedTypeBitfields { | ||||
1648 | friend class AttributedType; | ||||
1649 | |||||
1650 | unsigned : NumTypeBits; | ||||
1651 | |||||
1652 | /// An AttributedType::Kind | ||||
1653 | unsigned AttrKind : 32 - NumTypeBits; | ||||
1654 | }; | ||||
1655 | |||||
1656 | class AutoTypeBitfields { | ||||
1657 | friend class AutoType; | ||||
1658 | |||||
1659 | unsigned : NumTypeBits; | ||||
1660 | |||||
1661 | /// Was this placeholder type spelled as 'auto', 'decltype(auto)', | ||||
1662 | /// or '__auto_type'? AutoTypeKeyword value. | ||||
1663 | unsigned Keyword : 2; | ||||
1664 | }; | ||||
1665 | |||||
1666 | class SubstTemplateTypeParmPackTypeBitfields { | ||||
1667 | friend class SubstTemplateTypeParmPackType; | ||||
1668 | |||||
1669 | unsigned : NumTypeBits; | ||||
1670 | |||||
1671 | /// The number of template arguments in \c Arguments, which is | ||||
1672 | /// expected to be able to hold at least 1024 according to [implimits]. | ||||
1673 | /// However as this limit is somewhat easy to hit with template | ||||
1674 | /// metaprogramming we'd prefer to keep it as large as possible. | ||||
1675 | /// At the moment it has been left as a non-bitfield since this type | ||||
1676 | /// safely fits in 64 bits as an unsigned, so there is no reason to | ||||
1677 | /// introduce the performance impact of a bitfield. | ||||
1678 | unsigned NumArgs; | ||||
1679 | }; | ||||
1680 | |||||
1681 | class TemplateSpecializationTypeBitfields { | ||||
1682 | friend class TemplateSpecializationType; | ||||
1683 | |||||
1684 | unsigned : NumTypeBits; | ||||
1685 | |||||
1686 | /// Whether this template specialization type is a substituted type alias. | ||||
1687 | unsigned TypeAlias : 1; | ||||
1688 | |||||
1689 | /// The number of template arguments named in this class template | ||||
1690 | /// specialization, which is expected to be able to hold at least 1024 | ||||
1691 | /// according to [implimits]. However, as this limit is somewhat easy to | ||||
1692 | /// hit with template metaprogramming we'd prefer to keep it as large | ||||
1693 | /// as possible. At the moment it has been left as a non-bitfield since | ||||
1694 | /// this type safely fits in 64 bits as an unsigned, so there is no reason | ||||
1695 | /// to introduce the performance impact of a bitfield. | ||||
1696 | unsigned NumArgs; | ||||
1697 | }; | ||||
1698 | |||||
1699 | class DependentTemplateSpecializationTypeBitfields { | ||||
1700 | friend class DependentTemplateSpecializationType; | ||||
1701 | |||||
1702 | unsigned : NumTypeBits; | ||||
1703 | unsigned : NumTypeWithKeywordBits; | ||||
1704 | |||||
1705 | /// The number of template arguments named in this class template | ||||
1706 | /// specialization, which is expected to be able to hold at least 1024 | ||||
1707 | /// according to [implimits]. However, as this limit is somewhat easy to | ||||
1708 | /// hit with template metaprogramming we'd prefer to keep it as large | ||||
1709 | /// as possible. At the moment it has been left as a non-bitfield since | ||||
1710 | /// this type safely fits in 64 bits as an unsigned, so there is no reason | ||||
1711 | /// to introduce the performance impact of a bitfield. | ||||
1712 | unsigned NumArgs; | ||||
1713 | }; | ||||
1714 | |||||
1715 | class PackExpansionTypeBitfields { | ||||
1716 | friend class PackExpansionType; | ||||
1717 | |||||
1718 | unsigned : NumTypeBits; | ||||
1719 | |||||
1720 | /// The number of expansions that this pack expansion will | ||||
1721 | /// generate when substituted (+1), which is expected to be able to | ||||
1722 | /// hold at least 1024 according to [implimits]. However, as this limit | ||||
1723 | /// is somewhat easy to hit with template metaprogramming we'd prefer to | ||||
1724 | /// keep it as large as possible. At the moment it has been left as a | ||||
1725 | /// non-bitfield since this type safely fits in 64 bits as an unsigned, so | ||||
1726 | /// there is no reason to introduce the performance impact of a bitfield. | ||||
1727 | /// | ||||
1728 | /// This field will only have a non-zero value when some of the parameter | ||||
1729 | /// packs that occur within the pattern have been substituted but others | ||||
1730 | /// have not. | ||||
1731 | unsigned NumExpansions; | ||||
1732 | }; | ||||
1733 | |||||
1734 | union { | ||||
1735 | TypeBitfields TypeBits; | ||||
1736 | ArrayTypeBitfields ArrayTypeBits; | ||||
1737 | AttributedTypeBitfields AttributedTypeBits; | ||||
1738 | AutoTypeBitfields AutoTypeBits; | ||||
1739 | BuiltinTypeBitfields BuiltinTypeBits; | ||||
1740 | FunctionTypeBitfields FunctionTypeBits; | ||||
1741 | ObjCObjectTypeBitfields ObjCObjectTypeBits; | ||||
1742 | ReferenceTypeBitfields ReferenceTypeBits; | ||||
1743 | TypeWithKeywordBitfields TypeWithKeywordBits; | ||||
1744 | ElaboratedTypeBitfields ElaboratedTypeBits; | ||||
1745 | VectorTypeBitfields VectorTypeBits; | ||||
1746 | SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits; | ||||
1747 | TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits; | ||||
1748 | DependentTemplateSpecializationTypeBitfields | ||||
1749 | DependentTemplateSpecializationTypeBits; | ||||
1750 | PackExpansionTypeBitfields PackExpansionTypeBits; | ||||
1751 | |||||
1752 | static_assert(sizeof(TypeBitfields) <= 8, | ||||
1753 | "TypeBitfields is larger than 8 bytes!"); | ||||
1754 | static_assert(sizeof(ArrayTypeBitfields) <= 8, | ||||
1755 | "ArrayTypeBitfields is larger than 8 bytes!"); | ||||
1756 | static_assert(sizeof(AttributedTypeBitfields) <= 8, | ||||
1757 | "AttributedTypeBitfields is larger than 8 bytes!"); | ||||
1758 | static_assert(sizeof(AutoTypeBitfields) <= 8, | ||||
1759 | "AutoTypeBitfields is larger than 8 bytes!"); | ||||
1760 | static_assert(sizeof(BuiltinTypeBitfields) <= 8, | ||||
1761 | "BuiltinTypeBitfields is larger than 8 bytes!"); | ||||
1762 | static_assert(sizeof(FunctionTypeBitfields) <= 8, | ||||
1763 | "FunctionTypeBitfields is larger than 8 bytes!"); | ||||
1764 | static_assert(sizeof(ObjCObjectTypeBitfields) <= 8, | ||||
1765 | "ObjCObjectTypeBitfields is larger than 8 bytes!"); | ||||
1766 | static_assert(sizeof(ReferenceTypeBitfields) <= 8, | ||||
1767 | "ReferenceTypeBitfields is larger than 8 bytes!"); | ||||
1768 | static_assert(sizeof(TypeWithKeywordBitfields) <= 8, | ||||
1769 | "TypeWithKeywordBitfields is larger than 8 bytes!"); | ||||
1770 | static_assert(sizeof(ElaboratedTypeBitfields) <= 8, | ||||
1771 | "ElaboratedTypeBitfields is larger than 8 bytes!"); | ||||
1772 | static_assert(sizeof(VectorTypeBitfields) <= 8, | ||||
1773 | "VectorTypeBitfields is larger than 8 bytes!"); | ||||
1774 | static_assert(sizeof(SubstTemplateTypeParmPackTypeBitfields) <= 8, | ||||
1775 | "SubstTemplateTypeParmPackTypeBitfields is larger" | ||||
1776 | " than 8 bytes!"); | ||||
1777 | static_assert(sizeof(TemplateSpecializationTypeBitfields) <= 8, | ||||
1778 | "TemplateSpecializationTypeBitfields is larger" | ||||
1779 | " than 8 bytes!"); | ||||
1780 | static_assert(sizeof(DependentTemplateSpecializationTypeBitfields) <= 8, | ||||
1781 | "DependentTemplateSpecializationTypeBitfields is larger" | ||||
1782 | " than 8 bytes!"); | ||||
1783 | static_assert(sizeof(PackExpansionTypeBitfields) <= 8, | ||||
1784 | "PackExpansionTypeBitfields is larger than 8 bytes"); | ||||
1785 | }; | ||||
1786 | |||||
1787 | private: | ||||
1788 | template <class T> friend class TypePropertyCache; | ||||
1789 | |||||
1790 | /// Set whether this type comes from an AST file. | ||||
1791 | void setFromAST(bool V = true) const { | ||||
1792 | TypeBits.FromAST = V; | ||||
1793 | } | ||||
1794 | |||||
1795 | protected: | ||||
1796 | friend class ASTContext; | ||||
1797 | |||||
1798 | Type(TypeClass tc, QualType canon, bool Dependent, | ||||
1799 | bool InstantiationDependent, bool VariablyModified, | ||||
1800 | bool ContainsUnexpandedParameterPack) | ||||
1801 | : ExtQualsTypeCommonBase(this, | ||||
1802 | canon.isNull() ? QualType(this_(), 0) : canon) { | ||||
1803 | TypeBits.TC = tc; | ||||
1804 | TypeBits.Dependent = Dependent; | ||||
1805 | TypeBits.InstantiationDependent = Dependent || InstantiationDependent; | ||||
1806 | TypeBits.VariablyModified = VariablyModified; | ||||
1807 | TypeBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; | ||||
1808 | TypeBits.CacheValid = false; | ||||
1809 | TypeBits.CachedLocalOrUnnamed = false; | ||||
1810 | TypeBits.CachedLinkage = NoLinkage; | ||||
1811 | TypeBits.FromAST = false; | ||||
1812 | } | ||||
1813 | |||||
1814 | // silence VC++ warning C4355: 'this' : used in base member initializer list | ||||
1815 | Type *this_() { return this; } | ||||
1816 | |||||
1817 | void setDependent(bool D = true) { | ||||
1818 | TypeBits.Dependent = D; | ||||
1819 | if (D) | ||||
1820 | TypeBits.InstantiationDependent = true; | ||||
1821 | } | ||||
1822 | |||||
1823 | void setInstantiationDependent(bool D = true) { | ||||
1824 | TypeBits.InstantiationDependent = D; } | ||||
1825 | |||||
1826 | void setVariablyModified(bool VM = true) { TypeBits.VariablyModified = VM; } | ||||
1827 | |||||
1828 | void setContainsUnexpandedParameterPack(bool PP = true) { | ||||
1829 | TypeBits.ContainsUnexpandedParameterPack = PP; | ||||
1830 | } | ||||
1831 | |||||
1832 | public: | ||||
1833 | friend class ASTReader; | ||||
1834 | friend class ASTWriter; | ||||
1835 | |||||
1836 | Type(const Type &) = delete; | ||||
1837 | Type(Type &&) = delete; | ||||
1838 | Type &operator=(const Type &) = delete; | ||||
1839 | Type &operator=(Type &&) = delete; | ||||
1840 | |||||
1841 | TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); } | ||||
1842 | |||||
1843 | /// Whether this type comes from an AST file. | ||||
1844 | bool isFromAST() const { return TypeBits.FromAST; } | ||||
1845 | |||||
1846 | /// Whether this type is or contains an unexpanded parameter | ||||
1847 | /// pack, used to support C++0x variadic templates. | ||||
1848 | /// | ||||
1849 | /// A type that contains a parameter pack shall be expanded by the | ||||
1850 | /// ellipsis operator at some point. For example, the typedef in the | ||||
1851 | /// following example contains an unexpanded parameter pack 'T': | ||||
1852 | /// | ||||
1853 | /// \code | ||||
1854 | /// template<typename ...T> | ||||
1855 | /// struct X { | ||||
1856 | /// typedef T* pointer_types; // ill-formed; T is a parameter pack. | ||||
1857 | /// }; | ||||
1858 | /// \endcode | ||||
1859 | /// | ||||
1860 | /// Note that this routine does not specify which | ||||
1861 | bool containsUnexpandedParameterPack() const { | ||||
1862 | return TypeBits.ContainsUnexpandedParameterPack; | ||||
1863 | } | ||||
1864 | |||||
1865 | /// Determines if this type would be canonical if it had no further | ||||
1866 | /// qualification. | ||||
1867 | bool isCanonicalUnqualified() const { | ||||
1868 | return CanonicalType == QualType(this, 0); | ||||
1869 | } | ||||
1870 | |||||
1871 | /// Pull a single level of sugar off of this locally-unqualified type. | ||||
1872 | /// Users should generally prefer SplitQualType::getSingleStepDesugaredType() | ||||
1873 | /// or QualType::getSingleStepDesugaredType(const ASTContext&). | ||||
1874 | QualType getLocallyUnqualifiedSingleStepDesugaredType() const; | ||||
1875 | |||||
1876 | /// Types are partitioned into 3 broad categories (C99 6.2.5p1): | ||||
1877 | /// object types, function types, and incomplete types. | ||||
1878 | |||||
1879 | /// Return true if this is an incomplete type. | ||||
1880 | /// A type that can describe objects, but which lacks information needed to | ||||
1881 | /// determine its size (e.g. void, or a fwd declared struct). Clients of this | ||||
1882 | /// routine will need to determine if the size is actually required. | ||||
1883 | /// | ||||
1884 | /// Def If non-null, and the type refers to some kind of declaration | ||||
1885 | /// that can be completed (such as a C struct, C++ class, or Objective-C | ||||
1886 | /// class), will be set to the declaration. | ||||
1887 | bool isIncompleteType(NamedDecl **Def = nullptr) const; | ||||
1888 | |||||
1889 | /// Return true if this is an incomplete or object | ||||
1890 | /// type, in other words, not a function type. | ||||
1891 | bool isIncompleteOrObjectType() const { | ||||
1892 | return !isFunctionType(); | ||||
1893 | } | ||||
1894 | |||||
1895 | /// Determine whether this type is an object type. | ||||
1896 | bool isObjectType() const { | ||||
1897 | // C++ [basic.types]p8: | ||||
1898 | // An object type is a (possibly cv-qualified) type that is not a | ||||
1899 | // function type, not a reference type, and not a void type. | ||||
1900 | return !isReferenceType() && !isFunctionType() && !isVoidType(); | ||||
1901 | } | ||||
1902 | |||||
1903 | /// Return true if this is a literal type | ||||
1904 | /// (C++11 [basic.types]p10) | ||||
1905 | bool isLiteralType(const ASTContext &Ctx) const; | ||||
1906 | |||||
1907 | /// Test if this type is a standard-layout type. | ||||
1908 | /// (C++0x [basic.type]p9) | ||||
1909 | bool isStandardLayoutType() const; | ||||
1910 | |||||
1911 | /// Helper methods to distinguish type categories. All type predicates | ||||
1912 | /// operate on the canonical type, ignoring typedefs and qualifiers. | ||||
1913 | |||||
1914 | /// Returns true if the type is a builtin type. | ||||
1915 | bool isBuiltinType() const; | ||||
1916 | |||||
1917 | /// Test for a particular builtin type. | ||||
1918 | bool isSpecificBuiltinType(unsigned K) const; | ||||
1919 | |||||
1920 | /// Test for a type which does not represent an actual type-system type but | ||||
1921 | /// is instead used as a placeholder for various convenient purposes within | ||||
1922 | /// Clang. All such types are BuiltinTypes. | ||||
1923 | bool isPlaceholderType() const; | ||||
1924 | const BuiltinType *getAsPlaceholderType() const; | ||||
1925 | |||||
1926 | /// Test for a specific placeholder type. | ||||
1927 | bool isSpecificPlaceholderType(unsigned K) const; | ||||
1928 | |||||
1929 | /// Test for a placeholder type other than Overload; see | ||||
1930 | /// BuiltinType::isNonOverloadPlaceholderType. | ||||
1931 | bool isNonOverloadPlaceholderType() const; | ||||
1932 | |||||
1933 | /// isIntegerType() does *not* include complex integers (a GCC extension). | ||||
1934 | /// isComplexIntegerType() can be used to test for complex integers. | ||||
1935 | bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum) | ||||
1936 | bool isEnumeralType() const; | ||||
1937 | |||||
1938 | /// Determine whether this type is a scoped enumeration type. | ||||
1939 | bool isScopedEnumeralType() const; | ||||
1940 | bool isBooleanType() const; | ||||
1941 | bool isCharType() const; | ||||
1942 | bool isWideCharType() const; | ||||
1943 | bool isChar8Type() const; | ||||
1944 | bool isChar16Type() const; | ||||
1945 | bool isChar32Type() const; | ||||
1946 | bool isAnyCharacterType() const; | ||||
1947 | bool isIntegralType(const ASTContext &Ctx) const; | ||||
1948 | |||||
1949 | /// Determine whether this type is an integral or enumeration type. | ||||
1950 | bool isIntegralOrEnumerationType() const; | ||||
1951 | |||||
1952 | /// Determine whether this type is an integral or unscoped enumeration type. | ||||
1953 | bool isIntegralOrUnscopedEnumerationType() const; | ||||
1954 | |||||
1955 | /// Floating point categories. | ||||
1956 | bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double) | ||||
1957 | /// isComplexType() does *not* include complex integers (a GCC extension). | ||||
1958 | /// isComplexIntegerType() can be used to test for complex integers. | ||||
1959 | bool isComplexType() const; // C99 6.2.5p11 (complex) | ||||
1960 | bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int. | ||||
1961 | bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex) | ||||
1962 | bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half) | ||||
1963 | bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661 | ||||
1964 | bool isFloat128Type() const; | ||||
1965 | bool isRealType() const; // C99 6.2.5p17 (real floating + integer) | ||||
1966 | bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating) | ||||
1967 | bool isVoidType() const; // C99 6.2.5p19 | ||||
1968 | bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers) | ||||
1969 | bool isAggregateType() const; | ||||
1970 | bool isFundamentalType() const; | ||||
1971 | bool isCompoundType() const; | ||||
1972 | |||||
1973 | // Type Predicates: Check to see if this type is structurally the specified | ||||
1974 | // type, ignoring typedefs and qualifiers. | ||||
1975 | bool isFunctionType() const; | ||||
1976 | bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); } | ||||
1977 | bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); } | ||||
1978 | bool isPointerType() const; | ||||
1979 | bool isAnyPointerType() const; // Any C pointer or ObjC object pointer | ||||
1980 | bool isBlockPointerType() const; | ||||
1981 | bool isVoidPointerType() const; | ||||
1982 | bool isReferenceType() const; | ||||
1983 | bool isLValueReferenceType() const; | ||||
1984 | bool isRValueReferenceType() const; | ||||
1985 | bool isFunctionPointerType() const; | ||||
1986 | bool isFunctionReferenceType() const; | ||||
1987 | bool isMemberPointerType() const; | ||||
1988 | bool isMemberFunctionPointerType() const; | ||||
1989 | bool isMemberDataPointerType() const; | ||||
1990 | bool isArrayType() const; | ||||
1991 | bool isConstantArrayType() const; | ||||
1992 | bool isIncompleteArrayType() const; | ||||
1993 | bool isVariableArrayType() const; | ||||
1994 | bool isDependentSizedArrayType() const; | ||||
1995 | bool isRecordType() const; | ||||
1996 | bool isClassType() const; | ||||
1997 | bool isStructureType() const; | ||||
1998 | bool isObjCBoxableRecordType() const; | ||||
1999 | bool isInterfaceType() const; | ||||
2000 | bool isStructureOrClassType() const; | ||||
2001 | bool isUnionType() const; | ||||
2002 | bool isComplexIntegerType() const; // GCC _Complex integer type. | ||||
2003 | bool isVectorType() const; // GCC vector type. | ||||
2004 | bool isExtVectorType() const; // Extended vector type. | ||||
2005 | bool isDependentAddressSpaceType() const; // value-dependent address space qualifier | ||||
2006 | bool isObjCObjectPointerType() const; // pointer to ObjC object | ||||
2007 | bool isObjCRetainableType() const; // ObjC object or block pointer | ||||
2008 | bool isObjCLifetimeType() const; // (array of)* retainable type | ||||
2009 | bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type | ||||
2010 | bool isObjCNSObjectType() const; // __attribute__((NSObject)) | ||||
2011 | bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class)) | ||||
2012 | // FIXME: change this to 'raw' interface type, so we can used 'interface' type | ||||
2013 | // for the common case. | ||||
2014 | bool isObjCObjectType() const; // NSString or typeof(*(id)0) | ||||
2015 | bool isObjCQualifiedInterfaceType() const; // NSString<foo> | ||||
2016 | bool isObjCQualifiedIdType() const; // id<foo> | ||||
2017 | bool isObjCQualifiedClassType() const; // Class<foo> | ||||
2018 | bool isObjCObjectOrInterfaceType() const; | ||||
2019 | bool isObjCIdType() const; // id | ||||
2020 | bool isDecltypeType() const; | ||||
2021 | /// Was this type written with the special inert-in-ARC __unsafe_unretained | ||||
2022 | /// qualifier? | ||||
2023 | /// | ||||
2024 | /// This approximates the answer to the following question: if this | ||||
2025 | /// translation unit were compiled in ARC, would this type be qualified | ||||
2026 | /// with __unsafe_unretained? | ||||
2027 | bool isObjCInertUnsafeUnretainedType() const { | ||||
2028 | return hasAttr(attr::ObjCInertUnsafeUnretained); | ||||
2029 | } | ||||
2030 | |||||
2031 | /// Whether the type is Objective-C 'id' or a __kindof type of an | ||||
2032 | /// object type, e.g., __kindof NSView * or __kindof id | ||||
2033 | /// <NSCopying>. | ||||
2034 | /// | ||||
2035 | /// \param bound Will be set to the bound on non-id subtype types, | ||||
2036 | /// which will be (possibly specialized) Objective-C class type, or | ||||
2037 | /// null for 'id. | ||||
2038 | bool isObjCIdOrObjectKindOfType(const ASTContext &ctx, | ||||
2039 | const ObjCObjectType *&bound) const; | ||||
2040 | |||||
2041 | bool isObjCClassType() const; // Class | ||||
2042 | |||||
2043 | /// Whether the type is Objective-C 'Class' or a __kindof type of an | ||||
2044 | /// Class type, e.g., __kindof Class <NSCopying>. | ||||
2045 | /// | ||||
2046 | /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound | ||||
2047 | /// here because Objective-C's type system cannot express "a class | ||||
2048 | /// object for a subclass of NSFoo". | ||||
2049 | bool isObjCClassOrClassKindOfType() const; | ||||
2050 | |||||
2051 | bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const; | ||||
2052 | bool isObjCSelType() const; // Class | ||||
2053 | bool isObjCBuiltinType() const; // 'id' or 'Class' | ||||
2054 | bool isObjCARCBridgableType() const; | ||||
2055 | bool isCARCBridgableType() const; | ||||
2056 | bool isTemplateTypeParmType() const; // C++ template type parameter | ||||
2057 | bool isNullPtrType() const; // C++11 std::nullptr_t | ||||
2058 | bool isNothrowT() const; // C++ std::nothrow_t | ||||
2059 | bool isAlignValT() const; // C++17 std::align_val_t | ||||
2060 | bool isStdByteType() const; // C++17 std::byte | ||||
2061 | bool isAtomicType() const; // C11 _Atomic() | ||||
2062 | |||||
2063 | #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ | ||||
2064 | bool is##Id##Type() const; | ||||
2065 | #include "clang/Basic/OpenCLImageTypes.def" | ||||
2066 | |||||
2067 | bool isImageType() const; // Any OpenCL image type | ||||
2068 | |||||
2069 | bool isSamplerT() const; // OpenCL sampler_t | ||||
2070 | bool isEventT() const; // OpenCL event_t | ||||
2071 | bool isClkEventT() const; // OpenCL clk_event_t | ||||
2072 | bool isQueueT() const; // OpenCL queue_t | ||||
2073 | bool isReserveIDT() const; // OpenCL reserve_id_t | ||||
2074 | |||||
2075 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ | ||||
2076 | bool is##Id##Type() const; | ||||
2077 | #include "clang/Basic/OpenCLExtensionTypes.def" | ||||
2078 | // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension | ||||
2079 | bool isOCLIntelSubgroupAVCType() const; | ||||
2080 | bool isOCLExtOpaqueType() const; // Any OpenCL extension type | ||||
2081 | |||||
2082 | bool isPipeType() const; // OpenCL pipe type | ||||
2083 | bool isOpenCLSpecificType() const; // Any OpenCL specific type | ||||
2084 | |||||
2085 | /// Determines if this type, which must satisfy | ||||
2086 | /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather | ||||
2087 | /// than implicitly __strong. | ||||
2088 | bool isObjCARCImplicitlyUnretainedType() const; | ||||
2089 | |||||
2090 | /// Return the implicit lifetime for this type, which must not be dependent. | ||||
2091 | Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const; | ||||
2092 | |||||
2093 | enum ScalarTypeKind { | ||||
2094 | STK_CPointer, | ||||
2095 | STK_BlockPointer, | ||||
2096 | STK_ObjCObjectPointer, | ||||
2097 | STK_MemberPointer, | ||||
2098 | STK_Bool, | ||||
2099 | STK_Integral, | ||||
2100 | STK_Floating, | ||||
2101 | STK_IntegralComplex, | ||||
2102 | STK_FloatingComplex, | ||||
2103 | STK_FixedPoint | ||||
2104 | }; | ||||
2105 | |||||
2106 | /// Given that this is a scalar type, classify it. | ||||
2107 | ScalarTypeKind getScalarTypeKind() const; | ||||
2108 | |||||
2109 | /// Whether this type is a dependent type, meaning that its definition | ||||
2110 | /// somehow depends on a template parameter (C++ [temp.dep.type]). | ||||
2111 | bool isDependentType() const { return TypeBits.Dependent; } | ||||
2112 | |||||
2113 | /// Determine whether this type is an instantiation-dependent type, | ||||
2114 | /// meaning that the type involves a template parameter (even if the | ||||
2115 | /// definition does not actually depend on the type substituted for that | ||||
2116 | /// template parameter). | ||||
2117 | bool isInstantiationDependentType() const { | ||||
2118 | return TypeBits.InstantiationDependent; | ||||
2119 | } | ||||
2120 | |||||
2121 | /// Determine whether this type is an undeduced type, meaning that | ||||
2122 | /// it somehow involves a C++11 'auto' type or similar which has not yet been | ||||
2123 | /// deduced. | ||||
2124 | bool isUndeducedType() const; | ||||
2125 | |||||
2126 | /// Whether this type is a variably-modified type (C99 6.7.5). | ||||
2127 | bool isVariablyModifiedType() const { return TypeBits.VariablyModified; } | ||||
2128 | |||||
2129 | /// Whether this type involves a variable-length array type | ||||
2130 | /// with a definite size. | ||||
2131 | bool hasSizedVLAType() const; | ||||
2132 | |||||
2133 | /// Whether this type is or contains a local or unnamed type. | ||||
2134 | bool hasUnnamedOrLocalType() const; | ||||
2135 | |||||
2136 | bool isOverloadableType() const; | ||||
2137 | |||||
2138 | /// Determine wither this type is a C++ elaborated-type-specifier. | ||||
2139 | bool isElaboratedTypeSpecifier() const; | ||||
2140 | |||||
2141 | bool canDecayToPointerType() const; | ||||
2142 | |||||
2143 | /// Whether this type is represented natively as a pointer. This includes | ||||
2144 | /// pointers, references, block pointers, and Objective-C interface, | ||||
2145 | /// qualified id, and qualified interface types, as well as nullptr_t. | ||||
2146 | bool hasPointerRepresentation() const; | ||||
2147 | |||||
2148 | /// Whether this type can represent an objective pointer type for the | ||||
2149 | /// purpose of GC'ability | ||||
2150 | bool hasObjCPointerRepresentation() const; | ||||
2151 | |||||
2152 | /// Determine whether this type has an integer representation | ||||
2153 | /// of some sort, e.g., it is an integer type or a vector. | ||||
2154 | bool hasIntegerRepresentation() const; | ||||
2155 | |||||
2156 | /// Determine whether this type has an signed integer representation | ||||
2157 | /// of some sort, e.g., it is an signed integer type or a vector. | ||||
2158 | bool hasSignedIntegerRepresentation() const; | ||||
2159 | |||||
2160 | /// Determine whether this type has an unsigned integer representation | ||||
2161 | /// of some sort, e.g., it is an unsigned integer type or a vector. | ||||
2162 | bool hasUnsignedIntegerRepresentation() const; | ||||
2163 | |||||
2164 | /// Determine whether this type has a floating-point representation | ||||
2165 | /// of some sort, e.g., it is a floating-point type or a vector thereof. | ||||
2166 | bool hasFloatingRepresentation() const; | ||||
2167 | |||||
2168 | // Type Checking Functions: Check to see if this type is structurally the | ||||
2169 | // specified type, ignoring typedefs and qualifiers, and return a pointer to | ||||
2170 | // the best type we can. | ||||
2171 | const RecordType *getAsStructureType() const; | ||||
2172 | /// NOTE: getAs*ArrayType are methods on ASTContext. | ||||
2173 | const RecordType *getAsUnionType() const; | ||||
2174 | const ComplexType *getAsComplexIntegerType() const; // GCC complex int type. | ||||
2175 | const ObjCObjectType *getAsObjCInterfaceType() const; | ||||
2176 | |||||
2177 | // The following is a convenience method that returns an ObjCObjectPointerType | ||||
2178 | // for object declared using an interface. | ||||
2179 | const ObjCObjectPointerType *getAsObjCInterfacePointerType() const; | ||||
2180 | const ObjCObjectPointerType *getAsObjCQualifiedIdType() const; | ||||
2181 | const ObjCObjectPointerType *getAsObjCQualifiedClassType() const; | ||||
2182 | const ObjCObjectType *getAsObjCQualifiedInterfaceType() const; | ||||
2183 | |||||
2184 | /// Retrieves the CXXRecordDecl that this type refers to, either | ||||
2185 | /// because the type is a RecordType or because it is the injected-class-name | ||||
2186 | /// type of a class template or class template partial specialization. | ||||
2187 | CXXRecordDecl *getAsCXXRecordDecl() const; | ||||
2188 | |||||
2189 | /// Retrieves the RecordDecl this type refers to. | ||||
2190 | RecordDecl *getAsRecordDecl() const; | ||||
2191 | |||||
2192 | /// Retrieves the TagDecl that this type refers to, either | ||||
2193 | /// because the type is a TagType or because it is the injected-class-name | ||||
2194 | /// type of a class template or class template partial specialization. | ||||
2195 | TagDecl *getAsTagDecl() const; | ||||
2196 | |||||
2197 | /// If this is a pointer or reference to a RecordType, return the | ||||
2198 | /// CXXRecordDecl that the type refers to. | ||||
2199 | /// | ||||
2200 | /// If this is not a pointer or reference, or the type being pointed to does | ||||
2201 | /// not refer to a CXXRecordDecl, returns NULL. | ||||
2202 | const CXXRecordDecl *getPointeeCXXRecordDecl() const; | ||||
2203 | |||||
2204 | /// Get the DeducedType whose type will be deduced for a variable with | ||||
2205 | /// an initializer of this type. This looks through declarators like pointer | ||||
2206 | /// types, but not through decltype or typedefs. | ||||
2207 | DeducedType *getContainedDeducedType() const; | ||||
2208 | |||||
2209 | /// Get the AutoType whose type will be deduced for a variable with | ||||
2210 | /// an initializer of this type. This looks through declarators like pointer | ||||
2211 | /// types, but not through decltype or typedefs. | ||||
2212 | AutoType *getContainedAutoType() const { | ||||
2213 | return dyn_cast_or_null<AutoType>(getContainedDeducedType()); | ||||
2214 | } | ||||
2215 | |||||
2216 | /// Determine whether this type was written with a leading 'auto' | ||||
2217 | /// corresponding to a trailing return type (possibly for a nested | ||||
2218 | /// function type within a pointer to function type or similar). | ||||
2219 | bool hasAutoForTrailingReturnType() const; | ||||
2220 | |||||
2221 | /// Member-template getAs<specific type>'. Look through sugar for | ||||
2222 | /// an instance of \<specific type>. This scheme will eventually | ||||
2223 | /// replace the specific getAsXXXX methods above. | ||||
2224 | /// | ||||
2225 | /// There are some specializations of this member template listed | ||||
2226 | /// immediately following this class. | ||||
2227 | template <typename T> const T *getAs() const; | ||||
2228 | |||||
2229 | /// Member-template getAsAdjusted<specific type>. Look through specific kinds | ||||
2230 | /// of sugar (parens, attributes, etc) for an instance of \<specific type>. | ||||
2231 | /// This is used when you need to walk over sugar nodes that represent some | ||||
2232 | /// kind of type adjustment from a type that was written as a \<specific type> | ||||
2233 | /// to another type that is still canonically a \<specific type>. | ||||
2234 | template <typename T> const T *getAsAdjusted() const; | ||||
2235 | |||||
2236 | /// A variant of getAs<> for array types which silently discards | ||||
2237 | /// qualifiers from the outermost type. | ||||
2238 | const ArrayType *getAsArrayTypeUnsafe() const; | ||||
2239 | |||||
2240 | /// Member-template castAs<specific type>. Look through sugar for | ||||
2241 | /// the underlying instance of \<specific type>. | ||||
2242 | /// | ||||
2243 | /// This method has the same relationship to getAs<T> as cast<T> has | ||||
2244 | /// to dyn_cast<T>; which is to say, the underlying type *must* | ||||
2245 | /// have the intended type, and this method will never return null. | ||||
2246 | template <typename T> const T *castAs() const; | ||||
2247 | |||||
2248 | /// A variant of castAs<> for array type which silently discards | ||||
2249 | /// qualifiers from the outermost type. | ||||
2250 | const ArrayType *castAsArrayTypeUnsafe() const; | ||||
2251 | |||||
2252 | /// Determine whether this type had the specified attribute applied to it | ||||
2253 | /// (looking through top-level type sugar). | ||||
2254 | bool hasAttr(attr::Kind AK) const; | ||||
2255 | |||||
2256 | /// Get the base element type of this type, potentially discarding type | ||||
2257 | /// qualifiers. This should never be used when type qualifiers | ||||
2258 | /// are meaningful. | ||||
2259 | const Type *getBaseElementTypeUnsafe() const; | ||||
2260 | |||||
2261 | /// If this is an array type, return the element type of the array, | ||||
2262 | /// potentially with type qualifiers missing. | ||||
2263 | /// This should never be used when type qualifiers are meaningful. | ||||
2264 | const Type *getArrayElementTypeNoTypeQual() const; | ||||
2265 | |||||
2266 | /// If this is a pointer type, return the pointee type. | ||||
2267 | /// If this is an array type, return the array element type. | ||||
2268 | /// This should never be used when type qualifiers are meaningful. | ||||
2269 | const Type *getPointeeOrArrayElementType() const; | ||||
2270 | |||||
2271 | /// If this is a pointer, ObjC object pointer, or block | ||||
2272 | /// pointer, this returns the respective pointee. | ||||
2273 | QualType getPointeeType() const; | ||||
2274 | |||||
2275 | /// Return the specified type with any "sugar" removed from the type, | ||||
2276 | /// removing any typedefs, typeofs, etc., as well as any qualifiers. | ||||
2277 | const Type *getUnqualifiedDesugaredType() const; | ||||
2278 | |||||
2279 | /// More type predicates useful for type checking/promotion | ||||
2280 | bool isPromotableIntegerType() const; // C99 6.3.1.1p2 | ||||
2281 | |||||
2282 | /// Return true if this is an integer type that is | ||||
2283 | /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], | ||||
2284 | /// or an enum decl which has a signed representation. | ||||
2285 | bool isSignedIntegerType() const; | ||||
2286 | |||||
2287 | /// Return true if this is an integer type that is | ||||
2288 | /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], | ||||
2289 | /// or an enum decl which has an unsigned representation. | ||||
2290 | bool isUnsignedIntegerType() const; | ||||
2291 | |||||
2292 | /// Determines whether this is an integer type that is signed or an | ||||
2293 | /// enumeration types whose underlying type is a signed integer type. | ||||
2294 | bool isSignedIntegerOrEnumerationType() const; | ||||
2295 | |||||
2296 | /// Determines whether this is an integer type that is unsigned or an | ||||
2297 | /// enumeration types whose underlying type is a unsigned integer type. | ||||
2298 | bool isUnsignedIntegerOrEnumerationType() const; | ||||
2299 | |||||
2300 | /// Return true if this is a fixed point type according to | ||||
2301 | /// ISO/IEC JTC1 SC22 WG14 N1169. | ||||
2302 | bool isFixedPointType() const; | ||||
2303 | |||||
2304 | /// Return true if this is a fixed point or integer type. | ||||
2305 | bool isFixedPointOrIntegerType() const; | ||||
2306 | |||||
2307 | /// Return true if this is a saturated fixed point type according to | ||||
2308 | /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned. | ||||
2309 | bool isSaturatedFixedPointType() const; | ||||
2310 | |||||
2311 | /// Return true if this is a saturated fixed point type according to | ||||
2312 | /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned. | ||||
2313 | bool isUnsaturatedFixedPointType() const; | ||||
2314 | |||||
2315 | /// Return true if this is a fixed point type that is signed according | ||||
2316 | /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated. | ||||
2317 | bool isSignedFixedPointType() const; | ||||
2318 | |||||
2319 | /// Return true if this is a fixed point type that is unsigned according | ||||
2320 | /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated. | ||||
2321 | bool isUnsignedFixedPointType() const; | ||||
2322 | |||||
2323 | /// Return true if this is not a variable sized type, | ||||
2324 | /// according to the rules of C99 6.7.5p3. It is not legal to call this on | ||||
2325 | /// incomplete types. | ||||
2326 | bool isConstantSizeType() const; | ||||
2327 | |||||
2328 | /// Returns true if this type can be represented by some | ||||
2329 | /// set of type specifiers. | ||||
2330 | bool isSpecifierType() const; | ||||
2331 | |||||
2332 | /// Determine the linkage of this type. | ||||
2333 | Linkage getLinkage() const; | ||||
2334 | |||||
2335 | /// Determine the visibility of this type. | ||||
2336 | Visibility getVisibility() const { | ||||
2337 | return getLinkageAndVisibility().getVisibility(); | ||||
2338 | } | ||||
2339 | |||||
2340 | /// Return true if the visibility was explicitly set is the code. | ||||
2341 | bool isVisibilityExplicit() const { | ||||
2342 | return getLinkageAndVisibility().isVisibilityExplicit(); | ||||
2343 | } | ||||
2344 | |||||
2345 | /// Determine the linkage and visibility of this type. | ||||
2346 | LinkageInfo getLinkageAndVisibility() const; | ||||
2347 | |||||
2348 | /// True if the computed linkage is valid. Used for consistency | ||||
2349 | /// checking. Should always return true. | ||||
2350 | bool isLinkageValid() const; | ||||
2351 | |||||
2352 | /// Determine the nullability of the given type. | ||||
2353 | /// | ||||
2354 | /// Note that nullability is only captured as sugar within the type | ||||
2355 | /// system, not as part of the canonical type, so nullability will | ||||
2356 | /// be lost by canonicalization and desugaring. | ||||
2357 | Optional<NullabilityKind> getNullability(const ASTContext &context) const; | ||||
2358 | |||||
2359 | /// Determine whether the given type can have a nullability | ||||
2360 | /// specifier applied to it, i.e., if it is any kind of pointer type. | ||||
2361 | /// | ||||
2362 | /// \param ResultIfUnknown The value to return if we don't yet know whether | ||||
2363 | /// this type can have nullability because it is dependent. | ||||
2364 | bool canHaveNullability(bool ResultIfUnknown = true) const; | ||||
2365 | |||||
2366 | /// Retrieve the set of substitutions required when accessing a member | ||||
2367 | /// of the Objective-C receiver type that is declared in the given context. | ||||
2368 | /// | ||||
2369 | /// \c *this is the type of the object we're operating on, e.g., the | ||||
2370 | /// receiver for a message send or the base of a property access, and is | ||||
2371 | /// expected to be of some object or object pointer type. | ||||
2372 | /// | ||||
2373 | /// \param dc The declaration context for which we are building up a | ||||
2374 | /// substitution mapping, which should be an Objective-C class, extension, | ||||
2375 | /// category, or method within. | ||||
2376 | /// | ||||
2377 | /// \returns an array of type arguments that can be substituted for | ||||
2378 | /// the type parameters of the given declaration context in any type described | ||||
2379 | /// within that context, or an empty optional to indicate that no | ||||
2380 | /// substitution is required. | ||||
2381 | Optional<ArrayRef<QualType>> | ||||
2382 | getObjCSubstitutions(const DeclContext *dc) const; | ||||
2383 | |||||
2384 | /// Determines if this is an ObjC interface type that may accept type | ||||
2385 | /// parameters. | ||||
2386 | bool acceptsObjCTypeParams() const; | ||||
2387 | |||||
2388 | const char *getTypeClassName() const; | ||||
2389 | |||||
2390 | QualType getCanonicalTypeInternal() const { | ||||
2391 | return CanonicalType; | ||||
2392 | } | ||||
2393 | |||||
2394 | CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h | ||||
2395 | void dump() const; | ||||
2396 | void dump(llvm::raw_ostream &OS) const; | ||||
2397 | }; | ||||
2398 | |||||
2399 | /// This will check for a TypedefType by removing any existing sugar | ||||
2400 | /// until it reaches a TypedefType or a non-sugared type. | ||||
2401 | template <> const TypedefType *Type::getAs() const; | ||||
2402 | |||||
2403 | /// This will check for a TemplateSpecializationType by removing any | ||||
2404 | /// existing sugar until it reaches a TemplateSpecializationType or a | ||||
2405 | /// non-sugared type. | ||||
2406 | template <> const TemplateSpecializationType *Type::getAs() const; | ||||
2407 | |||||
2408 | /// This will check for an AttributedType by removing any existing sugar | ||||
2409 | /// until it reaches an AttributedType or a non-sugared type. | ||||
2410 | template <> const AttributedType *Type::getAs() const; | ||||
2411 | |||||
2412 | // We can do canonical leaf types faster, because we don't have to | ||||
2413 | // worry about preserving child type decoration. | ||||
2414 | #define TYPE(Class, Base) | ||||
2415 | #define LEAF_TYPE(Class) \ | ||||
2416 | template <> inline const Class##Type *Type::getAs() const { \ | ||||
2417 | return dyn_cast<Class##Type>(CanonicalType); \ | ||||
2418 | } \ | ||||
2419 | template <> inline const Class##Type *Type::castAs() const { \ | ||||
2420 | return cast<Class##Type>(CanonicalType); \ | ||||
2421 | } | ||||
2422 | #include "clang/AST/TypeNodes.inc" | ||||
2423 | |||||
2424 | /// This class is used for builtin types like 'int'. Builtin | ||||
2425 | /// types are always canonical and have a literal name field. | ||||
2426 | class BuiltinType : public Type { | ||||
2427 | public: | ||||
2428 | enum Kind { | ||||
2429 | // OpenCL image types | ||||
2430 | #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id, | ||||
2431 | #include "clang/Basic/OpenCLImageTypes.def" | ||||
2432 | // OpenCL extension types | ||||
2433 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id, | ||||
2434 | #include "clang/Basic/OpenCLExtensionTypes.def" | ||||
2435 | // SVE Types | ||||
2436 | #define SVE_TYPE(Name, Id, SingletonId) Id, | ||||
2437 | #include "clang/Basic/AArch64SVEACLETypes.def" | ||||
2438 | // All other builtin types | ||||
2439 | #define BUILTIN_TYPE(Id, SingletonId) Id, | ||||
2440 | #define LAST_BUILTIN_TYPE(Id) LastKind = Id | ||||
2441 | #include "clang/AST/BuiltinTypes.def" | ||||
2442 | }; | ||||
2443 | |||||
2444 | private: | ||||
2445 | friend class ASTContext; // ASTContext creates these. | ||||
2446 | |||||
2447 | BuiltinType(Kind K) | ||||
2448 | : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent), | ||||
2449 | /*InstantiationDependent=*/(K == Dependent), | ||||
2450 | /*VariablyModified=*/false, | ||||
2451 | /*Unexpanded parameter pack=*/false) { | ||||
2452 | BuiltinTypeBits.Kind = K; | ||||
2453 | } | ||||
2454 | |||||
2455 | public: | ||||
2456 | Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); } | ||||
2457 | StringRef getName(const PrintingPolicy &Policy) const; | ||||
2458 | |||||
2459 | const char *getNameAsCString(const PrintingPolicy &Policy) const { | ||||
2460 | // The StringRef is null-terminated. | ||||
2461 | StringRef str = getName(Policy); | ||||
2462 | assert(!str.empty() && str.data()[str.size()] == '\0')((!str.empty() && str.data()[str.size()] == '\0') ? static_cast <void> (0) : __assert_fail ("!str.empty() && str.data()[str.size()] == '\\0'" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 2462, __PRETTY_FUNCTION__)); | ||||
2463 | return str.data(); | ||||
2464 | } | ||||
2465 | |||||
2466 | bool isSugared() const { return false; } | ||||
2467 | QualType desugar() const { return QualType(this, 0); } | ||||
2468 | |||||
2469 | bool isInteger() const { | ||||
2470 | return getKind() >= Bool && getKind() <= Int128; | ||||
2471 | } | ||||
2472 | |||||
2473 | bool isSignedInteger() const { | ||||
2474 | return getKind() >= Char_S && getKind() <= Int128; | ||||
2475 | } | ||||
2476 | |||||
2477 | bool isUnsignedInteger() const { | ||||
2478 | return getKind() >= Bool && getKind() <= UInt128; | ||||
2479 | } | ||||
2480 | |||||
2481 | bool isFloatingPoint() const { | ||||
2482 | return getKind() >= Half && getKind() <= Float128; | ||||
2483 | } | ||||
2484 | |||||
2485 | /// Determines whether the given kind corresponds to a placeholder type. | ||||
2486 | static bool isPlaceholderTypeKind(Kind K) { | ||||
2487 | return K >= Overload; | ||||
2488 | } | ||||
2489 | |||||
2490 | /// Determines whether this type is a placeholder type, i.e. a type | ||||
2491 | /// which cannot appear in arbitrary positions in a fully-formed | ||||
2492 | /// expression. | ||||
2493 | bool isPlaceholderType() const { | ||||
2494 | return isPlaceholderTypeKind(getKind()); | ||||
2495 | } | ||||
2496 | |||||
2497 | /// Determines whether this type is a placeholder type other than | ||||
2498 | /// Overload. Most placeholder types require only syntactic | ||||
2499 | /// information about their context in order to be resolved (e.g. | ||||
2500 | /// whether it is a call expression), which means they can (and | ||||
2501 | /// should) be resolved in an earlier "phase" of analysis. | ||||
2502 | /// Overload expressions sometimes pick up further information | ||||
2503 | /// from their context, like whether the context expects a | ||||
2504 | /// specific function-pointer type, and so frequently need | ||||
2505 | /// special treatment. | ||||
2506 | bool isNonOverloadPlaceholderType() const { | ||||
2507 | return getKind() > Overload; | ||||
2508 | } | ||||
2509 | |||||
2510 | static bool classof(const Type *T) { return T->getTypeClass() == Builtin; } | ||||
2511 | }; | ||||
2512 | |||||
2513 | /// Complex values, per C99 6.2.5p11. This supports the C99 complex | ||||
2514 | /// types (_Complex float etc) as well as the GCC integer complex extensions. | ||||
2515 | class ComplexType : public Type, public llvm::FoldingSetNode { | ||||
2516 | friend class ASTContext; // ASTContext creates these. | ||||
2517 | |||||
2518 | QualType ElementType; | ||||
2519 | |||||
2520 | ComplexType(QualType Element, QualType CanonicalPtr) | ||||
2521 | : Type(Complex, CanonicalPtr, Element->isDependentType(), | ||||
2522 | Element->isInstantiationDependentType(), | ||||
2523 | Element->isVariablyModifiedType(), | ||||
2524 | Element->containsUnexpandedParameterPack()), | ||||
2525 | ElementType(Element) {} | ||||
2526 | |||||
2527 | public: | ||||
2528 | QualType getElementType() const { return ElementType; } | ||||
2529 | |||||
2530 | bool isSugared() const { return false; } | ||||
2531 | QualType desugar() const { return QualType(this, 0); } | ||||
2532 | |||||
2533 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2534 | Profile(ID, getElementType()); | ||||
2535 | } | ||||
2536 | |||||
2537 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) { | ||||
2538 | ID.AddPointer(Element.getAsOpaquePtr()); | ||||
2539 | } | ||||
2540 | |||||
2541 | static bool classof(const Type *T) { return T->getTypeClass() == Complex; } | ||||
2542 | }; | ||||
2543 | |||||
2544 | /// Sugar for parentheses used when specifying types. | ||||
2545 | class ParenType : public Type, public llvm::FoldingSetNode { | ||||
2546 | friend class ASTContext; // ASTContext creates these. | ||||
2547 | |||||
2548 | QualType Inner; | ||||
2549 | |||||
2550 | ParenType(QualType InnerType, QualType CanonType) | ||||
2551 | : Type(Paren, CanonType, InnerType->isDependentType(), | ||||
2552 | InnerType->isInstantiationDependentType(), | ||||
2553 | InnerType->isVariablyModifiedType(), | ||||
2554 | InnerType->containsUnexpandedParameterPack()), | ||||
2555 | Inner(InnerType) {} | ||||
2556 | |||||
2557 | public: | ||||
2558 | QualType getInnerType() const { return Inner; } | ||||
2559 | |||||
2560 | bool isSugared() const { return true; } | ||||
2561 | QualType desugar() const { return getInnerType(); } | ||||
2562 | |||||
2563 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2564 | Profile(ID, getInnerType()); | ||||
2565 | } | ||||
2566 | |||||
2567 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) { | ||||
2568 | Inner.Profile(ID); | ||||
2569 | } | ||||
2570 | |||||
2571 | static bool classof(const Type *T) { return T->getTypeClass() == Paren; } | ||||
2572 | }; | ||||
2573 | |||||
2574 | /// PointerType - C99 6.7.5.1 - Pointer Declarators. | ||||
2575 | class PointerType : public Type, public llvm::FoldingSetNode { | ||||
2576 | friend class ASTContext; // ASTContext creates these. | ||||
2577 | |||||
2578 | QualType PointeeType; | ||||
2579 | |||||
2580 | PointerType(QualType Pointee, QualType CanonicalPtr) | ||||
2581 | : Type(Pointer, CanonicalPtr, Pointee->isDependentType(), | ||||
2582 | Pointee->isInstantiationDependentType(), | ||||
2583 | Pointee->isVariablyModifiedType(), | ||||
2584 | Pointee->containsUnexpandedParameterPack()), | ||||
2585 | PointeeType(Pointee) {} | ||||
2586 | |||||
2587 | public: | ||||
2588 | QualType getPointeeType() const { return PointeeType; } | ||||
2589 | |||||
2590 | /// Returns true if address spaces of pointers overlap. | ||||
2591 | /// OpenCL v2.0 defines conversion rules for pointers to different | ||||
2592 | /// address spaces (OpenCLC v2.0 s6.5.5) and notion of overlapping | ||||
2593 | /// address spaces. | ||||
2594 | /// CL1.1 or CL1.2: | ||||
2595 | /// address spaces overlap iff they are they same. | ||||
2596 | /// CL2.0 adds: | ||||
2597 | /// __generic overlaps with any address space except for __constant. | ||||
2598 | bool isAddressSpaceOverlapping(const PointerType &other) const { | ||||
2599 | Qualifiers thisQuals = PointeeType.getQualifiers(); | ||||
2600 | Qualifiers otherQuals = other.getPointeeType().getQualifiers(); | ||||
2601 | // Address spaces overlap if at least one of them is a superset of another | ||||
2602 | return thisQuals.isAddressSpaceSupersetOf(otherQuals) || | ||||
2603 | otherQuals.isAddressSpaceSupersetOf(thisQuals); | ||||
2604 | } | ||||
2605 | |||||
2606 | bool isSugared() const { return false; } | ||||
2607 | QualType desugar() const { return QualType(this, 0); } | ||||
2608 | |||||
2609 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2610 | Profile(ID, getPointeeType()); | ||||
2611 | } | ||||
2612 | |||||
2613 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) { | ||||
2614 | ID.AddPointer(Pointee.getAsOpaquePtr()); | ||||
2615 | } | ||||
2616 | |||||
2617 | static bool classof(const Type *T) { return T->getTypeClass() == Pointer; } | ||||
2618 | }; | ||||
2619 | |||||
2620 | /// Represents a type which was implicitly adjusted by the semantic | ||||
2621 | /// engine for arbitrary reasons. For example, array and function types can | ||||
2622 | /// decay, and function types can have their calling conventions adjusted. | ||||
2623 | class AdjustedType : public Type, public llvm::FoldingSetNode { | ||||
2624 | QualType OriginalTy; | ||||
2625 | QualType AdjustedTy; | ||||
2626 | |||||
2627 | protected: | ||||
2628 | friend class ASTContext; // ASTContext creates these. | ||||
2629 | |||||
2630 | AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy, | ||||
2631 | QualType CanonicalPtr) | ||||
2632 | : Type(TC, CanonicalPtr, OriginalTy->isDependentType(), | ||||
2633 | OriginalTy->isInstantiationDependentType(), | ||||
2634 | OriginalTy->isVariablyModifiedType(), | ||||
2635 | OriginalTy->containsUnexpandedParameterPack()), | ||||
2636 | OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {} | ||||
2637 | |||||
2638 | public: | ||||
2639 | QualType getOriginalType() const { return OriginalTy; } | ||||
2640 | QualType getAdjustedType() const { return AdjustedTy; } | ||||
2641 | |||||
2642 | bool isSugared() const { return true; } | ||||
2643 | QualType desugar() const { return AdjustedTy; } | ||||
2644 | |||||
2645 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2646 | Profile(ID, OriginalTy, AdjustedTy); | ||||
2647 | } | ||||
2648 | |||||
2649 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) { | ||||
2650 | ID.AddPointer(Orig.getAsOpaquePtr()); | ||||
2651 | ID.AddPointer(New.getAsOpaquePtr()); | ||||
2652 | } | ||||
2653 | |||||
2654 | static bool classof(const Type *T) { | ||||
2655 | return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed; | ||||
2656 | } | ||||
2657 | }; | ||||
2658 | |||||
2659 | /// Represents a pointer type decayed from an array or function type. | ||||
2660 | class DecayedType : public AdjustedType { | ||||
2661 | friend class ASTContext; // ASTContext creates these. | ||||
2662 | |||||
2663 | inline | ||||
2664 | DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical); | ||||
2665 | |||||
2666 | public: | ||||
2667 | QualType getDecayedType() const { return getAdjustedType(); } | ||||
2668 | |||||
2669 | inline QualType getPointeeType() const; | ||||
2670 | |||||
2671 | static bool classof(const Type *T) { return T->getTypeClass() == Decayed; } | ||||
2672 | }; | ||||
2673 | |||||
2674 | /// Pointer to a block type. | ||||
2675 | /// This type is to represent types syntactically represented as | ||||
2676 | /// "void (^)(int)", etc. Pointee is required to always be a function type. | ||||
2677 | class BlockPointerType : public Type, public llvm::FoldingSetNode { | ||||
2678 | friend class ASTContext; // ASTContext creates these. | ||||
2679 | |||||
2680 | // Block is some kind of pointer type | ||||
2681 | QualType PointeeType; | ||||
2682 | |||||
2683 | BlockPointerType(QualType Pointee, QualType CanonicalCls) | ||||
2684 | : Type(BlockPointer, CanonicalCls, Pointee->isDependentType(), | ||||
2685 | Pointee->isInstantiationDependentType(), | ||||
2686 | Pointee->isVariablyModifiedType(), | ||||
2687 | Pointee->containsUnexpandedParameterPack()), | ||||
2688 | PointeeType(Pointee) {} | ||||
2689 | |||||
2690 | public: | ||||
2691 | // Get the pointee type. Pointee is required to always be a function type. | ||||
2692 | QualType getPointeeType() const { return PointeeType; } | ||||
2693 | |||||
2694 | bool isSugared() const { return false; } | ||||
2695 | QualType desugar() const { return QualType(this, 0); } | ||||
2696 | |||||
2697 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2698 | Profile(ID, getPointeeType()); | ||||
2699 | } | ||||
2700 | |||||
2701 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) { | ||||
2702 | ID.AddPointer(Pointee.getAsOpaquePtr()); | ||||
2703 | } | ||||
2704 | |||||
2705 | static bool classof(const Type *T) { | ||||
2706 | return T->getTypeClass() == BlockPointer; | ||||
2707 | } | ||||
2708 | }; | ||||
2709 | |||||
2710 | /// Base for LValueReferenceType and RValueReferenceType | ||||
2711 | class ReferenceType : public Type, public llvm::FoldingSetNode { | ||||
2712 | QualType PointeeType; | ||||
2713 | |||||
2714 | protected: | ||||
2715 | ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef, | ||||
2716 | bool SpelledAsLValue) | ||||
2717 | : Type(tc, CanonicalRef, Referencee->isDependentType(), | ||||
2718 | Referencee->isInstantiationDependentType(), | ||||
2719 | Referencee->isVariablyModifiedType(), | ||||
2720 | Referencee->containsUnexpandedParameterPack()), | ||||
2721 | PointeeType(Referencee) { | ||||
2722 | ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue; | ||||
2723 | ReferenceTypeBits.InnerRef = Referencee->isReferenceType(); | ||||
2724 | } | ||||
2725 | |||||
2726 | public: | ||||
2727 | bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; } | ||||
2728 | bool isInnerRef() const { return ReferenceTypeBits.InnerRef; } | ||||
2729 | |||||
2730 | QualType getPointeeTypeAsWritten() const { return PointeeType; } | ||||
2731 | |||||
2732 | QualType getPointeeType() const { | ||||
2733 | // FIXME: this might strip inner qualifiers; okay? | ||||
2734 | const ReferenceType *T = this; | ||||
2735 | while (T->isInnerRef()) | ||||
2736 | T = T->PointeeType->castAs<ReferenceType>(); | ||||
2737 | return T->PointeeType; | ||||
2738 | } | ||||
2739 | |||||
2740 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2741 | Profile(ID, PointeeType, isSpelledAsLValue()); | ||||
2742 | } | ||||
2743 | |||||
2744 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
2745 | QualType Referencee, | ||||
2746 | bool SpelledAsLValue) { | ||||
2747 | ID.AddPointer(Referencee.getAsOpaquePtr()); | ||||
2748 | ID.AddBoolean(SpelledAsLValue); | ||||
2749 | } | ||||
2750 | |||||
2751 | static bool classof(const Type *T) { | ||||
2752 | return T->getTypeClass() == LValueReference || | ||||
2753 | T->getTypeClass() == RValueReference; | ||||
2754 | } | ||||
2755 | }; | ||||
2756 | |||||
2757 | /// An lvalue reference type, per C++11 [dcl.ref]. | ||||
2758 | class LValueReferenceType : public ReferenceType { | ||||
2759 | friend class ASTContext; // ASTContext creates these | ||||
2760 | |||||
2761 | LValueReferenceType(QualType Referencee, QualType CanonicalRef, | ||||
2762 | bool SpelledAsLValue) | ||||
2763 | : ReferenceType(LValueReference, Referencee, CanonicalRef, | ||||
2764 | SpelledAsLValue) {} | ||||
2765 | |||||
2766 | public: | ||||
2767 | bool isSugared() const { return false; } | ||||
2768 | QualType desugar() const { return QualType(this, 0); } | ||||
2769 | |||||
2770 | static bool classof(const Type *T) { | ||||
2771 | return T->getTypeClass() == LValueReference; | ||||
2772 | } | ||||
2773 | }; | ||||
2774 | |||||
2775 | /// An rvalue reference type, per C++11 [dcl.ref]. | ||||
2776 | class RValueReferenceType : public ReferenceType { | ||||
2777 | friend class ASTContext; // ASTContext creates these | ||||
2778 | |||||
2779 | RValueReferenceType(QualType Referencee, QualType CanonicalRef) | ||||
2780 | : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {} | ||||
2781 | |||||
2782 | public: | ||||
2783 | bool isSugared() const { return false; } | ||||
2784 | QualType desugar() const { return QualType(this, 0); } | ||||
2785 | |||||
2786 | static bool classof(const Type *T) { | ||||
2787 | return T->getTypeClass() == RValueReference; | ||||
2788 | } | ||||
2789 | }; | ||||
2790 | |||||
2791 | /// A pointer to member type per C++ 8.3.3 - Pointers to members. | ||||
2792 | /// | ||||
2793 | /// This includes both pointers to data members and pointer to member functions. | ||||
2794 | class MemberPointerType : public Type, public llvm::FoldingSetNode { | ||||
2795 | friend class ASTContext; // ASTContext creates these. | ||||
2796 | |||||
2797 | QualType PointeeType; | ||||
2798 | |||||
2799 | /// The class of which the pointee is a member. Must ultimately be a | ||||
2800 | /// RecordType, but could be a typedef or a template parameter too. | ||||
2801 | const Type *Class; | ||||
2802 | |||||
2803 | MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr) | ||||
2804 | : Type(MemberPointer, CanonicalPtr, | ||||
2805 | Cls->isDependentType() || Pointee->isDependentType(), | ||||
2806 | (Cls->isInstantiationDependentType() || | ||||
2807 | Pointee->isInstantiationDependentType()), | ||||
2808 | Pointee->isVariablyModifiedType(), | ||||
2809 | (Cls->containsUnexpandedParameterPack() || | ||||
2810 | Pointee->containsUnexpandedParameterPack())), | ||||
2811 | PointeeType(Pointee), Class(Cls) {} | ||||
2812 | |||||
2813 | public: | ||||
2814 | QualType getPointeeType() const { return PointeeType; } | ||||
2815 | |||||
2816 | /// Returns true if the member type (i.e. the pointee type) is a | ||||
2817 | /// function type rather than a data-member type. | ||||
2818 | bool isMemberFunctionPointer() const { | ||||
2819 | return PointeeType->isFunctionProtoType(); | ||||
2820 | } | ||||
2821 | |||||
2822 | /// Returns true if the member type (i.e. the pointee type) is a | ||||
2823 | /// data type rather than a function type. | ||||
2824 | bool isMemberDataPointer() const { | ||||
2825 | return !PointeeType->isFunctionProtoType(); | ||||
2826 | } | ||||
2827 | |||||
2828 | const Type *getClass() const { return Class; } | ||||
2829 | CXXRecordDecl *getMostRecentCXXRecordDecl() const; | ||||
2830 | |||||
2831 | bool isSugared() const { return false; } | ||||
2832 | QualType desugar() const { return QualType(this, 0); } | ||||
2833 | |||||
2834 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2835 | Profile(ID, getPointeeType(), getClass()); | ||||
2836 | } | ||||
2837 | |||||
2838 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee, | ||||
2839 | const Type *Class) { | ||||
2840 | ID.AddPointer(Pointee.getAsOpaquePtr()); | ||||
2841 | ID.AddPointer(Class); | ||||
2842 | } | ||||
2843 | |||||
2844 | static bool classof(const Type *T) { | ||||
2845 | return T->getTypeClass() == MemberPointer; | ||||
2846 | } | ||||
2847 | }; | ||||
2848 | |||||
2849 | /// Represents an array type, per C99 6.7.5.2 - Array Declarators. | ||||
2850 | class ArrayType : public Type, public llvm::FoldingSetNode { | ||||
2851 | public: | ||||
2852 | /// Capture whether this is a normal array (e.g. int X[4]) | ||||
2853 | /// an array with a static size (e.g. int X[static 4]), or an array | ||||
2854 | /// with a star size (e.g. int X[*]). | ||||
2855 | /// 'static' is only allowed on function parameters. | ||||
2856 | enum ArraySizeModifier { | ||||
2857 | Normal, Static, Star | ||||
2858 | }; | ||||
2859 | |||||
2860 | private: | ||||
2861 | /// The element type of the array. | ||||
2862 | QualType ElementType; | ||||
2863 | |||||
2864 | protected: | ||||
2865 | friend class ASTContext; // ASTContext creates these. | ||||
2866 | |||||
2867 | // C++ [temp.dep.type]p1: | ||||
2868 | // A type is dependent if it is... | ||||
2869 | // - an array type constructed from any dependent type or whose | ||||
2870 | // size is specified by a constant expression that is | ||||
2871 | // value-dependent, | ||||
2872 | ArrayType(TypeClass tc, QualType et, QualType can, | ||||
2873 | ArraySizeModifier sm, unsigned tq, | ||||
2874 | bool ContainsUnexpandedParameterPack) | ||||
2875 | : Type(tc, can, et->isDependentType() || tc == DependentSizedArray, | ||||
2876 | et->isInstantiationDependentType() || tc == DependentSizedArray, | ||||
2877 | (tc == VariableArray || et->isVariablyModifiedType()), | ||||
2878 | ContainsUnexpandedParameterPack), | ||||
2879 | ElementType(et) { | ||||
2880 | ArrayTypeBits.IndexTypeQuals = tq; | ||||
2881 | ArrayTypeBits.SizeModifier = sm; | ||||
2882 | } | ||||
2883 | |||||
2884 | public: | ||||
2885 | QualType getElementType() const { return ElementType; } | ||||
2886 | |||||
2887 | ArraySizeModifier getSizeModifier() const { | ||||
2888 | return ArraySizeModifier(ArrayTypeBits.SizeModifier); | ||||
2889 | } | ||||
2890 | |||||
2891 | Qualifiers getIndexTypeQualifiers() const { | ||||
2892 | return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers()); | ||||
2893 | } | ||||
2894 | |||||
2895 | unsigned getIndexTypeCVRQualifiers() const { | ||||
2896 | return ArrayTypeBits.IndexTypeQuals; | ||||
2897 | } | ||||
2898 | |||||
2899 | static bool classof(const Type *T) { | ||||
2900 | return T->getTypeClass() == ConstantArray || | ||||
2901 | T->getTypeClass() == VariableArray || | ||||
2902 | T->getTypeClass() == IncompleteArray || | ||||
2903 | T->getTypeClass() == DependentSizedArray; | ||||
2904 | } | ||||
2905 | }; | ||||
2906 | |||||
2907 | /// Represents the canonical version of C arrays with a specified constant size. | ||||
2908 | /// For example, the canonical type for 'int A[4 + 4*100]' is a | ||||
2909 | /// ConstantArrayType where the element type is 'int' and the size is 404. | ||||
2910 | class ConstantArrayType : public ArrayType { | ||||
2911 | llvm::APInt Size; // Allows us to unique the type. | ||||
2912 | |||||
2913 | ConstantArrayType(QualType et, QualType can, const llvm::APInt &size, | ||||
2914 | ArraySizeModifier sm, unsigned tq) | ||||
2915 | : ArrayType(ConstantArray, et, can, sm, tq, | ||||
2916 | et->containsUnexpandedParameterPack()), | ||||
2917 | Size(size) {} | ||||
2918 | |||||
2919 | protected: | ||||
2920 | friend class ASTContext; // ASTContext creates these. | ||||
2921 | |||||
2922 | ConstantArrayType(TypeClass tc, QualType et, QualType can, | ||||
2923 | const llvm::APInt &size, ArraySizeModifier sm, unsigned tq) | ||||
2924 | : ArrayType(tc, et, can, sm, tq, et->containsUnexpandedParameterPack()), | ||||
2925 | Size(size) {} | ||||
2926 | |||||
2927 | public: | ||||
2928 | const llvm::APInt &getSize() const { return Size; } | ||||
2929 | bool isSugared() const { return false; } | ||||
2930 | QualType desugar() const { return QualType(this, 0); } | ||||
2931 | |||||
2932 | /// Determine the number of bits required to address a member of | ||||
2933 | // an array with the given element type and number of elements. | ||||
2934 | static unsigned getNumAddressingBits(const ASTContext &Context, | ||||
2935 | QualType ElementType, | ||||
2936 | const llvm::APInt &NumElements); | ||||
2937 | |||||
2938 | /// Determine the maximum number of active bits that an array's size | ||||
2939 | /// can require, which limits the maximum size of the array. | ||||
2940 | static unsigned getMaxSizeBits(const ASTContext &Context); | ||||
2941 | |||||
2942 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2943 | Profile(ID, getElementType(), getSize(), | ||||
2944 | getSizeModifier(), getIndexTypeCVRQualifiers()); | ||||
2945 | } | ||||
2946 | |||||
2947 | static void Profile(llvm::FoldingSetNodeID &ID, QualType ET, | ||||
2948 | const llvm::APInt &ArraySize, ArraySizeModifier SizeMod, | ||||
2949 | unsigned TypeQuals) { | ||||
2950 | ID.AddPointer(ET.getAsOpaquePtr()); | ||||
2951 | ID.AddInteger(ArraySize.getZExtValue()); | ||||
2952 | ID.AddInteger(SizeMod); | ||||
2953 | ID.AddInteger(TypeQuals); | ||||
2954 | } | ||||
2955 | |||||
2956 | static bool classof(const Type *T) { | ||||
2957 | return T->getTypeClass() == ConstantArray; | ||||
2958 | } | ||||
2959 | }; | ||||
2960 | |||||
2961 | /// Represents a C array with an unspecified size. For example 'int A[]' has | ||||
2962 | /// an IncompleteArrayType where the element type is 'int' and the size is | ||||
2963 | /// unspecified. | ||||
2964 | class IncompleteArrayType : public ArrayType { | ||||
2965 | friend class ASTContext; // ASTContext creates these. | ||||
2966 | |||||
2967 | IncompleteArrayType(QualType et, QualType can, | ||||
2968 | ArraySizeModifier sm, unsigned tq) | ||||
2969 | : ArrayType(IncompleteArray, et, can, sm, tq, | ||||
2970 | et->containsUnexpandedParameterPack()) {} | ||||
2971 | |||||
2972 | public: | ||||
2973 | friend class StmtIteratorBase; | ||||
2974 | |||||
2975 | bool isSugared() const { return false; } | ||||
2976 | QualType desugar() const { return QualType(this, 0); } | ||||
2977 | |||||
2978 | static bool classof(const Type *T) { | ||||
2979 | return T->getTypeClass() == IncompleteArray; | ||||
2980 | } | ||||
2981 | |||||
2982 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
2983 | Profile(ID, getElementType(), getSizeModifier(), | ||||
2984 | getIndexTypeCVRQualifiers()); | ||||
2985 | } | ||||
2986 | |||||
2987 | static void Profile(llvm::FoldingSetNodeID &ID, QualType ET, | ||||
2988 | ArraySizeModifier SizeMod, unsigned TypeQuals) { | ||||
2989 | ID.AddPointer(ET.getAsOpaquePtr()); | ||||
2990 | ID.AddInteger(SizeMod); | ||||
2991 | ID.AddInteger(TypeQuals); | ||||
2992 | } | ||||
2993 | }; | ||||
2994 | |||||
2995 | /// Represents a C array with a specified size that is not an | ||||
2996 | /// integer-constant-expression. For example, 'int s[x+foo()]'. | ||||
2997 | /// Since the size expression is an arbitrary expression, we store it as such. | ||||
2998 | /// | ||||
2999 | /// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and | ||||
3000 | /// should not be: two lexically equivalent variable array types could mean | ||||
3001 | /// different things, for example, these variables do not have the same type | ||||
3002 | /// dynamically: | ||||
3003 | /// | ||||
3004 | /// void foo(int x) { | ||||
3005 | /// int Y[x]; | ||||
3006 | /// ++x; | ||||
3007 | /// int Z[x]; | ||||
3008 | /// } | ||||
3009 | class VariableArrayType : public ArrayType { | ||||
3010 | friend class ASTContext; // ASTContext creates these. | ||||
3011 | |||||
3012 | /// An assignment-expression. VLA's are only permitted within | ||||
3013 | /// a function block. | ||||
3014 | Stmt *SizeExpr; | ||||
3015 | |||||
3016 | /// The range spanned by the left and right array brackets. | ||||
3017 | SourceRange Brackets; | ||||
3018 | |||||
3019 | VariableArrayType(QualType et, QualType can, Expr *e, | ||||
3020 | ArraySizeModifier sm, unsigned tq, | ||||
3021 | SourceRange brackets) | ||||
3022 | : ArrayType(VariableArray, et, can, sm, tq, | ||||
3023 | et->containsUnexpandedParameterPack()), | ||||
3024 | SizeExpr((Stmt*) e), Brackets(brackets) {} | ||||
3025 | |||||
3026 | public: | ||||
3027 | friend class StmtIteratorBase; | ||||
3028 | |||||
3029 | Expr *getSizeExpr() const { | ||||
3030 | // We use C-style casts instead of cast<> here because we do not wish | ||||
3031 | // to have a dependency of Type.h on Stmt.h/Expr.h. | ||||
3032 | return (Expr*) SizeExpr; | ||||
3033 | } | ||||
3034 | |||||
3035 | SourceRange getBracketsRange() const { return Brackets; } | ||||
3036 | SourceLocation getLBracketLoc() const { return Brackets.getBegin(); } | ||||
3037 | SourceLocation getRBracketLoc() const { return Brackets.getEnd(); } | ||||
3038 | |||||
3039 | bool isSugared() const { return false; } | ||||
3040 | QualType desugar() const { return QualType(this, 0); } | ||||
3041 | |||||
3042 | static bool classof(const Type *T) { | ||||
3043 | return T->getTypeClass() == VariableArray; | ||||
3044 | } | ||||
3045 | |||||
3046 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
3047 | llvm_unreachable("Cannot unique VariableArrayTypes.")::llvm::llvm_unreachable_internal("Cannot unique VariableArrayTypes." , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 3047); | ||||
3048 | } | ||||
3049 | }; | ||||
3050 | |||||
3051 | /// Represents an array type in C++ whose size is a value-dependent expression. | ||||
3052 | /// | ||||
3053 | /// For example: | ||||
3054 | /// \code | ||||
3055 | /// template<typename T, int Size> | ||||
3056 | /// class array { | ||||
3057 | /// T data[Size]; | ||||
3058 | /// }; | ||||
3059 | /// \endcode | ||||
3060 | /// | ||||
3061 | /// For these types, we won't actually know what the array bound is | ||||
3062 | /// until template instantiation occurs, at which point this will | ||||
3063 | /// become either a ConstantArrayType or a VariableArrayType. | ||||
3064 | class DependentSizedArrayType : public ArrayType { | ||||
3065 | friend class ASTContext; // ASTContext creates these. | ||||
3066 | |||||
3067 | const ASTContext &Context; | ||||
3068 | |||||
3069 | /// An assignment expression that will instantiate to the | ||||
3070 | /// size of the array. | ||||
3071 | /// | ||||
3072 | /// The expression itself might be null, in which case the array | ||||
3073 | /// type will have its size deduced from an initializer. | ||||
3074 | Stmt *SizeExpr; | ||||
3075 | |||||
3076 | /// The range spanned by the left and right array brackets. | ||||
3077 | SourceRange Brackets; | ||||
3078 | |||||
3079 | DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can, | ||||
3080 | Expr *e, ArraySizeModifier sm, unsigned tq, | ||||
3081 | SourceRange brackets); | ||||
3082 | |||||
3083 | public: | ||||
3084 | friend class StmtIteratorBase; | ||||
3085 | |||||
3086 | Expr *getSizeExpr() const { | ||||
3087 | // We use C-style casts instead of cast<> here because we do not wish | ||||
3088 | // to have a dependency of Type.h on Stmt.h/Expr.h. | ||||
3089 | return (Expr*) SizeExpr; | ||||
3090 | } | ||||
3091 | |||||
3092 | SourceRange getBracketsRange() const { return Brackets; } | ||||
3093 | SourceLocation getLBracketLoc() const { return Brackets.getBegin(); } | ||||
3094 | SourceLocation getRBracketLoc() const { return Brackets.getEnd(); } | ||||
3095 | |||||
3096 | bool isSugared() const { return false; } | ||||
3097 | QualType desugar() const { return QualType(this, 0); } | ||||
3098 | |||||
3099 | static bool classof(const Type *T) { | ||||
3100 | return T->getTypeClass() == DependentSizedArray; | ||||
3101 | } | ||||
3102 | |||||
3103 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
3104 | Profile(ID, Context, getElementType(), | ||||
3105 | getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr()); | ||||
3106 | } | ||||
3107 | |||||
3108 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, | ||||
3109 | QualType ET, ArraySizeModifier SizeMod, | ||||
3110 | unsigned TypeQuals, Expr *E); | ||||
3111 | }; | ||||
3112 | |||||
3113 | /// Represents an extended address space qualifier where the input address space | ||||
3114 | /// value is dependent. Non-dependent address spaces are not represented with a | ||||
3115 | /// special Type subclass; they are stored on an ExtQuals node as part of a QualType. | ||||
3116 | /// | ||||
3117 | /// For example: | ||||
3118 | /// \code | ||||
3119 | /// template<typename T, int AddrSpace> | ||||
3120 | /// class AddressSpace { | ||||
3121 | /// typedef T __attribute__((address_space(AddrSpace))) type; | ||||
3122 | /// } | ||||
3123 | /// \endcode | ||||
3124 | class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode { | ||||
3125 | friend class ASTContext; | ||||
3126 | |||||
3127 | const ASTContext &Context; | ||||
3128 | Expr *AddrSpaceExpr; | ||||
3129 | QualType PointeeType; | ||||
3130 | SourceLocation loc; | ||||
3131 | |||||
3132 | DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType, | ||||
3133 | QualType can, Expr *AddrSpaceExpr, | ||||
3134 | SourceLocation loc); | ||||
3135 | |||||
3136 | public: | ||||
3137 | Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; } | ||||
3138 | QualType getPointeeType() const { return PointeeType; } | ||||
3139 | SourceLocation getAttributeLoc() const { return loc; } | ||||
3140 | |||||
3141 | bool isSugared() const { return false; } | ||||
3142 | QualType desugar() const { return QualType(this, 0); } | ||||
3143 | |||||
3144 | static bool classof(const Type *T) { | ||||
3145 | return T->getTypeClass() == DependentAddressSpace; | ||||
3146 | } | ||||
3147 | |||||
3148 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
3149 | Profile(ID, Context, getPointeeType(), getAddrSpaceExpr()); | ||||
3150 | } | ||||
3151 | |||||
3152 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, | ||||
3153 | QualType PointeeType, Expr *AddrSpaceExpr); | ||||
3154 | }; | ||||
3155 | |||||
3156 | /// Represents an extended vector type where either the type or size is | ||||
3157 | /// dependent. | ||||
3158 | /// | ||||
3159 | /// For example: | ||||
3160 | /// \code | ||||
3161 | /// template<typename T, int Size> | ||||
3162 | /// class vector { | ||||
3163 | /// typedef T __attribute__((ext_vector_type(Size))) type; | ||||
3164 | /// } | ||||
3165 | /// \endcode | ||||
3166 | class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode { | ||||
3167 | friend class ASTContext; | ||||
3168 | |||||
3169 | const ASTContext &Context; | ||||
3170 | Expr *SizeExpr; | ||||
3171 | |||||
3172 | /// The element type of the array. | ||||
3173 | QualType ElementType; | ||||
3174 | |||||
3175 | SourceLocation loc; | ||||
3176 | |||||
3177 | DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType, | ||||
3178 | QualType can, Expr *SizeExpr, SourceLocation loc); | ||||
3179 | |||||
3180 | public: | ||||
3181 | Expr *getSizeExpr() const { return SizeExpr; } | ||||
3182 | QualType getElementType() const { return ElementType; } | ||||
3183 | SourceLocation getAttributeLoc() const { return loc; } | ||||
3184 | |||||
3185 | bool isSugared() const { return false; } | ||||
3186 | QualType desugar() const { return QualType(this, 0); } | ||||
3187 | |||||
3188 | static bool classof(const Type *T) { | ||||
3189 | return T->getTypeClass() == DependentSizedExtVector; | ||||
3190 | } | ||||
3191 | |||||
3192 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
3193 | Profile(ID, Context, getElementType(), getSizeExpr()); | ||||
3194 | } | ||||
3195 | |||||
3196 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, | ||||
3197 | QualType ElementType, Expr *SizeExpr); | ||||
3198 | }; | ||||
3199 | |||||
3200 | |||||
3201 | /// Represents a GCC generic vector type. This type is created using | ||||
3202 | /// __attribute__((vector_size(n)), where "n" specifies the vector size in | ||||
3203 | /// bytes; or from an Altivec __vector or vector declaration. | ||||
3204 | /// Since the constructor takes the number of vector elements, the | ||||
3205 | /// client is responsible for converting the size into the number of elements. | ||||
3206 | class VectorType : public Type, public llvm::FoldingSetNode { | ||||
3207 | public: | ||||
3208 | enum VectorKind { | ||||
3209 | /// not a target-specific vector type | ||||
3210 | GenericVector, | ||||
3211 | |||||
3212 | /// is AltiVec vector | ||||
3213 | AltiVecVector, | ||||
3214 | |||||
3215 | /// is AltiVec 'vector Pixel' | ||||
3216 | AltiVecPixel, | ||||
3217 | |||||
3218 | /// is AltiVec 'vector bool ...' | ||||
3219 | AltiVecBool, | ||||
3220 | |||||
3221 | /// is ARM Neon vector | ||||
3222 | NeonVector, | ||||
3223 | |||||
3224 | /// is ARM Neon polynomial vector | ||||
3225 | NeonPolyVector | ||||
3226 | }; | ||||
3227 | |||||
3228 | protected: | ||||
3229 | friend class ASTContext; // ASTContext creates these. | ||||
3230 | |||||
3231 | /// The element type of the vector. | ||||
3232 | QualType ElementType; | ||||
3233 | |||||
3234 | VectorType(QualType vecType, unsigned nElements, QualType canonType, | ||||
3235 | VectorKind vecKind); | ||||
3236 | |||||
3237 | VectorType(TypeClass tc, QualType vecType, unsigned nElements, | ||||
3238 | QualType canonType, VectorKind vecKind); | ||||
3239 | |||||
3240 | public: | ||||
3241 | QualType getElementType() const { return ElementType; } | ||||
3242 | unsigned getNumElements() const { return VectorTypeBits.NumElements; } | ||||
3243 | |||||
3244 | static bool isVectorSizeTooLarge(unsigned NumElements) { | ||||
3245 | return NumElements > VectorTypeBitfields::MaxNumElements; | ||||
3246 | } | ||||
3247 | |||||
3248 | bool isSugared() const { return false; } | ||||
3249 | QualType desugar() const { return QualType(this, 0); } | ||||
3250 | |||||
3251 | VectorKind getVectorKind() const { | ||||
3252 | return VectorKind(VectorTypeBits.VecKind); | ||||
3253 | } | ||||
3254 | |||||
3255 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
3256 | Profile(ID, getElementType(), getNumElements(), | ||||
3257 | getTypeClass(), getVectorKind()); | ||||
3258 | } | ||||
3259 | |||||
3260 | static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType, | ||||
3261 | unsigned NumElements, TypeClass TypeClass, | ||||
3262 | VectorKind VecKind) { | ||||
3263 | ID.AddPointer(ElementType.getAsOpaquePtr()); | ||||
3264 | ID.AddInteger(NumElements); | ||||
3265 | ID.AddInteger(TypeClass); | ||||
3266 | ID.AddInteger(VecKind); | ||||
3267 | } | ||||
3268 | |||||
3269 | static bool classof(const Type *T) { | ||||
3270 | return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector; | ||||
3271 | } | ||||
3272 | }; | ||||
3273 | |||||
3274 | /// Represents a vector type where either the type or size is dependent. | ||||
3275 | //// | ||||
3276 | /// For example: | ||||
3277 | /// \code | ||||
3278 | /// template<typename T, int Size> | ||||
3279 | /// class vector { | ||||
3280 | /// typedef T __attribute__((vector_size(Size))) type; | ||||
3281 | /// } | ||||
3282 | /// \endcode | ||||
3283 | class DependentVectorType : public Type, public llvm::FoldingSetNode { | ||||
3284 | friend class ASTContext; | ||||
3285 | |||||
3286 | const ASTContext &Context; | ||||
3287 | QualType ElementType; | ||||
3288 | Expr *SizeExpr; | ||||
3289 | SourceLocation Loc; | ||||
3290 | |||||
3291 | DependentVectorType(const ASTContext &Context, QualType ElementType, | ||||
3292 | QualType CanonType, Expr *SizeExpr, | ||||
3293 | SourceLocation Loc, VectorType::VectorKind vecKind); | ||||
3294 | |||||
3295 | public: | ||||
3296 | Expr *getSizeExpr() const { return SizeExpr; } | ||||
3297 | QualType getElementType() const { return ElementType; } | ||||
3298 | SourceLocation getAttributeLoc() const { return Loc; } | ||||
3299 | VectorType::VectorKind getVectorKind() const { | ||||
3300 | return VectorType::VectorKind(VectorTypeBits.VecKind); | ||||
3301 | } | ||||
3302 | |||||
3303 | bool isSugared() const { return false; } | ||||
3304 | QualType desugar() const { return QualType(this, 0); } | ||||
3305 | |||||
3306 | static bool classof(const Type *T) { | ||||
3307 | return T->getTypeClass() == DependentVector; | ||||
3308 | } | ||||
3309 | |||||
3310 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
3311 | Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind()); | ||||
3312 | } | ||||
3313 | |||||
3314 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, | ||||
3315 | QualType ElementType, const Expr *SizeExpr, | ||||
3316 | VectorType::VectorKind VecKind); | ||||
3317 | }; | ||||
3318 | |||||
3319 | /// ExtVectorType - Extended vector type. This type is created using | ||||
3320 | /// __attribute__((ext_vector_type(n)), where "n" is the number of elements. | ||||
3321 | /// Unlike vector_size, ext_vector_type is only allowed on typedef's. This | ||||
3322 | /// class enables syntactic extensions, like Vector Components for accessing | ||||
3323 | /// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL | ||||
3324 | /// Shading Language). | ||||
3325 | class ExtVectorType : public VectorType { | ||||
3326 | friend class ASTContext; // ASTContext creates these. | ||||
3327 | |||||
3328 | ExtVectorType(QualType vecType, unsigned nElements, QualType canonType) | ||||
3329 | : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {} | ||||
3330 | |||||
3331 | public: | ||||
3332 | static int getPointAccessorIdx(char c) { | ||||
3333 | switch (c) { | ||||
3334 | default: return -1; | ||||
3335 | case 'x': case 'r': return 0; | ||||
3336 | case 'y': case 'g': return 1; | ||||
3337 | case 'z': case 'b': return 2; | ||||
3338 | case 'w': case 'a': return 3; | ||||
3339 | } | ||||
3340 | } | ||||
3341 | |||||
3342 | static int getNumericAccessorIdx(char c) { | ||||
3343 | switch (c) { | ||||
3344 | default: return -1; | ||||
3345 | case '0': return 0; | ||||
3346 | case '1': return 1; | ||||
3347 | case '2': return 2; | ||||
3348 | case '3': return 3; | ||||
3349 | case '4': return 4; | ||||
3350 | case '5': return 5; | ||||
3351 | case '6': return 6; | ||||
3352 | case '7': return 7; | ||||
3353 | case '8': return 8; | ||||
3354 | case '9': return 9; | ||||
3355 | case 'A': | ||||
3356 | case 'a': return 10; | ||||
3357 | case 'B': | ||||
3358 | case 'b': return 11; | ||||
3359 | case 'C': | ||||
3360 | case 'c': return 12; | ||||
3361 | case 'D': | ||||
3362 | case 'd': return 13; | ||||
3363 | case 'E': | ||||
3364 | case 'e': return 14; | ||||
3365 | case 'F': | ||||
3366 | case 'f': return 15; | ||||
3367 | } | ||||
3368 | } | ||||
3369 | |||||
3370 | static int getAccessorIdx(char c, bool isNumericAccessor) { | ||||
3371 | if (isNumericAccessor) | ||||
3372 | return getNumericAccessorIdx(c); | ||||
3373 | else | ||||
3374 | return getPointAccessorIdx(c); | ||||
3375 | } | ||||
3376 | |||||
3377 | bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const { | ||||
3378 | if (int idx = getAccessorIdx(c, isNumericAccessor)+1) | ||||
3379 | return unsigned(idx-1) < getNumElements(); | ||||
3380 | return false; | ||||
3381 | } | ||||
3382 | |||||
3383 | bool isSugared() const { return false; } | ||||
3384 | QualType desugar() const { return QualType(this, 0); } | ||||
3385 | |||||
3386 | static bool classof(const Type *T) { | ||||
3387 | return T->getTypeClass() == ExtVector; | ||||
3388 | } | ||||
3389 | }; | ||||
3390 | |||||
3391 | /// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base | ||||
3392 | /// class of FunctionNoProtoType and FunctionProtoType. | ||||
3393 | class FunctionType : public Type { | ||||
3394 | // The type returned by the function. | ||||
3395 | QualType ResultType; | ||||
3396 | |||||
3397 | public: | ||||
3398 | /// Interesting information about a specific parameter that can't simply | ||||
3399 | /// be reflected in parameter's type. This is only used by FunctionProtoType | ||||
3400 | /// but is in FunctionType to make this class available during the | ||||
3401 | /// specification of the bases of FunctionProtoType. | ||||
3402 | /// | ||||
3403 | /// It makes sense to model language features this way when there's some | ||||
3404 | /// sort of parameter-specific override (such as an attribute) that | ||||
3405 | /// affects how the function is called. For example, the ARC ns_consumed | ||||
3406 | /// attribute changes whether a parameter is passed at +0 (the default) | ||||
3407 | /// or +1 (ns_consumed). This must be reflected in the function type, | ||||
3408 | /// but isn't really a change to the parameter type. | ||||
3409 | /// | ||||
3410 | /// One serious disadvantage of modelling language features this way is | ||||
3411 | /// that they generally do not work with language features that attempt | ||||
3412 | /// to destructure types. For example, template argument deduction will | ||||
3413 | /// not be able to match a parameter declared as | ||||
3414 | /// T (*)(U) | ||||
3415 | /// against an argument of type | ||||
3416 | /// void (*)(__attribute__((ns_consumed)) id) | ||||
3417 | /// because the substitution of T=void, U=id into the former will | ||||
3418 | /// not produce the latter. | ||||
3419 | class ExtParameterInfo { | ||||
3420 | enum { | ||||
3421 | ABIMask = 0x0F, | ||||
3422 | IsConsumed = 0x10, | ||||
3423 | HasPassObjSize = 0x20, | ||||
3424 | IsNoEscape = 0x40, | ||||
3425 | }; | ||||
3426 | unsigned char Data = 0; | ||||
3427 | |||||
3428 | public: | ||||
3429 | ExtParameterInfo() = default; | ||||
3430 | |||||
3431 | /// Return the ABI treatment of this parameter. | ||||
3432 | ParameterABI getABI() const { return ParameterABI(Data & ABIMask); } | ||||
3433 | ExtParameterInfo withABI(ParameterABI kind) const { | ||||
3434 | ExtParameterInfo copy = *this; | ||||
3435 | copy.Data = (copy.Data & ~ABIMask) | unsigned(kind); | ||||
3436 | return copy; | ||||
3437 | } | ||||
3438 | |||||
3439 | /// Is this parameter considered "consumed" by Objective-C ARC? | ||||
3440 | /// Consumed parameters must have retainable object type. | ||||
3441 | bool isConsumed() const { return (Data & IsConsumed); } | ||||
3442 | ExtParameterInfo withIsConsumed(bool consumed) const { | ||||
3443 | ExtParameterInfo copy = *this; | ||||
3444 | if (consumed) | ||||
3445 | copy.Data |= IsConsumed; | ||||
3446 | else | ||||
3447 | copy.Data &= ~IsConsumed; | ||||
3448 | return copy; | ||||
3449 | } | ||||
3450 | |||||
3451 | bool hasPassObjectSize() const { return Data & HasPassObjSize; } | ||||
3452 | ExtParameterInfo withHasPassObjectSize() const { | ||||
3453 | ExtParameterInfo Copy = *this; | ||||
3454 | Copy.Data |= HasPassObjSize; | ||||
3455 | return Copy; | ||||
3456 | } | ||||
3457 | |||||
3458 | bool isNoEscape() const { return Data & IsNoEscape; } | ||||
3459 | ExtParameterInfo withIsNoEscape(bool NoEscape) const { | ||||
3460 | ExtParameterInfo Copy = *this; | ||||
3461 | if (NoEscape) | ||||
3462 | Copy.Data |= IsNoEscape; | ||||
3463 | else | ||||
3464 | Copy.Data &= ~IsNoEscape; | ||||
3465 | return Copy; | ||||
3466 | } | ||||
3467 | |||||
3468 | unsigned char getOpaqueValue() const { return Data; } | ||||
3469 | static ExtParameterInfo getFromOpaqueValue(unsigned char data) { | ||||
3470 | ExtParameterInfo result; | ||||
3471 | result.Data = data; | ||||
3472 | return result; | ||||
3473 | } | ||||
3474 | |||||
3475 | friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) { | ||||
3476 | return lhs.Data == rhs.Data; | ||||
3477 | } | ||||
3478 | |||||
3479 | friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) { | ||||
3480 | return lhs.Data != rhs.Data; | ||||
3481 | } | ||||
3482 | }; | ||||
3483 | |||||
3484 | /// A class which abstracts out some details necessary for | ||||
3485 | /// making a call. | ||||
3486 | /// | ||||
3487 | /// It is not actually used directly for storing this information in | ||||
3488 | /// a FunctionType, although FunctionType does currently use the | ||||
3489 | /// same bit-pattern. | ||||
3490 | /// | ||||
3491 | // If you add a field (say Foo), other than the obvious places (both, | ||||
3492 | // constructors, compile failures), what you need to update is | ||||
3493 | // * Operator== | ||||
3494 | // * getFoo | ||||
3495 | // * withFoo | ||||
3496 | // * functionType. Add Foo, getFoo. | ||||
3497 | // * ASTContext::getFooType | ||||
3498 | // * ASTContext::mergeFunctionTypes | ||||
3499 | // * FunctionNoProtoType::Profile | ||||
3500 | // * FunctionProtoType::Profile | ||||
3501 | // * TypePrinter::PrintFunctionProto | ||||
3502 | // * AST read and write | ||||
3503 | // * Codegen | ||||
3504 | class ExtInfo { | ||||
3505 | friend class FunctionType; | ||||
3506 | |||||
3507 | // Feel free to rearrange or add bits, but if you go over 12, | ||||
3508 | // you'll need to adjust both the Bits field below and | ||||
3509 | // Type::FunctionTypeBitfields. | ||||
3510 | |||||
3511 | // | CC |noreturn|produces|nocallersavedregs|regparm|nocfcheck| | ||||
3512 | // |0 .. 4| 5 | 6 | 7 |8 .. 10| 11 | | ||||
3513 | // | ||||
3514 | // regparm is either 0 (no regparm attribute) or the regparm value+1. | ||||
3515 | enum { CallConvMask = 0x1F }; | ||||
3516 | enum { NoReturnMask = 0x20 }; | ||||
3517 | enum { ProducesResultMask = 0x40 }; | ||||
3518 | enum { NoCallerSavedRegsMask = 0x80 }; | ||||
3519 | enum { NoCfCheckMask = 0x800 }; | ||||
3520 | enum { | ||||
3521 | RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask | | ||||
3522 | NoCallerSavedRegsMask | NoCfCheckMask), | ||||
3523 | RegParmOffset = 8 | ||||
3524 | }; // Assumed to be the last field | ||||
3525 | uint16_t Bits = CC_C; | ||||
3526 | |||||
3527 | ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {} | ||||
3528 | |||||
3529 | public: | ||||
3530 | // Constructor with no defaults. Use this when you know that you | ||||
3531 | // have all the elements (when reading an AST file for example). | ||||
3532 | ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc, | ||||
3533 | bool producesResult, bool noCallerSavedRegs, bool NoCfCheck) { | ||||
3534 | assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(((!hasRegParm || regParm < 7) && "Invalid regparm value" ) ? static_cast<void> (0) : __assert_fail ("(!hasRegParm || regParm < 7) && \"Invalid regparm value\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 3534, __PRETTY_FUNCTION__)); | ||||
3535 | Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) | | ||||
3536 | (producesResult ? ProducesResultMask : 0) | | ||||
3537 | (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) | | ||||
3538 | (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) | | ||||
3539 | (NoCfCheck ? NoCfCheckMask : 0); | ||||
3540 | } | ||||
3541 | |||||
3542 | // Constructor with all defaults. Use when for example creating a | ||||
3543 | // function known to use defaults. | ||||
3544 | ExtInfo() = default; | ||||
3545 | |||||
3546 | // Constructor with just the calling convention, which is an important part | ||||
3547 | // of the canonical type. | ||||
3548 | ExtInfo(CallingConv CC) : Bits(CC) {} | ||||
3549 | |||||
3550 | bool getNoReturn() const { return Bits & NoReturnMask; } | ||||
3551 | bool getProducesResult() const { return Bits & ProducesResultMask; } | ||||
3552 | bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; } | ||||
3553 | bool getNoCfCheck() const { return Bits & NoCfCheckMask; } | ||||
3554 | bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; } | ||||
3555 | |||||
3556 | unsigned getRegParm() const { | ||||
3557 | unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset; | ||||
3558 | if (RegParm > 0) | ||||
3559 | --RegParm; | ||||
3560 | return RegParm; | ||||
3561 | } | ||||
3562 | |||||
3563 | CallingConv getCC() const { return CallingConv(Bits & CallConvMask); } | ||||
3564 | |||||
3565 | bool operator==(ExtInfo Other) const { | ||||
3566 | return Bits == Other.Bits; | ||||
3567 | } | ||||
3568 | bool operator!=(ExtInfo Other) const { | ||||
3569 | return Bits != Other.Bits; | ||||
3570 | } | ||||
3571 | |||||
3572 | // Note that we don't have setters. That is by design, use | ||||
3573 | // the following with methods instead of mutating these objects. | ||||
3574 | |||||
3575 | ExtInfo withNoReturn(bool noReturn) const { | ||||
3576 | if (noReturn) | ||||
3577 | return ExtInfo(Bits | NoReturnMask); | ||||
3578 | else | ||||
3579 | return ExtInfo(Bits & ~NoReturnMask); | ||||
3580 | } | ||||
3581 | |||||
3582 | ExtInfo withProducesResult(bool producesResult) const { | ||||
3583 | if (producesResult) | ||||
3584 | return ExtInfo(Bits | ProducesResultMask); | ||||
3585 | else | ||||
3586 | return ExtInfo(Bits & ~ProducesResultMask); | ||||
3587 | } | ||||
3588 | |||||
3589 | ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const { | ||||
3590 | if (noCallerSavedRegs) | ||||
3591 | return ExtInfo(Bits | NoCallerSavedRegsMask); | ||||
3592 | else | ||||
3593 | return ExtInfo(Bits & ~NoCallerSavedRegsMask); | ||||
3594 | } | ||||
3595 | |||||
3596 | ExtInfo withNoCfCheck(bool noCfCheck) const { | ||||
3597 | if (noCfCheck) | ||||
3598 | return ExtInfo(Bits | NoCfCheckMask); | ||||
3599 | else | ||||
3600 | return ExtInfo(Bits & ~NoCfCheckMask); | ||||
3601 | } | ||||
3602 | |||||
3603 | ExtInfo withRegParm(unsigned RegParm) const { | ||||
3604 | assert(RegParm < 7 && "Invalid regparm value")((RegParm < 7 && "Invalid regparm value") ? static_cast <void> (0) : __assert_fail ("RegParm < 7 && \"Invalid regparm value\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 3604, __PRETTY_FUNCTION__)); | ||||
3605 | return ExtInfo((Bits & ~RegParmMask) | | ||||
3606 | ((RegParm + 1) << RegParmOffset)); | ||||
3607 | } | ||||
3608 | |||||
3609 | ExtInfo withCallingConv(CallingConv cc) const { | ||||
3610 | return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc); | ||||
3611 | } | ||||
3612 | |||||
3613 | void Profile(llvm::FoldingSetNodeID &ID) const { | ||||
3614 | ID.AddInteger(Bits); | ||||
3615 | } | ||||
3616 | }; | ||||
3617 | |||||
3618 | /// A simple holder for a QualType representing a type in an | ||||
3619 | /// exception specification. Unfortunately needed by FunctionProtoType | ||||
3620 | /// because TrailingObjects cannot handle repeated types. | ||||
3621 | struct ExceptionType { QualType Type; }; | ||||
3622 | |||||
3623 | /// A simple holder for various uncommon bits which do not fit in | ||||
3624 | /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the | ||||
3625 | /// alignment of subsequent objects in TrailingObjects. You must update | ||||
3626 | /// hasExtraBitfields in FunctionProtoType after adding extra data here. | ||||
3627 | struct alignas(void *) FunctionTypeExtraBitfields { | ||||
3628 | /// The number of types in the exception specification. | ||||
3629 | /// A whole unsigned is not needed here and according to | ||||
3630 | /// [implimits] 8 bits would be enough here. | ||||
3631 | unsigned NumExceptionType; | ||||
3632 | }; | ||||
3633 | |||||
3634 | protected: | ||||
3635 | FunctionType(TypeClass tc, QualType res, | ||||
3636 | QualType Canonical, bool Dependent, | ||||
3637 | bool InstantiationDependent, | ||||
3638 | bool VariablyModified, bool ContainsUnexpandedParameterPack, | ||||
3639 | ExtInfo Info) | ||||
3640 | : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified, | ||||
3641 | ContainsUnexpandedParameterPack), | ||||
3642 | ResultType(res) { | ||||
3643 | FunctionTypeBits.ExtInfo = Info.Bits; | ||||
3644 | } | ||||
3645 | |||||
3646 | Qualifiers getFastTypeQuals() const { | ||||
3647 | return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals); | ||||
3648 | } | ||||
3649 | |||||
3650 | public: | ||||
3651 | QualType getReturnType() const { return ResultType; } | ||||
3652 | |||||
3653 | bool getHasRegParm() const { return getExtInfo().getHasRegParm(); } | ||||
3654 | unsigned getRegParmType() const { return getExtInfo().getRegParm(); } | ||||
3655 | |||||
3656 | /// Determine whether this function type includes the GNU noreturn | ||||
3657 | /// attribute. The C++11 [[noreturn]] attribute does not affect the function | ||||
3658 | /// type. | ||||
3659 | bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); } | ||||
3660 | |||||
3661 | CallingConv getCallConv() const { return getExtInfo().getCC(); } | ||||
3662 | ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); } | ||||
3663 | |||||
3664 | static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0, | ||||
3665 | "Const, volatile and restrict are assumed to be a subset of " | ||||
3666 | "the fast qualifiers."); | ||||
3667 | |||||
3668 | bool isConst() const { return getFastTypeQuals().hasConst(); } | ||||
3669 | bool isVolatile() const { return getFastTypeQuals().hasVolatile(); } | ||||
3670 | bool isRestrict() const { return getFastTypeQuals().hasRestrict(); } | ||||
3671 | |||||
3672 | /// Determine the type of an expression that calls a function of | ||||
3673 | /// this type. | ||||
3674 | QualType getCallResultType(const ASTContext &Context) const { | ||||
3675 | return getReturnType().getNonLValueExprType(Context); | ||||
3676 | } | ||||
3677 | |||||
3678 | static StringRef getNameForCallConv(CallingConv CC); | ||||
3679 | |||||
3680 | static bool classof(const Type *T) { | ||||
3681 | return T->getTypeClass() == FunctionNoProto || | ||||
3682 | T->getTypeClass() == FunctionProto; | ||||
3683 | } | ||||
3684 | }; | ||||
3685 | |||||
3686 | /// Represents a K&R-style 'int foo()' function, which has | ||||
3687 | /// no information available about its arguments. | ||||
3688 | class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode { | ||||
3689 | friend class ASTContext; // ASTContext creates these. | ||||
3690 | |||||
3691 | FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info) | ||||
3692 | : FunctionType(FunctionNoProto, Result, Canonical, | ||||
3693 | /*Dependent=*/false, /*InstantiationDependent=*/false, | ||||
3694 | Result->isVariablyModifiedType(), | ||||
3695 | /*ContainsUnexpandedParameterPack=*/false, Info) {} | ||||
3696 | |||||
3697 | public: | ||||
3698 | // No additional state past what FunctionType provides. | ||||
3699 | |||||
3700 | bool isSugared() const { return false; } | ||||
3701 | QualType desugar() const { return QualType(this, 0); } | ||||
3702 | |||||
3703 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
3704 | Profile(ID, getReturnType(), getExtInfo()); | ||||
3705 | } | ||||
3706 | |||||
3707 | static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType, | ||||
3708 | ExtInfo Info) { | ||||
3709 | Info.Profile(ID); | ||||
3710 | ID.AddPointer(ResultType.getAsOpaquePtr()); | ||||
3711 | } | ||||
3712 | |||||
3713 | static bool classof(const Type *T) { | ||||
3714 | return T->getTypeClass() == FunctionNoProto; | ||||
3715 | } | ||||
3716 | }; | ||||
3717 | |||||
3718 | /// Represents a prototype with parameter type info, e.g. | ||||
3719 | /// 'int foo(int)' or 'int foo(void)'. 'void' is represented as having no | ||||
3720 | /// parameters, not as having a single void parameter. Such a type can have | ||||
3721 | /// an exception specification, but this specification is not part of the | ||||
3722 | /// canonical type. FunctionProtoType has several trailing objects, some of | ||||
3723 | /// which optional. For more information about the trailing objects see | ||||
3724 | /// the first comment inside FunctionProtoType. | ||||
3725 | class FunctionProtoType final | ||||
3726 | : public FunctionType, | ||||
3727 | public llvm::FoldingSetNode, | ||||
3728 | private llvm::TrailingObjects< | ||||
3729 | FunctionProtoType, QualType, FunctionType::FunctionTypeExtraBitfields, | ||||
3730 | FunctionType::ExceptionType, Expr *, FunctionDecl *, | ||||
3731 | FunctionType::ExtParameterInfo, Qualifiers> { | ||||
3732 | friend class ASTContext; // ASTContext creates these. | ||||
3733 | friend TrailingObjects; | ||||
3734 | |||||
3735 | // FunctionProtoType is followed by several trailing objects, some of | ||||
3736 | // which optional. They are in order: | ||||
3737 | // | ||||
3738 | // * An array of getNumParams() QualType holding the parameter types. | ||||
3739 | // Always present. Note that for the vast majority of FunctionProtoType, | ||||
3740 | // these will be the only trailing objects. | ||||
3741 | // | ||||
3742 | // * Optionally if some extra data is stored in FunctionTypeExtraBitfields | ||||
3743 | // (see FunctionTypeExtraBitfields and FunctionTypeBitfields): | ||||
3744 | // a single FunctionTypeExtraBitfields. Present if and only if | ||||
3745 | // hasExtraBitfields() is true. | ||||
3746 | // | ||||
3747 | // * Optionally exactly one of: | ||||
3748 | // * an array of getNumExceptions() ExceptionType, | ||||
3749 | // * a single Expr *, | ||||
3750 | // * a pair of FunctionDecl *, | ||||
3751 | // * a single FunctionDecl * | ||||
3752 | // used to store information about the various types of exception | ||||
3753 | // specification. See getExceptionSpecSize for the details. | ||||
3754 | // | ||||
3755 | // * Optionally an array of getNumParams() ExtParameterInfo holding | ||||
3756 | // an ExtParameterInfo for each of the parameters. Present if and | ||||
3757 | // only if hasExtParameterInfos() is true. | ||||
3758 | // | ||||
3759 | // * Optionally a Qualifiers object to represent extra qualifiers that can't | ||||
3760 | // be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only | ||||
3761 | // if hasExtQualifiers() is true. | ||||
3762 | // | ||||
3763 | // The optional FunctionTypeExtraBitfields has to be before the data | ||||
3764 | // related to the exception specification since it contains the number | ||||
3765 | // of exception types. | ||||
3766 | // | ||||
3767 | // We put the ExtParameterInfos last. If all were equal, it would make | ||||
3768 | // more sense to put these before the exception specification, because | ||||
3769 | // it's much easier to skip past them compared to the elaborate switch | ||||
3770 | // required to skip the exception specification. However, all is not | ||||
3771 | // equal; ExtParameterInfos are used to model very uncommon features, | ||||
3772 | // and it's better not to burden the more common paths. | ||||
3773 | |||||
3774 | public: | ||||
3775 | /// Holds information about the various types of exception specification. | ||||
3776 | /// ExceptionSpecInfo is not stored as such in FunctionProtoType but is | ||||
3777 | /// used to group together the various bits of information about the | ||||
3778 | /// exception specification. | ||||
3779 | struct ExceptionSpecInfo { | ||||
3780 | /// The kind of exception specification this is. | ||||
3781 | ExceptionSpecificationType Type = EST_None; | ||||
3782 | |||||
3783 | /// Explicitly-specified list of exception types. | ||||
3784 | ArrayRef<QualType> Exceptions; | ||||
3785 | |||||
3786 | /// Noexcept expression, if this is a computed noexcept specification. | ||||
3787 | Expr *NoexceptExpr = nullptr; | ||||
3788 | |||||
3789 | /// The function whose exception specification this is, for | ||||
3790 | /// EST_Unevaluated and EST_Uninstantiated. | ||||
3791 | FunctionDecl *SourceDecl = nullptr; | ||||
3792 | |||||
3793 | /// The function template whose exception specification this is instantiated | ||||
3794 | /// from, for EST_Uninstantiated. | ||||
3795 | FunctionDecl *SourceTemplate = nullptr; | ||||
3796 | |||||
3797 | ExceptionSpecInfo() = default; | ||||
3798 | |||||
3799 | ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {} | ||||
3800 | }; | ||||
3801 | |||||
3802 | /// Extra information about a function prototype. ExtProtoInfo is not | ||||
3803 | /// stored as such in FunctionProtoType but is used to group together | ||||
3804 | /// the various bits of extra information about a function prototype. | ||||
3805 | struct ExtProtoInfo { | ||||
3806 | FunctionType::ExtInfo ExtInfo; | ||||
3807 | bool Variadic : 1; | ||||
3808 | bool HasTrailingReturn : 1; | ||||
3809 | Qualifiers TypeQuals; | ||||
3810 | RefQualifierKind RefQualifier = RQ_None; | ||||
3811 | ExceptionSpecInfo ExceptionSpec; | ||||
3812 | const ExtParameterInfo *ExtParameterInfos = nullptr; | ||||
3813 | |||||
3814 | ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {} | ||||
3815 | |||||
3816 | ExtProtoInfo(CallingConv CC) | ||||
3817 | : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {} | ||||
3818 | |||||
3819 | ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) { | ||||
3820 | ExtProtoInfo Result(*this); | ||||
3821 | Result.ExceptionSpec = ESI; | ||||
3822 | return Result; | ||||
3823 | } | ||||
3824 | }; | ||||
3825 | |||||
3826 | private: | ||||
3827 | unsigned numTrailingObjects(OverloadToken<QualType>) const { | ||||
3828 | return getNumParams(); | ||||
3829 | } | ||||
3830 | |||||
3831 | unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const { | ||||
3832 | return hasExtraBitfields(); | ||||
3833 | } | ||||
3834 | |||||
3835 | unsigned numTrailingObjects(OverloadToken<ExceptionType>) const { | ||||
3836 | return getExceptionSpecSize().NumExceptionType; | ||||
3837 | } | ||||
3838 | |||||
3839 | unsigned numTrailingObjects(OverloadToken<Expr *>) const { | ||||
3840 | return getExceptionSpecSize().NumExprPtr; | ||||
3841 | } | ||||
3842 | |||||
3843 | unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const { | ||||
3844 | return getExceptionSpecSize().NumFunctionDeclPtr; | ||||
3845 | } | ||||
3846 | |||||
3847 | unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const { | ||||
3848 | return hasExtParameterInfos() ? getNumParams() : 0; | ||||
3849 | } | ||||
3850 | |||||
3851 | /// Determine whether there are any argument types that | ||||
3852 | /// contain an unexpanded parameter pack. | ||||
3853 | static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray, | ||||
3854 | unsigned numArgs) { | ||||
3855 | for (unsigned Idx = 0; Idx < numArgs; ++Idx) | ||||
3856 | if (ArgArray[Idx]->containsUnexpandedParameterPack()) | ||||
3857 | return true; | ||||
3858 | |||||
3859 | return false; | ||||
3860 | } | ||||
3861 | |||||
3862 | FunctionProtoType(QualType result, ArrayRef<QualType> params, | ||||
3863 | QualType canonical, const ExtProtoInfo &epi); | ||||
3864 | |||||
3865 | /// This struct is returned by getExceptionSpecSize and is used to | ||||
3866 | /// translate an ExceptionSpecificationType to the number and kind | ||||
3867 | /// of trailing objects related to the exception specification. | ||||
3868 | struct ExceptionSpecSizeHolder { | ||||
3869 | unsigned NumExceptionType; | ||||
3870 | unsigned NumExprPtr; | ||||
3871 | unsigned NumFunctionDeclPtr; | ||||
3872 | }; | ||||
3873 | |||||
3874 | /// Return the number and kind of trailing objects | ||||
3875 | /// related to the exception specification. | ||||
3876 | static ExceptionSpecSizeHolder | ||||
3877 | getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) { | ||||
3878 | switch (EST) { | ||||
3879 | case EST_None: | ||||
3880 | case EST_DynamicNone: | ||||
3881 | case EST_MSAny: | ||||
3882 | case EST_BasicNoexcept: | ||||
3883 | case EST_Unparsed: | ||||
3884 | case EST_NoThrow: | ||||
3885 | return {0, 0, 0}; | ||||
3886 | |||||
3887 | case EST_Dynamic: | ||||
3888 | return {NumExceptions, 0, 0}; | ||||
3889 | |||||
3890 | case EST_DependentNoexcept: | ||||
3891 | case EST_NoexceptFalse: | ||||
3892 | case EST_NoexceptTrue: | ||||
3893 | return {0, 1, 0}; | ||||
3894 | |||||
3895 | case EST_Uninstantiated: | ||||
3896 | return {0, 0, 2}; | ||||
3897 | |||||
3898 | case EST_Unevaluated: | ||||
3899 | return {0, 0, 1}; | ||||
3900 | } | ||||
3901 | llvm_unreachable("bad exception specification kind")::llvm::llvm_unreachable_internal("bad exception specification kind" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 3901); | ||||
3902 | } | ||||
3903 | |||||
3904 | /// Return the number and kind of trailing objects | ||||
3905 | /// related to the exception specification. | ||||
3906 | ExceptionSpecSizeHolder getExceptionSpecSize() const { | ||||
3907 | return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions()); | ||||
3908 | } | ||||
3909 | |||||
3910 | /// Whether the trailing FunctionTypeExtraBitfields is present. | ||||
3911 | static bool hasExtraBitfields(ExceptionSpecificationType EST) { | ||||
3912 | // If the exception spec type is EST_Dynamic then we have > 0 exception | ||||
3913 | // types and the exact number is stored in FunctionTypeExtraBitfields. | ||||
3914 | return EST == EST_Dynamic; | ||||
3915 | } | ||||
3916 | |||||
3917 | /// Whether the trailing FunctionTypeExtraBitfields is present. | ||||
3918 | bool hasExtraBitfields() const { | ||||
3919 | return hasExtraBitfields(getExceptionSpecType()); | ||||
3920 | } | ||||
3921 | |||||
3922 | bool hasExtQualifiers() const { | ||||
3923 | return FunctionTypeBits.HasExtQuals; | ||||
3924 | } | ||||
3925 | |||||
3926 | public: | ||||
3927 | unsigned getNumParams() const { return FunctionTypeBits.NumParams; } | ||||
3928 | |||||
3929 | QualType getParamType(unsigned i) const { | ||||
3930 | assert(i < getNumParams() && "invalid parameter index")((i < getNumParams() && "invalid parameter index") ? static_cast<void> (0) : __assert_fail ("i < getNumParams() && \"invalid parameter index\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 3930, __PRETTY_FUNCTION__)); | ||||
3931 | return param_type_begin()[i]; | ||||
3932 | } | ||||
3933 | |||||
3934 | ArrayRef<QualType> getParamTypes() const { | ||||
3935 | return llvm::makeArrayRef(param_type_begin(), param_type_end()); | ||||
3936 | } | ||||
3937 | |||||
3938 | ExtProtoInfo getExtProtoInfo() const { | ||||
3939 | ExtProtoInfo EPI; | ||||
3940 | EPI.ExtInfo = getExtInfo(); | ||||
3941 | EPI.Variadic = isVariadic(); | ||||
3942 | EPI.HasTrailingReturn = hasTrailingReturn(); | ||||
3943 | EPI.ExceptionSpec.Type = getExceptionSpecType(); | ||||
3944 | EPI.TypeQuals = getMethodQuals(); | ||||
3945 | EPI.RefQualifier = getRefQualifier(); | ||||
3946 | if (EPI.ExceptionSpec.Type == EST_Dynamic) { | ||||
3947 | EPI.ExceptionSpec.Exceptions = exceptions(); | ||||
3948 | } else if (isComputedNoexcept(EPI.ExceptionSpec.Type)) { | ||||
3949 | EPI.ExceptionSpec.NoexceptExpr = getNoexceptExpr(); | ||||
3950 | } else if (EPI.ExceptionSpec.Type == EST_Uninstantiated) { | ||||
3951 | EPI.ExceptionSpec.SourceDecl = getExceptionSpecDecl(); | ||||
3952 | EPI.ExceptionSpec.SourceTemplate = getExceptionSpecTemplate(); | ||||
3953 | } else if (EPI.ExceptionSpec.Type == EST_Unevaluated) { | ||||
3954 | EPI.ExceptionSpec.SourceDecl = getExceptionSpecDecl(); | ||||
3955 | } | ||||
3956 | EPI.ExtParameterInfos = getExtParameterInfosOrNull(); | ||||
3957 | return EPI; | ||||
3958 | } | ||||
3959 | |||||
3960 | /// Get the kind of exception specification on this function. | ||||
3961 | ExceptionSpecificationType getExceptionSpecType() const { | ||||
3962 | return static_cast<ExceptionSpecificationType>( | ||||
3963 | FunctionTypeBits.ExceptionSpecType); | ||||
3964 | } | ||||
3965 | |||||
3966 | /// Return whether this function has any kind of exception spec. | ||||
3967 | bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; } | ||||
3968 | |||||
3969 | /// Return whether this function has a dynamic (throw) exception spec. | ||||
3970 | bool hasDynamicExceptionSpec() const { | ||||
3971 | return isDynamicExceptionSpec(getExceptionSpecType()); | ||||
3972 | } | ||||
3973 | |||||
3974 | /// Return whether this function has a noexcept exception spec. | ||||
3975 | bool hasNoexceptExceptionSpec() const { | ||||
3976 | return isNoexceptExceptionSpec(getExceptionSpecType()); | ||||
3977 | } | ||||
3978 | |||||
3979 | /// Return whether this function has a dependent exception spec. | ||||
3980 | bool hasDependentExceptionSpec() const; | ||||
3981 | |||||
3982 | /// Return whether this function has an instantiation-dependent exception | ||||
3983 | /// spec. | ||||
3984 | bool hasInstantiationDependentExceptionSpec() const; | ||||
3985 | |||||
3986 | /// Return the number of types in the exception specification. | ||||
3987 | unsigned getNumExceptions() const { | ||||
3988 | return getExceptionSpecType() == EST_Dynamic | ||||
3989 | ? getTrailingObjects<FunctionTypeExtraBitfields>() | ||||
3990 | ->NumExceptionType | ||||
3991 | : 0; | ||||
3992 | } | ||||
3993 | |||||
3994 | /// Return the ith exception type, where 0 <= i < getNumExceptions(). | ||||
3995 | QualType getExceptionType(unsigned i) const { | ||||
3996 | assert(i < getNumExceptions() && "Invalid exception number!")((i < getNumExceptions() && "Invalid exception number!" ) ? static_cast<void> (0) : __assert_fail ("i < getNumExceptions() && \"Invalid exception number!\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 3996, __PRETTY_FUNCTION__)); | ||||
3997 | return exception_begin()[i]; | ||||
3998 | } | ||||
3999 | |||||
4000 | /// Return the expression inside noexcept(expression), or a null pointer | ||||
4001 | /// if there is none (because the exception spec is not of this form). | ||||
4002 | Expr *getNoexceptExpr() const { | ||||
4003 | if (!isComputedNoexcept(getExceptionSpecType())) | ||||
4004 | return nullptr; | ||||
4005 | return *getTrailingObjects<Expr *>(); | ||||
4006 | } | ||||
4007 | |||||
4008 | /// If this function type has an exception specification which hasn't | ||||
4009 | /// been determined yet (either because it has not been evaluated or because | ||||
4010 | /// it has not been instantiated), this is the function whose exception | ||||
4011 | /// specification is represented by this type. | ||||
4012 | FunctionDecl *getExceptionSpecDecl() const { | ||||
4013 | if (getExceptionSpecType() != EST_Uninstantiated && | ||||
4014 | getExceptionSpecType() != EST_Unevaluated) | ||||
4015 | return nullptr; | ||||
4016 | return getTrailingObjects<FunctionDecl *>()[0]; | ||||
4017 | } | ||||
4018 | |||||
4019 | /// If this function type has an uninstantiated exception | ||||
4020 | /// specification, this is the function whose exception specification | ||||
4021 | /// should be instantiated to find the exception specification for | ||||
4022 | /// this type. | ||||
4023 | FunctionDecl *getExceptionSpecTemplate() const { | ||||
4024 | if (getExceptionSpecType() != EST_Uninstantiated) | ||||
4025 | return nullptr; | ||||
4026 | return getTrailingObjects<FunctionDecl *>()[1]; | ||||
4027 | } | ||||
4028 | |||||
4029 | /// Determine whether this function type has a non-throwing exception | ||||
4030 | /// specification. | ||||
4031 | CanThrowResult canThrow() const; | ||||
4032 | |||||
4033 | /// Determine whether this function type has a non-throwing exception | ||||
4034 | /// specification. If this depends on template arguments, returns | ||||
4035 | /// \c ResultIfDependent. | ||||
4036 | bool isNothrow(bool ResultIfDependent = false) const { | ||||
4037 | return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot; | ||||
4038 | } | ||||
4039 | |||||
4040 | /// Whether this function prototype is variadic. | ||||
4041 | bool isVariadic() const { return FunctionTypeBits.Variadic; } | ||||
4042 | |||||
4043 | /// Determines whether this function prototype contains a | ||||
4044 | /// parameter pack at the end. | ||||
4045 | /// | ||||
4046 | /// A function template whose last parameter is a parameter pack can be | ||||
4047 | /// called with an arbitrary number of arguments, much like a variadic | ||||
4048 | /// function. | ||||
4049 | bool isTemplateVariadic() const; | ||||
4050 | |||||
4051 | /// Whether this function prototype has a trailing return type. | ||||
4052 | bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; } | ||||
4053 | |||||
4054 | Qualifiers getMethodQuals() const { | ||||
4055 | if (hasExtQualifiers()) | ||||
4056 | return *getTrailingObjects<Qualifiers>(); | ||||
4057 | else | ||||
4058 | return getFastTypeQuals(); | ||||
4059 | } | ||||
4060 | |||||
4061 | /// Retrieve the ref-qualifier associated with this function type. | ||||
4062 | RefQualifierKind getRefQualifier() const { | ||||
4063 | return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier); | ||||
4064 | } | ||||
4065 | |||||
4066 | using param_type_iterator = const QualType *; | ||||
4067 | using param_type_range = llvm::iterator_range<param_type_iterator>; | ||||
4068 | |||||
4069 | param_type_range param_types() const { | ||||
4070 | return param_type_range(param_type_begin(), param_type_end()); | ||||
4071 | } | ||||
4072 | |||||
4073 | param_type_iterator param_type_begin() const { | ||||
4074 | return getTrailingObjects<QualType>(); | ||||
4075 | } | ||||
4076 | |||||
4077 | param_type_iterator param_type_end() const { | ||||
4078 | return param_type_begin() + getNumParams(); | ||||
4079 | } | ||||
4080 | |||||
4081 | using exception_iterator = const QualType *; | ||||
4082 | |||||
4083 | ArrayRef<QualType> exceptions() const { | ||||
4084 | return llvm::makeArrayRef(exception_begin(), exception_end()); | ||||
4085 | } | ||||
4086 | |||||
4087 | exception_iterator exception_begin() const { | ||||
4088 | return reinterpret_cast<exception_iterator>( | ||||
4089 | getTrailingObjects<ExceptionType>()); | ||||
4090 | } | ||||
4091 | |||||
4092 | exception_iterator exception_end() const { | ||||
4093 | return exception_begin() + getNumExceptions(); | ||||
4094 | } | ||||
4095 | |||||
4096 | /// Is there any interesting extra information for any of the parameters | ||||
4097 | /// of this function type? | ||||
4098 | bool hasExtParameterInfos() const { | ||||
4099 | return FunctionTypeBits.HasExtParameterInfos; | ||||
4100 | } | ||||
4101 | |||||
4102 | ArrayRef<ExtParameterInfo> getExtParameterInfos() const { | ||||
4103 | assert(hasExtParameterInfos())((hasExtParameterInfos()) ? static_cast<void> (0) : __assert_fail ("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4103, __PRETTY_FUNCTION__)); | ||||
4104 | return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(), | ||||
4105 | getNumParams()); | ||||
4106 | } | ||||
4107 | |||||
4108 | /// Return a pointer to the beginning of the array of extra parameter | ||||
4109 | /// information, if present, or else null if none of the parameters | ||||
4110 | /// carry it. This is equivalent to getExtProtoInfo().ExtParameterInfos. | ||||
4111 | const ExtParameterInfo *getExtParameterInfosOrNull() const { | ||||
4112 | if (!hasExtParameterInfos()) | ||||
4113 | return nullptr; | ||||
4114 | return getTrailingObjects<ExtParameterInfo>(); | ||||
4115 | } | ||||
4116 | |||||
4117 | ExtParameterInfo getExtParameterInfo(unsigned I) const { | ||||
4118 | assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range" ) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4118, __PRETTY_FUNCTION__)); | ||||
4119 | if (hasExtParameterInfos()) | ||||
4120 | return getTrailingObjects<ExtParameterInfo>()[I]; | ||||
4121 | return ExtParameterInfo(); | ||||
4122 | } | ||||
4123 | |||||
4124 | ParameterABI getParameterABI(unsigned I) const { | ||||
4125 | assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range" ) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4125, __PRETTY_FUNCTION__)); | ||||
4126 | if (hasExtParameterInfos()) | ||||
4127 | return getTrailingObjects<ExtParameterInfo>()[I].getABI(); | ||||
4128 | return ParameterABI::Ordinary; | ||||
4129 | } | ||||
4130 | |||||
4131 | bool isParamConsumed(unsigned I) const { | ||||
4132 | assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range" ) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4132, __PRETTY_FUNCTION__)); | ||||
4133 | if (hasExtParameterInfos()) | ||||
4134 | return getTrailingObjects<ExtParameterInfo>()[I].isConsumed(); | ||||
4135 | return false; | ||||
4136 | } | ||||
4137 | |||||
4138 | bool isSugared() const { return false; } | ||||
4139 | QualType desugar() const { return QualType(this, 0); } | ||||
4140 | |||||
4141 | void printExceptionSpecification(raw_ostream &OS, | ||||
4142 | const PrintingPolicy &Policy) const; | ||||
4143 | |||||
4144 | static bool classof(const Type *T) { | ||||
4145 | return T->getTypeClass() == FunctionProto; | ||||
4146 | } | ||||
4147 | |||||
4148 | void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx); | ||||
4149 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Result, | ||||
4150 | param_type_iterator ArgTys, unsigned NumArgs, | ||||
4151 | const ExtProtoInfo &EPI, const ASTContext &Context, | ||||
4152 | bool Canonical); | ||||
4153 | }; | ||||
4154 | |||||
4155 | /// Represents the dependent type named by a dependently-scoped | ||||
4156 | /// typename using declaration, e.g. | ||||
4157 | /// using typename Base<T>::foo; | ||||
4158 | /// | ||||
4159 | /// Template instantiation turns these into the underlying type. | ||||
4160 | class UnresolvedUsingType : public Type { | ||||
4161 | friend class ASTContext; // ASTContext creates these. | ||||
4162 | |||||
4163 | UnresolvedUsingTypenameDecl *Decl; | ||||
4164 | |||||
4165 | UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D) | ||||
4166 | : Type(UnresolvedUsing, QualType(), true, true, false, | ||||
4167 | /*ContainsUnexpandedParameterPack=*/false), | ||||
4168 | Decl(const_cast<UnresolvedUsingTypenameDecl*>(D)) {} | ||||
4169 | |||||
4170 | public: | ||||
4171 | UnresolvedUsingTypenameDecl *getDecl() const { return Decl; } | ||||
4172 | |||||
4173 | bool isSugared() const { return false; } | ||||
4174 | QualType desugar() const { return QualType(this, 0); } | ||||
4175 | |||||
4176 | static bool classof(const Type *T) { | ||||
4177 | return T->getTypeClass() == UnresolvedUsing; | ||||
4178 | } | ||||
4179 | |||||
4180 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4181 | return Profile(ID, Decl); | ||||
4182 | } | ||||
4183 | |||||
4184 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
4185 | UnresolvedUsingTypenameDecl *D) { | ||||
4186 | ID.AddPointer(D); | ||||
4187 | } | ||||
4188 | }; | ||||
4189 | |||||
4190 | class TypedefType : public Type { | ||||
4191 | TypedefNameDecl *Decl; | ||||
4192 | |||||
4193 | protected: | ||||
4194 | friend class ASTContext; // ASTContext creates these. | ||||
4195 | |||||
4196 | TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType can) | ||||
4197 | : Type(tc, can, can->isDependentType(), | ||||
4198 | can->isInstantiationDependentType(), | ||||
4199 | can->isVariablyModifiedType(), | ||||
4200 | /*ContainsUnexpandedParameterPack=*/false), | ||||
4201 | Decl(const_cast<TypedefNameDecl*>(D)) { | ||||
4202 | assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type" ) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4202, __PRETTY_FUNCTION__)); | ||||
4203 | } | ||||
4204 | |||||
4205 | public: | ||||
4206 | TypedefNameDecl *getDecl() const { return Decl; } | ||||
4207 | |||||
4208 | bool isSugared() const { return true; } | ||||
4209 | QualType desugar() const; | ||||
4210 | |||||
4211 | static bool classof(const Type *T) { return T->getTypeClass() == Typedef; } | ||||
4212 | }; | ||||
4213 | |||||
4214 | /// Sugar type that represents a type that was qualified by a qualifier written | ||||
4215 | /// as a macro invocation. | ||||
4216 | class MacroQualifiedType : public Type { | ||||
4217 | friend class ASTContext; // ASTContext creates these. | ||||
4218 | |||||
4219 | QualType UnderlyingTy; | ||||
4220 | const IdentifierInfo *MacroII; | ||||
4221 | |||||
4222 | MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy, | ||||
4223 | const IdentifierInfo *MacroII) | ||||
4224 | : Type(MacroQualified, CanonTy, UnderlyingTy->isDependentType(), | ||||
4225 | UnderlyingTy->isInstantiationDependentType(), | ||||
4226 | UnderlyingTy->isVariablyModifiedType(), | ||||
4227 | UnderlyingTy->containsUnexpandedParameterPack()), | ||||
4228 | UnderlyingTy(UnderlyingTy), MacroII(MacroII) { | ||||
4229 | assert(isa<AttributedType>(UnderlyingTy) &&((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types." ) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4230, __PRETTY_FUNCTION__)) | ||||
4230 | "Expected a macro qualified type to only wrap attributed types.")((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types." ) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4230, __PRETTY_FUNCTION__)); | ||||
4231 | } | ||||
4232 | |||||
4233 | public: | ||||
4234 | const IdentifierInfo *getMacroIdentifier() const { return MacroII; } | ||||
4235 | QualType getUnderlyingType() const { return UnderlyingTy; } | ||||
4236 | |||||
4237 | /// Return this attributed type's modified type with no qualifiers attached to | ||||
4238 | /// it. | ||||
4239 | QualType getModifiedType() const; | ||||
4240 | |||||
4241 | bool isSugared() const { return true; } | ||||
4242 | QualType desugar() const; | ||||
4243 | |||||
4244 | static bool classof(const Type *T) { | ||||
4245 | return T->getTypeClass() == MacroQualified; | ||||
4246 | } | ||||
4247 | }; | ||||
4248 | |||||
4249 | /// Represents a `typeof` (or __typeof__) expression (a GCC extension). | ||||
4250 | class TypeOfExprType : public Type { | ||||
4251 | Expr *TOExpr; | ||||
4252 | |||||
4253 | protected: | ||||
4254 | friend class ASTContext; // ASTContext creates these. | ||||
4255 | |||||
4256 | TypeOfExprType(Expr *E, QualType can = QualType()); | ||||
4257 | |||||
4258 | public: | ||||
4259 | Expr *getUnderlyingExpr() const { return TOExpr; } | ||||
4260 | |||||
4261 | /// Remove a single level of sugar. | ||||
4262 | QualType desugar() const; | ||||
4263 | |||||
4264 | /// Returns whether this type directly provides sugar. | ||||
4265 | bool isSugared() const; | ||||
4266 | |||||
4267 | static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; } | ||||
4268 | }; | ||||
4269 | |||||
4270 | /// Internal representation of canonical, dependent | ||||
4271 | /// `typeof(expr)` types. | ||||
4272 | /// | ||||
4273 | /// This class is used internally by the ASTContext to manage | ||||
4274 | /// canonical, dependent types, only. Clients will only see instances | ||||
4275 | /// of this class via TypeOfExprType nodes. | ||||
4276 | class DependentTypeOfExprType | ||||
4277 | : public TypeOfExprType, public llvm::FoldingSetNode { | ||||
4278 | const ASTContext &Context; | ||||
4279 | |||||
4280 | public: | ||||
4281 | DependentTypeOfExprType(const ASTContext &Context, Expr *E) | ||||
4282 | : TypeOfExprType(E), Context(Context) {} | ||||
4283 | |||||
4284 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4285 | Profile(ID, Context, getUnderlyingExpr()); | ||||
4286 | } | ||||
4287 | |||||
4288 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, | ||||
4289 | Expr *E); | ||||
4290 | }; | ||||
4291 | |||||
4292 | /// Represents `typeof(type)`, a GCC extension. | ||||
4293 | class TypeOfType : public Type { | ||||
4294 | friend class ASTContext; // ASTContext creates these. | ||||
4295 | |||||
4296 | QualType TOType; | ||||
4297 | |||||
4298 | TypeOfType(QualType T, QualType can) | ||||
4299 | : Type(TypeOf, can, T->isDependentType(), | ||||
4300 | T->isInstantiationDependentType(), | ||||
4301 | T->isVariablyModifiedType(), | ||||
4302 | T->containsUnexpandedParameterPack()), | ||||
4303 | TOType(T) { | ||||
4304 | assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type" ) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4304, __PRETTY_FUNCTION__)); | ||||
4305 | } | ||||
4306 | |||||
4307 | public: | ||||
4308 | QualType getUnderlyingType() const { return TOType; } | ||||
4309 | |||||
4310 | /// Remove a single level of sugar. | ||||
4311 | QualType desugar() const { return getUnderlyingType(); } | ||||
4312 | |||||
4313 | /// Returns whether this type directly provides sugar. | ||||
4314 | bool isSugared() const { return true; } | ||||
4315 | |||||
4316 | static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; } | ||||
4317 | }; | ||||
4318 | |||||
4319 | /// Represents the type `decltype(expr)` (C++11). | ||||
4320 | class DecltypeType : public Type { | ||||
4321 | Expr *E; | ||||
4322 | QualType UnderlyingType; | ||||
4323 | |||||
4324 | protected: | ||||
4325 | friend class ASTContext; // ASTContext creates these. | ||||
4326 | |||||
4327 | DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType()); | ||||
4328 | |||||
4329 | public: | ||||
4330 | Expr *getUnderlyingExpr() const { return E; } | ||||
4331 | QualType getUnderlyingType() const { return UnderlyingType; } | ||||
4332 | |||||
4333 | /// Remove a single level of sugar. | ||||
4334 | QualType desugar() const; | ||||
4335 | |||||
4336 | /// Returns whether this type directly provides sugar. | ||||
4337 | bool isSugared() const; | ||||
4338 | |||||
4339 | static bool classof(const Type *T) { return T->getTypeClass() == Decltype; } | ||||
4340 | }; | ||||
4341 | |||||
4342 | /// Internal representation of canonical, dependent | ||||
4343 | /// decltype(expr) types. | ||||
4344 | /// | ||||
4345 | /// This class is used internally by the ASTContext to manage | ||||
4346 | /// canonical, dependent types, only. Clients will only see instances | ||||
4347 | /// of this class via DecltypeType nodes. | ||||
4348 | class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode { | ||||
4349 | const ASTContext &Context; | ||||
4350 | |||||
4351 | public: | ||||
4352 | DependentDecltypeType(const ASTContext &Context, Expr *E); | ||||
4353 | |||||
4354 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4355 | Profile(ID, Context, getUnderlyingExpr()); | ||||
4356 | } | ||||
4357 | |||||
4358 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, | ||||
4359 | Expr *E); | ||||
4360 | }; | ||||
4361 | |||||
4362 | /// A unary type transform, which is a type constructed from another. | ||||
4363 | class UnaryTransformType : public Type { | ||||
4364 | public: | ||||
4365 | enum UTTKind { | ||||
4366 | EnumUnderlyingType | ||||
4367 | }; | ||||
4368 | |||||
4369 | private: | ||||
4370 | /// The untransformed type. | ||||
4371 | QualType BaseType; | ||||
4372 | |||||
4373 | /// The transformed type if not dependent, otherwise the same as BaseType. | ||||
4374 | QualType UnderlyingType; | ||||
4375 | |||||
4376 | UTTKind UKind; | ||||
4377 | |||||
4378 | protected: | ||||
4379 | friend class ASTContext; | ||||
4380 | |||||
4381 | UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind, | ||||
4382 | QualType CanonicalTy); | ||||
4383 | |||||
4384 | public: | ||||
4385 | bool isSugared() const { return !isDependentType(); } | ||||
4386 | QualType desugar() const { return UnderlyingType; } | ||||
4387 | |||||
4388 | QualType getUnderlyingType() const { return UnderlyingType; } | ||||
4389 | QualType getBaseType() const { return BaseType; } | ||||
4390 | |||||
4391 | UTTKind getUTTKind() const { return UKind; } | ||||
4392 | |||||
4393 | static bool classof(const Type *T) { | ||||
4394 | return T->getTypeClass() == UnaryTransform; | ||||
4395 | } | ||||
4396 | }; | ||||
4397 | |||||
4398 | /// Internal representation of canonical, dependent | ||||
4399 | /// __underlying_type(type) types. | ||||
4400 | /// | ||||
4401 | /// This class is used internally by the ASTContext to manage | ||||
4402 | /// canonical, dependent types, only. Clients will only see instances | ||||
4403 | /// of this class via UnaryTransformType nodes. | ||||
4404 | class DependentUnaryTransformType : public UnaryTransformType, | ||||
4405 | public llvm::FoldingSetNode { | ||||
4406 | public: | ||||
4407 | DependentUnaryTransformType(const ASTContext &C, QualType BaseType, | ||||
4408 | UTTKind UKind); | ||||
4409 | |||||
4410 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4411 | Profile(ID, getBaseType(), getUTTKind()); | ||||
4412 | } | ||||
4413 | |||||
4414 | static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType, | ||||
4415 | UTTKind UKind) { | ||||
4416 | ID.AddPointer(BaseType.getAsOpaquePtr()); | ||||
4417 | ID.AddInteger((unsigned)UKind); | ||||
4418 | } | ||||
4419 | }; | ||||
4420 | |||||
4421 | class TagType : public Type { | ||||
4422 | friend class ASTReader; | ||||
4423 | |||||
4424 | /// Stores the TagDecl associated with this type. The decl may point to any | ||||
4425 | /// TagDecl that declares the entity. | ||||
4426 | TagDecl *decl; | ||||
4427 | |||||
4428 | protected: | ||||
4429 | TagType(TypeClass TC, const TagDecl *D, QualType can); | ||||
4430 | |||||
4431 | public: | ||||
4432 | TagDecl *getDecl() const; | ||||
4433 | |||||
4434 | /// Determines whether this type is in the process of being defined. | ||||
4435 | bool isBeingDefined() const; | ||||
4436 | |||||
4437 | static bool classof(const Type *T) { | ||||
4438 | return T->getTypeClass() == Enum || T->getTypeClass() == Record; | ||||
4439 | } | ||||
4440 | }; | ||||
4441 | |||||
4442 | /// A helper class that allows the use of isa/cast/dyncast | ||||
4443 | /// to detect TagType objects of structs/unions/classes. | ||||
4444 | class RecordType : public TagType { | ||||
4445 | protected: | ||||
4446 | friend class ASTContext; // ASTContext creates these. | ||||
4447 | |||||
4448 | explicit RecordType(const RecordDecl *D) | ||||
4449 | : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {} | ||||
4450 | explicit RecordType(TypeClass TC, RecordDecl *D) | ||||
4451 | : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {} | ||||
4452 | |||||
4453 | public: | ||||
4454 | RecordDecl *getDecl() const { | ||||
4455 | return reinterpret_cast<RecordDecl*>(TagType::getDecl()); | ||||
4456 | } | ||||
4457 | |||||
4458 | /// Recursively check all fields in the record for const-ness. If any field | ||||
4459 | /// is declared const, return true. Otherwise, return false. | ||||
4460 | bool hasConstFields() const; | ||||
4461 | |||||
4462 | bool isSugared() const { return false; } | ||||
4463 | QualType desugar() const { return QualType(this, 0); } | ||||
4464 | |||||
4465 | static bool classof(const Type *T) { return T->getTypeClass() == Record; } | ||||
4466 | }; | ||||
4467 | |||||
4468 | /// A helper class that allows the use of isa/cast/dyncast | ||||
4469 | /// to detect TagType objects of enums. | ||||
4470 | class EnumType : public TagType { | ||||
4471 | friend class ASTContext; // ASTContext creates these. | ||||
4472 | |||||
4473 | explicit EnumType(const EnumDecl *D) | ||||
4474 | : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {} | ||||
4475 | |||||
4476 | public: | ||||
4477 | EnumDecl *getDecl() const { | ||||
4478 | return reinterpret_cast<EnumDecl*>(TagType::getDecl()); | ||||
4479 | } | ||||
4480 | |||||
4481 | bool isSugared() const { return false; } | ||||
4482 | QualType desugar() const { return QualType(this, 0); } | ||||
4483 | |||||
4484 | static bool classof(const Type *T) { return T->getTypeClass() == Enum; } | ||||
4485 | }; | ||||
4486 | |||||
4487 | /// An attributed type is a type to which a type attribute has been applied. | ||||
4488 | /// | ||||
4489 | /// The "modified type" is the fully-sugared type to which the attributed | ||||
4490 | /// type was applied; generally it is not canonically equivalent to the | ||||
4491 | /// attributed type. The "equivalent type" is the minimally-desugared type | ||||
4492 | /// which the type is canonically equivalent to. | ||||
4493 | /// | ||||
4494 | /// For example, in the following attributed type: | ||||
4495 | /// int32_t __attribute__((vector_size(16))) | ||||
4496 | /// - the modified type is the TypedefType for int32_t | ||||
4497 | /// - the equivalent type is VectorType(16, int32_t) | ||||
4498 | /// - the canonical type is VectorType(16, int) | ||||
4499 | class AttributedType : public Type, public llvm::FoldingSetNode { | ||||
4500 | public: | ||||
4501 | using Kind = attr::Kind; | ||||
4502 | |||||
4503 | private: | ||||
4504 | friend class ASTContext; // ASTContext creates these | ||||
4505 | |||||
4506 | QualType ModifiedType; | ||||
4507 | QualType EquivalentType; | ||||
4508 | |||||
4509 | AttributedType(QualType canon, attr::Kind attrKind, QualType modified, | ||||
4510 | QualType equivalent) | ||||
4511 | : Type(Attributed, canon, equivalent->isDependentType(), | ||||
4512 | equivalent->isInstantiationDependentType(), | ||||
4513 | equivalent->isVariablyModifiedType(), | ||||
4514 | equivalent->containsUnexpandedParameterPack()), | ||||
4515 | ModifiedType(modified), EquivalentType(equivalent) { | ||||
4516 | AttributedTypeBits.AttrKind = attrKind; | ||||
4517 | } | ||||
4518 | |||||
4519 | public: | ||||
4520 | Kind getAttrKind() const { | ||||
4521 | return static_cast<Kind>(AttributedTypeBits.AttrKind); | ||||
4522 | } | ||||
4523 | |||||
4524 | QualType getModifiedType() const { return ModifiedType; } | ||||
4525 | QualType getEquivalentType() const { return EquivalentType; } | ||||
4526 | |||||
4527 | bool isSugared() const { return true; } | ||||
4528 | QualType desugar() const { return getEquivalentType(); } | ||||
4529 | |||||
4530 | /// Does this attribute behave like a type qualifier? | ||||
4531 | /// | ||||
4532 | /// A type qualifier adjusts a type to provide specialized rules for | ||||
4533 | /// a specific object, like the standard const and volatile qualifiers. | ||||
4534 | /// This includes attributes controlling things like nullability, | ||||
4535 | /// address spaces, and ARC ownership. The value of the object is still | ||||
4536 | /// largely described by the modified type. | ||||
4537 | /// | ||||
4538 | /// In contrast, many type attributes "rewrite" their modified type to | ||||
4539 | /// produce a fundamentally different type, not necessarily related in any | ||||
4540 | /// formalizable way to the original type. For example, calling convention | ||||
4541 | /// and vector attributes are not simple type qualifiers. | ||||
4542 | /// | ||||
4543 | /// Type qualifiers are often, but not always, reflected in the canonical | ||||
4544 | /// type. | ||||
4545 | bool isQualifier() const; | ||||
4546 | |||||
4547 | bool isMSTypeSpec() const; | ||||
4548 | |||||
4549 | bool isCallingConv() const; | ||||
4550 | |||||
4551 | llvm::Optional<NullabilityKind> getImmediateNullability() const; | ||||
4552 | |||||
4553 | /// Retrieve the attribute kind corresponding to the given | ||||
4554 | /// nullability kind. | ||||
4555 | static Kind getNullabilityAttrKind(NullabilityKind kind) { | ||||
4556 | switch (kind) { | ||||
4557 | case NullabilityKind::NonNull: | ||||
4558 | return attr::TypeNonNull; | ||||
4559 | |||||
4560 | case NullabilityKind::Nullable: | ||||
4561 | return attr::TypeNullable; | ||||
4562 | |||||
4563 | case NullabilityKind::Unspecified: | ||||
4564 | return attr::TypeNullUnspecified; | ||||
4565 | } | ||||
4566 | llvm_unreachable("Unknown nullability kind.")::llvm::llvm_unreachable_internal("Unknown nullability kind." , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4566); | ||||
4567 | } | ||||
4568 | |||||
4569 | /// Strip off the top-level nullability annotation on the given | ||||
4570 | /// type, if it's there. | ||||
4571 | /// | ||||
4572 | /// \param T The type to strip. If the type is exactly an | ||||
4573 | /// AttributedType specifying nullability (without looking through | ||||
4574 | /// type sugar), the nullability is returned and this type changed | ||||
4575 | /// to the underlying modified type. | ||||
4576 | /// | ||||
4577 | /// \returns the top-level nullability, if present. | ||||
4578 | static Optional<NullabilityKind> stripOuterNullability(QualType &T); | ||||
4579 | |||||
4580 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4581 | Profile(ID, getAttrKind(), ModifiedType, EquivalentType); | ||||
4582 | } | ||||
4583 | |||||
4584 | static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind, | ||||
4585 | QualType modified, QualType equivalent) { | ||||
4586 | ID.AddInteger(attrKind); | ||||
4587 | ID.AddPointer(modified.getAsOpaquePtr()); | ||||
4588 | ID.AddPointer(equivalent.getAsOpaquePtr()); | ||||
4589 | } | ||||
4590 | |||||
4591 | static bool classof(const Type *T) { | ||||
4592 | return T->getTypeClass() == Attributed; | ||||
4593 | } | ||||
4594 | }; | ||||
4595 | |||||
4596 | class TemplateTypeParmType : public Type, public llvm::FoldingSetNode { | ||||
4597 | friend class ASTContext; // ASTContext creates these | ||||
4598 | |||||
4599 | // Helper data collector for canonical types. | ||||
4600 | struct CanonicalTTPTInfo { | ||||
4601 | unsigned Depth : 15; | ||||
4602 | unsigned ParameterPack : 1; | ||||
4603 | unsigned Index : 16; | ||||
4604 | }; | ||||
4605 | |||||
4606 | union { | ||||
4607 | // Info for the canonical type. | ||||
4608 | CanonicalTTPTInfo CanTTPTInfo; | ||||
4609 | |||||
4610 | // Info for the non-canonical type. | ||||
4611 | TemplateTypeParmDecl *TTPDecl; | ||||
4612 | }; | ||||
4613 | |||||
4614 | /// Build a non-canonical type. | ||||
4615 | TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon) | ||||
4616 | : Type(TemplateTypeParm, Canon, /*Dependent=*/true, | ||||
4617 | /*InstantiationDependent=*/true, | ||||
4618 | /*VariablyModified=*/false, | ||||
4619 | Canon->containsUnexpandedParameterPack()), | ||||
4620 | TTPDecl(TTPDecl) {} | ||||
4621 | |||||
4622 | /// Build the canonical type. | ||||
4623 | TemplateTypeParmType(unsigned D, unsigned I, bool PP) | ||||
4624 | : Type(TemplateTypeParm, QualType(this, 0), | ||||
4625 | /*Dependent=*/true, | ||||
4626 | /*InstantiationDependent=*/true, | ||||
4627 | /*VariablyModified=*/false, PP) { | ||||
4628 | CanTTPTInfo.Depth = D; | ||||
4629 | CanTTPTInfo.Index = I; | ||||
4630 | CanTTPTInfo.ParameterPack = PP; | ||||
4631 | } | ||||
4632 | |||||
4633 | const CanonicalTTPTInfo& getCanTTPTInfo() const { | ||||
4634 | QualType Can = getCanonicalTypeInternal(); | ||||
4635 | return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo; | ||||
4636 | } | ||||
4637 | |||||
4638 | public: | ||||
4639 | unsigned getDepth() const { return getCanTTPTInfo().Depth; } | ||||
4640 | unsigned getIndex() const { return getCanTTPTInfo().Index; } | ||||
4641 | bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; } | ||||
4642 | |||||
4643 | TemplateTypeParmDecl *getDecl() const { | ||||
4644 | return isCanonicalUnqualified() ? nullptr : TTPDecl; | ||||
4645 | } | ||||
4646 | |||||
4647 | IdentifierInfo *getIdentifier() const; | ||||
4648 | |||||
4649 | bool isSugared() const { return false; } | ||||
4650 | QualType desugar() const { return QualType(this, 0); } | ||||
4651 | |||||
4652 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4653 | Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl()); | ||||
4654 | } | ||||
4655 | |||||
4656 | static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth, | ||||
4657 | unsigned Index, bool ParameterPack, | ||||
4658 | TemplateTypeParmDecl *TTPDecl) { | ||||
4659 | ID.AddInteger(Depth); | ||||
4660 | ID.AddInteger(Index); | ||||
4661 | ID.AddBoolean(ParameterPack); | ||||
4662 | ID.AddPointer(TTPDecl); | ||||
4663 | } | ||||
4664 | |||||
4665 | static bool classof(const Type *T) { | ||||
4666 | return T->getTypeClass() == TemplateTypeParm; | ||||
4667 | } | ||||
4668 | }; | ||||
4669 | |||||
4670 | /// Represents the result of substituting a type for a template | ||||
4671 | /// type parameter. | ||||
4672 | /// | ||||
4673 | /// Within an instantiated template, all template type parameters have | ||||
4674 | /// been replaced with these. They are used solely to record that a | ||||
4675 | /// type was originally written as a template type parameter; | ||||
4676 | /// therefore they are never canonical. | ||||
4677 | class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode { | ||||
4678 | friend class ASTContext; | ||||
4679 | |||||
4680 | // The original type parameter. | ||||
4681 | const TemplateTypeParmType *Replaced; | ||||
4682 | |||||
4683 | SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon) | ||||
4684 | : Type(SubstTemplateTypeParm, Canon, Canon->isDependentType(), | ||||
4685 | Canon->isInstantiationDependentType(), | ||||
4686 | Canon->isVariablyModifiedType(), | ||||
4687 | Canon->containsUnexpandedParameterPack()), | ||||
4688 | Replaced(Param) {} | ||||
4689 | |||||
4690 | public: | ||||
4691 | /// Gets the template parameter that was substituted for. | ||||
4692 | const TemplateTypeParmType *getReplacedParameter() const { | ||||
4693 | return Replaced; | ||||
4694 | } | ||||
4695 | |||||
4696 | /// Gets the type that was substituted for the template | ||||
4697 | /// parameter. | ||||
4698 | QualType getReplacementType() const { | ||||
4699 | return getCanonicalTypeInternal(); | ||||
4700 | } | ||||
4701 | |||||
4702 | bool isSugared() const { return true; } | ||||
4703 | QualType desugar() const { return getReplacementType(); } | ||||
4704 | |||||
4705 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4706 | Profile(ID, getReplacedParameter(), getReplacementType()); | ||||
4707 | } | ||||
4708 | |||||
4709 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
4710 | const TemplateTypeParmType *Replaced, | ||||
4711 | QualType Replacement) { | ||||
4712 | ID.AddPointer(Replaced); | ||||
4713 | ID.AddPointer(Replacement.getAsOpaquePtr()); | ||||
4714 | } | ||||
4715 | |||||
4716 | static bool classof(const Type *T) { | ||||
4717 | return T->getTypeClass() == SubstTemplateTypeParm; | ||||
4718 | } | ||||
4719 | }; | ||||
4720 | |||||
4721 | /// Represents the result of substituting a set of types for a template | ||||
4722 | /// type parameter pack. | ||||
4723 | /// | ||||
4724 | /// When a pack expansion in the source code contains multiple parameter packs | ||||
4725 | /// and those parameter packs correspond to different levels of template | ||||
4726 | /// parameter lists, this type node is used to represent a template type | ||||
4727 | /// parameter pack from an outer level, which has already had its argument pack | ||||
4728 | /// substituted but that still lives within a pack expansion that itself | ||||
4729 | /// could not be instantiated. When actually performing a substitution into | ||||
4730 | /// that pack expansion (e.g., when all template parameters have corresponding | ||||
4731 | /// arguments), this type will be replaced with the \c SubstTemplateTypeParmType | ||||
4732 | /// at the current pack substitution index. | ||||
4733 | class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode { | ||||
4734 | friend class ASTContext; | ||||
4735 | |||||
4736 | /// The original type parameter. | ||||
4737 | const TemplateTypeParmType *Replaced; | ||||
4738 | |||||
4739 | /// A pointer to the set of template arguments that this | ||||
4740 | /// parameter pack is instantiated with. | ||||
4741 | const TemplateArgument *Arguments; | ||||
4742 | |||||
4743 | SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param, | ||||
4744 | QualType Canon, | ||||
4745 | const TemplateArgument &ArgPack); | ||||
4746 | |||||
4747 | public: | ||||
4748 | IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); } | ||||
4749 | |||||
4750 | /// Gets the template parameter that was substituted for. | ||||
4751 | const TemplateTypeParmType *getReplacedParameter() const { | ||||
4752 | return Replaced; | ||||
4753 | } | ||||
4754 | |||||
4755 | unsigned getNumArgs() const { | ||||
4756 | return SubstTemplateTypeParmPackTypeBits.NumArgs; | ||||
4757 | } | ||||
4758 | |||||
4759 | bool isSugared() const { return false; } | ||||
4760 | QualType desugar() const { return QualType(this, 0); } | ||||
4761 | |||||
4762 | TemplateArgument getArgumentPack() const; | ||||
4763 | |||||
4764 | void Profile(llvm::FoldingSetNodeID &ID); | ||||
4765 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
4766 | const TemplateTypeParmType *Replaced, | ||||
4767 | const TemplateArgument &ArgPack); | ||||
4768 | |||||
4769 | static bool classof(const Type *T) { | ||||
4770 | return T->getTypeClass() == SubstTemplateTypeParmPack; | ||||
4771 | } | ||||
4772 | }; | ||||
4773 | |||||
4774 | /// Common base class for placeholders for types that get replaced by | ||||
4775 | /// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced | ||||
4776 | /// class template types, and (eventually) constrained type names from the C++ | ||||
4777 | /// Concepts TS. | ||||
4778 | /// | ||||
4779 | /// These types are usually a placeholder for a deduced type. However, before | ||||
4780 | /// the initializer is attached, or (usually) if the initializer is | ||||
4781 | /// type-dependent, there is no deduced type and the type is canonical. In | ||||
4782 | /// the latter case, it is also a dependent type. | ||||
4783 | class DeducedType : public Type { | ||||
4784 | protected: | ||||
4785 | DeducedType(TypeClass TC, QualType DeducedAsType, bool IsDependent, | ||||
4786 | bool IsInstantiationDependent, bool ContainsParameterPack) | ||||
4787 | : Type(TC, | ||||
4788 | // FIXME: Retain the sugared deduced type? | ||||
4789 | DeducedAsType.isNull() ? QualType(this, 0) | ||||
4790 | : DeducedAsType.getCanonicalType(), | ||||
4791 | IsDependent, IsInstantiationDependent, | ||||
4792 | /*VariablyModified=*/false, ContainsParameterPack) { | ||||
4793 | if (!DeducedAsType.isNull()) { | ||||
4794 | if (DeducedAsType->isDependentType()) | ||||
4795 | setDependent(); | ||||
4796 | if (DeducedAsType->isInstantiationDependentType()) | ||||
4797 | setInstantiationDependent(); | ||||
4798 | if (DeducedAsType->containsUnexpandedParameterPack()) | ||||
4799 | setContainsUnexpandedParameterPack(); | ||||
4800 | } | ||||
4801 | } | ||||
4802 | |||||
4803 | public: | ||||
4804 | bool isSugared() const { return !isCanonicalUnqualified(); } | ||||
4805 | QualType desugar() const { return getCanonicalTypeInternal(); } | ||||
4806 | |||||
4807 | /// Get the type deduced for this placeholder type, or null if it's | ||||
4808 | /// either not been deduced or was deduced to a dependent type. | ||||
4809 | QualType getDeducedType() const { | ||||
4810 | return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType(); | ||||
4811 | } | ||||
4812 | bool isDeduced() const { | ||||
4813 | return !isCanonicalUnqualified() || isDependentType(); | ||||
4814 | } | ||||
4815 | |||||
4816 | static bool classof(const Type *T) { | ||||
4817 | return T->getTypeClass() == Auto || | ||||
4818 | T->getTypeClass() == DeducedTemplateSpecialization; | ||||
4819 | } | ||||
4820 | }; | ||||
4821 | |||||
4822 | /// Represents a C++11 auto or C++14 decltype(auto) type. | ||||
4823 | class AutoType : public DeducedType, public llvm::FoldingSetNode { | ||||
4824 | friend class ASTContext; // ASTContext creates these | ||||
4825 | |||||
4826 | AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword, | ||||
4827 | bool IsDeducedAsDependent, bool IsDeducedAsPack) | ||||
4828 | : DeducedType(Auto, DeducedAsType, IsDeducedAsDependent, | ||||
4829 | IsDeducedAsDependent, IsDeducedAsPack) { | ||||
4830 | AutoTypeBits.Keyword = (unsigned)Keyword; | ||||
4831 | } | ||||
4832 | |||||
4833 | public: | ||||
4834 | bool isDecltypeAuto() const { | ||||
4835 | return getKeyword() == AutoTypeKeyword::DecltypeAuto; | ||||
4836 | } | ||||
4837 | |||||
4838 | AutoTypeKeyword getKeyword() const { | ||||
4839 | return (AutoTypeKeyword)AutoTypeBits.Keyword; | ||||
4840 | } | ||||
4841 | |||||
4842 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4843 | Profile(ID, getDeducedType(), getKeyword(), isDependentType(), | ||||
4844 | containsUnexpandedParameterPack()); | ||||
4845 | } | ||||
4846 | |||||
4847 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Deduced, | ||||
4848 | AutoTypeKeyword Keyword, bool IsDependent, bool IsPack) { | ||||
4849 | ID.AddPointer(Deduced.getAsOpaquePtr()); | ||||
4850 | ID.AddInteger((unsigned)Keyword); | ||||
4851 | ID.AddBoolean(IsDependent); | ||||
4852 | ID.AddBoolean(IsPack); | ||||
4853 | } | ||||
4854 | |||||
4855 | static bool classof(const Type *T) { | ||||
4856 | return T->getTypeClass() == Auto; | ||||
4857 | } | ||||
4858 | }; | ||||
4859 | |||||
4860 | /// Represents a C++17 deduced template specialization type. | ||||
4861 | class DeducedTemplateSpecializationType : public DeducedType, | ||||
4862 | public llvm::FoldingSetNode { | ||||
4863 | friend class ASTContext; // ASTContext creates these | ||||
4864 | |||||
4865 | /// The name of the template whose arguments will be deduced. | ||||
4866 | TemplateName Template; | ||||
4867 | |||||
4868 | DeducedTemplateSpecializationType(TemplateName Template, | ||||
4869 | QualType DeducedAsType, | ||||
4870 | bool IsDeducedAsDependent) | ||||
4871 | : DeducedType(DeducedTemplateSpecialization, DeducedAsType, | ||||
4872 | IsDeducedAsDependent || Template.isDependent(), | ||||
4873 | IsDeducedAsDependent || Template.isInstantiationDependent(), | ||||
4874 | Template.containsUnexpandedParameterPack()), | ||||
4875 | Template(Template) {} | ||||
4876 | |||||
4877 | public: | ||||
4878 | /// Retrieve the name of the template that we are deducing. | ||||
4879 | TemplateName getTemplateName() const { return Template;} | ||||
4880 | |||||
4881 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
4882 | Profile(ID, getTemplateName(), getDeducedType(), isDependentType()); | ||||
4883 | } | ||||
4884 | |||||
4885 | static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template, | ||||
4886 | QualType Deduced, bool IsDependent) { | ||||
4887 | Template.Profile(ID); | ||||
4888 | ID.AddPointer(Deduced.getAsOpaquePtr()); | ||||
4889 | ID.AddBoolean(IsDependent); | ||||
4890 | } | ||||
4891 | |||||
4892 | static bool classof(const Type *T) { | ||||
4893 | return T->getTypeClass() == DeducedTemplateSpecialization; | ||||
4894 | } | ||||
4895 | }; | ||||
4896 | |||||
4897 | /// Represents a type template specialization; the template | ||||
4898 | /// must be a class template, a type alias template, or a template | ||||
4899 | /// template parameter. A template which cannot be resolved to one of | ||||
4900 | /// these, e.g. because it is written with a dependent scope | ||||
4901 | /// specifier, is instead represented as a | ||||
4902 | /// @c DependentTemplateSpecializationType. | ||||
4903 | /// | ||||
4904 | /// A non-dependent template specialization type is always "sugar", | ||||
4905 | /// typically for a \c RecordType. For example, a class template | ||||
4906 | /// specialization type of \c vector<int> will refer to a tag type for | ||||
4907 | /// the instantiation \c std::vector<int, std::allocator<int>> | ||||
4908 | /// | ||||
4909 | /// Template specializations are dependent if either the template or | ||||
4910 | /// any of the template arguments are dependent, in which case the | ||||
4911 | /// type may also be canonical. | ||||
4912 | /// | ||||
4913 | /// Instances of this type are allocated with a trailing array of | ||||
4914 | /// TemplateArguments, followed by a QualType representing the | ||||
4915 | /// non-canonical aliased type when the template is a type alias | ||||
4916 | /// template. | ||||
4917 | class alignas(8) TemplateSpecializationType | ||||
4918 | : public Type, | ||||
4919 | public llvm::FoldingSetNode { | ||||
4920 | friend class ASTContext; // ASTContext creates these | ||||
4921 | |||||
4922 | /// The name of the template being specialized. This is | ||||
4923 | /// either a TemplateName::Template (in which case it is a | ||||
4924 | /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a | ||||
4925 | /// TypeAliasTemplateDecl*), a | ||||
4926 | /// TemplateName::SubstTemplateTemplateParmPack, or a | ||||
4927 | /// TemplateName::SubstTemplateTemplateParm (in which case the | ||||
4928 | /// replacement must, recursively, be one of these). | ||||
4929 | TemplateName Template; | ||||
4930 | |||||
4931 | TemplateSpecializationType(TemplateName T, | ||||
4932 | ArrayRef<TemplateArgument> Args, | ||||
4933 | QualType Canon, | ||||
4934 | QualType Aliased); | ||||
4935 | |||||
4936 | public: | ||||
4937 | /// Determine whether any of the given template arguments are dependent. | ||||
4938 | static bool anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args, | ||||
4939 | bool &InstantiationDependent); | ||||
4940 | |||||
4941 | static bool anyDependentTemplateArguments(const TemplateArgumentListInfo &, | ||||
4942 | bool &InstantiationDependent); | ||||
4943 | |||||
4944 | /// True if this template specialization type matches a current | ||||
4945 | /// instantiation in the context in which it is found. | ||||
4946 | bool isCurrentInstantiation() const { | ||||
4947 | return isa<InjectedClassNameType>(getCanonicalTypeInternal()); | ||||
4948 | } | ||||
4949 | |||||
4950 | /// Determine if this template specialization type is for a type alias | ||||
4951 | /// template that has been substituted. | ||||
4952 | /// | ||||
4953 | /// Nearly every template specialization type whose template is an alias | ||||
4954 | /// template will be substituted. However, this is not the case when | ||||
4955 | /// the specialization contains a pack expansion but the template alias | ||||
4956 | /// does not have a corresponding parameter pack, e.g., | ||||
4957 | /// | ||||
4958 | /// \code | ||||
4959 | /// template<typename T, typename U, typename V> struct S; | ||||
4960 | /// template<typename T, typename U> using A = S<T, int, U>; | ||||
4961 | /// template<typename... Ts> struct X { | ||||
4962 | /// typedef A<Ts...> type; // not a type alias | ||||
4963 | /// }; | ||||
4964 | /// \endcode | ||||
4965 | bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; } | ||||
4966 | |||||
4967 | /// Get the aliased type, if this is a specialization of a type alias | ||||
4968 | /// template. | ||||
4969 | QualType getAliasedType() const { | ||||
4970 | assert(isTypeAlias() && "not a type alias template specialization")((isTypeAlias() && "not a type alias template specialization" ) ? static_cast<void> (0) : __assert_fail ("isTypeAlias() && \"not a type alias template specialization\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 4970, __PRETTY_FUNCTION__)); | ||||
4971 | return *reinterpret_cast<const QualType*>(end()); | ||||
4972 | } | ||||
4973 | |||||
4974 | using iterator = const TemplateArgument *; | ||||
4975 | |||||
4976 | iterator begin() const { return getArgs(); } | ||||
4977 | iterator end() const; // defined inline in TemplateBase.h | ||||
4978 | |||||
4979 | /// Retrieve the name of the template that we are specializing. | ||||
4980 | TemplateName getTemplateName() const { return Template; } | ||||
4981 | |||||
4982 | /// Retrieve the template arguments. | ||||
4983 | const TemplateArgument *getArgs() const { | ||||
4984 | return reinterpret_cast<const TemplateArgument *>(this + 1); | ||||
4985 | } | ||||
4986 | |||||
4987 | /// Retrieve the number of template arguments. | ||||
4988 | unsigned getNumArgs() const { | ||||
4989 | return TemplateSpecializationTypeBits.NumArgs; | ||||
4990 | } | ||||
4991 | |||||
4992 | /// Retrieve a specific template argument as a type. | ||||
4993 | /// \pre \c isArgType(Arg) | ||||
4994 | const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h | ||||
4995 | |||||
4996 | ArrayRef<TemplateArgument> template_arguments() const { | ||||
4997 | return {getArgs(), getNumArgs()}; | ||||
4998 | } | ||||
4999 | |||||
5000 | bool isSugared() const { | ||||
5001 | return !isDependentType() || isCurrentInstantiation() || isTypeAlias(); | ||||
5002 | } | ||||
5003 | |||||
5004 | QualType desugar() const { | ||||
5005 | return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal(); | ||||
5006 | } | ||||
5007 | |||||
5008 | void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) { | ||||
5009 | Profile(ID, Template, template_arguments(), Ctx); | ||||
5010 | if (isTypeAlias()) | ||||
5011 | getAliasedType().Profile(ID); | ||||
5012 | } | ||||
5013 | |||||
5014 | static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T, | ||||
5015 | ArrayRef<TemplateArgument> Args, | ||||
5016 | const ASTContext &Context); | ||||
5017 | |||||
5018 | static bool classof(const Type *T) { | ||||
5019 | return T->getTypeClass() == TemplateSpecialization; | ||||
5020 | } | ||||
5021 | }; | ||||
5022 | |||||
5023 | /// Print a template argument list, including the '<' and '>' | ||||
5024 | /// enclosing the template arguments. | ||||
5025 | void printTemplateArgumentList(raw_ostream &OS, | ||||
5026 | ArrayRef<TemplateArgument> Args, | ||||
5027 | const PrintingPolicy &Policy); | ||||
5028 | |||||
5029 | void printTemplateArgumentList(raw_ostream &OS, | ||||
5030 | ArrayRef<TemplateArgumentLoc> Args, | ||||
5031 | const PrintingPolicy &Policy); | ||||
5032 | |||||
5033 | void printTemplateArgumentList(raw_ostream &OS, | ||||
5034 | const TemplateArgumentListInfo &Args, | ||||
5035 | const PrintingPolicy &Policy); | ||||
5036 | |||||
5037 | /// The injected class name of a C++ class template or class | ||||
5038 | /// template partial specialization. Used to record that a type was | ||||
5039 | /// spelled with a bare identifier rather than as a template-id; the | ||||
5040 | /// equivalent for non-templated classes is just RecordType. | ||||
5041 | /// | ||||
5042 | /// Injected class name types are always dependent. Template | ||||
5043 | /// instantiation turns these into RecordTypes. | ||||
5044 | /// | ||||
5045 | /// Injected class name types are always canonical. This works | ||||
5046 | /// because it is impossible to compare an injected class name type | ||||
5047 | /// with the corresponding non-injected template type, for the same | ||||
5048 | /// reason that it is impossible to directly compare template | ||||
5049 | /// parameters from different dependent contexts: injected class name | ||||
5050 | /// types can only occur within the scope of a particular templated | ||||
5051 | /// declaration, and within that scope every template specialization | ||||
5052 | /// will canonicalize to the injected class name (when appropriate | ||||
5053 | /// according to the rules of the language). | ||||
5054 | class InjectedClassNameType : public Type { | ||||
5055 | friend class ASTContext; // ASTContext creates these. | ||||
5056 | friend class ASTNodeImporter; | ||||
5057 | friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not | ||||
5058 | // currently suitable for AST reading, too much | ||||
5059 | // interdependencies. | ||||
5060 | |||||
5061 | CXXRecordDecl *Decl; | ||||
5062 | |||||
5063 | /// The template specialization which this type represents. | ||||
5064 | /// For example, in | ||||
5065 | /// template <class T> class A { ... }; | ||||
5066 | /// this is A<T>, whereas in | ||||
5067 | /// template <class X, class Y> class A<B<X,Y> > { ... }; | ||||
5068 | /// this is A<B<X,Y> >. | ||||
5069 | /// | ||||
5070 | /// It is always unqualified, always a template specialization type, | ||||
5071 | /// and always dependent. | ||||
5072 | QualType InjectedType; | ||||
5073 | |||||
5074 | InjectedClassNameType(CXXRecordDecl *D, QualType TST) | ||||
5075 | : Type(InjectedClassName, QualType(), /*Dependent=*/true, | ||||
5076 | /*InstantiationDependent=*/true, | ||||
5077 | /*VariablyModified=*/false, | ||||
5078 | /*ContainsUnexpandedParameterPack=*/false), | ||||
5079 | Decl(D), InjectedType(TST) { | ||||
5080 | assert(isa<TemplateSpecializationType>(TST))((isa<TemplateSpecializationType>(TST)) ? static_cast< void> (0) : __assert_fail ("isa<TemplateSpecializationType>(TST)" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5080, __PRETTY_FUNCTION__)); | ||||
5081 | assert(!TST.hasQualifiers())((!TST.hasQualifiers()) ? static_cast<void> (0) : __assert_fail ("!TST.hasQualifiers()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5081, __PRETTY_FUNCTION__)); | ||||
5082 | assert(TST->isDependentType())((TST->isDependentType()) ? static_cast<void> (0) : __assert_fail ("TST->isDependentType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5082, __PRETTY_FUNCTION__)); | ||||
5083 | } | ||||
5084 | |||||
5085 | public: | ||||
5086 | QualType getInjectedSpecializationType() const { return InjectedType; } | ||||
5087 | |||||
5088 | const TemplateSpecializationType *getInjectedTST() const { | ||||
5089 | return cast<TemplateSpecializationType>(InjectedType.getTypePtr()); | ||||
5090 | } | ||||
5091 | |||||
5092 | TemplateName getTemplateName() const { | ||||
5093 | return getInjectedTST()->getTemplateName(); | ||||
5094 | } | ||||
5095 | |||||
5096 | CXXRecordDecl *getDecl() const; | ||||
5097 | |||||
5098 | bool isSugared() const { return false; } | ||||
5099 | QualType desugar() const { return QualType(this, 0); } | ||||
5100 | |||||
5101 | static bool classof(const Type *T) { | ||||
5102 | return T->getTypeClass() == InjectedClassName; | ||||
5103 | } | ||||
5104 | }; | ||||
5105 | |||||
5106 | /// The kind of a tag type. | ||||
5107 | enum TagTypeKind { | ||||
5108 | /// The "struct" keyword. | ||||
5109 | TTK_Struct, | ||||
5110 | |||||
5111 | /// The "__interface" keyword. | ||||
5112 | TTK_Interface, | ||||
5113 | |||||
5114 | /// The "union" keyword. | ||||
5115 | TTK_Union, | ||||
5116 | |||||
5117 | /// The "class" keyword. | ||||
5118 | TTK_Class, | ||||
5119 | |||||
5120 | /// The "enum" keyword. | ||||
5121 | TTK_Enum | ||||
5122 | }; | ||||
5123 | |||||
5124 | /// The elaboration keyword that precedes a qualified type name or | ||||
5125 | /// introduces an elaborated-type-specifier. | ||||
5126 | enum ElaboratedTypeKeyword { | ||||
5127 | /// The "struct" keyword introduces the elaborated-type-specifier. | ||||
5128 | ETK_Struct, | ||||
5129 | |||||
5130 | /// The "__interface" keyword introduces the elaborated-type-specifier. | ||||
5131 | ETK_Interface, | ||||
5132 | |||||
5133 | /// The "union" keyword introduces the elaborated-type-specifier. | ||||
5134 | ETK_Union, | ||||
5135 | |||||
5136 | /// The "class" keyword introduces the elaborated-type-specifier. | ||||
5137 | ETK_Class, | ||||
5138 | |||||
5139 | /// The "enum" keyword introduces the elaborated-type-specifier. | ||||
5140 | ETK_Enum, | ||||
5141 | |||||
5142 | /// The "typename" keyword precedes the qualified type name, e.g., | ||||
5143 | /// \c typename T::type. | ||||
5144 | ETK_Typename, | ||||
5145 | |||||
5146 | /// No keyword precedes the qualified type name. | ||||
5147 | ETK_None | ||||
5148 | }; | ||||
5149 | |||||
5150 | /// A helper class for Type nodes having an ElaboratedTypeKeyword. | ||||
5151 | /// The keyword in stored in the free bits of the base class. | ||||
5152 | /// Also provides a few static helpers for converting and printing | ||||
5153 | /// elaborated type keyword and tag type kind enumerations. | ||||
5154 | class TypeWithKeyword : public Type { | ||||
5155 | protected: | ||||
5156 | TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc, | ||||
5157 | QualType Canonical, bool Dependent, | ||||
5158 | bool InstantiationDependent, bool VariablyModified, | ||||
5159 | bool ContainsUnexpandedParameterPack) | ||||
5160 | : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified, | ||||
5161 | ContainsUnexpandedParameterPack) { | ||||
5162 | TypeWithKeywordBits.Keyword = Keyword; | ||||
5163 | } | ||||
5164 | |||||
5165 | public: | ||||
5166 | ElaboratedTypeKeyword getKeyword() const { | ||||
5167 | return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword); | ||||
5168 | } | ||||
5169 | |||||
5170 | /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword. | ||||
5171 | static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec); | ||||
5172 | |||||
5173 | /// Converts a type specifier (DeclSpec::TST) into a tag type kind. | ||||
5174 | /// It is an error to provide a type specifier which *isn't* a tag kind here. | ||||
5175 | static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec); | ||||
5176 | |||||
5177 | /// Converts a TagTypeKind into an elaborated type keyword. | ||||
5178 | static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag); | ||||
5179 | |||||
5180 | /// Converts an elaborated type keyword into a TagTypeKind. | ||||
5181 | /// It is an error to provide an elaborated type keyword | ||||
5182 | /// which *isn't* a tag kind here. | ||||
5183 | static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword); | ||||
5184 | |||||
5185 | static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword); | ||||
5186 | |||||
5187 | static StringRef getKeywordName(ElaboratedTypeKeyword Keyword); | ||||
5188 | |||||
5189 | static StringRef getTagTypeKindName(TagTypeKind Kind) { | ||||
5190 | return getKeywordName(getKeywordForTagTypeKind(Kind)); | ||||
5191 | } | ||||
5192 | |||||
5193 | class CannotCastToThisType {}; | ||||
5194 | static CannotCastToThisType classof(const Type *); | ||||
5195 | }; | ||||
5196 | |||||
5197 | /// Represents a type that was referred to using an elaborated type | ||||
5198 | /// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type, | ||||
5199 | /// or both. | ||||
5200 | /// | ||||
5201 | /// This type is used to keep track of a type name as written in the | ||||
5202 | /// source code, including tag keywords and any nested-name-specifiers. | ||||
5203 | /// The type itself is always "sugar", used to express what was written | ||||
5204 | /// in the source code but containing no additional semantic information. | ||||
5205 | class ElaboratedType final | ||||
5206 | : public TypeWithKeyword, | ||||
5207 | public llvm::FoldingSetNode, | ||||
5208 | private llvm::TrailingObjects<ElaboratedType, TagDecl *> { | ||||
5209 | friend class ASTContext; // ASTContext creates these | ||||
5210 | friend TrailingObjects; | ||||
5211 | |||||
5212 | /// The nested name specifier containing the qualifier. | ||||
5213 | NestedNameSpecifier *NNS; | ||||
5214 | |||||
5215 | /// The type that this qualified name refers to. | ||||
5216 | QualType NamedType; | ||||
5217 | |||||
5218 | /// The (re)declaration of this tag type owned by this occurrence is stored | ||||
5219 | /// as a trailing object if there is one. Use getOwnedTagDecl to obtain | ||||
5220 | /// it, or obtain a null pointer if there is none. | ||||
5221 | |||||
5222 | ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, | ||||
5223 | QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl) | ||||
5224 | : TypeWithKeyword(Keyword, Elaborated, CanonType, | ||||
5225 | NamedType->isDependentType(), | ||||
5226 | NamedType->isInstantiationDependentType(), | ||||
5227 | NamedType->isVariablyModifiedType(), | ||||
5228 | NamedType->containsUnexpandedParameterPack()), | ||||
5229 | NNS(NNS), NamedType(NamedType) { | ||||
5230 | ElaboratedTypeBits.HasOwnedTagDecl = false; | ||||
5231 | if (OwnedTagDecl) { | ||||
5232 | ElaboratedTypeBits.HasOwnedTagDecl = true; | ||||
5233 | *getTrailingObjects<TagDecl *>() = OwnedTagDecl; | ||||
5234 | } | ||||
5235 | assert(!(Keyword == ETK_None && NNS == nullptr) &&((!(Keyword == ETK_None && NNS == nullptr) && "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null." ) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5237, __PRETTY_FUNCTION__)) | ||||
5236 | "ElaboratedType cannot have elaborated type keyword "((!(Keyword == ETK_None && NNS == nullptr) && "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null." ) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5237, __PRETTY_FUNCTION__)) | ||||
5237 | "and name qualifier both null.")((!(Keyword == ETK_None && NNS == nullptr) && "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null." ) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5237, __PRETTY_FUNCTION__)); | ||||
5238 | } | ||||
5239 | |||||
5240 | public: | ||||
5241 | /// Retrieve the qualification on this type. | ||||
5242 | NestedNameSpecifier *getQualifier() const { return NNS; } | ||||
5243 | |||||
5244 | /// Retrieve the type named by the qualified-id. | ||||
5245 | QualType getNamedType() const { return NamedType; } | ||||
5246 | |||||
5247 | /// Remove a single level of sugar. | ||||
5248 | QualType desugar() const { return getNamedType(); } | ||||
5249 | |||||
5250 | /// Returns whether this type directly provides sugar. | ||||
5251 | bool isSugared() const { return true; } | ||||
5252 | |||||
5253 | /// Return the (re)declaration of this type owned by this occurrence of this | ||||
5254 | /// type, or nullptr if there is none. | ||||
5255 | TagDecl *getOwnedTagDecl() const { | ||||
5256 | return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>() | ||||
5257 | : nullptr; | ||||
5258 | } | ||||
5259 | |||||
5260 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
5261 | Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl()); | ||||
5262 | } | ||||
5263 | |||||
5264 | static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, | ||||
5265 | NestedNameSpecifier *NNS, QualType NamedType, | ||||
5266 | TagDecl *OwnedTagDecl) { | ||||
5267 | ID.AddInteger(Keyword); | ||||
5268 | ID.AddPointer(NNS); | ||||
5269 | NamedType.Profile(ID); | ||||
5270 | ID.AddPointer(OwnedTagDecl); | ||||
5271 | } | ||||
5272 | |||||
5273 | static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; } | ||||
5274 | }; | ||||
5275 | |||||
5276 | /// Represents a qualified type name for which the type name is | ||||
5277 | /// dependent. | ||||
5278 | /// | ||||
5279 | /// DependentNameType represents a class of dependent types that involve a | ||||
5280 | /// possibly dependent nested-name-specifier (e.g., "T::") followed by a | ||||
5281 | /// name of a type. The DependentNameType may start with a "typename" (for a | ||||
5282 | /// typename-specifier), "class", "struct", "union", or "enum" (for a | ||||
5283 | /// dependent elaborated-type-specifier), or nothing (in contexts where we | ||||
5284 | /// know that we must be referring to a type, e.g., in a base class specifier). | ||||
5285 | /// Typically the nested-name-specifier is dependent, but in MSVC compatibility | ||||
5286 | /// mode, this type is used with non-dependent names to delay name lookup until | ||||
5287 | /// instantiation. | ||||
5288 | class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode { | ||||
5289 | friend class ASTContext; // ASTContext creates these | ||||
5290 | |||||
5291 | /// The nested name specifier containing the qualifier. | ||||
5292 | NestedNameSpecifier *NNS; | ||||
5293 | |||||
5294 | /// The type that this typename specifier refers to. | ||||
5295 | const IdentifierInfo *Name; | ||||
5296 | |||||
5297 | DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, | ||||
5298 | const IdentifierInfo *Name, QualType CanonType) | ||||
5299 | : TypeWithKeyword(Keyword, DependentName, CanonType, /*Dependent=*/true, | ||||
5300 | /*InstantiationDependent=*/true, | ||||
5301 | /*VariablyModified=*/false, | ||||
5302 | NNS->containsUnexpandedParameterPack()), | ||||
5303 | NNS(NNS), Name(Name) {} | ||||
5304 | |||||
5305 | public: | ||||
5306 | /// Retrieve the qualification on this type. | ||||
5307 | NestedNameSpecifier *getQualifier() const { return NNS; } | ||||
5308 | |||||
5309 | /// Retrieve the type named by the typename specifier as an identifier. | ||||
5310 | /// | ||||
5311 | /// This routine will return a non-NULL identifier pointer when the | ||||
5312 | /// form of the original typename was terminated by an identifier, | ||||
5313 | /// e.g., "typename T::type". | ||||
5314 | const IdentifierInfo *getIdentifier() const { | ||||
5315 | return Name; | ||||
5316 | } | ||||
5317 | |||||
5318 | bool isSugared() const { return false; } | ||||
5319 | QualType desugar() const { return QualType(this, 0); } | ||||
5320 | |||||
5321 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
5322 | Profile(ID, getKeyword(), NNS, Name); | ||||
5323 | } | ||||
5324 | |||||
5325 | static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, | ||||
5326 | NestedNameSpecifier *NNS, const IdentifierInfo *Name) { | ||||
5327 | ID.AddInteger(Keyword); | ||||
5328 | ID.AddPointer(NNS); | ||||
5329 | ID.AddPointer(Name); | ||||
5330 | } | ||||
5331 | |||||
5332 | static bool classof(const Type *T) { | ||||
5333 | return T->getTypeClass() == DependentName; | ||||
5334 | } | ||||
5335 | }; | ||||
5336 | |||||
5337 | /// Represents a template specialization type whose template cannot be | ||||
5338 | /// resolved, e.g. | ||||
5339 | /// A<T>::template B<T> | ||||
5340 | class alignas(8) DependentTemplateSpecializationType | ||||
5341 | : public TypeWithKeyword, | ||||
5342 | public llvm::FoldingSetNode { | ||||
5343 | friend class ASTContext; // ASTContext creates these | ||||
5344 | |||||
5345 | /// The nested name specifier containing the qualifier. | ||||
5346 | NestedNameSpecifier *NNS; | ||||
5347 | |||||
5348 | /// The identifier of the template. | ||||
5349 | const IdentifierInfo *Name; | ||||
5350 | |||||
5351 | DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, | ||||
5352 | NestedNameSpecifier *NNS, | ||||
5353 | const IdentifierInfo *Name, | ||||
5354 | ArrayRef<TemplateArgument> Args, | ||||
5355 | QualType Canon); | ||||
5356 | |||||
5357 | const TemplateArgument *getArgBuffer() const { | ||||
5358 | return reinterpret_cast<const TemplateArgument*>(this+1); | ||||
5359 | } | ||||
5360 | |||||
5361 | TemplateArgument *getArgBuffer() { | ||||
5362 | return reinterpret_cast<TemplateArgument*>(this+1); | ||||
5363 | } | ||||
5364 | |||||
5365 | public: | ||||
5366 | NestedNameSpecifier *getQualifier() const { return NNS; } | ||||
5367 | const IdentifierInfo *getIdentifier() const { return Name; } | ||||
5368 | |||||
5369 | /// Retrieve the template arguments. | ||||
5370 | const TemplateArgument *getArgs() const { | ||||
5371 | return getArgBuffer(); | ||||
5372 | } | ||||
5373 | |||||
5374 | /// Retrieve the number of template arguments. | ||||
5375 | unsigned getNumArgs() const { | ||||
5376 | return DependentTemplateSpecializationTypeBits.NumArgs; | ||||
5377 | } | ||||
5378 | |||||
5379 | const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h | ||||
5380 | |||||
5381 | ArrayRef<TemplateArgument> template_arguments() const { | ||||
5382 | return {getArgs(), getNumArgs()}; | ||||
5383 | } | ||||
5384 | |||||
5385 | using iterator = const TemplateArgument *; | ||||
5386 | |||||
5387 | iterator begin() const { return getArgs(); } | ||||
5388 | iterator end() const; // inline in TemplateBase.h | ||||
5389 | |||||
5390 | bool isSugared() const { return false; } | ||||
5391 | QualType desugar() const { return QualType(this, 0); } | ||||
5392 | |||||
5393 | void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) { | ||||
5394 | Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()}); | ||||
5395 | } | ||||
5396 | |||||
5397 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
5398 | const ASTContext &Context, | ||||
5399 | ElaboratedTypeKeyword Keyword, | ||||
5400 | NestedNameSpecifier *Qualifier, | ||||
5401 | const IdentifierInfo *Name, | ||||
5402 | ArrayRef<TemplateArgument> Args); | ||||
5403 | |||||
5404 | static bool classof(const Type *T) { | ||||
5405 | return T->getTypeClass() == DependentTemplateSpecialization; | ||||
5406 | } | ||||
5407 | }; | ||||
5408 | |||||
5409 | /// Represents a pack expansion of types. | ||||
5410 | /// | ||||
5411 | /// Pack expansions are part of C++11 variadic templates. A pack | ||||
5412 | /// expansion contains a pattern, which itself contains one or more | ||||
5413 | /// "unexpanded" parameter packs. When instantiated, a pack expansion | ||||
5414 | /// produces a series of types, each instantiated from the pattern of | ||||
5415 | /// the expansion, where the Ith instantiation of the pattern uses the | ||||
5416 | /// Ith arguments bound to each of the unexpanded parameter packs. The | ||||
5417 | /// pack expansion is considered to "expand" these unexpanded | ||||
5418 | /// parameter packs. | ||||
5419 | /// | ||||
5420 | /// \code | ||||
5421 | /// template<typename ...Types> struct tuple; | ||||
5422 | /// | ||||
5423 | /// template<typename ...Types> | ||||
5424 | /// struct tuple_of_references { | ||||
5425 | /// typedef tuple<Types&...> type; | ||||
5426 | /// }; | ||||
5427 | /// \endcode | ||||
5428 | /// | ||||
5429 | /// Here, the pack expansion \c Types&... is represented via a | ||||
5430 | /// PackExpansionType whose pattern is Types&. | ||||
5431 | class PackExpansionType : public Type, public llvm::FoldingSetNode { | ||||
5432 | friend class ASTContext; // ASTContext creates these | ||||
5433 | |||||
5434 | /// The pattern of the pack expansion. | ||||
5435 | QualType Pattern; | ||||
5436 | |||||
5437 | PackExpansionType(QualType Pattern, QualType Canon, | ||||
5438 | Optional<unsigned> NumExpansions) | ||||
5439 | : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(), | ||||
5440 | /*InstantiationDependent=*/true, | ||||
5441 | /*VariablyModified=*/Pattern->isVariablyModifiedType(), | ||||
5442 | /*ContainsUnexpandedParameterPack=*/false), | ||||
5443 | Pattern(Pattern) { | ||||
5444 | PackExpansionTypeBits.NumExpansions = | ||||
5445 | NumExpansions ? *NumExpansions + 1 : 0; | ||||
5446 | } | ||||
5447 | |||||
5448 | public: | ||||
5449 | /// Retrieve the pattern of this pack expansion, which is the | ||||
5450 | /// type that will be repeatedly instantiated when instantiating the | ||||
5451 | /// pack expansion itself. | ||||
5452 | QualType getPattern() const { return Pattern; } | ||||
5453 | |||||
5454 | /// Retrieve the number of expansions that this pack expansion will | ||||
5455 | /// generate, if known. | ||||
5456 | Optional<unsigned> getNumExpansions() const { | ||||
5457 | if (PackExpansionTypeBits.NumExpansions) | ||||
5458 | return PackExpansionTypeBits.NumExpansions - 1; | ||||
5459 | return None; | ||||
5460 | } | ||||
5461 | |||||
5462 | bool isSugared() const { return !Pattern->isDependentType(); } | ||||
5463 | QualType desugar() const { return isSugared() ? Pattern : QualType(this, 0); } | ||||
5464 | |||||
5465 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
5466 | Profile(ID, getPattern(), getNumExpansions()); | ||||
5467 | } | ||||
5468 | |||||
5469 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern, | ||||
5470 | Optional<unsigned> NumExpansions) { | ||||
5471 | ID.AddPointer(Pattern.getAsOpaquePtr()); | ||||
5472 | ID.AddBoolean(NumExpansions.hasValue()); | ||||
5473 | if (NumExpansions) | ||||
5474 | ID.AddInteger(*NumExpansions); | ||||
5475 | } | ||||
5476 | |||||
5477 | static bool classof(const Type *T) { | ||||
5478 | return T->getTypeClass() == PackExpansion; | ||||
5479 | } | ||||
5480 | }; | ||||
5481 | |||||
5482 | /// This class wraps the list of protocol qualifiers. For types that can | ||||
5483 | /// take ObjC protocol qualifers, they can subclass this class. | ||||
5484 | template <class T> | ||||
5485 | class ObjCProtocolQualifiers { | ||||
5486 | protected: | ||||
5487 | ObjCProtocolQualifiers() = default; | ||||
5488 | |||||
5489 | ObjCProtocolDecl * const *getProtocolStorage() const { | ||||
5490 | return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage(); | ||||
5491 | } | ||||
5492 | |||||
5493 | ObjCProtocolDecl **getProtocolStorage() { | ||||
5494 | return static_cast<T*>(this)->getProtocolStorageImpl(); | ||||
5495 | } | ||||
5496 | |||||
5497 | void setNumProtocols(unsigned N) { | ||||
5498 | static_cast<T*>(this)->setNumProtocolsImpl(N); | ||||
5499 | } | ||||
5500 | |||||
5501 | void initialize(ArrayRef<ObjCProtocolDecl *> protocols) { | ||||
5502 | setNumProtocols(protocols.size()); | ||||
5503 | assert(getNumProtocols() == protocols.size() &&((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count" ) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5504, __PRETTY_FUNCTION__)) | ||||
5504 | "bitfield overflow in protocol count")((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count" ) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5504, __PRETTY_FUNCTION__)); | ||||
5505 | if (!protocols.empty()) | ||||
5506 | memcpy(getProtocolStorage(), protocols.data(), | ||||
5507 | protocols.size() * sizeof(ObjCProtocolDecl*)); | ||||
5508 | } | ||||
5509 | |||||
5510 | public: | ||||
5511 | using qual_iterator = ObjCProtocolDecl * const *; | ||||
5512 | using qual_range = llvm::iterator_range<qual_iterator>; | ||||
5513 | |||||
5514 | qual_range quals() const { return qual_range(qual_begin(), qual_end()); } | ||||
5515 | qual_iterator qual_begin() const { return getProtocolStorage(); } | ||||
5516 | qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); } | ||||
5517 | |||||
5518 | bool qual_empty() const { return getNumProtocols() == 0; } | ||||
5519 | |||||
5520 | /// Return the number of qualifying protocols in this type, or 0 if | ||||
5521 | /// there are none. | ||||
5522 | unsigned getNumProtocols() const { | ||||
5523 | return static_cast<const T*>(this)->getNumProtocolsImpl(); | ||||
5524 | } | ||||
5525 | |||||
5526 | /// Fetch a protocol by index. | ||||
5527 | ObjCProtocolDecl *getProtocol(unsigned I) const { | ||||
5528 | assert(I < getNumProtocols() && "Out-of-range protocol access")((I < getNumProtocols() && "Out-of-range protocol access" ) ? static_cast<void> (0) : __assert_fail ("I < getNumProtocols() && \"Out-of-range protocol access\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5528, __PRETTY_FUNCTION__)); | ||||
5529 | return qual_begin()[I]; | ||||
5530 | } | ||||
5531 | |||||
5532 | /// Retrieve all of the protocol qualifiers. | ||||
5533 | ArrayRef<ObjCProtocolDecl *> getProtocols() const { | ||||
5534 | return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols()); | ||||
5535 | } | ||||
5536 | }; | ||||
5537 | |||||
5538 | /// Represents a type parameter type in Objective C. It can take | ||||
5539 | /// a list of protocols. | ||||
5540 | class ObjCTypeParamType : public Type, | ||||
5541 | public ObjCProtocolQualifiers<ObjCTypeParamType>, | ||||
5542 | public llvm::FoldingSetNode { | ||||
5543 | friend class ASTContext; | ||||
5544 | friend class ObjCProtocolQualifiers<ObjCTypeParamType>; | ||||
5545 | |||||
5546 | /// The number of protocols stored on this type. | ||||
5547 | unsigned NumProtocols : 6; | ||||
5548 | |||||
5549 | ObjCTypeParamDecl *OTPDecl; | ||||
5550 | |||||
5551 | /// The protocols are stored after the ObjCTypeParamType node. In the | ||||
5552 | /// canonical type, the list of protocols are sorted alphabetically | ||||
5553 | /// and uniqued. | ||||
5554 | ObjCProtocolDecl **getProtocolStorageImpl(); | ||||
5555 | |||||
5556 | /// Return the number of qualifying protocols in this interface type, | ||||
5557 | /// or 0 if there are none. | ||||
5558 | unsigned getNumProtocolsImpl() const { | ||||
5559 | return NumProtocols; | ||||
5560 | } | ||||
5561 | |||||
5562 | void setNumProtocolsImpl(unsigned N) { | ||||
5563 | NumProtocols = N; | ||||
5564 | } | ||||
5565 | |||||
5566 | ObjCTypeParamType(const ObjCTypeParamDecl *D, | ||||
5567 | QualType can, | ||||
5568 | ArrayRef<ObjCProtocolDecl *> protocols); | ||||
5569 | |||||
5570 | public: | ||||
5571 | bool isSugared() const { return true; } | ||||
5572 | QualType desugar() const { return getCanonicalTypeInternal(); } | ||||
5573 | |||||
5574 | static bool classof(const Type *T) { | ||||
5575 | return T->getTypeClass() == ObjCTypeParam; | ||||
5576 | } | ||||
5577 | |||||
5578 | void Profile(llvm::FoldingSetNodeID &ID); | ||||
5579 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
5580 | const ObjCTypeParamDecl *OTPDecl, | ||||
5581 | ArrayRef<ObjCProtocolDecl *> protocols); | ||||
5582 | |||||
5583 | ObjCTypeParamDecl *getDecl() const { return OTPDecl; } | ||||
5584 | }; | ||||
5585 | |||||
5586 | /// Represents a class type in Objective C. | ||||
5587 | /// | ||||
5588 | /// Every Objective C type is a combination of a base type, a set of | ||||
5589 | /// type arguments (optional, for parameterized classes) and a list of | ||||
5590 | /// protocols. | ||||
5591 | /// | ||||
5592 | /// Given the following declarations: | ||||
5593 | /// \code | ||||
5594 | /// \@class C<T>; | ||||
5595 | /// \@protocol P; | ||||
5596 | /// \endcode | ||||
5597 | /// | ||||
5598 | /// 'C' is an ObjCInterfaceType C. It is sugar for an ObjCObjectType | ||||
5599 | /// with base C and no protocols. | ||||
5600 | /// | ||||
5601 | /// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P]. | ||||
5602 | /// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no | ||||
5603 | /// protocol list. | ||||
5604 | /// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*', | ||||
5605 | /// and protocol list [P]. | ||||
5606 | /// | ||||
5607 | /// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose | ||||
5608 | /// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType | ||||
5609 | /// and no protocols. | ||||
5610 | /// | ||||
5611 | /// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType | ||||
5612 | /// with base BuiltinType::ObjCIdType and protocol list [P]. Eventually | ||||
5613 | /// this should get its own sugar class to better represent the source. | ||||
5614 | class ObjCObjectType : public Type, | ||||
5615 | public ObjCProtocolQualifiers<ObjCObjectType> { | ||||
5616 | friend class ObjCProtocolQualifiers<ObjCObjectType>; | ||||
5617 | |||||
5618 | // ObjCObjectType.NumTypeArgs - the number of type arguments stored | ||||
5619 | // after the ObjCObjectPointerType node. | ||||
5620 | // ObjCObjectType.NumProtocols - the number of protocols stored | ||||
5621 | // after the type arguments of ObjCObjectPointerType node. | ||||
5622 | // | ||||
5623 | // These protocols are those written directly on the type. If | ||||
5624 | // protocol qualifiers ever become additive, the iterators will need | ||||
5625 | // to get kindof complicated. | ||||
5626 | // | ||||
5627 | // In the canonical object type, these are sorted alphabetically | ||||
5628 | // and uniqued. | ||||
5629 | |||||
5630 | /// Either a BuiltinType or an InterfaceType or sugar for either. | ||||
5631 | QualType BaseType; | ||||
5632 | |||||
5633 | /// Cached superclass type. | ||||
5634 | mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool> | ||||
5635 | CachedSuperClassType; | ||||
5636 | |||||
5637 | QualType *getTypeArgStorage(); | ||||
5638 | const QualType *getTypeArgStorage() const { | ||||
5639 | return const_cast<ObjCObjectType *>(this)->getTypeArgStorage(); | ||||
5640 | } | ||||
5641 | |||||
5642 | ObjCProtocolDecl **getProtocolStorageImpl(); | ||||
5643 | /// Return the number of qualifying protocols in this interface type, | ||||
5644 | /// or 0 if there are none. | ||||
5645 | unsigned getNumProtocolsImpl() const { | ||||
5646 | return ObjCObjectTypeBits.NumProtocols; | ||||
5647 | } | ||||
5648 | void setNumProtocolsImpl(unsigned N) { | ||||
5649 | ObjCObjectTypeBits.NumProtocols = N; | ||||
5650 | } | ||||
5651 | |||||
5652 | protected: | ||||
5653 | enum Nonce_ObjCInterface { Nonce_ObjCInterface }; | ||||
5654 | |||||
5655 | ObjCObjectType(QualType Canonical, QualType Base, | ||||
5656 | ArrayRef<QualType> typeArgs, | ||||
5657 | ArrayRef<ObjCProtocolDecl *> protocols, | ||||
5658 | bool isKindOf); | ||||
5659 | |||||
5660 | ObjCObjectType(enum Nonce_ObjCInterface) | ||||
5661 | : Type(ObjCInterface, QualType(), false, false, false, false), | ||||
5662 | BaseType(QualType(this_(), 0)) { | ||||
5663 | ObjCObjectTypeBits.NumProtocols = 0; | ||||
5664 | ObjCObjectTypeBits.NumTypeArgs = 0; | ||||
5665 | ObjCObjectTypeBits.IsKindOf = 0; | ||||
5666 | } | ||||
5667 | |||||
5668 | void computeSuperClassTypeSlow() const; | ||||
5669 | |||||
5670 | public: | ||||
5671 | /// Gets the base type of this object type. This is always (possibly | ||||
5672 | /// sugar for) one of: | ||||
5673 | /// - the 'id' builtin type (as opposed to the 'id' type visible to the | ||||
5674 | /// user, which is a typedef for an ObjCObjectPointerType) | ||||
5675 | /// - the 'Class' builtin type (same caveat) | ||||
5676 | /// - an ObjCObjectType (currently always an ObjCInterfaceType) | ||||
5677 | QualType getBaseType() const { return BaseType; } | ||||
5678 | |||||
5679 | bool isObjCId() const { | ||||
5680 | return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId); | ||||
5681 | } | ||||
5682 | |||||
5683 | bool isObjCClass() const { | ||||
5684 | return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass); | ||||
5685 | } | ||||
5686 | |||||
5687 | bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); } | ||||
5688 | bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); } | ||||
5689 | bool isObjCUnqualifiedIdOrClass() const { | ||||
5690 | if (!qual_empty()) return false; | ||||
5691 | if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>()) | ||||
5692 | return T->getKind() == BuiltinType::ObjCId || | ||||
5693 | T->getKind() == BuiltinType::ObjCClass; | ||||
5694 | return false; | ||||
5695 | } | ||||
5696 | bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); } | ||||
5697 | bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); } | ||||
5698 | |||||
5699 | /// Gets the interface declaration for this object type, if the base type | ||||
5700 | /// really is an interface. | ||||
5701 | ObjCInterfaceDecl *getInterface() const; | ||||
5702 | |||||
5703 | /// Determine whether this object type is "specialized", meaning | ||||
5704 | /// that it has type arguments. | ||||
5705 | bool isSpecialized() const; | ||||
5706 | |||||
5707 | /// Determine whether this object type was written with type arguments. | ||||
5708 | bool isSpecializedAsWritten() const { | ||||
5709 | return ObjCObjectTypeBits.NumTypeArgs > 0; | ||||
5710 | } | ||||
5711 | |||||
5712 | /// Determine whether this object type is "unspecialized", meaning | ||||
5713 | /// that it has no type arguments. | ||||
5714 | bool isUnspecialized() const { return !isSpecialized(); } | ||||
5715 | |||||
5716 | /// Determine whether this object type is "unspecialized" as | ||||
5717 | /// written, meaning that it has no type arguments. | ||||
5718 | bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); } | ||||
5719 | |||||
5720 | /// Retrieve the type arguments of this object type (semantically). | ||||
5721 | ArrayRef<QualType> getTypeArgs() const; | ||||
5722 | |||||
5723 | /// Retrieve the type arguments of this object type as they were | ||||
5724 | /// written. | ||||
5725 | ArrayRef<QualType> getTypeArgsAsWritten() const { | ||||
5726 | return llvm::makeArrayRef(getTypeArgStorage(), | ||||
5727 | ObjCObjectTypeBits.NumTypeArgs); | ||||
5728 | } | ||||
5729 | |||||
5730 | /// Whether this is a "__kindof" type as written. | ||||
5731 | bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; } | ||||
5732 | |||||
5733 | /// Whether this ia a "__kindof" type (semantically). | ||||
5734 | bool isKindOfType() const; | ||||
5735 | |||||
5736 | /// Retrieve the type of the superclass of this object type. | ||||
5737 | /// | ||||
5738 | /// This operation substitutes any type arguments into the | ||||
5739 | /// superclass of the current class type, potentially producing a | ||||
5740 | /// specialization of the superclass type. Produces a null type if | ||||
5741 | /// there is no superclass. | ||||
5742 | QualType getSuperClassType() const { | ||||
5743 | if (!CachedSuperClassType.getInt()) | ||||
5744 | computeSuperClassTypeSlow(); | ||||
5745 | |||||
5746 | assert(CachedSuperClassType.getInt() && "Superclass not set?")((CachedSuperClassType.getInt() && "Superclass not set?" ) ? static_cast<void> (0) : __assert_fail ("CachedSuperClassType.getInt() && \"Superclass not set?\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 5746, __PRETTY_FUNCTION__)); | ||||
5747 | return QualType(CachedSuperClassType.getPointer(), 0); | ||||
5748 | } | ||||
5749 | |||||
5750 | /// Strip off the Objective-C "kindof" type and (with it) any | ||||
5751 | /// protocol qualifiers. | ||||
5752 | QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const; | ||||
5753 | |||||
5754 | bool isSugared() const { return false; } | ||||
5755 | QualType desugar() const { return QualType(this, 0); } | ||||
5756 | |||||
5757 | static bool classof(const Type *T) { | ||||
5758 | return T->getTypeClass() == ObjCObject || | ||||
5759 | T->getTypeClass() == ObjCInterface; | ||||
5760 | } | ||||
5761 | }; | ||||
5762 | |||||
5763 | /// A class providing a concrete implementation | ||||
5764 | /// of ObjCObjectType, so as to not increase the footprint of | ||||
5765 | /// ObjCInterfaceType. Code outside of ASTContext and the core type | ||||
5766 | /// system should not reference this type. | ||||
5767 | class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode { | ||||
5768 | friend class ASTContext; | ||||
5769 | |||||
5770 | // If anyone adds fields here, ObjCObjectType::getProtocolStorage() | ||||
5771 | // will need to be modified. | ||||
5772 | |||||
5773 | ObjCObjectTypeImpl(QualType Canonical, QualType Base, | ||||
5774 | ArrayRef<QualType> typeArgs, | ||||
5775 | ArrayRef<ObjCProtocolDecl *> protocols, | ||||
5776 | bool isKindOf) | ||||
5777 | : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {} | ||||
5778 | |||||
5779 | public: | ||||
5780 | void Profile(llvm::FoldingSetNodeID &ID); | ||||
5781 | static void Profile(llvm::FoldingSetNodeID &ID, | ||||
5782 | QualType Base, | ||||
5783 | ArrayRef<QualType> typeArgs, | ||||
5784 | ArrayRef<ObjCProtocolDecl *> protocols, | ||||
5785 | bool isKindOf); | ||||
5786 | }; | ||||
5787 | |||||
5788 | inline QualType *ObjCObjectType::getTypeArgStorage() { | ||||
5789 | return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1); | ||||
5790 | } | ||||
5791 | |||||
5792 | inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() { | ||||
5793 | return reinterpret_cast<ObjCProtocolDecl**>( | ||||
5794 | getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs); | ||||
5795 | } | ||||
5796 | |||||
5797 | inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() { | ||||
5798 | return reinterpret_cast<ObjCProtocolDecl**>( | ||||
5799 | static_cast<ObjCTypeParamType*>(this)+1); | ||||
5800 | } | ||||
5801 | |||||
5802 | /// Interfaces are the core concept in Objective-C for object oriented design. | ||||
5803 | /// They basically correspond to C++ classes. There are two kinds of interface | ||||
5804 | /// types: normal interfaces like `NSString`, and qualified interfaces, which | ||||
5805 | /// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`. | ||||
5806 | /// | ||||
5807 | /// ObjCInterfaceType guarantees the following properties when considered | ||||
5808 | /// as a subtype of its superclass, ObjCObjectType: | ||||
5809 | /// - There are no protocol qualifiers. To reinforce this, code which | ||||
5810 | /// tries to invoke the protocol methods via an ObjCInterfaceType will | ||||
5811 | /// fail to compile. | ||||
5812 | /// - It is its own base type. That is, if T is an ObjCInterfaceType*, | ||||
5813 | /// T->getBaseType() == QualType(T, 0). | ||||
5814 | class ObjCInterfaceType : public ObjCObjectType { | ||||
5815 | friend class ASTContext; // ASTContext creates these. | ||||
5816 | friend class ASTReader; | ||||
5817 | friend class ObjCInterfaceDecl; | ||||
5818 | |||||
5819 | mutable ObjCInterfaceDecl *Decl; | ||||
5820 | |||||
5821 | ObjCInterfaceType(const ObjCInterfaceDecl *D) | ||||
5822 | : ObjCObjectType(Nonce_ObjCInterface), | ||||
5823 | Decl(const_cast<ObjCInterfaceDecl*>(D)) {} | ||||
5824 | |||||
5825 | public: | ||||
5826 | /// Get the declaration of this interface. | ||||
5827 | ObjCInterfaceDecl *getDecl() const { return Decl; } | ||||
5828 | |||||
5829 | bool isSugared() const { return false; } | ||||
5830 | QualType desugar() const { return QualType(this, 0); } | ||||
5831 | |||||
5832 | static bool classof(const Type *T) { | ||||
5833 | return T->getTypeClass() == ObjCInterface; | ||||
5834 | } | ||||
5835 | |||||
5836 | // Nonsense to "hide" certain members of ObjCObjectType within this | ||||
5837 | // class. People asking for protocols on an ObjCInterfaceType are | ||||
5838 | // not going to get what they want: ObjCInterfaceTypes are | ||||
5839 | // guaranteed to have no protocols. | ||||
5840 | enum { | ||||
5841 | qual_iterator, | ||||
5842 | qual_begin, | ||||
5843 | qual_end, | ||||
5844 | getNumProtocols, | ||||
5845 | getProtocol | ||||
5846 | }; | ||||
5847 | }; | ||||
5848 | |||||
5849 | inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const { | ||||
5850 | QualType baseType = getBaseType(); | ||||
5851 | while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) { | ||||
5852 | if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT)) | ||||
5853 | return T->getDecl(); | ||||
5854 | |||||
5855 | baseType = ObjT->getBaseType(); | ||||
5856 | } | ||||
5857 | |||||
5858 | return nullptr; | ||||
5859 | } | ||||
5860 | |||||
5861 | /// Represents a pointer to an Objective C object. | ||||
5862 | /// | ||||
5863 | /// These are constructed from pointer declarators when the pointee type is | ||||
5864 | /// an ObjCObjectType (or sugar for one). In addition, the 'id' and 'Class' | ||||
5865 | /// types are typedefs for these, and the protocol-qualified types 'id<P>' | ||||
5866 | /// and 'Class<P>' are translated into these. | ||||
5867 | /// | ||||
5868 | /// Pointers to pointers to Objective C objects are still PointerTypes; | ||||
5869 | /// only the first level of pointer gets it own type implementation. | ||||
5870 | class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode { | ||||
5871 | friend class ASTContext; // ASTContext creates these. | ||||
5872 | |||||
5873 | QualType PointeeType; | ||||
5874 | |||||
5875 | ObjCObjectPointerType(QualType Canonical, QualType Pointee) | ||||
5876 | : Type(ObjCObjectPointer, Canonical, | ||||
5877 | Pointee->isDependentType(), | ||||
5878 | Pointee->isInstantiationDependentType(), | ||||
5879 | Pointee->isVariablyModifiedType(), | ||||
5880 | Pointee->containsUnexpandedParameterPack()), | ||||
5881 | PointeeType(Pointee) {} | ||||
5882 | |||||
5883 | public: | ||||
5884 | /// Gets the type pointed to by this ObjC pointer. | ||||
5885 | /// The result will always be an ObjCObjectType or sugar thereof. | ||||
5886 | QualType getPointeeType() const { return PointeeType; } | ||||
5887 | |||||
5888 | /// Gets the type pointed to by this ObjC pointer. Always returns non-null. | ||||
5889 | /// | ||||
5890 | /// This method is equivalent to getPointeeType() except that | ||||
5891 | /// it discards any typedefs (or other sugar) between this | ||||
5892 | /// type and the "outermost" object type. So for: | ||||
5893 | /// \code | ||||
5894 | /// \@class A; \@protocol P; \@protocol Q; | ||||
5895 | /// typedef A<P> AP; | ||||
5896 | /// typedef A A1; | ||||
5897 | /// typedef A1<P> A1P; | ||||
5898 | /// typedef A1P<Q> A1PQ; | ||||
5899 | /// \endcode | ||||
5900 | /// For 'A*', getObjectType() will return 'A'. | ||||
5901 | /// For 'A<P>*', getObjectType() will return 'A<P>'. | ||||
5902 | /// For 'AP*', getObjectType() will return 'A<P>'. | ||||
5903 | /// For 'A1*', getObjectType() will return 'A'. | ||||
5904 | /// For 'A1<P>*', getObjectType() will return 'A1<P>'. | ||||
5905 | /// For 'A1P*', getObjectType() will return 'A1<P>'. | ||||
5906 | /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because | ||||
5907 | /// adding protocols to a protocol-qualified base discards the | ||||
5908 | /// old qualifiers (for now). But if it didn't, getObjectType() | ||||
5909 | /// would return 'A1P<Q>' (and we'd have to make iterating over | ||||
5910 | /// qualifiers more complicated). | ||||
5911 | const ObjCObjectType *getObjectType() const { | ||||
5912 | return PointeeType->castAs<ObjCObjectType>(); | ||||
5913 | } | ||||
5914 | |||||
5915 | /// If this pointer points to an Objective C | ||||
5916 | /// \@interface type, gets the type for that interface. Any protocol | ||||
5917 | /// qualifiers on the interface are ignored. | ||||
5918 | /// | ||||
5919 | /// \return null if the base type for this pointer is 'id' or 'Class' | ||||
5920 | const ObjCInterfaceType *getInterfaceType() const; | ||||
5921 | |||||
5922 | /// If this pointer points to an Objective \@interface | ||||
5923 | /// type, gets the declaration for that interface. | ||||
5924 | /// | ||||
5925 | /// \return null if the base type for this pointer is 'id' or 'Class' | ||||
5926 | ObjCInterfaceDecl *getInterfaceDecl() const { | ||||
5927 | return getObjectType()->getInterface(); | ||||
5928 | } | ||||
5929 | |||||
5930 | /// True if this is equivalent to the 'id' type, i.e. if | ||||
5931 | /// its object type is the primitive 'id' type with no protocols. | ||||
5932 | bool isObjCIdType() const { | ||||
5933 | return getObjectType()->isObjCUnqualifiedId(); | ||||
5934 | } | ||||
5935 | |||||
5936 | /// True if this is equivalent to the 'Class' type, | ||||
5937 | /// i.e. if its object tive is the primitive 'Class' type with no protocols. | ||||
5938 | bool isObjCClassType() const { | ||||
5939 | return getObjectType()->isObjCUnqualifiedClass(); | ||||
5940 | } | ||||
5941 | |||||
5942 | /// True if this is equivalent to the 'id' or 'Class' type, | ||||
5943 | bool isObjCIdOrClassType() const { | ||||
5944 | return getObjectType()->isObjCUnqualifiedIdOrClass(); | ||||
5945 | } | ||||
5946 | |||||
5947 | /// True if this is equivalent to 'id<P>' for some non-empty set of | ||||
5948 | /// protocols. | ||||
5949 | bool isObjCQualifiedIdType() const { | ||||
5950 | return getObjectType()->isObjCQualifiedId(); | ||||
5951 | } | ||||
5952 | |||||
5953 | /// True if this is equivalent to 'Class<P>' for some non-empty set of | ||||
5954 | /// protocols. | ||||
5955 | bool isObjCQualifiedClassType() const { | ||||
5956 | return getObjectType()->isObjCQualifiedClass(); | ||||
5957 | } | ||||
5958 | |||||
5959 | /// Whether this is a "__kindof" type. | ||||
5960 | bool isKindOfType() const { return getObjectType()->isKindOfType(); } | ||||
5961 | |||||
5962 | /// Whether this type is specialized, meaning that it has type arguments. | ||||
5963 | bool isSpecialized() const { return getObjectType()->isSpecialized(); } | ||||
5964 | |||||
5965 | /// Whether this type is specialized, meaning that it has type arguments. | ||||
5966 | bool isSpecializedAsWritten() const { | ||||
5967 | return getObjectType()->isSpecializedAsWritten(); | ||||
5968 | } | ||||
5969 | |||||
5970 | /// Whether this type is unspecialized, meaning that is has no type arguments. | ||||
5971 | bool isUnspecialized() const { return getObjectType()->isUnspecialized(); } | ||||
5972 | |||||
5973 | /// Determine whether this object type is "unspecialized" as | ||||
5974 | /// written, meaning that it has no type arguments. | ||||
5975 | bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); } | ||||
5976 | |||||
5977 | /// Retrieve the type arguments for this type. | ||||
5978 | ArrayRef<QualType> getTypeArgs() const { | ||||
5979 | return getObjectType()->getTypeArgs(); | ||||
5980 | } | ||||
5981 | |||||
5982 | /// Retrieve the type arguments for this type. | ||||
5983 | ArrayRef<QualType> getTypeArgsAsWritten() const { | ||||
5984 | return getObjectType()->getTypeArgsAsWritten(); | ||||
5985 | } | ||||
5986 | |||||
5987 | /// An iterator over the qualifiers on the object type. Provided | ||||
5988 | /// for convenience. This will always iterate over the full set of | ||||
5989 | /// protocols on a type, not just those provided directly. | ||||
5990 | using qual_iterator = ObjCObjectType::qual_iterator; | ||||
5991 | using qual_range = llvm::iterator_range<qual_iterator>; | ||||
5992 | |||||
5993 | qual_range quals() const { return qual_range(qual_begin(), qual_end()); } | ||||
5994 | |||||
5995 | qual_iterator qual_begin() const { | ||||
5996 | return getObjectType()->qual_begin(); | ||||
5997 | } | ||||
5998 | |||||
5999 | qual_iterator qual_end() const { | ||||
6000 | return getObjectType()->qual_end(); | ||||
6001 | } | ||||
6002 | |||||
6003 | bool qual_empty() const { return getObjectType()->qual_empty(); } | ||||
6004 | |||||
6005 | /// Return the number of qualifying protocols on the object type. | ||||
6006 | unsigned getNumProtocols() const { | ||||
6007 | return getObjectType()->getNumProtocols(); | ||||
6008 | } | ||||
6009 | |||||
6010 | /// Retrieve a qualifying protocol by index on the object type. | ||||
6011 | ObjCProtocolDecl *getProtocol(unsigned I) const { | ||||
6012 | return getObjectType()->getProtocol(I); | ||||
6013 | } | ||||
6014 | |||||
6015 | bool isSugared() const { return false; } | ||||
6016 | QualType desugar() const { return QualType(this, 0); } | ||||
6017 | |||||
6018 | /// Retrieve the type of the superclass of this object pointer type. | ||||
6019 | /// | ||||
6020 | /// This operation substitutes any type arguments into the | ||||
6021 | /// superclass of the current class type, potentially producing a | ||||
6022 | /// pointer to a specialization of the superclass type. Produces a | ||||
6023 | /// null type if there is no superclass. | ||||
6024 | QualType getSuperClassType() const; | ||||
6025 | |||||
6026 | /// Strip off the Objective-C "kindof" type and (with it) any | ||||
6027 | /// protocol qualifiers. | ||||
6028 | const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals( | ||||
6029 | const ASTContext &ctx) const; | ||||
6030 | |||||
6031 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
6032 | Profile(ID, getPointeeType()); | ||||
6033 | } | ||||
6034 | |||||
6035 | static void Profile(llvm::FoldingSetNodeID &ID, QualType T) { | ||||
6036 | ID.AddPointer(T.getAsOpaquePtr()); | ||||
6037 | } | ||||
6038 | |||||
6039 | static bool classof(const Type *T) { | ||||
6040 | return T->getTypeClass() == ObjCObjectPointer; | ||||
6041 | } | ||||
6042 | }; | ||||
6043 | |||||
6044 | class AtomicType : public Type, public llvm::FoldingSetNode { | ||||
6045 | friend class ASTContext; // ASTContext creates these. | ||||
6046 | |||||
6047 | QualType ValueType; | ||||
6048 | |||||
6049 | AtomicType(QualType ValTy, QualType Canonical) | ||||
6050 | : Type(Atomic, Canonical, ValTy->isDependentType(), | ||||
6051 | ValTy->isInstantiationDependentType(), | ||||
6052 | ValTy->isVariablyModifiedType(), | ||||
6053 | ValTy->containsUnexpandedParameterPack()), | ||||
6054 | ValueType(ValTy) {} | ||||
6055 | |||||
6056 | public: | ||||
6057 | /// Gets the type contained by this atomic type, i.e. | ||||
6058 | /// the type returned by performing an atomic load of this atomic type. | ||||
6059 | QualType getValueType() const { return ValueType; } | ||||
6060 | |||||
6061 | bool isSugared() const { return false; } | ||||
6062 | QualType desugar() const { return QualType(this, 0); } | ||||
6063 | |||||
6064 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
6065 | Profile(ID, getValueType()); | ||||
6066 | } | ||||
6067 | |||||
6068 | static void Profile(llvm::FoldingSetNodeID &ID, QualType T) { | ||||
6069 | ID.AddPointer(T.getAsOpaquePtr()); | ||||
6070 | } | ||||
6071 | |||||
6072 | static bool classof(const Type *T) { | ||||
6073 | return T->getTypeClass() == Atomic; | ||||
6074 | } | ||||
6075 | }; | ||||
6076 | |||||
6077 | /// PipeType - OpenCL20. | ||||
6078 | class PipeType : public Type, public llvm::FoldingSetNode { | ||||
6079 | friend class ASTContext; // ASTContext creates these. | ||||
6080 | |||||
6081 | QualType ElementType; | ||||
6082 | bool isRead; | ||||
6083 | |||||
6084 | PipeType(QualType elemType, QualType CanonicalPtr, bool isRead) | ||||
6085 | : Type(Pipe, CanonicalPtr, elemType->isDependentType(), | ||||
6086 | elemType->isInstantiationDependentType(), | ||||
6087 | elemType->isVariablyModifiedType(), | ||||
6088 | elemType->containsUnexpandedParameterPack()), | ||||
6089 | ElementType(elemType), isRead(isRead) {} | ||||
6090 | |||||
6091 | public: | ||||
6092 | QualType getElementType() const { return ElementType; } | ||||
6093 | |||||
6094 | bool isSugared() const { return false; } | ||||
6095 | |||||
6096 | QualType desugar() const { return QualType(this, 0); } | ||||
6097 | |||||
6098 | void Profile(llvm::FoldingSetNodeID &ID) { | ||||
6099 | Profile(ID, getElementType(), isReadOnly()); | ||||
6100 | } | ||||
6101 | |||||
6102 | static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) { | ||||
6103 | ID.AddPointer(T.getAsOpaquePtr()); | ||||
6104 | ID.AddBoolean(isRead); | ||||
6105 | } | ||||
6106 | |||||
6107 | static bool classof(const Type *T) { | ||||
6108 | return T->getTypeClass() == Pipe; | ||||
6109 | } | ||||
6110 | |||||
6111 | bool isReadOnly() const { return isRead; } | ||||
6112 | }; | ||||
6113 | |||||
6114 | /// A qualifier set is used to build a set of qualifiers. | ||||
6115 | class QualifierCollector : public Qualifiers { | ||||
6116 | public: | ||||
6117 | QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {} | ||||
6118 | |||||
6119 | /// Collect any qualifiers on the given type and return an | ||||
6120 | /// unqualified type. The qualifiers are assumed to be consistent | ||||
6121 | /// with those already in the type. | ||||
6122 | const Type *strip(QualType type) { | ||||
6123 | addFastQualifiers(type.getLocalFastQualifiers()); | ||||
6124 | if (!type.hasLocalNonFastQualifiers()) | ||||
6125 | return type.getTypePtrUnsafe(); | ||||
6126 | |||||
6127 | const ExtQuals *extQuals = type.getExtQualsUnsafe(); | ||||
6128 | addConsistentQualifiers(extQuals->getQualifiers()); | ||||
6129 | return extQuals->getBaseType(); | ||||
6130 | } | ||||
6131 | |||||
6132 | /// Apply the collected qualifiers to the given type. | ||||
6133 | QualType apply(const ASTContext &Context, QualType QT) const; | ||||
6134 | |||||
6135 | /// Apply the collected qualifiers to the given type. | ||||
6136 | QualType apply(const ASTContext &Context, const Type* T) const; | ||||
6137 | }; | ||||
6138 | |||||
6139 | // Inline function definitions. | ||||
6140 | |||||
6141 | inline SplitQualType SplitQualType::getSingleStepDesugaredType() const { | ||||
6142 | SplitQualType desugar = | ||||
6143 | Ty->getLocallyUnqualifiedSingleStepDesugaredType().split(); | ||||
6144 | desugar.Quals.addConsistentQualifiers(Quals); | ||||
6145 | return desugar; | ||||
6146 | } | ||||
6147 | |||||
6148 | inline const Type *QualType::getTypePtr() const { | ||||
6149 | return getCommonPtr()->BaseType; | ||||
6150 | } | ||||
6151 | |||||
6152 | inline const Type *QualType::getTypePtrOrNull() const { | ||||
6153 | return (isNull() ? nullptr : getCommonPtr()->BaseType); | ||||
6154 | } | ||||
6155 | |||||
6156 | inline SplitQualType QualType::split() const { | ||||
6157 | if (!hasLocalNonFastQualifiers()) | ||||
6158 | return SplitQualType(getTypePtrUnsafe(), | ||||
6159 | Qualifiers::fromFastMask(getLocalFastQualifiers())); | ||||
6160 | |||||
6161 | const ExtQuals *eq = getExtQualsUnsafe(); | ||||
6162 | Qualifiers qs = eq->getQualifiers(); | ||||
6163 | qs.addFastQualifiers(getLocalFastQualifiers()); | ||||
6164 | return SplitQualType(eq->getBaseType(), qs); | ||||
6165 | } | ||||
6166 | |||||
6167 | inline Qualifiers QualType::getLocalQualifiers() const { | ||||
6168 | Qualifiers Quals; | ||||
6169 | if (hasLocalNonFastQualifiers()) | ||||
6170 | Quals = getExtQualsUnsafe()->getQualifiers(); | ||||
6171 | Quals.addFastQualifiers(getLocalFastQualifiers()); | ||||
6172 | return Quals; | ||||
6173 | } | ||||
6174 | |||||
6175 | inline Qualifiers QualType::getQualifiers() const { | ||||
6176 | Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers(); | ||||
6177 | quals.addFastQualifiers(getLocalFastQualifiers()); | ||||
6178 | return quals; | ||||
6179 | } | ||||
6180 | |||||
6181 | inline unsigned QualType::getCVRQualifiers() const { | ||||
6182 | unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers(); | ||||
6183 | cvr |= getLocalCVRQualifiers(); | ||||
6184 | return cvr; | ||||
6185 | } | ||||
6186 | |||||
6187 | inline QualType QualType::getCanonicalType() const { | ||||
6188 | QualType canon = getCommonPtr()->CanonicalType; | ||||
6189 | return canon.withFastQualifiers(getLocalFastQualifiers()); | ||||
6190 | } | ||||
6191 | |||||
6192 | inline bool QualType::isCanonical() const { | ||||
6193 | return getTypePtr()->isCanonicalUnqualified(); | ||||
6194 | } | ||||
6195 | |||||
6196 | inline bool QualType::isCanonicalAsParam() const { | ||||
6197 | if (!isCanonical()) return false; | ||||
6198 | if (hasLocalQualifiers()) return false; | ||||
6199 | |||||
6200 | const Type *T = getTypePtr(); | ||||
6201 | if (T->isVariablyModifiedType() && T->hasSizedVLAType()) | ||||
6202 | return false; | ||||
6203 | |||||
6204 | return !isa<FunctionType>(T) && !isa<ArrayType>(T); | ||||
6205 | } | ||||
6206 | |||||
6207 | inline bool QualType::isConstQualified() const { | ||||
6208 | return isLocalConstQualified() || | ||||
6209 | getCommonPtr()->CanonicalType.isLocalConstQualified(); | ||||
6210 | } | ||||
6211 | |||||
6212 | inline bool QualType::isRestrictQualified() const { | ||||
6213 | return isLocalRestrictQualified() || | ||||
6214 | getCommonPtr()->CanonicalType.isLocalRestrictQualified(); | ||||
6215 | } | ||||
6216 | |||||
6217 | |||||
6218 | inline bool QualType::isVolatileQualified() const { | ||||
6219 | return isLocalVolatileQualified() || | ||||
6220 | getCommonPtr()->CanonicalType.isLocalVolatileQualified(); | ||||
6221 | } | ||||
6222 | |||||
6223 | inline bool QualType::hasQualifiers() const { | ||||
6224 | return hasLocalQualifiers() || | ||||
6225 | getCommonPtr()->CanonicalType.hasLocalQualifiers(); | ||||
6226 | } | ||||
6227 | |||||
6228 | inline QualType QualType::getUnqualifiedType() const { | ||||
6229 | if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers()) | ||||
6230 | return QualType(getTypePtr(), 0); | ||||
6231 | |||||
6232 | return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0); | ||||
6233 | } | ||||
6234 | |||||
6235 | inline SplitQualType QualType::getSplitUnqualifiedType() const { | ||||
6236 | if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers()) | ||||
6237 | return split(); | ||||
6238 | |||||
6239 | return getSplitUnqualifiedTypeImpl(*this); | ||||
6240 | } | ||||
6241 | |||||
6242 | inline void QualType::removeLocalConst() { | ||||
6243 | removeLocalFastQualifiers(Qualifiers::Const); | ||||
6244 | } | ||||
6245 | |||||
6246 | inline void QualType::removeLocalRestrict() { | ||||
6247 | removeLocalFastQualifiers(Qualifiers::Restrict); | ||||
6248 | } | ||||
6249 | |||||
6250 | inline void QualType::removeLocalVolatile() { | ||||
6251 | removeLocalFastQualifiers(Qualifiers::Volatile); | ||||
6252 | } | ||||
6253 | |||||
6254 | inline void QualType::removeLocalCVRQualifiers(unsigned Mask) { | ||||
6255 | assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits" ) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::CVRMask) && \"mask has non-CVR bits\"" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 6255, __PRETTY_FUNCTION__)); | ||||
6256 | static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask, | ||||
6257 | "Fast bits differ from CVR bits!"); | ||||
6258 | |||||
6259 | // Fast path: we don't need to touch the slow qualifiers. | ||||
6260 | removeLocalFastQualifiers(Mask); | ||||
6261 | } | ||||
6262 | |||||
6263 | /// Return the address space of this type. | ||||
6264 | inline LangAS QualType::getAddressSpace() const { | ||||
6265 | return getQualifiers().getAddressSpace(); | ||||
6266 | } | ||||
6267 | |||||
6268 | /// Return the gc attribute of this type. | ||||
6269 | inline Qualifiers::GC QualType::getObjCGCAttr() const { | ||||
6270 | return getQualifiers().getObjCGCAttr(); | ||||
6271 | } | ||||
6272 | |||||
6273 | inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const { | ||||
6274 | if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl()) | ||||
6275 | return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD); | ||||
6276 | return false; | ||||
6277 | } | ||||
6278 | |||||
6279 | inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const { | ||||
6280 | if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl()) | ||||
6281 | return hasNonTrivialToPrimitiveDestructCUnion(RD); | ||||
6282 | return false; | ||||
6283 | } | ||||
6284 | |||||
6285 | inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const { | ||||
6286 | if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl()) | ||||
6287 | return hasNonTrivialToPrimitiveCopyCUnion(RD); | ||||
6288 | return false; | ||||
6289 | } | ||||
6290 | |||||
6291 | inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) { | ||||
6292 | if (const auto *PT = t.getAs<PointerType>()) { | ||||
6293 | if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>()) | ||||
6294 | return FT->getExtInfo(); | ||||
6295 | } else if (const auto *FT = t.getAs<FunctionType>()) | ||||
6296 | return FT->getExtInfo(); | ||||
6297 | |||||
6298 | return FunctionType::ExtInfo(); | ||||
6299 | } | ||||
6300 | |||||
6301 | inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) { | ||||
6302 | return getFunctionExtInfo(*t); | ||||
6303 | } | ||||
6304 | |||||
6305 | /// Determine whether this type is more | ||||
6306 | /// qualified than the Other type. For example, "const volatile int" | ||||
6307 | /// is more qualified than "const int", "volatile int", and | ||||
6308 | /// "int". However, it is not more qualified than "const volatile | ||||
6309 | /// int". | ||||
6310 | inline bool QualType::isMoreQualifiedThan(QualType other) const { | ||||
6311 | Qualifiers MyQuals = getQualifiers(); | ||||
6312 | Qualifiers OtherQuals = other.getQualifiers(); | ||||
6313 | return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals)); | ||||
6314 | } | ||||
6315 | |||||
6316 | /// Determine whether this type is at last | ||||
6317 | /// as qualified as the Other type. For example, "const volatile | ||||
6318 | /// int" is at least as qualified as "const int", "volatile int", | ||||
6319 | /// "int", and "const volatile int". | ||||
6320 | inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const { | ||||
6321 | Qualifiers OtherQuals = other.getQualifiers(); | ||||
6322 | |||||
6323 | // Ignore __unaligned qualifier if this type is a void. | ||||
6324 | if (getUnqualifiedType()->isVoidType()) | ||||
6325 | OtherQuals.removeUnaligned(); | ||||
6326 | |||||
6327 | return getQualifiers().compatiblyIncludes(OtherQuals); | ||||
6328 | } | ||||
6329 | |||||
6330 | /// If Type is a reference type (e.g., const | ||||
6331 | /// int&), returns the type that the reference refers to ("const | ||||
6332 | /// int"). Otherwise, returns the type itself. This routine is used | ||||
6333 | /// throughout Sema to implement C++ 5p6: | ||||
6334 | /// | ||||
6335 | /// If an expression initially has the type "reference to T" (8.3.2, | ||||
6336 | /// 8.5.3), the type is adjusted to "T" prior to any further | ||||
6337 | /// analysis, the expression designates the object or function | ||||
6338 | /// denoted by the reference, and the expression is an lvalue. | ||||
6339 | inline QualType QualType::getNonReferenceType() const { | ||||
6340 | if (const auto *RefType = (*this)->getAs<ReferenceType>()) | ||||
6341 | return RefType->getPointeeType(); | ||||
6342 | else | ||||
6343 | return *this; | ||||
6344 | } | ||||
6345 | |||||
6346 | inline bool QualType::isCForbiddenLValueType() const { | ||||
6347 | return ((getTypePtr()->isVoidType() && !hasQualifiers()) || | ||||
6348 | getTypePtr()->isFunctionType()); | ||||
6349 | } | ||||
6350 | |||||
6351 | /// Tests whether the type is categorized as a fundamental type. | ||||
6352 | /// | ||||
6353 | /// \returns True for types specified in C++0x [basic.fundamental]. | ||||
6354 | inline bool Type::isFundamentalType() const { | ||||
6355 | return isVoidType() || | ||||
6356 | isNullPtrType() || | ||||
6357 | // FIXME: It's really annoying that we don't have an | ||||
6358 | // 'isArithmeticType()' which agrees with the standard definition. | ||||
6359 | (isArithmeticType() && !isEnumeralType()); | ||||
6360 | } | ||||
6361 | |||||
6362 | /// Tests whether the type is categorized as a compound type. | ||||
6363 | /// | ||||
6364 | /// \returns True for types specified in C++0x [basic.compound]. | ||||
6365 | inline bool Type::isCompoundType() const { | ||||
6366 | // C++0x [basic.compound]p1: | ||||
6367 | // Compound types can be constructed in the following ways: | ||||
6368 | // -- arrays of objects of a given type [...]; | ||||
6369 | return isArrayType() || | ||||
6370 | // -- functions, which have parameters of given types [...]; | ||||
6371 | isFunctionType() || | ||||
6372 | // -- pointers to void or objects or functions [...]; | ||||
6373 | isPointerType() || | ||||
6374 | // -- references to objects or functions of a given type. [...] | ||||
6375 | isReferenceType() || | ||||
6376 | // -- classes containing a sequence of objects of various types, [...]; | ||||
6377 | isRecordType() || | ||||
6378 | // -- unions, which are classes capable of containing objects of different | ||||
6379 | // types at different times; | ||||
6380 | isUnionType() || | ||||
6381 | // -- enumerations, which comprise a set of named constant values. [...]; | ||||
6382 | isEnumeralType() || | ||||
6383 | // -- pointers to non-static class members, [...]. | ||||
6384 | isMemberPointerType(); | ||||
6385 | } | ||||
6386 | |||||
6387 | inline bool Type::isFunctionType() const { | ||||
6388 | return isa<FunctionType>(CanonicalType); | ||||
6389 | } | ||||
6390 | |||||
6391 | inline bool Type::isPointerType() const { | ||||
6392 | return isa<PointerType>(CanonicalType); | ||||
6393 | } | ||||
6394 | |||||
6395 | inline bool Type::isAnyPointerType() const { | ||||
6396 | return isPointerType() || isObjCObjectPointerType(); | ||||
6397 | } | ||||
6398 | |||||
6399 | inline bool Type::isBlockPointerType() const { | ||||
6400 | return isa<BlockPointerType>(CanonicalType); | ||||
6401 | } | ||||
6402 | |||||
6403 | inline bool Type::isReferenceType() const { | ||||
6404 | return isa<ReferenceType>(CanonicalType); | ||||
6405 | } | ||||
6406 | |||||
6407 | inline bool Type::isLValueReferenceType() const { | ||||
6408 | return isa<LValueReferenceType>(CanonicalType); | ||||
6409 | } | ||||
6410 | |||||
6411 | inline bool Type::isRValueReferenceType() const { | ||||
6412 | return isa<RValueReferenceType>(CanonicalType); | ||||
6413 | } | ||||
6414 | |||||
6415 | inline bool Type::isFunctionPointerType() const { | ||||
6416 | if (const auto *T
| ||||
6417 | return T->getPointeeType()->isFunctionType(); | ||||
6418 | else | ||||
6419 | return false; | ||||
6420 | } | ||||
6421 | |||||
6422 | inline bool Type::isFunctionReferenceType() const { | ||||
6423 | if (const auto *T = getAs<ReferenceType>()) | ||||
6424 | return T->getPointeeType()->isFunctionType(); | ||||
6425 | else | ||||
6426 | return false; | ||||
6427 | } | ||||
6428 | |||||
6429 | inline bool Type::isMemberPointerType() const { | ||||
6430 | return isa<MemberPointerType>(CanonicalType); | ||||
6431 | } | ||||
6432 | |||||
6433 | inline bool Type::isMemberFunctionPointerType() const { | ||||
6434 | if (const auto *T = getAs<MemberPointerType>()) | ||||
6435 | return T->isMemberFunctionPointer(); | ||||
6436 | else | ||||
6437 | return false; | ||||
6438 | } | ||||
6439 | |||||
6440 | inline bool Type::isMemberDataPointerType() const { | ||||
6441 | if (const auto *T = getAs<MemberPointerType>()) | ||||
6442 | return T->isMemberDataPointer(); | ||||
6443 | else | ||||
6444 | return false; | ||||
6445 | } | ||||
6446 | |||||
6447 | inline bool Type::isArrayType() const { | ||||
6448 | return isa<ArrayType>(CanonicalType); | ||||
6449 | } | ||||
6450 | |||||
6451 | inline bool Type::isConstantArrayType() const { | ||||
6452 | return isa<ConstantArrayType>(CanonicalType); | ||||
6453 | } | ||||
6454 | |||||
6455 | inline bool Type::isIncompleteArrayType() const { | ||||
6456 | return isa<IncompleteArrayType>(CanonicalType); | ||||
6457 | } | ||||
6458 | |||||
6459 | inline bool Type::isVariableArrayType() const { | ||||
6460 | return isa<VariableArrayType>(CanonicalType); | ||||
6461 | } | ||||
6462 | |||||
6463 | inline bool Type::isDependentSizedArrayType() const { | ||||
6464 | return isa<DependentSizedArrayType>(CanonicalType); | ||||
6465 | } | ||||
6466 | |||||
6467 | inline bool Type::isBuiltinType() const { | ||||
6468 | return isa<BuiltinType>(CanonicalType); | ||||
6469 | } | ||||
6470 | |||||
6471 | inline bool Type::isRecordType() const { | ||||
6472 | return isa<RecordType>(CanonicalType); | ||||
6473 | } | ||||
6474 | |||||
6475 | inline bool Type::isEnumeralType() const { | ||||
6476 | return isa<EnumType>(CanonicalType); | ||||
6477 | } | ||||
6478 | |||||
6479 | inline bool Type::isAnyComplexType() const { | ||||
6480 | return isa<ComplexType>(CanonicalType); | ||||
6481 | } | ||||
6482 | |||||
6483 | inline bool Type::isVectorType() const { | ||||
6484 | return isa<VectorType>(CanonicalType); | ||||
6485 | } | ||||
6486 | |||||
6487 | inline bool Type::isExtVectorType() const { | ||||
6488 | return isa<ExtVectorType>(CanonicalType); | ||||
6489 | } | ||||
6490 | |||||
6491 | inline bool Type::isDependentAddressSpaceType() const { | ||||
6492 | return isa<DependentAddressSpaceType>(CanonicalType); | ||||
6493 | } | ||||
6494 | |||||
6495 | inline bool Type::isObjCObjectPointerType() const { | ||||
6496 | return isa<ObjCObjectPointerType>(CanonicalType); | ||||
6497 | } | ||||
6498 | |||||
6499 | inline bool Type::isObjCObjectType() const { | ||||
6500 | return isa<ObjCObjectType>(CanonicalType); | ||||
6501 | } | ||||
6502 | |||||
6503 | inline bool Type::isObjCObjectOrInterfaceType() const { | ||||
6504 | return isa<ObjCInterfaceType>(CanonicalType) || | ||||
6505 | isa<ObjCObjectType>(CanonicalType); | ||||
6506 | } | ||||
6507 | |||||
6508 | inline bool Type::isAtomicType() const { | ||||
6509 | return isa<AtomicType>(CanonicalType); | ||||
6510 | } | ||||
6511 | |||||
6512 | inline bool Type::isObjCQualifiedIdType() const { | ||||
6513 | if (const auto *OPT = getAs<ObjCObjectPointerType>()) | ||||
6514 | return OPT->isObjCQualifiedIdType(); | ||||
6515 | return false; | ||||
6516 | } | ||||
6517 | |||||
6518 | inline bool Type::isObjCQualifiedClassType() const { | ||||
6519 | if (const auto *OPT = getAs<ObjCObjectPointerType>()) | ||||
6520 | return OPT->isObjCQualifiedClassType(); | ||||
6521 | return false; | ||||
6522 | } | ||||
6523 | |||||
6524 | inline bool Type::isObjCIdType() const { | ||||
6525 | if (const auto *OPT = getAs<ObjCObjectPointerType>()) | ||||
6526 | return OPT->isObjCIdType(); | ||||
6527 | return false; | ||||
6528 | } | ||||
6529 | |||||
6530 | inline bool Type::isObjCClassType() const { | ||||
6531 | if (const auto *OPT = getAs<ObjCObjectPointerType>()) | ||||
6532 | return OPT->isObjCClassType(); | ||||
6533 | return false; | ||||
6534 | } | ||||
6535 | |||||
6536 | inline bool Type::isObjCSelType() const { | ||||
6537 | if (const auto *OPT = getAs<PointerType>()) | ||||
6538 | return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel); | ||||
6539 | return false; | ||||
6540 | } | ||||
6541 | |||||
6542 | inline bool Type::isObjCBuiltinType() const { | ||||
6543 | return isObjCIdType() || isObjCClassType() || isObjCSelType(); | ||||
6544 | } | ||||
6545 | |||||
6546 | inline bool Type::isDecltypeType() const { | ||||
6547 | return isa<DecltypeType>(this); | ||||
6548 | } | ||||
6549 | |||||
6550 | #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ | ||||
6551 | inline bool Type::is##Id##Type() const { \ | ||||
6552 | return isSpecificBuiltinType(BuiltinType::Id); \ | ||||
6553 | } | ||||
6554 | #include "clang/Basic/OpenCLImageTypes.def" | ||||
6555 | |||||
6556 | inline bool Type::isSamplerT() const { | ||||
6557 | return isSpecificBuiltinType(BuiltinType::OCLSampler); | ||||
6558 | } | ||||
6559 | |||||
6560 | inline bool Type::isEventT() const { | ||||
6561 | return isSpecificBuiltinType(BuiltinType::OCLEvent); | ||||
6562 | } | ||||
6563 | |||||
6564 | inline bool Type::isClkEventT() const { | ||||
6565 | return isSpecificBuiltinType(BuiltinType::OCLClkEvent); | ||||
6566 | } | ||||
6567 | |||||
6568 | inline bool Type::isQueueT() const { | ||||
6569 | return isSpecificBuiltinType(BuiltinType::OCLQueue); | ||||
6570 | } | ||||
6571 | |||||
6572 | inline bool Type::isReserveIDT() const { | ||||
6573 | return isSpecificBuiltinType(BuiltinType::OCLReserveID); | ||||
6574 | } | ||||
6575 | |||||
6576 | inline bool Type::isImageType() const { | ||||
6577 | #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() || | ||||
6578 | return | ||||
6579 | #include "clang/Basic/OpenCLImageTypes.def" | ||||
6580 | false; // end boolean or operation | ||||
6581 | } | ||||
6582 | |||||
6583 | inline bool Type::isPipeType() const { | ||||
6584 | return isa<PipeType>(CanonicalType); | ||||
6585 | } | ||||
6586 | |||||
6587 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ | ||||
6588 | inline bool Type::is##Id##Type() const { \ | ||||
6589 | return isSpecificBuiltinType(BuiltinType::Id); \ | ||||
6590 | } | ||||
6591 | #include "clang/Basic/OpenCLExtensionTypes.def" | ||||
6592 | |||||
6593 | inline bool Type::isOCLIntelSubgroupAVCType() const { | ||||
6594 | #define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \ | ||||
6595 | isOCLIntelSubgroupAVC##Id##Type() || | ||||
6596 | return | ||||
6597 | #include "clang/Basic/OpenCLExtensionTypes.def" | ||||
6598 | false; // end of boolean or operation | ||||
6599 | } | ||||
6600 | |||||
6601 | inline bool Type::isOCLExtOpaqueType() const { | ||||
6602 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() || | ||||
6603 | return | ||||
6604 | #include "clang/Basic/OpenCLExtensionTypes.def" | ||||
6605 | false; // end of boolean or operation | ||||
6606 | } | ||||
6607 | |||||
6608 | inline bool Type::isOpenCLSpecificType() const { | ||||
6609 | return isSamplerT() || isEventT() || isImageType() || isClkEventT() || | ||||
6610 | isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType(); | ||||
6611 | } | ||||
6612 | |||||
6613 | inline bool Type::isTemplateTypeParmType() const { | ||||
6614 | return isa<TemplateTypeParmType>(CanonicalType); | ||||
6615 | } | ||||
6616 | |||||
6617 | inline bool Type::isSpecificBuiltinType(unsigned K) const { | ||||
6618 | if (const BuiltinType *BT = getAs<BuiltinType>()) | ||||
6619 | if (BT->getKind() == (BuiltinType::Kind) K) | ||||
6620 | return true; | ||||
6621 | return false; | ||||
6622 | } | ||||
6623 | |||||
6624 | inline bool Type::isPlaceholderType() const { | ||||
6625 | if (const auto *BT = dyn_cast<BuiltinType>(this)) | ||||
6626 | return BT->isPlaceholderType(); | ||||
6627 | return false; | ||||
6628 | } | ||||
6629 | |||||
6630 | inline const BuiltinType *Type::getAsPlaceholderType() const { | ||||
6631 | if (const auto *BT = dyn_cast<BuiltinType>(this)) | ||||
6632 | if (BT->isPlaceholderType()) | ||||
6633 | return BT; | ||||
6634 | return nullptr; | ||||
6635 | } | ||||
6636 | |||||
6637 | inline bool Type::isSpecificPlaceholderType(unsigned K) const { | ||||
6638 | assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)) ? static_cast<void> (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)" , "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 6638, __PRETTY_FUNCTION__)); | ||||
6639 | if (const auto *BT = dyn_cast<BuiltinType>(this)) | ||||
6640 | return (BT->getKind() == (BuiltinType::Kind) K); | ||||
6641 | return false; | ||||
6642 | } | ||||
6643 | |||||
6644 | inline bool Type::isNonOverloadPlaceholderType() const { | ||||
6645 | if (const auto *BT = dyn_cast<BuiltinType>(this)) | ||||
6646 | return BT->isNonOverloadPlaceholderType(); | ||||
6647 | return false; | ||||
6648 | } | ||||
6649 | |||||
6650 | inline bool Type::isVoidType() const { | ||||
6651 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6652 | return BT->getKind() == BuiltinType::Void; | ||||
6653 | return false; | ||||
6654 | } | ||||
6655 | |||||
6656 | inline bool Type::isHalfType() const { | ||||
6657 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6658 | return BT->getKind() == BuiltinType::Half; | ||||
6659 | // FIXME: Should we allow complex __fp16? Probably not. | ||||
6660 | return false; | ||||
6661 | } | ||||
6662 | |||||
6663 | inline bool Type::isFloat16Type() const { | ||||
6664 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6665 | return BT->getKind() == BuiltinType::Float16; | ||||
6666 | return false; | ||||
6667 | } | ||||
6668 | |||||
6669 | inline bool Type::isFloat128Type() const { | ||||
6670 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6671 | return BT->getKind() == BuiltinType::Float128; | ||||
6672 | return false; | ||||
6673 | } | ||||
6674 | |||||
6675 | inline bool Type::isNullPtrType() const { | ||||
6676 | if (const auto *BT = getAs<BuiltinType>()) | ||||
6677 | return BT->getKind() == BuiltinType::NullPtr; | ||||
6678 | return false; | ||||
6679 | } | ||||
6680 | |||||
6681 | bool IsEnumDeclComplete(EnumDecl *); | ||||
6682 | bool IsEnumDeclScoped(EnumDecl *); | ||||
6683 | |||||
6684 | inline bool Type::isIntegerType() const { | ||||
6685 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6686 | return BT->getKind() >= BuiltinType::Bool && | ||||
6687 | BT->getKind() <= BuiltinType::Int128; | ||||
6688 | if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) { | ||||
6689 | // Incomplete enum types are not treated as integer types. | ||||
6690 | // FIXME: In C++, enum types are never integer types. | ||||
6691 | return IsEnumDeclComplete(ET->getDecl()) && | ||||
6692 | !IsEnumDeclScoped(ET->getDecl()); | ||||
6693 | } | ||||
6694 | return false; | ||||
6695 | } | ||||
6696 | |||||
6697 | inline bool Type::isFixedPointType() const { | ||||
6698 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) { | ||||
6699 | return BT->getKind() >= BuiltinType::ShortAccum && | ||||
6700 | BT->getKind() <= BuiltinType::SatULongFract; | ||||
6701 | } | ||||
6702 | return false; | ||||
6703 | } | ||||
6704 | |||||
6705 | inline bool Type::isFixedPointOrIntegerType() const { | ||||
6706 | return isFixedPointType() || isIntegerType(); | ||||
6707 | } | ||||
6708 | |||||
6709 | inline bool Type::isSaturatedFixedPointType() const { | ||||
6710 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) { | ||||
6711 | return BT->getKind() >= BuiltinType::SatShortAccum && | ||||
6712 | BT->getKind() <= BuiltinType::SatULongFract; | ||||
6713 | } | ||||
6714 | return false; | ||||
6715 | } | ||||
6716 | |||||
6717 | inline bool Type::isUnsaturatedFixedPointType() const { | ||||
6718 | return isFixedPointType() && !isSaturatedFixedPointType(); | ||||
6719 | } | ||||
6720 | |||||
6721 | inline bool Type::isSignedFixedPointType() const { | ||||
6722 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) { | ||||
6723 | return ((BT->getKind() >= BuiltinType::ShortAccum && | ||||
6724 | BT->getKind() <= BuiltinType::LongAccum) || | ||||
6725 | (BT->getKind() >= BuiltinType::ShortFract && | ||||
6726 | BT->getKind() <= BuiltinType::LongFract) || | ||||
6727 | (BT->getKind() >= BuiltinType::SatShortAccum && | ||||
6728 | BT->getKind() <= BuiltinType::SatLongAccum) || | ||||
6729 | (BT->getKind() >= BuiltinType::SatShortFract && | ||||
6730 | BT->getKind() <= BuiltinType::SatLongFract)); | ||||
6731 | } | ||||
6732 | return false; | ||||
6733 | } | ||||
6734 | |||||
6735 | inline bool Type::isUnsignedFixedPointType() const { | ||||
6736 | return isFixedPointType() && !isSignedFixedPointType(); | ||||
6737 | } | ||||
6738 | |||||
6739 | inline bool Type::isScalarType() const { | ||||
6740 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6741 | return BT->getKind() > BuiltinType::Void && | ||||
6742 | BT->getKind() <= BuiltinType::NullPtr; | ||||
6743 | if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) | ||||
6744 | // Enums are scalar types, but only if they are defined. Incomplete enums | ||||
6745 | // are not treated as scalar types. | ||||
6746 | return IsEnumDeclComplete(ET->getDecl()); | ||||
6747 | return isa<PointerType>(CanonicalType) || | ||||
6748 | isa<BlockPointerType>(CanonicalType) || | ||||
6749 | isa<MemberPointerType>(CanonicalType) || | ||||
6750 | isa<ComplexType>(CanonicalType) || | ||||
6751 | isa<ObjCObjectPointerType>(CanonicalType); | ||||
6752 | } | ||||
6753 | |||||
6754 | inline bool Type::isIntegralOrEnumerationType() const { | ||||
6755 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6756 | return BT->getKind() >= BuiltinType::Bool && | ||||
6757 | BT->getKind() <= BuiltinType::Int128; | ||||
6758 | |||||
6759 | // Check for a complete enum type; incomplete enum types are not properly an | ||||
6760 | // enumeration type in the sense required here. | ||||
6761 | if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) | ||||
6762 | return IsEnumDeclComplete(ET->getDecl()); | ||||
6763 | |||||
6764 | return false; | ||||
6765 | } | ||||
6766 | |||||
6767 | inline bool Type::isBooleanType() const { | ||||
6768 | if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) | ||||
6769 | return BT->getKind() == BuiltinType::Bool; | ||||
6770 | return false; | ||||
6771 | } | ||||
6772 | |||||
6773 | inline bool Type::isUndeducedType() const { | ||||
6774 | auto *DT = getContainedDeducedType(); | ||||
6775 | return DT && !DT->isDeduced(); | ||||
6776 | } | ||||
6777 | |||||
6778 | /// Determines whether this is a type for which one can define | ||||
6779 | /// an overloaded operator. | ||||
6780 | inline bool Type::isOverloadableType() const { | ||||
6781 | return isDependentType() || isRecordType() || isEnumeralType(); | ||||
6782 | } | ||||
6783 | |||||
6784 | /// Determines whether this type can decay to a pointer type. | ||||
6785 | inline bool Type::canDecayToPointerType() const { | ||||
6786 | return isFunctionType() || isArrayType(); | ||||
6787 | } | ||||
6788 | |||||
6789 | inline bool Type::hasPointerRepresentation() const { | ||||
6790 | return (isPointerType() || isReferenceType() || isBlockPointerType() || | ||||
6791 | isObjCObjectPointerType() || isNullPtrType()); | ||||
6792 | } | ||||
6793 | |||||
6794 | inline bool Type::hasObjCPointerRepresentation() const { | ||||
6795 | return isObjCObjectPointerType(); | ||||
6796 | } | ||||
6797 | |||||
6798 | inline const Type *Type::getBaseElementTypeUnsafe() const { | ||||
6799 | const Type *type = this; | ||||
6800 | while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe()) | ||||
6801 | type = arrayType->getElementType().getTypePtr(); | ||||
6802 | return type; | ||||
6803 | } | ||||
6804 | |||||
6805 | inline const Type *Type::getPointeeOrArrayElementType() const { | ||||
6806 | const Type *type = this; | ||||
6807 | if (type->isAnyPointerType()) | ||||
6808 | return type->getPointeeType().getTypePtr(); | ||||
6809 | else if (type->isArrayType()) | ||||
6810 | return type->getBaseElementTypeUnsafe(); | ||||
6811 | return type; | ||||
6812 | } | ||||
6813 | |||||
6814 | /// Insertion operator for diagnostics. This allows sending Qualifiers into a | ||||
6815 | /// diagnostic with <<. | ||||
6816 | inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, | ||||
6817 | Qualifiers Q) { | ||||
6818 | DB.AddTaggedVal(Q.getAsOpaqueValue(), | ||||
6819 | DiagnosticsEngine::ArgumentKind::ak_qual); | ||||
6820 | return DB; | ||||
6821 | } | ||||
6822 | |||||
6823 | /// Insertion operator for partial diagnostics. This allows sending Qualifiers | ||||
6824 | /// into a diagnostic with <<. | ||||
6825 | inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, | ||||
6826 | Qualifiers Q) { | ||||
6827 | PD.AddTaggedVal(Q.getAsOpaqueValue(), | ||||
6828 | DiagnosticsEngine::ArgumentKind::ak_qual); | ||||
6829 | return PD; | ||||
6830 | } | ||||
6831 | |||||
6832 | /// Insertion operator for diagnostics. This allows sending QualType's into a | ||||
6833 | /// diagnostic with <<. | ||||
6834 | inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, | ||||
6835 | QualType T) { | ||||
6836 | DB.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()), | ||||
6837 | DiagnosticsEngine::ak_qualtype); | ||||
6838 | return DB; | ||||
6839 | } | ||||
6840 | |||||
6841 | /// Insertion operator for partial diagnostics. This allows sending QualType's | ||||
6842 | /// into a diagnostic with <<. | ||||
6843 | inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, | ||||
6844 | QualType T) { | ||||
6845 | PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()), | ||||
6846 | DiagnosticsEngine::ak_qualtype); | ||||
6847 | return PD; | ||||
6848 | } | ||||
6849 | |||||
6850 | // Helper class template that is used by Type::getAs to ensure that one does | ||||
6851 | // not try to look through a qualified type to get to an array type. | ||||
6852 | template <typename T> | ||||
6853 | using TypeIsArrayType = | ||||
6854 | std::integral_constant<bool, std::is_same<T, ArrayType>::value || | ||||
6855 | std::is_base_of<ArrayType, T>::value>; | ||||
6856 | |||||
6857 | // Member-template getAs<specific type>'. | ||||
6858 | template <typename T> const T *Type::getAs() const { | ||||
6859 | static_assert(!TypeIsArrayType<T>::value, | ||||
6860 | "ArrayType cannot be used with getAs!"); | ||||
6861 | |||||
6862 | // If this is directly a T type, return it. | ||||
6863 | if (const auto *Ty = dyn_cast<T>(this)) | ||||
6864 | return Ty; | ||||
6865 | |||||
6866 | // If the canonical form of this type isn't the right kind, reject it. | ||||
6867 | if (!isa<T>(CanonicalType)) | ||||
6868 | return nullptr; | ||||
6869 | |||||
6870 | // If this is a typedef for the type, strip the typedef off without | ||||
6871 | // losing all typedef information. | ||||
6872 | return cast<T>(getUnqualifiedDesugaredType()); | ||||
6873 | } | ||||
6874 | |||||
6875 | template <typename T> const T *Type::getAsAdjusted() const { | ||||
6876 | static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!"); | ||||
6877 | |||||
6878 | // If this is directly a T type, return it. | ||||
6879 | if (const auto *Ty = dyn_cast<T>(this)) | ||||
6880 | return Ty; | ||||
6881 | |||||
6882 | // If the canonical form of this type isn't the right kind, reject it. | ||||
6883 | if (!isa<T>(CanonicalType)) | ||||
6884 | return nullptr; | ||||
6885 | |||||
6886 | // Strip off type adjustments that do not modify the underlying nature of the | ||||
6887 | // type. | ||||
6888 | const Type *Ty = this; | ||||
6889 | while (Ty) { | ||||
6890 | if (const auto *A = dyn_cast<AttributedType>(Ty)) | ||||
6891 | Ty = A->getModifiedType().getTypePtr(); | ||||
6892 | else if (const auto *E = dyn_cast<ElaboratedType>(Ty)) | ||||
6893 | Ty = E->desugar().getTypePtr(); | ||||
6894 | else if (const auto *P = dyn_cast<ParenType>(Ty)) | ||||
6895 | Ty = P->desugar().getTypePtr(); | ||||
6896 | else if (const auto *A = dyn_cast<AdjustedType>(Ty)) | ||||
6897 | Ty = A->desugar().getTypePtr(); | ||||
6898 | else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty)) | ||||
6899 | Ty = M->desugar().getTypePtr(); | ||||
6900 | else | ||||
6901 | break; | ||||
6902 | } | ||||
6903 | |||||
6904 | // Just because the canonical type is correct does not mean we can use cast<>, | ||||
6905 | // since we may not have stripped off all the sugar down to the base type. | ||||
6906 | return dyn_cast<T>(Ty); | ||||
6907 | } | ||||
6908 | |||||
6909 | inline const ArrayType *Type::getAsArrayTypeUnsafe() const { | ||||
6910 | // If this is directly an array type, return it. | ||||
6911 | if (const auto *arr = dyn_cast<ArrayType>(this)) | ||||
6912 | return arr; | ||||
6913 | |||||
6914 | // If the canonical form of this type isn't the right kind, reject it. | ||||
6915 | if (!isa<ArrayType>(CanonicalType)) | ||||
6916 | return nullptr; | ||||
6917 | |||||
6918 | // If this is a typedef for the type, strip the typedef off without | ||||
6919 | // losing all typedef information. | ||||
6920 | return cast<ArrayType>(getUnqualifiedDesugaredType()); | ||||
6921 | } | ||||
6922 | |||||
6923 | template <typename T> const T *Type::castAs() const { | ||||
6924 | static_assert(!TypeIsArrayType<T>::value, | ||||
6925 | "ArrayType cannot be used with castAs!"); | ||||
6926 | |||||
6927 | if (const auto *ty = dyn_cast<T>(this)) return ty; | ||||
6928 | assert(isa<T>(CanonicalType))((isa<T>(CanonicalType)) ? static_cast<void> (0) : __assert_fail ("isa<T>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 6928, __PRETTY_FUNCTION__)); | ||||
6929 | return cast<T>(getUnqualifiedDesugaredType()); | ||||
6930 | } | ||||
6931 | |||||
6932 | inline const ArrayType *Type::castAsArrayTypeUnsafe() const { | ||||
6933 | assert(isa<ArrayType>(CanonicalType))((isa<ArrayType>(CanonicalType)) ? static_cast<void> (0) : __assert_fail ("isa<ArrayType>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 6933, __PRETTY_FUNCTION__)); | ||||
6934 | if (const auto *arr = dyn_cast<ArrayType>(this)) return arr; | ||||
6935 | return cast<ArrayType>(getUnqualifiedDesugaredType()); | ||||
6936 | } | ||||
6937 | |||||
6938 | DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr, | ||||
6939 | QualType CanonicalPtr) | ||||
6940 | : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) { | ||||
6941 | #ifndef NDEBUG | ||||
6942 | QualType Adjusted = getAdjustedType(); | ||||
6943 | (void)AttributedType::stripOuterNullability(Adjusted); | ||||
6944 | assert(isa<PointerType>(Adjusted))((isa<PointerType>(Adjusted)) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Adjusted)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h" , 6944, __PRETTY_FUNCTION__)); | ||||
6945 | #endif | ||||
6946 | } | ||||
6947 | |||||
6948 | QualType DecayedType::getPointeeType() const { | ||||
6949 | QualType Decayed = getDecayedType(); | ||||
6950 | (void)AttributedType::stripOuterNullability(Decayed); | ||||
6951 | return cast<PointerType>(Decayed)->getPointeeType(); | ||||
6952 | } | ||||
6953 | |||||
6954 | // Get the decimal string representation of a fixed point type, represented | ||||
6955 | // as a scaled integer. | ||||
6956 | // TODO: At some point, we should change the arguments to instead just accept an | ||||
6957 | // APFixedPoint instead of APSInt and scale. | ||||
6958 | void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val, | ||||
6959 | unsigned Scale); | ||||
6960 | |||||
6961 | } // namespace clang | ||||
6962 | |||||
6963 | #endif // LLVM_CLANG_AST_TYPE_H |