Bug Summary

File:clang/lib/Sema/SemaType.cpp
Warning:line 6054, column 45
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaType.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Sema -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Sema/SemaType.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Sema/SemaType.cpp

1//===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
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 type-related semantic analysis.
10//
11//===----------------------------------------------------------------------===//
12
13#include "TypeLocBuilder.h"
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/ASTStructuralEquivalence.h"
18#include "clang/AST/CXXInheritance.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/TypeLoc.h"
23#include "clang/AST/TypeLocVisitor.h"
24#include "clang/Basic/PartialDiagnostic.h"
25#include "clang/Basic/TargetInfo.h"
26#include "clang/Lex/Preprocessor.h"
27#include "clang/Sema/DeclSpec.h"
28#include "clang/Sema/DelayedDiagnostic.h"
29#include "clang/Sema/Lookup.h"
30#include "clang/Sema/ParsedTemplate.h"
31#include "clang/Sema/ScopeInfo.h"
32#include "clang/Sema/SemaInternal.h"
33#include "clang/Sema/Template.h"
34#include "clang/Sema/TemplateInstCallback.h"
35#include "llvm/ADT/SmallPtrSet.h"
36#include "llvm/ADT/SmallString.h"
37#include "llvm/ADT/StringSwitch.h"
38#include "llvm/IR/DerivedTypes.h"
39#include "llvm/Support/ErrorHandling.h"
40#include <bitset>
41
42using namespace clang;
43
44enum TypeDiagSelector {
45 TDS_Function,
46 TDS_Pointer,
47 TDS_ObjCObjOrBlock
48};
49
50/// isOmittedBlockReturnType - Return true if this declarator is missing a
51/// return type because this is a omitted return type on a block literal.
52static bool isOmittedBlockReturnType(const Declarator &D) {
53 if (D.getContext() != DeclaratorContext::BlockLiteral ||
54 D.getDeclSpec().hasTypeSpecifier())
55 return false;
56
57 if (D.getNumTypeObjects() == 0)
58 return true; // ^{ ... }
59
60 if (D.getNumTypeObjects() == 1 &&
61 D.getTypeObject(0).Kind == DeclaratorChunk::Function)
62 return true; // ^(int X, float Y) { ... }
63
64 return false;
65}
66
67/// diagnoseBadTypeAttribute - Diagnoses a type attribute which
68/// doesn't apply to the given type.
69static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr,
70 QualType type) {
71 TypeDiagSelector WhichType;
72 bool useExpansionLoc = true;
73 switch (attr.getKind()) {
74 case ParsedAttr::AT_ObjCGC:
75 WhichType = TDS_Pointer;
76 break;
77 case ParsedAttr::AT_ObjCOwnership:
78 WhichType = TDS_ObjCObjOrBlock;
79 break;
80 default:
81 // Assume everything else was a function attribute.
82 WhichType = TDS_Function;
83 useExpansionLoc = false;
84 break;
85 }
86
87 SourceLocation loc = attr.getLoc();
88 StringRef name = attr.getAttrName()->getName();
89
90 // The GC attributes are usually written with macros; special-case them.
91 IdentifierInfo *II = attr.isArgIdent(0) ? attr.getArgAsIdent(0)->Ident
92 : nullptr;
93 if (useExpansionLoc && loc.isMacroID() && II) {
94 if (II->isStr("strong")) {
95 if (S.findMacroSpelling(loc, "__strong")) name = "__strong";
96 } else if (II->isStr("weak")) {
97 if (S.findMacroSpelling(loc, "__weak")) name = "__weak";
98 }
99 }
100
101 S.Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType
102 << type;
103}
104
105// objc_gc applies to Objective-C pointers or, otherwise, to the
106// smallest available pointer type (i.e. 'void*' in 'void**').
107#define OBJC_POINTER_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_ObjCGC: case ParsedAttr::AT_ObjCOwnership \
108 case ParsedAttr::AT_ObjCGC: \
109 case ParsedAttr::AT_ObjCOwnership
110
111// Calling convention attributes.
112#define CALLING_CONV_ATTRS_CASELISTcase ParsedAttr::AT_CDecl: case ParsedAttr::AT_FastCall: case
ParsedAttr::AT_StdCall: case ParsedAttr::AT_ThisCall: case ParsedAttr
::AT_RegCall: case ParsedAttr::AT_Pascal: case ParsedAttr::AT_SwiftCall
: case ParsedAttr::AT_SwiftAsyncCall: case ParsedAttr::AT_VectorCall
: case ParsedAttr::AT_AArch64VectorPcs: case ParsedAttr::AT_MSABI
: case ParsedAttr::AT_SysVABI: case ParsedAttr::AT_Pcs: case ParsedAttr
::AT_IntelOclBicc: case ParsedAttr::AT_PreserveMost: case ParsedAttr
::AT_PreserveAll
\
113 case ParsedAttr::AT_CDecl: \
114 case ParsedAttr::AT_FastCall: \
115 case ParsedAttr::AT_StdCall: \
116 case ParsedAttr::AT_ThisCall: \
117 case ParsedAttr::AT_RegCall: \
118 case ParsedAttr::AT_Pascal: \
119 case ParsedAttr::AT_SwiftCall: \
120 case ParsedAttr::AT_SwiftAsyncCall: \
121 case ParsedAttr::AT_VectorCall: \
122 case ParsedAttr::AT_AArch64VectorPcs: \
123 case ParsedAttr::AT_MSABI: \
124 case ParsedAttr::AT_SysVABI: \
125 case ParsedAttr::AT_Pcs: \
126 case ParsedAttr::AT_IntelOclBicc: \
127 case ParsedAttr::AT_PreserveMost: \
128 case ParsedAttr::AT_PreserveAll
129
130// Function type attributes.
131#define FUNCTION_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_NSReturnsRetained: case ParsedAttr::AT_NoReturn
: case ParsedAttr::AT_Regparm: case ParsedAttr::AT_CmseNSCall
: case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: case ParsedAttr
::AT_AnyX86NoCfCheck: case ParsedAttr::AT_CDecl: case ParsedAttr
::AT_FastCall: case ParsedAttr::AT_StdCall: case ParsedAttr::
AT_ThisCall: case ParsedAttr::AT_RegCall: case ParsedAttr::AT_Pascal
: case ParsedAttr::AT_SwiftCall: case ParsedAttr::AT_SwiftAsyncCall
: case ParsedAttr::AT_VectorCall: case ParsedAttr::AT_AArch64VectorPcs
: case ParsedAttr::AT_MSABI: case ParsedAttr::AT_SysVABI: case
ParsedAttr::AT_Pcs: case ParsedAttr::AT_IntelOclBicc: case ParsedAttr
::AT_PreserveMost: case ParsedAttr::AT_PreserveAll
\
132 case ParsedAttr::AT_NSReturnsRetained: \
133 case ParsedAttr::AT_NoReturn: \
134 case ParsedAttr::AT_Regparm: \
135 case ParsedAttr::AT_CmseNSCall: \
136 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
137 case ParsedAttr::AT_AnyX86NoCfCheck: \
138 CALLING_CONV_ATTRS_CASELISTcase ParsedAttr::AT_CDecl: case ParsedAttr::AT_FastCall: case
ParsedAttr::AT_StdCall: case ParsedAttr::AT_ThisCall: case ParsedAttr
::AT_RegCall: case ParsedAttr::AT_Pascal: case ParsedAttr::AT_SwiftCall
: case ParsedAttr::AT_SwiftAsyncCall: case ParsedAttr::AT_VectorCall
: case ParsedAttr::AT_AArch64VectorPcs: case ParsedAttr::AT_MSABI
: case ParsedAttr::AT_SysVABI: case ParsedAttr::AT_Pcs: case ParsedAttr
::AT_IntelOclBicc: case ParsedAttr::AT_PreserveMost: case ParsedAttr
::AT_PreserveAll
139
140// Microsoft-specific type qualifiers.
141#define MS_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_Ptr32: case ParsedAttr::AT_Ptr64: case ParsedAttr
::AT_SPtr: case ParsedAttr::AT_UPtr
\
142 case ParsedAttr::AT_Ptr32: \
143 case ParsedAttr::AT_Ptr64: \
144 case ParsedAttr::AT_SPtr: \
145 case ParsedAttr::AT_UPtr
146
147// Nullability qualifiers.
148#define NULLABILITY_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_TypeNonNull: case ParsedAttr::AT_TypeNullable
: case ParsedAttr::AT_TypeNullableResult: case ParsedAttr::AT_TypeNullUnspecified
\
149 case ParsedAttr::AT_TypeNonNull: \
150 case ParsedAttr::AT_TypeNullable: \
151 case ParsedAttr::AT_TypeNullableResult: \
152 case ParsedAttr::AT_TypeNullUnspecified
153
154namespace {
155 /// An object which stores processing state for the entire
156 /// GetTypeForDeclarator process.
157 class TypeProcessingState {
158 Sema &sema;
159
160 /// The declarator being processed.
161 Declarator &declarator;
162
163 /// The index of the declarator chunk we're currently processing.
164 /// May be the total number of valid chunks, indicating the
165 /// DeclSpec.
166 unsigned chunkIndex;
167
168 /// Whether there are non-trivial modifications to the decl spec.
169 bool trivial;
170
171 /// Whether we saved the attributes in the decl spec.
172 bool hasSavedAttrs;
173
174 /// The original set of attributes on the DeclSpec.
175 SmallVector<ParsedAttr *, 2> savedAttrs;
176
177 /// A list of attributes to diagnose the uselessness of when the
178 /// processing is complete.
179 SmallVector<ParsedAttr *, 2> ignoredTypeAttrs;
180
181 /// Attributes corresponding to AttributedTypeLocs that we have not yet
182 /// populated.
183 // FIXME: The two-phase mechanism by which we construct Types and fill
184 // their TypeLocs makes it hard to correctly assign these. We keep the
185 // attributes in creation order as an attempt to make them line up
186 // properly.
187 using TypeAttrPair = std::pair<const AttributedType*, const Attr*>;
188 SmallVector<TypeAttrPair, 8> AttrsForTypes;
189 bool AttrsForTypesSorted = true;
190
191 /// MacroQualifiedTypes mapping to macro expansion locations that will be
192 /// stored in a MacroQualifiedTypeLoc.
193 llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
194
195 /// Flag to indicate we parsed a noderef attribute. This is used for
196 /// validating that noderef was used on a pointer or array.
197 bool parsedNoDeref;
198
199 public:
200 TypeProcessingState(Sema &sema, Declarator &declarator)
201 : sema(sema), declarator(declarator),
202 chunkIndex(declarator.getNumTypeObjects()), trivial(true),
203 hasSavedAttrs(false), parsedNoDeref(false) {}
204
205 Sema &getSema() const {
206 return sema;
207 }
208
209 Declarator &getDeclarator() const {
210 return declarator;
211 }
212
213 bool isProcessingDeclSpec() const {
214 return chunkIndex == declarator.getNumTypeObjects();
215 }
216
217 unsigned getCurrentChunkIndex() const {
218 return chunkIndex;
219 }
220
221 void setCurrentChunkIndex(unsigned idx) {
222 assert(idx <= declarator.getNumTypeObjects())(static_cast<void> (0));
223 chunkIndex = idx;
224 }
225
226 ParsedAttributesView &getCurrentAttributes() const {
227 if (isProcessingDeclSpec())
228 return getMutableDeclSpec().getAttributes();
229 return declarator.getTypeObject(chunkIndex).getAttrs();
230 }
231
232 /// Save the current set of attributes on the DeclSpec.
233 void saveDeclSpecAttrs() {
234 // Don't try to save them multiple times.
235 if (hasSavedAttrs) return;
236
237 DeclSpec &spec = getMutableDeclSpec();
238 for (ParsedAttr &AL : spec.getAttributes())
239 savedAttrs.push_back(&AL);
240 trivial &= savedAttrs.empty();
241 hasSavedAttrs = true;
242 }
243
244 /// Record that we had nowhere to put the given type attribute.
245 /// We will diagnose such attributes later.
246 void addIgnoredTypeAttr(ParsedAttr &attr) {
247 ignoredTypeAttrs.push_back(&attr);
248 }
249
250 /// Diagnose all the ignored type attributes, given that the
251 /// declarator worked out to the given type.
252 void diagnoseIgnoredTypeAttrs(QualType type) const {
253 for (auto *Attr : ignoredTypeAttrs)
254 diagnoseBadTypeAttribute(getSema(), *Attr, type);
255 }
256
257 /// Get an attributed type for the given attribute, and remember the Attr
258 /// object so that we can attach it to the AttributedTypeLoc.
259 QualType getAttributedType(Attr *A, QualType ModifiedType,
260 QualType EquivType) {
261 QualType T =
262 sema.Context.getAttributedType(A->getKind(), ModifiedType, EquivType);
263 AttrsForTypes.push_back({cast<AttributedType>(T.getTypePtr()), A});
264 AttrsForTypesSorted = false;
265 return T;
266 }
267
268 /// Completely replace the \c auto in \p TypeWithAuto by
269 /// \p Replacement. Also replace \p TypeWithAuto in \c TypeAttrPair if
270 /// necessary.
271 QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement) {
272 QualType T = sema.ReplaceAutoType(TypeWithAuto, Replacement);
273 if (auto *AttrTy = TypeWithAuto->getAs<AttributedType>()) {
274 // Attributed type still should be an attributed type after replacement.
275 auto *NewAttrTy = cast<AttributedType>(T.getTypePtr());
276 for (TypeAttrPair &A : AttrsForTypes) {
277 if (A.first == AttrTy)
278 A.first = NewAttrTy;
279 }
280 AttrsForTypesSorted = false;
281 }
282 return T;
283 }
284
285 /// Extract and remove the Attr* for a given attributed type.
286 const Attr *takeAttrForAttributedType(const AttributedType *AT) {
287 if (!AttrsForTypesSorted) {
288 llvm::stable_sort(AttrsForTypes, llvm::less_first());
289 AttrsForTypesSorted = true;
290 }
291
292 // FIXME: This is quadratic if we have lots of reuses of the same
293 // attributed type.
294 for (auto It = std::partition_point(
295 AttrsForTypes.begin(), AttrsForTypes.end(),
296 [=](const TypeAttrPair &A) { return A.first < AT; });
297 It != AttrsForTypes.end() && It->first == AT; ++It) {
298 if (It->second) {
299 const Attr *Result = It->second;
300 It->second = nullptr;
301 return Result;
302 }
303 }
304
305 llvm_unreachable("no Attr* for AttributedType*")__builtin_unreachable();
306 }
307
308 SourceLocation
309 getExpansionLocForMacroQualifiedType(const MacroQualifiedType *MQT) const {
310 auto FoundLoc = LocsForMacros.find(MQT);
311 assert(FoundLoc != LocsForMacros.end() &&(static_cast<void> (0))
312 "Unable to find macro expansion location for MacroQualifedType")(static_cast<void> (0));
313 return FoundLoc->second;
314 }
315
316 void setExpansionLocForMacroQualifiedType(const MacroQualifiedType *MQT,
317 SourceLocation Loc) {
318 LocsForMacros[MQT] = Loc;
319 }
320
321 void setParsedNoDeref(bool parsed) { parsedNoDeref = parsed; }
322
323 bool didParseNoDeref() const { return parsedNoDeref; }
324
325 ~TypeProcessingState() {
326 if (trivial) return;
327
328 restoreDeclSpecAttrs();
329 }
330
331 private:
332 DeclSpec &getMutableDeclSpec() const {
333 return const_cast<DeclSpec&>(declarator.getDeclSpec());
334 }
335
336 void restoreDeclSpecAttrs() {
337 assert(hasSavedAttrs)(static_cast<void> (0));
338
339 getMutableDeclSpec().getAttributes().clearListOnly();
340 for (ParsedAttr *AL : savedAttrs)
341 getMutableDeclSpec().getAttributes().addAtEnd(AL);
342 }
343 };
344} // end anonymous namespace
345
346static void moveAttrFromListToList(ParsedAttr &attr,
347 ParsedAttributesView &fromList,
348 ParsedAttributesView &toList) {
349 fromList.remove(&attr);
350 toList.addAtEnd(&attr);
351}
352
353/// The location of a type attribute.
354enum TypeAttrLocation {
355 /// The attribute is in the decl-specifier-seq.
356 TAL_DeclSpec,
357 /// The attribute is part of a DeclaratorChunk.
358 TAL_DeclChunk,
359 /// The attribute is immediately after the declaration's name.
360 TAL_DeclName
361};
362
363static void processTypeAttrs(TypeProcessingState &state, QualType &type,
364 TypeAttrLocation TAL, ParsedAttributesView &attrs);
365
366static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
367 QualType &type);
368
369static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state,
370 ParsedAttr &attr, QualType &type);
371
372static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
373 QualType &type);
374
375static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state,
376 ParsedAttr &attr, QualType &type);
377
378static bool handleObjCPointerTypeAttr(TypeProcessingState &state,
379 ParsedAttr &attr, QualType &type) {
380 if (attr.getKind() == ParsedAttr::AT_ObjCGC)
381 return handleObjCGCTypeAttr(state, attr, type);
382 assert(attr.getKind() == ParsedAttr::AT_ObjCOwnership)(static_cast<void> (0));
383 return handleObjCOwnershipTypeAttr(state, attr, type);
384}
385
386/// Given the index of a declarator chunk, check whether that chunk
387/// directly specifies the return type of a function and, if so, find
388/// an appropriate place for it.
389///
390/// \param i - a notional index which the search will start
391/// immediately inside
392///
393/// \param onlyBlockPointers Whether we should only look into block
394/// pointer types (vs. all pointer types).
395static DeclaratorChunk *maybeMovePastReturnType(Declarator &declarator,
396 unsigned i,
397 bool onlyBlockPointers) {
398 assert(i <= declarator.getNumTypeObjects())(static_cast<void> (0));
399
400 DeclaratorChunk *result = nullptr;
401
402 // First, look inwards past parens for a function declarator.
403 for (; i != 0; --i) {
404 DeclaratorChunk &fnChunk = declarator.getTypeObject(i-1);
405 switch (fnChunk.Kind) {
406 case DeclaratorChunk::Paren:
407 continue;
408
409 // If we find anything except a function, bail out.
410 case DeclaratorChunk::Pointer:
411 case DeclaratorChunk::BlockPointer:
412 case DeclaratorChunk::Array:
413 case DeclaratorChunk::Reference:
414 case DeclaratorChunk::MemberPointer:
415 case DeclaratorChunk::Pipe:
416 return result;
417
418 // If we do find a function declarator, scan inwards from that,
419 // looking for a (block-)pointer declarator.
420 case DeclaratorChunk::Function:
421 for (--i; i != 0; --i) {
422 DeclaratorChunk &ptrChunk = declarator.getTypeObject(i-1);
423 switch (ptrChunk.Kind) {
424 case DeclaratorChunk::Paren:
425 case DeclaratorChunk::Array:
426 case DeclaratorChunk::Function:
427 case DeclaratorChunk::Reference:
428 case DeclaratorChunk::Pipe:
429 continue;
430
431 case DeclaratorChunk::MemberPointer:
432 case DeclaratorChunk::Pointer:
433 if (onlyBlockPointers)
434 continue;
435
436 LLVM_FALLTHROUGH[[gnu::fallthrough]];
437
438 case DeclaratorChunk::BlockPointer:
439 result = &ptrChunk;
440 goto continue_outer;
441 }
442 llvm_unreachable("bad declarator chunk kind")__builtin_unreachable();
443 }
444
445 // If we run out of declarators doing that, we're done.
446 return result;
447 }
448 llvm_unreachable("bad declarator chunk kind")__builtin_unreachable();
449
450 // Okay, reconsider from our new point.
451 continue_outer: ;
452 }
453
454 // Ran out of chunks, bail out.
455 return result;
456}
457
458/// Given that an objc_gc attribute was written somewhere on a
459/// declaration *other* than on the declarator itself (for which, use
460/// distributeObjCPointerTypeAttrFromDeclarator), and given that it
461/// didn't apply in whatever position it was written in, try to move
462/// it to a more appropriate position.
463static void distributeObjCPointerTypeAttr(TypeProcessingState &state,
464 ParsedAttr &attr, QualType type) {
465 Declarator &declarator = state.getDeclarator();
466
467 // Move it to the outermost normal or block pointer declarator.
468 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
469 DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
470 switch (chunk.Kind) {
471 case DeclaratorChunk::Pointer:
472 case DeclaratorChunk::BlockPointer: {
473 // But don't move an ARC ownership attribute to the return type
474 // of a block.
475 DeclaratorChunk *destChunk = nullptr;
476 if (state.isProcessingDeclSpec() &&
477 attr.getKind() == ParsedAttr::AT_ObjCOwnership)
478 destChunk = maybeMovePastReturnType(declarator, i - 1,
479 /*onlyBlockPointers=*/true);
480 if (!destChunk) destChunk = &chunk;
481
482 moveAttrFromListToList(attr, state.getCurrentAttributes(),
483 destChunk->getAttrs());
484 return;
485 }
486
487 case DeclaratorChunk::Paren:
488 case DeclaratorChunk::Array:
489 continue;
490
491 // We may be starting at the return type of a block.
492 case DeclaratorChunk::Function:
493 if (state.isProcessingDeclSpec() &&
494 attr.getKind() == ParsedAttr::AT_ObjCOwnership) {
495 if (DeclaratorChunk *dest = maybeMovePastReturnType(
496 declarator, i,
497 /*onlyBlockPointers=*/true)) {
498 moveAttrFromListToList(attr, state.getCurrentAttributes(),
499 dest->getAttrs());
500 return;
501 }
502 }
503 goto error;
504
505 // Don't walk through these.
506 case DeclaratorChunk::Reference:
507 case DeclaratorChunk::MemberPointer:
508 case DeclaratorChunk::Pipe:
509 goto error;
510 }
511 }
512 error:
513
514 diagnoseBadTypeAttribute(state.getSema(), attr, type);
515}
516
517/// Distribute an objc_gc type attribute that was written on the
518/// declarator.
519static void distributeObjCPointerTypeAttrFromDeclarator(
520 TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType) {
521 Declarator &declarator = state.getDeclarator();
522
523 // objc_gc goes on the innermost pointer to something that's not a
524 // pointer.
525 unsigned innermost = -1U;
526 bool considerDeclSpec = true;
527 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
528 DeclaratorChunk &chunk = declarator.getTypeObject(i);
529 switch (chunk.Kind) {
530 case DeclaratorChunk::Pointer:
531 case DeclaratorChunk::BlockPointer:
532 innermost = i;
533 continue;
534
535 case DeclaratorChunk::Reference:
536 case DeclaratorChunk::MemberPointer:
537 case DeclaratorChunk::Paren:
538 case DeclaratorChunk::Array:
539 case DeclaratorChunk::Pipe:
540 continue;
541
542 case DeclaratorChunk::Function:
543 considerDeclSpec = false;
544 goto done;
545 }
546 }
547 done:
548
549 // That might actually be the decl spec if we weren't blocked by
550 // anything in the declarator.
551 if (considerDeclSpec) {
552 if (handleObjCPointerTypeAttr(state, attr, declSpecType)) {
553 // Splice the attribute into the decl spec. Prevents the
554 // attribute from being applied multiple times and gives
555 // the source-location-filler something to work with.
556 state.saveDeclSpecAttrs();
557 declarator.getMutableDeclSpec().getAttributes().takeOneFrom(
558 declarator.getAttributes(), &attr);
559 return;
560 }
561 }
562
563 // Otherwise, if we found an appropriate chunk, splice the attribute
564 // into it.
565 if (innermost != -1U) {
566 moveAttrFromListToList(attr, declarator.getAttributes(),
567 declarator.getTypeObject(innermost).getAttrs());
568 return;
569 }
570
571 // Otherwise, diagnose when we're done building the type.
572 declarator.getAttributes().remove(&attr);
573 state.addIgnoredTypeAttr(attr);
574}
575
576/// A function type attribute was written somewhere in a declaration
577/// *other* than on the declarator itself or in the decl spec. Given
578/// that it didn't apply in whatever position it was written in, try
579/// to move it to a more appropriate position.
580static void distributeFunctionTypeAttr(TypeProcessingState &state,
581 ParsedAttr &attr, QualType type) {
582 Declarator &declarator = state.getDeclarator();
583
584 // Try to push the attribute from the return type of a function to
585 // the function itself.
586 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
587 DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
588 switch (chunk.Kind) {
589 case DeclaratorChunk::Function:
590 moveAttrFromListToList(attr, state.getCurrentAttributes(),
591 chunk.getAttrs());
592 return;
593
594 case DeclaratorChunk::Paren:
595 case DeclaratorChunk::Pointer:
596 case DeclaratorChunk::BlockPointer:
597 case DeclaratorChunk::Array:
598 case DeclaratorChunk::Reference:
599 case DeclaratorChunk::MemberPointer:
600 case DeclaratorChunk::Pipe:
601 continue;
602 }
603 }
604
605 diagnoseBadTypeAttribute(state.getSema(), attr, type);
606}
607
608/// Try to distribute a function type attribute to the innermost
609/// function chunk or type. Returns true if the attribute was
610/// distributed, false if no location was found.
611static bool distributeFunctionTypeAttrToInnermost(
612 TypeProcessingState &state, ParsedAttr &attr,
613 ParsedAttributesView &attrList, QualType &declSpecType) {
614 Declarator &declarator = state.getDeclarator();
615
616 // Put it on the innermost function chunk, if there is one.
617 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
618 DeclaratorChunk &chunk = declarator.getTypeObject(i);
619 if (chunk.Kind != DeclaratorChunk::Function) continue;
620
621 moveAttrFromListToList(attr, attrList, chunk.getAttrs());
622 return true;
623 }
624
625 return handleFunctionTypeAttr(state, attr, declSpecType);
626}
627
628/// A function type attribute was written in the decl spec. Try to
629/// apply it somewhere.
630static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state,
631 ParsedAttr &attr,
632 QualType &declSpecType) {
633 state.saveDeclSpecAttrs();
634
635 // C++11 attributes before the decl specifiers actually appertain to
636 // the declarators. Move them straight there. We don't support the
637 // 'put them wherever you like' semantics we allow for GNU attributes.
638 if (attr.isStandardAttributeSyntax()) {
639 moveAttrFromListToList(attr, state.getCurrentAttributes(),
640 state.getDeclarator().getAttributes());
641 return;
642 }
643
644 // Try to distribute to the innermost.
645 if (distributeFunctionTypeAttrToInnermost(
646 state, attr, state.getCurrentAttributes(), declSpecType))
647 return;
648
649 // If that failed, diagnose the bad attribute when the declarator is
650 // fully built.
651 state.addIgnoredTypeAttr(attr);
652}
653
654/// A function type attribute was written on the declarator. Try to
655/// apply it somewhere.
656static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state,
657 ParsedAttr &attr,
658 QualType &declSpecType) {
659 Declarator &declarator = state.getDeclarator();
660
661 // Try to distribute to the innermost.
662 if (distributeFunctionTypeAttrToInnermost(
663 state, attr, declarator.getAttributes(), declSpecType))
664 return;
665
666 // If that failed, diagnose the bad attribute when the declarator is
667 // fully built.
668 declarator.getAttributes().remove(&attr);
669 state.addIgnoredTypeAttr(attr);
670}
671
672/// Given that there are attributes written on the declarator
673/// itself, try to distribute any type attributes to the appropriate
674/// declarator chunk.
675///
676/// These are attributes like the following:
677/// int f ATTR;
678/// int (f ATTR)();
679/// but not necessarily this:
680/// int f() ATTR;
681static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state,
682 QualType &declSpecType) {
683 // Collect all the type attributes from the declarator itself.
684 assert(!state.getDeclarator().getAttributes().empty() &&(static_cast<void> (0))
685 "declarator has no attrs!")(static_cast<void> (0));
686 // The called functions in this loop actually remove things from the current
687 // list, so iterating over the existing list isn't possible. Instead, make a
688 // non-owning copy and iterate over that.
689 ParsedAttributesView AttrsCopy{state.getDeclarator().getAttributes()};
690 for (ParsedAttr &attr : AttrsCopy) {
691 // Do not distribute [[]] attributes. They have strict rules for what
692 // they appertain to.
693 if (attr.isStandardAttributeSyntax())
694 continue;
695
696 switch (attr.getKind()) {
697 OBJC_POINTER_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_ObjCGC: case ParsedAttr::AT_ObjCOwnership:
698 distributeObjCPointerTypeAttrFromDeclarator(state, attr, declSpecType);
699 break;
700
701 FUNCTION_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_NSReturnsRetained: case ParsedAttr::AT_NoReturn
: case ParsedAttr::AT_Regparm: case ParsedAttr::AT_CmseNSCall
: case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: case ParsedAttr
::AT_AnyX86NoCfCheck: case ParsedAttr::AT_CDecl: case ParsedAttr
::AT_FastCall: case ParsedAttr::AT_StdCall: case ParsedAttr::
AT_ThisCall: case ParsedAttr::AT_RegCall: case ParsedAttr::AT_Pascal
: case ParsedAttr::AT_SwiftCall: case ParsedAttr::AT_SwiftAsyncCall
: case ParsedAttr::AT_VectorCall: case ParsedAttr::AT_AArch64VectorPcs
: case ParsedAttr::AT_MSABI: case ParsedAttr::AT_SysVABI: case
ParsedAttr::AT_Pcs: case ParsedAttr::AT_IntelOclBicc: case ParsedAttr
::AT_PreserveMost: case ParsedAttr::AT_PreserveAll
:
702 distributeFunctionTypeAttrFromDeclarator(state, attr, declSpecType);
703 break;
704
705 MS_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_Ptr32: case ParsedAttr::AT_Ptr64: case ParsedAttr
::AT_SPtr: case ParsedAttr::AT_UPtr
:
706 // Microsoft type attributes cannot go after the declarator-id.
707 continue;
708
709 NULLABILITY_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_TypeNonNull: case ParsedAttr::AT_TypeNullable
: case ParsedAttr::AT_TypeNullableResult: case ParsedAttr::AT_TypeNullUnspecified
:
710 // Nullability specifiers cannot go after the declarator-id.
711
712 // Objective-C __kindof does not get distributed.
713 case ParsedAttr::AT_ObjCKindOf:
714 continue;
715
716 default:
717 break;
718 }
719 }
720}
721
722/// Add a synthetic '()' to a block-literal declarator if it is
723/// required, given the return type.
724static void maybeSynthesizeBlockSignature(TypeProcessingState &state,
725 QualType declSpecType) {
726 Declarator &declarator = state.getDeclarator();
727
728 // First, check whether the declarator would produce a function,
729 // i.e. whether the innermost semantic chunk is a function.
730 if (declarator.isFunctionDeclarator()) {
731 // If so, make that declarator a prototyped declarator.
732 declarator.getFunctionTypeInfo().hasPrototype = true;
733 return;
734 }
735
736 // If there are any type objects, the type as written won't name a
737 // function, regardless of the decl spec type. This is because a
738 // block signature declarator is always an abstract-declarator, and
739 // abstract-declarators can't just be parentheses chunks. Therefore
740 // we need to build a function chunk unless there are no type
741 // objects and the decl spec type is a function.
742 if (!declarator.getNumTypeObjects() && declSpecType->isFunctionType())
743 return;
744
745 // Note that there *are* cases with invalid declarators where
746 // declarators consist solely of parentheses. In general, these
747 // occur only in failed efforts to make function declarators, so
748 // faking up the function chunk is still the right thing to do.
749
750 // Otherwise, we need to fake up a function declarator.
751 SourceLocation loc = declarator.getBeginLoc();
752
753 // ...and *prepend* it to the declarator.
754 SourceLocation NoLoc;
755 declarator.AddInnermostTypeInfo(DeclaratorChunk::getFunction(
756 /*HasProto=*/true,
757 /*IsAmbiguous=*/false,
758 /*LParenLoc=*/NoLoc,
759 /*ArgInfo=*/nullptr,
760 /*NumParams=*/0,
761 /*EllipsisLoc=*/NoLoc,
762 /*RParenLoc=*/NoLoc,
763 /*RefQualifierIsLvalueRef=*/true,
764 /*RefQualifierLoc=*/NoLoc,
765 /*MutableLoc=*/NoLoc, EST_None,
766 /*ESpecRange=*/SourceRange(),
767 /*Exceptions=*/nullptr,
768 /*ExceptionRanges=*/nullptr,
769 /*NumExceptions=*/0,
770 /*NoexceptExpr=*/nullptr,
771 /*ExceptionSpecTokens=*/nullptr,
772 /*DeclsInPrototype=*/None, loc, loc, declarator));
773
774 // For consistency, make sure the state still has us as processing
775 // the decl spec.
776 assert(state.getCurrentChunkIndex() == declarator.getNumTypeObjects() - 1)(static_cast<void> (0));
777 state.setCurrentChunkIndex(declarator.getNumTypeObjects());
778}
779
780static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS,
781 unsigned &TypeQuals,
782 QualType TypeSoFar,
783 unsigned RemoveTQs,
784 unsigned DiagID) {
785 // If this occurs outside a template instantiation, warn the user about
786 // it; they probably didn't mean to specify a redundant qualifier.
787 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
788 for (QualLoc Qual : {QualLoc(DeclSpec::TQ_const, DS.getConstSpecLoc()),
789 QualLoc(DeclSpec::TQ_restrict, DS.getRestrictSpecLoc()),
790 QualLoc(DeclSpec::TQ_volatile, DS.getVolatileSpecLoc()),
791 QualLoc(DeclSpec::TQ_atomic, DS.getAtomicSpecLoc())}) {
792 if (!(RemoveTQs & Qual.first))
793 continue;
794
795 if (!S.inTemplateInstantiation()) {
796 if (TypeQuals & Qual.first)
797 S.Diag(Qual.second, DiagID)
798 << DeclSpec::getSpecifierName(Qual.first) << TypeSoFar
799 << FixItHint::CreateRemoval(Qual.second);
800 }
801
802 TypeQuals &= ~Qual.first;
803 }
804}
805
806/// Return true if this is omitted block return type. Also check type
807/// attributes and type qualifiers when returning true.
808static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator,
809 QualType Result) {
810 if (!isOmittedBlockReturnType(declarator))
811 return false;
812
813 // Warn if we see type attributes for omitted return type on a block literal.
814 SmallVector<ParsedAttr *, 2> ToBeRemoved;
815 for (ParsedAttr &AL : declarator.getMutableDeclSpec().getAttributes()) {
816 if (AL.isInvalid() || !AL.isTypeAttr())
817 continue;
818 S.Diag(AL.getLoc(),
819 diag::warn_block_literal_attributes_on_omitted_return_type)
820 << AL;
821 ToBeRemoved.push_back(&AL);
822 }
823 // Remove bad attributes from the list.
824 for (ParsedAttr *AL : ToBeRemoved)
825 declarator.getMutableDeclSpec().getAttributes().remove(AL);
826
827 // Warn if we see type qualifiers for omitted return type on a block literal.
828 const DeclSpec &DS = declarator.getDeclSpec();
829 unsigned TypeQuals = DS.getTypeQualifiers();
830 diagnoseAndRemoveTypeQualifiers(S, DS, TypeQuals, Result, (unsigned)-1,
831 diag::warn_block_literal_qualifiers_on_omitted_return_type);
832 declarator.getMutableDeclSpec().ClearTypeQualifiers();
833
834 return true;
835}
836
837/// Apply Objective-C type arguments to the given type.
838static QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type,
839 ArrayRef<TypeSourceInfo *> typeArgs,
840 SourceRange typeArgsRange,
841 bool failOnError = false) {
842 // We can only apply type arguments to an Objective-C class type.
843 const auto *objcObjectType = type->getAs<ObjCObjectType>();
844 if (!objcObjectType || !objcObjectType->getInterface()) {
845 S.Diag(loc, diag::err_objc_type_args_non_class)
846 << type
847 << typeArgsRange;
848
849 if (failOnError)
850 return QualType();
851 return type;
852 }
853
854 // The class type must be parameterized.
855 ObjCInterfaceDecl *objcClass = objcObjectType->getInterface();
856 ObjCTypeParamList *typeParams = objcClass->getTypeParamList();
857 if (!typeParams) {
858 S.Diag(loc, diag::err_objc_type_args_non_parameterized_class)
859 << objcClass->getDeclName()
860 << FixItHint::CreateRemoval(typeArgsRange);
861
862 if (failOnError)
863 return QualType();
864
865 return type;
866 }
867
868 // The type must not already be specialized.
869 if (objcObjectType->isSpecialized()) {
870 S.Diag(loc, diag::err_objc_type_args_specialized_class)
871 << type
872 << FixItHint::CreateRemoval(typeArgsRange);
873
874 if (failOnError)
875 return QualType();
876
877 return type;
878 }
879
880 // Check the type arguments.
881 SmallVector<QualType, 4> finalTypeArgs;
882 unsigned numTypeParams = typeParams->size();
883 bool anyPackExpansions = false;
884 for (unsigned i = 0, n = typeArgs.size(); i != n; ++i) {
885 TypeSourceInfo *typeArgInfo = typeArgs[i];
886 QualType typeArg = typeArgInfo->getType();
887
888 // Type arguments cannot have explicit qualifiers or nullability.
889 // We ignore indirect sources of these, e.g. behind typedefs or
890 // template arguments.
891 if (TypeLoc qual = typeArgInfo->getTypeLoc().findExplicitQualifierLoc()) {
892 bool diagnosed = false;
893 SourceRange rangeToRemove;
894 if (auto attr = qual.getAs<AttributedTypeLoc>()) {
895 rangeToRemove = attr.getLocalSourceRange();
896 if (attr.getTypePtr()->getImmediateNullability()) {
897 typeArg = attr.getTypePtr()->getModifiedType();
898 S.Diag(attr.getBeginLoc(),
899 diag::err_objc_type_arg_explicit_nullability)
900 << typeArg << FixItHint::CreateRemoval(rangeToRemove);
901 diagnosed = true;
902 }
903 }
904
905 if (!diagnosed) {
906 S.Diag(qual.getBeginLoc(), diag::err_objc_type_arg_qualified)
907 << typeArg << typeArg.getQualifiers().getAsString()
908 << FixItHint::CreateRemoval(rangeToRemove);
909 }
910 }
911
912 // Remove qualifiers even if they're non-local.
913 typeArg = typeArg.getUnqualifiedType();
914
915 finalTypeArgs.push_back(typeArg);
916
917 if (typeArg->getAs<PackExpansionType>())
918 anyPackExpansions = true;
919
920 // Find the corresponding type parameter, if there is one.
921 ObjCTypeParamDecl *typeParam = nullptr;
922 if (!anyPackExpansions) {
923 if (i < numTypeParams) {
924 typeParam = typeParams->begin()[i];
925 } else {
926 // Too many arguments.
927 S.Diag(loc, diag::err_objc_type_args_wrong_arity)
928 << false
929 << objcClass->getDeclName()
930 << (unsigned)typeArgs.size()
931 << numTypeParams;
932 S.Diag(objcClass->getLocation(), diag::note_previous_decl)
933 << objcClass;
934
935 if (failOnError)
936 return QualType();
937
938 return type;
939 }
940 }
941
942 // Objective-C object pointer types must be substitutable for the bounds.
943 if (const auto *typeArgObjC = typeArg->getAs<ObjCObjectPointerType>()) {
944 // If we don't have a type parameter to match against, assume
945 // everything is fine. There was a prior pack expansion that
946 // means we won't be able to match anything.
947 if (!typeParam) {
948 assert(anyPackExpansions && "Too many arguments?")(static_cast<void> (0));
949 continue;
950 }
951
952 // Retrieve the bound.
953 QualType bound = typeParam->getUnderlyingType();
954 const auto *boundObjC = bound->getAs<ObjCObjectPointerType>();
955
956 // Determine whether the type argument is substitutable for the bound.
957 if (typeArgObjC->isObjCIdType()) {
958 // When the type argument is 'id', the only acceptable type
959 // parameter bound is 'id'.
960 if (boundObjC->isObjCIdType())
961 continue;
962 } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC)) {
963 // Otherwise, we follow the assignability rules.
964 continue;
965 }
966
967 // Diagnose the mismatch.
968 S.Diag(typeArgInfo->getTypeLoc().getBeginLoc(),
969 diag::err_objc_type_arg_does_not_match_bound)
970 << typeArg << bound << typeParam->getDeclName();
971 S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here)
972 << typeParam->getDeclName();
973
974 if (failOnError)
975 return QualType();
976
977 return type;
978 }
979
980 // Block pointer types are permitted for unqualified 'id' bounds.
981 if (typeArg->isBlockPointerType()) {
982 // If we don't have a type parameter to match against, assume
983 // everything is fine. There was a prior pack expansion that
984 // means we won't be able to match anything.
985 if (!typeParam) {
986 assert(anyPackExpansions && "Too many arguments?")(static_cast<void> (0));
987 continue;
988 }
989
990 // Retrieve the bound.
991 QualType bound = typeParam->getUnderlyingType();
992 if (bound->isBlockCompatibleObjCPointerType(S.Context))
993 continue;
994
995 // Diagnose the mismatch.
996 S.Diag(typeArgInfo->getTypeLoc().getBeginLoc(),
997 diag::err_objc_type_arg_does_not_match_bound)
998 << typeArg << bound << typeParam->getDeclName();
999 S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here)
1000 << typeParam->getDeclName();
1001
1002 if (failOnError)
1003 return QualType();
1004
1005 return type;
1006 }
1007
1008 // Dependent types will be checked at instantiation time.
1009 if (typeArg->isDependentType()) {
1010 continue;
1011 }
1012
1013 // Diagnose non-id-compatible type arguments.
1014 S.Diag(typeArgInfo->getTypeLoc().getBeginLoc(),
1015 diag::err_objc_type_arg_not_id_compatible)
1016 << typeArg << typeArgInfo->getTypeLoc().getSourceRange();
1017
1018 if (failOnError)
1019 return QualType();
1020
1021 return type;
1022 }
1023
1024 // Make sure we didn't have the wrong number of arguments.
1025 if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) {
1026 S.Diag(loc, diag::err_objc_type_args_wrong_arity)
1027 << (typeArgs.size() < typeParams->size())
1028 << objcClass->getDeclName()
1029 << (unsigned)finalTypeArgs.size()
1030 << (unsigned)numTypeParams;
1031 S.Diag(objcClass->getLocation(), diag::note_previous_decl)
1032 << objcClass;
1033
1034 if (failOnError)
1035 return QualType();
1036
1037 return type;
1038 }
1039
1040 // Success. Form the specialized type.
1041 return S.Context.getObjCObjectType(type, finalTypeArgs, { }, false);
1042}
1043
1044QualType Sema::BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
1045 SourceLocation ProtocolLAngleLoc,
1046 ArrayRef<ObjCProtocolDecl *> Protocols,
1047 ArrayRef<SourceLocation> ProtocolLocs,
1048 SourceLocation ProtocolRAngleLoc,
1049 bool FailOnError) {
1050 QualType Result = QualType(Decl->getTypeForDecl(), 0);
1051 if (!Protocols.empty()) {
1052 bool HasError;
1053 Result = Context.applyObjCProtocolQualifiers(Result, Protocols,
1054 HasError);
1055 if (HasError) {
1056 Diag(SourceLocation(), diag::err_invalid_protocol_qualifiers)
1057 << SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1058 if (FailOnError) Result = QualType();
1059 }
1060 if (FailOnError && Result.isNull())
1061 return QualType();
1062 }
1063
1064 return Result;
1065}
1066
1067QualType Sema::BuildObjCObjectType(QualType BaseType,
1068 SourceLocation Loc,
1069 SourceLocation TypeArgsLAngleLoc,
1070 ArrayRef<TypeSourceInfo *> TypeArgs,
1071 SourceLocation TypeArgsRAngleLoc,
1072 SourceLocation ProtocolLAngleLoc,
1073 ArrayRef<ObjCProtocolDecl *> Protocols,
1074 ArrayRef<SourceLocation> ProtocolLocs,
1075 SourceLocation ProtocolRAngleLoc,
1076 bool FailOnError) {
1077 QualType Result = BaseType;
1078 if (!TypeArgs.empty()) {
1079 Result = applyObjCTypeArgs(*this, Loc, Result, TypeArgs,
1080 SourceRange(TypeArgsLAngleLoc,
1081 TypeArgsRAngleLoc),
1082 FailOnError);
1083 if (FailOnError && Result.isNull())
1084 return QualType();
1085 }
1086
1087 if (!Protocols.empty()) {
1088 bool HasError;
1089 Result = Context.applyObjCProtocolQualifiers(Result, Protocols,
1090 HasError);
1091 if (HasError) {
1092 Diag(Loc, diag::err_invalid_protocol_qualifiers)
1093 << SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1094 if (FailOnError) Result = QualType();
1095 }
1096 if (FailOnError && Result.isNull())
1097 return QualType();
1098 }
1099
1100 return Result;
1101}
1102
1103TypeResult Sema::actOnObjCProtocolQualifierType(
1104 SourceLocation lAngleLoc,
1105 ArrayRef<Decl *> protocols,
1106 ArrayRef<SourceLocation> protocolLocs,
1107 SourceLocation rAngleLoc) {
1108 // Form id<protocol-list>.
1109 QualType Result = Context.getObjCObjectType(
1110 Context.ObjCBuiltinIdTy, { },
1111 llvm::makeArrayRef(
1112 (ObjCProtocolDecl * const *)protocols.data(),
1113 protocols.size()),
1114 false);
1115 Result = Context.getObjCObjectPointerType(Result);
1116
1117 TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
1118 TypeLoc ResultTL = ResultTInfo->getTypeLoc();
1119
1120 auto ObjCObjectPointerTL = ResultTL.castAs<ObjCObjectPointerTypeLoc>();
1121 ObjCObjectPointerTL.setStarLoc(SourceLocation()); // implicit
1122
1123 auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc()
1124 .castAs<ObjCObjectTypeLoc>();
1125 ObjCObjectTL.setHasBaseTypeAsWritten(false);
1126 ObjCObjectTL.getBaseLoc().initialize(Context, SourceLocation());
1127
1128 // No type arguments.
1129 ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation());
1130 ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation());
1131
1132 // Fill in protocol qualifiers.
1133 ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc);
1134 ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc);
1135 for (unsigned i = 0, n = protocols.size(); i != n; ++i)
1136 ObjCObjectTL.setProtocolLoc(i, protocolLocs[i]);
1137
1138 // We're done. Return the completed type to the parser.
1139 return CreateParsedType(Result, ResultTInfo);
1140}
1141
1142TypeResult Sema::actOnObjCTypeArgsAndProtocolQualifiers(
1143 Scope *S,
1144 SourceLocation Loc,
1145 ParsedType BaseType,
1146 SourceLocation TypeArgsLAngleLoc,
1147 ArrayRef<ParsedType> TypeArgs,
1148 SourceLocation TypeArgsRAngleLoc,
1149 SourceLocation ProtocolLAngleLoc,
1150 ArrayRef<Decl *> Protocols,
1151 ArrayRef<SourceLocation> ProtocolLocs,
1152 SourceLocation ProtocolRAngleLoc) {
1153 TypeSourceInfo *BaseTypeInfo = nullptr;
1154 QualType T = GetTypeFromParser(BaseType, &BaseTypeInfo);
1155 if (T.isNull())
1156 return true;
1157
1158 // Handle missing type-source info.
1159 if (!BaseTypeInfo)
1160 BaseTypeInfo = Context.getTrivialTypeSourceInfo(T, Loc);
1161
1162 // Extract type arguments.
1163 SmallVector<TypeSourceInfo *, 4> ActualTypeArgInfos;
1164 for (unsigned i = 0, n = TypeArgs.size(); i != n; ++i) {
1165 TypeSourceInfo *TypeArgInfo = nullptr;
1166 QualType TypeArg = GetTypeFromParser(TypeArgs[i], &TypeArgInfo);
1167 if (TypeArg.isNull()) {
1168 ActualTypeArgInfos.clear();
1169 break;
1170 }
1171
1172 assert(TypeArgInfo && "No type source info?")(static_cast<void> (0));
1173 ActualTypeArgInfos.push_back(TypeArgInfo);
1174 }
1175
1176 // Build the object type.
1177 QualType Result = BuildObjCObjectType(
1178 T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(),
1179 TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
1180 ProtocolLAngleLoc,
1181 llvm::makeArrayRef((ObjCProtocolDecl * const *)Protocols.data(),
1182 Protocols.size()),
1183 ProtocolLocs, ProtocolRAngleLoc,
1184 /*FailOnError=*/false);
1185
1186 if (Result == T)
1187 return BaseType;
1188
1189 // Create source information for this type.
1190 TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
1191 TypeLoc ResultTL = ResultTInfo->getTypeLoc();
1192
1193 // For id<Proto1, Proto2> or Class<Proto1, Proto2>, we'll have an
1194 // object pointer type. Fill in source information for it.
1195 if (auto ObjCObjectPointerTL = ResultTL.getAs<ObjCObjectPointerTypeLoc>()) {
1196 // The '*' is implicit.
1197 ObjCObjectPointerTL.setStarLoc(SourceLocation());
1198 ResultTL = ObjCObjectPointerTL.getPointeeLoc();
1199 }
1200
1201 if (auto OTPTL = ResultTL.getAs<ObjCTypeParamTypeLoc>()) {
1202 // Protocol qualifier information.
1203 if (OTPTL.getNumProtocols() > 0) {
1204 assert(OTPTL.getNumProtocols() == Protocols.size())(static_cast<void> (0));
1205 OTPTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1206 OTPTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1207 for (unsigned i = 0, n = Protocols.size(); i != n; ++i)
1208 OTPTL.setProtocolLoc(i, ProtocolLocs[i]);
1209 }
1210
1211 // We're done. Return the completed type to the parser.
1212 return CreateParsedType(Result, ResultTInfo);
1213 }
1214
1215 auto ObjCObjectTL = ResultTL.castAs<ObjCObjectTypeLoc>();
1216
1217 // Type argument information.
1218 if (ObjCObjectTL.getNumTypeArgs() > 0) {
1219 assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size())(static_cast<void> (0));
1220 ObjCObjectTL.setTypeArgsLAngleLoc(TypeArgsLAngleLoc);
1221 ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc);
1222 for (unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i)
1223 ObjCObjectTL.setTypeArgTInfo(i, ActualTypeArgInfos[i]);
1224 } else {
1225 ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation());
1226 ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation());
1227 }
1228
1229 // Protocol qualifier information.
1230 if (ObjCObjectTL.getNumProtocols() > 0) {
1231 assert(ObjCObjectTL.getNumProtocols() == Protocols.size())(static_cast<void> (0));
1232 ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1233 ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1234 for (unsigned i = 0, n = Protocols.size(); i != n; ++i)
1235 ObjCObjectTL.setProtocolLoc(i, ProtocolLocs[i]);
1236 } else {
1237 ObjCObjectTL.setProtocolLAngleLoc(SourceLocation());
1238 ObjCObjectTL.setProtocolRAngleLoc(SourceLocation());
1239 }
1240
1241 // Base type.
1242 ObjCObjectTL.setHasBaseTypeAsWritten(true);
1243 if (ObjCObjectTL.getType() == T)
1244 ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->getTypeLoc());
1245 else
1246 ObjCObjectTL.getBaseLoc().initialize(Context, Loc);
1247
1248 // We're done. Return the completed type to the parser.
1249 return CreateParsedType(Result, ResultTInfo);
1250}
1251
1252static OpenCLAccessAttr::Spelling
1253getImageAccess(const ParsedAttributesView &Attrs) {
1254 for (const ParsedAttr &AL : Attrs)
1255 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
1256 return static_cast<OpenCLAccessAttr::Spelling>(AL.getSemanticSpelling());
1257 return OpenCLAccessAttr::Keyword_read_only;
1258}
1259
1260/// Convert the specified declspec to the appropriate type
1261/// object.
1262/// \param state Specifies the declarator containing the declaration specifier
1263/// to be converted, along with other associated processing state.
1264/// \returns The type described by the declaration specifiers. This function
1265/// never returns null.
1266static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
1267 // FIXME: Should move the logic from DeclSpec::Finish to here for validity
1268 // checking.
1269
1270 Sema &S = state.getSema();
1271 Declarator &declarator = state.getDeclarator();
1272 DeclSpec &DS = declarator.getMutableDeclSpec();
1273 SourceLocation DeclLoc = declarator.getIdentifierLoc();
1274 if (DeclLoc.isInvalid())
1275 DeclLoc = DS.getBeginLoc();
1276
1277 ASTContext &Context = S.Context;
1278
1279 QualType Result;
1280 switch (DS.getTypeSpecType()) {
1281 case DeclSpec::TST_void:
1282 Result = Context.VoidTy;
1283 break;
1284 case DeclSpec::TST_char:
1285 if (DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified)
1286 Result = Context.CharTy;
1287 else if (DS.getTypeSpecSign() == TypeSpecifierSign::Signed)
1288 Result = Context.SignedCharTy;
1289 else {
1290 assert(DS.getTypeSpecSign() == TypeSpecifierSign::Unsigned &&(static_cast<void> (0))
1291 "Unknown TSS value")(static_cast<void> (0));
1292 Result = Context.UnsignedCharTy;
1293 }
1294 break;
1295 case DeclSpec::TST_wchar:
1296 if (DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified)
1297 Result = Context.WCharTy;
1298 else if (DS.getTypeSpecSign() == TypeSpecifierSign::Signed) {
1299 S.Diag(DS.getTypeSpecSignLoc(), diag::ext_wchar_t_sign_spec)
1300 << DS.getSpecifierName(DS.getTypeSpecType(),
1301 Context.getPrintingPolicy());
1302 Result = Context.getSignedWCharType();
1303 } else {
1304 assert(DS.getTypeSpecSign() == TypeSpecifierSign::Unsigned &&(static_cast<void> (0))
1305 "Unknown TSS value")(static_cast<void> (0));
1306 S.Diag(DS.getTypeSpecSignLoc(), diag::ext_wchar_t_sign_spec)
1307 << DS.getSpecifierName(DS.getTypeSpecType(),
1308 Context.getPrintingPolicy());
1309 Result = Context.getUnsignedWCharType();
1310 }
1311 break;
1312 case DeclSpec::TST_char8:
1313 assert(DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&(static_cast<void> (0))
1314 "Unknown TSS value")(static_cast<void> (0));
1315 Result = Context.Char8Ty;
1316 break;
1317 case DeclSpec::TST_char16:
1318 assert(DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&(static_cast<void> (0))
1319 "Unknown TSS value")(static_cast<void> (0));
1320 Result = Context.Char16Ty;
1321 break;
1322 case DeclSpec::TST_char32:
1323 assert(DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&(static_cast<void> (0))
1324 "Unknown TSS value")(static_cast<void> (0));
1325 Result = Context.Char32Ty;
1326 break;
1327 case DeclSpec::TST_unspecified:
1328 // If this is a missing declspec in a block literal return context, then it
1329 // is inferred from the return statements inside the block.
1330 // The declspec is always missing in a lambda expr context; it is either
1331 // specified with a trailing return type or inferred.
1332 if (S.getLangOpts().CPlusPlus14 &&
1333 declarator.getContext() == DeclaratorContext::LambdaExpr) {
1334 // In C++1y, a lambda's implicit return type is 'auto'.
1335 Result = Context.getAutoDeductType();
1336 break;
1337 } else if (declarator.getContext() == DeclaratorContext::LambdaExpr ||
1338 checkOmittedBlockReturnType(S, declarator,
1339 Context.DependentTy)) {
1340 Result = Context.DependentTy;
1341 break;
1342 }
1343
1344 // Unspecified typespec defaults to int in C90. However, the C90 grammar
1345 // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
1346 // type-qualifier, or storage-class-specifier. If not, emit an extwarn.
1347 // Note that the one exception to this is function definitions, which are
1348 // allowed to be completely missing a declspec. This is handled in the
1349 // parser already though by it pretending to have seen an 'int' in this
1350 // case.
1351 if (S.getLangOpts().ImplicitInt) {
1352 // In C89 mode, we only warn if there is a completely missing declspec
1353 // when one is not allowed.
1354 if (DS.isEmpty()) {
1355 S.Diag(DeclLoc, diag::ext_missing_declspec)
1356 << DS.getSourceRange()
1357 << FixItHint::CreateInsertion(DS.getBeginLoc(), "int");
1358 }
1359 } else if (!DS.hasTypeSpecifier()) {
1360 // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says:
1361 // "At least one type specifier shall be given in the declaration
1362 // specifiers in each declaration, and in the specifier-qualifier list in
1363 // each struct declaration and type name."
1364 if (S.getLangOpts().CPlusPlus && !DS.isTypeSpecPipe()) {
1365 S.Diag(DeclLoc, diag::err_missing_type_specifier)
1366 << DS.getSourceRange();
1367
1368 // When this occurs in C++ code, often something is very broken with the
1369 // value being declared, poison it as invalid so we don't get chains of
1370 // errors.
1371 declarator.setInvalidType(true);
1372 } else if (S.getLangOpts().getOpenCLCompatibleVersion() >= 200 &&
1373 DS.isTypeSpecPipe()) {
1374 S.Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1375 << DS.getSourceRange();
1376 declarator.setInvalidType(true);
1377 } else {
1378 S.Diag(DeclLoc, diag::ext_missing_type_specifier)
1379 << DS.getSourceRange();
1380 }
1381 }
1382
1383 LLVM_FALLTHROUGH[[gnu::fallthrough]];
1384 case DeclSpec::TST_int: {
1385 if (DS.getTypeSpecSign() != TypeSpecifierSign::Unsigned) {
1386 switch (DS.getTypeSpecWidth()) {
1387 case TypeSpecifierWidth::Unspecified:
1388 Result = Context.IntTy;
1389 break;
1390 case TypeSpecifierWidth::Short:
1391 Result = Context.ShortTy;
1392 break;
1393 case TypeSpecifierWidth::Long:
1394 Result = Context.LongTy;
1395 break;
1396 case TypeSpecifierWidth::LongLong:
1397 Result = Context.LongLongTy;
1398
1399 // 'long long' is a C99 or C++11 feature.
1400 if (!S.getLangOpts().C99) {
1401 if (S.getLangOpts().CPlusPlus)
1402 S.Diag(DS.getTypeSpecWidthLoc(),
1403 S.getLangOpts().CPlusPlus11 ?
1404 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1405 else
1406 S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
1407 }
1408 break;
1409 }
1410 } else {
1411 switch (DS.getTypeSpecWidth()) {
1412 case TypeSpecifierWidth::Unspecified:
1413 Result = Context.UnsignedIntTy;
1414 break;
1415 case TypeSpecifierWidth::Short:
1416 Result = Context.UnsignedShortTy;
1417 break;
1418 case TypeSpecifierWidth::Long:
1419 Result = Context.UnsignedLongTy;
1420 break;
1421 case TypeSpecifierWidth::LongLong:
1422 Result = Context.UnsignedLongLongTy;
1423
1424 // 'long long' is a C99 or C++11 feature.
1425 if (!S.getLangOpts().C99) {
1426 if (S.getLangOpts().CPlusPlus)
1427 S.Diag(DS.getTypeSpecWidthLoc(),
1428 S.getLangOpts().CPlusPlus11 ?
1429 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1430 else
1431 S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
1432 }
1433 break;
1434 }
1435 }
1436 break;
1437 }
1438 case DeclSpec::TST_extint: {
1439 if (!S.Context.getTargetInfo().hasExtIntType())
1440 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1441 << "_ExtInt";
1442 Result =
1443 S.BuildExtIntType(DS.getTypeSpecSign() == TypeSpecifierSign::Unsigned,
1444 DS.getRepAsExpr(), DS.getBeginLoc());
1445 if (Result.isNull()) {
1446 Result = Context.IntTy;
1447 declarator.setInvalidType(true);
1448 }
1449 break;
1450 }
1451 case DeclSpec::TST_accum: {
1452 switch (DS.getTypeSpecWidth()) {
1453 case TypeSpecifierWidth::Short:
1454 Result = Context.ShortAccumTy;
1455 break;
1456 case TypeSpecifierWidth::Unspecified:
1457 Result = Context.AccumTy;
1458 break;
1459 case TypeSpecifierWidth::Long:
1460 Result = Context.LongAccumTy;
1461 break;
1462 case TypeSpecifierWidth::LongLong:
1463 llvm_unreachable("Unable to specify long long as _Accum width")__builtin_unreachable();
1464 }
1465
1466 if (DS.getTypeSpecSign() == TypeSpecifierSign::Unsigned)
1467 Result = Context.getCorrespondingUnsignedType(Result);
1468
1469 if (DS.isTypeSpecSat())
1470 Result = Context.getCorrespondingSaturatedType(Result);
1471
1472 break;
1473 }
1474 case DeclSpec::TST_fract: {
1475 switch (DS.getTypeSpecWidth()) {
1476 case TypeSpecifierWidth::Short:
1477 Result = Context.ShortFractTy;
1478 break;
1479 case TypeSpecifierWidth::Unspecified:
1480 Result = Context.FractTy;
1481 break;
1482 case TypeSpecifierWidth::Long:
1483 Result = Context.LongFractTy;
1484 break;
1485 case TypeSpecifierWidth::LongLong:
1486 llvm_unreachable("Unable to specify long long as _Fract width")__builtin_unreachable();
1487 }
1488
1489 if (DS.getTypeSpecSign() == TypeSpecifierSign::Unsigned)
1490 Result = Context.getCorrespondingUnsignedType(Result);
1491
1492 if (DS.isTypeSpecSat())
1493 Result = Context.getCorrespondingSaturatedType(Result);
1494
1495 break;
1496 }
1497 case DeclSpec::TST_int128:
1498 if (!S.Context.getTargetInfo().hasInt128Type() &&
1499 !S.getLangOpts().SYCLIsDevice &&
1500 !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
1501 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1502 << "__int128";
1503 if (DS.getTypeSpecSign() == TypeSpecifierSign::Unsigned)
1504 Result = Context.UnsignedInt128Ty;
1505 else
1506 Result = Context.Int128Ty;
1507 break;
1508 case DeclSpec::TST_float16:
1509 // CUDA host and device may have different _Float16 support, therefore
1510 // do not diagnose _Float16 usage to avoid false alarm.
1511 // ToDo: more precise diagnostics for CUDA.
1512 if (!S.Context.getTargetInfo().hasFloat16Type() && !S.getLangOpts().CUDA &&
1513 !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
1514 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1515 << "_Float16";
1516 Result = Context.Float16Ty;
1517 break;
1518 case DeclSpec::TST_half: Result = Context.HalfTy; break;
1519 case DeclSpec::TST_BFloat16:
1520 if (!S.Context.getTargetInfo().hasBFloat16Type())
1521 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1522 << "__bf16";
1523 Result = Context.BFloat16Ty;
1524 break;
1525 case DeclSpec::TST_float: Result = Context.FloatTy; break;
1526 case DeclSpec::TST_double:
1527 if (DS.getTypeSpecWidth() == TypeSpecifierWidth::Long)
1528 Result = Context.LongDoubleTy;
1529 else
1530 Result = Context.DoubleTy;
1531 if (S.getLangOpts().OpenCL) {
1532 if (!S.getOpenCLOptions().isSupported("cl_khr_fp64", S.getLangOpts()))
1533 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_opencl_requires_extension)
1534 << 0 << Result
1535 << (S.getLangOpts().getOpenCLCompatibleVersion() == 300
1536 ? "cl_khr_fp64 and __opencl_c_fp64"
1537 : "cl_khr_fp64");
1538 else if (!S.getOpenCLOptions().isAvailableOption("cl_khr_fp64", S.getLangOpts()))
1539 S.Diag(DS.getTypeSpecTypeLoc(), diag::ext_opencl_double_without_pragma);
1540 }
1541 break;
1542 case DeclSpec::TST_float128:
1543 if (!S.Context.getTargetInfo().hasFloat128Type() &&
1544 !S.getLangOpts().SYCLIsDevice &&
1545 !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
1546 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1547 << "__float128";
1548 Result = Context.Float128Ty;
1549 break;
1550 case DeclSpec::TST_bool:
1551 Result = Context.BoolTy; // _Bool or bool
1552 break;
1553 case DeclSpec::TST_decimal32: // _Decimal32
1554 case DeclSpec::TST_decimal64: // _Decimal64
1555 case DeclSpec::TST_decimal128: // _Decimal128
1556 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported);
1557 Result = Context.IntTy;
1558 declarator.setInvalidType(true);
1559 break;
1560 case DeclSpec::TST_class:
1561 case DeclSpec::TST_enum:
1562 case DeclSpec::TST_union:
1563 case DeclSpec::TST_struct:
1564 case DeclSpec::TST_interface: {
1565 TagDecl *D = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl());
1566 if (!D) {
1567 // This can happen in C++ with ambiguous lookups.
1568 Result = Context.IntTy;
1569 declarator.setInvalidType(true);
1570 break;
1571 }
1572
1573 // If the type is deprecated or unavailable, diagnose it.
1574 S.DiagnoseUseOfDecl(D, DS.getTypeSpecTypeNameLoc());
1575
1576 assert(DS.getTypeSpecWidth() == TypeSpecifierWidth::Unspecified &&(static_cast<void> (0))
1577 DS.getTypeSpecComplex() == 0 &&(static_cast<void> (0))
1578 DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&(static_cast<void> (0))
1579 "No qualifiers on tag names!")(static_cast<void> (0));
1580
1581 // TypeQuals handled by caller.
1582 Result = Context.getTypeDeclType(D);
1583
1584 // In both C and C++, make an ElaboratedType.
1585 ElaboratedTypeKeyword Keyword
1586 = ElaboratedType::getKeywordForTypeSpec(DS.getTypeSpecType());
1587 Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result,
1588 DS.isTypeSpecOwned() ? D : nullptr);
1589 break;
1590 }
1591 case DeclSpec::TST_typename: {
1592 assert(DS.getTypeSpecWidth() == TypeSpecifierWidth::Unspecified &&(static_cast<void> (0))
1593 DS.getTypeSpecComplex() == 0 &&(static_cast<void> (0))
1594 DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&(static_cast<void> (0))
1595 "Can't handle qualifiers on typedef names yet!")(static_cast<void> (0));
1596 Result = S.GetTypeFromParser(DS.getRepAsType());
1597 if (Result.isNull()) {
1598 declarator.setInvalidType(true);
1599 }
1600
1601 // TypeQuals handled by caller.
1602 break;
1603 }
1604 case DeclSpec::TST_typeofType:
1605 // FIXME: Preserve type source info.
1606 Result = S.GetTypeFromParser(DS.getRepAsType());
1607 assert(!Result.isNull() && "Didn't get a type for typeof?")(static_cast<void> (0));
1608 if (!Result->isDependentType())
1609 if (const TagType *TT = Result->getAs<TagType>())
1610 S.DiagnoseUseOfDecl(TT->getDecl(), DS.getTypeSpecTypeLoc());
1611 // TypeQuals handled by caller.
1612 Result = Context.getTypeOfType(Result);
1613 break;
1614 case DeclSpec::TST_typeofExpr: {
1615 Expr *E = DS.getRepAsExpr();
1616 assert(E && "Didn't get an expression for typeof?")(static_cast<void> (0));
1617 // TypeQuals handled by caller.
1618 Result = S.BuildTypeofExprType(E, DS.getTypeSpecTypeLoc());
1619 if (Result.isNull()) {
1620 Result = Context.IntTy;
1621 declarator.setInvalidType(true);
1622 }
1623 break;
1624 }
1625 case DeclSpec::TST_decltype: {
1626 Expr *E = DS.getRepAsExpr();
1627 assert(E && "Didn't get an expression for decltype?")(static_cast<void> (0));
1628 // TypeQuals handled by caller.
1629 Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc());
1630 if (Result.isNull()) {
1631 Result = Context.IntTy;
1632 declarator.setInvalidType(true);
1633 }
1634 break;
1635 }
1636 case DeclSpec::TST_underlyingType:
1637 Result = S.GetTypeFromParser(DS.getRepAsType());
1638 assert(!Result.isNull() && "Didn't get a type for __underlying_type?")(static_cast<void> (0));
1639 Result = S.BuildUnaryTransformType(Result,
1640 UnaryTransformType::EnumUnderlyingType,
1641 DS.getTypeSpecTypeLoc());
1642 if (Result.isNull()) {
1643 Result = Context.IntTy;
1644 declarator.setInvalidType(true);
1645 }
1646 break;
1647
1648 case DeclSpec::TST_auto:
1649 case DeclSpec::TST_decltype_auto: {
1650 auto AutoKW = DS.getTypeSpecType() == DeclSpec::TST_decltype_auto
1651 ? AutoTypeKeyword::DecltypeAuto
1652 : AutoTypeKeyword::Auto;
1653
1654 ConceptDecl *TypeConstraintConcept = nullptr;
1655 llvm::SmallVector<TemplateArgument, 8> TemplateArgs;
1656 if (DS.isConstrainedAuto()) {
1657 if (TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId()) {
1658 TypeConstraintConcept =
1659 cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());
1660 TemplateArgumentListInfo TemplateArgsInfo;
1661 TemplateArgsInfo.setLAngleLoc(TemplateId->LAngleLoc);
1662 TemplateArgsInfo.setRAngleLoc(TemplateId->RAngleLoc);
1663 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
1664 TemplateId->NumArgs);
1665 S.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
1666 for (const auto &ArgLoc : TemplateArgsInfo.arguments())
1667 TemplateArgs.push_back(ArgLoc.getArgument());
1668 } else {
1669 declarator.setInvalidType(true);
1670 }
1671 }
1672 Result = S.Context.getAutoType(QualType(), AutoKW,
1673 /*IsDependent*/ false, /*IsPack=*/false,
1674 TypeConstraintConcept, TemplateArgs);
1675 break;
1676 }
1677
1678 case DeclSpec::TST_auto_type:
1679 Result = Context.getAutoType(QualType(), AutoTypeKeyword::GNUAutoType, false);
1680 break;
1681
1682 case DeclSpec::TST_unknown_anytype:
1683 Result = Context.UnknownAnyTy;
1684 break;
1685
1686 case DeclSpec::TST_atomic:
1687 Result = S.GetTypeFromParser(DS.getRepAsType());
1688 assert(!Result.isNull() && "Didn't get a type for _Atomic?")(static_cast<void> (0));
1689 Result = S.BuildAtomicType(Result, DS.getTypeSpecTypeLoc());
1690 if (Result.isNull()) {
1691 Result = Context.IntTy;
1692 declarator.setInvalidType(true);
1693 }
1694 break;
1695
1696#define GENERIC_IMAGE_TYPE(ImgType, Id) \
1697 case DeclSpec::TST_##ImgType##_t: \
1698 switch (getImageAccess(DS.getAttributes())) { \
1699 case OpenCLAccessAttr::Keyword_write_only: \
1700 Result = Context.Id##WOTy; \
1701 break; \
1702 case OpenCLAccessAttr::Keyword_read_write: \
1703 Result = Context.Id##RWTy; \
1704 break; \
1705 case OpenCLAccessAttr::Keyword_read_only: \
1706 Result = Context.Id##ROTy; \
1707 break; \
1708 case OpenCLAccessAttr::SpellingNotCalculated: \
1709 llvm_unreachable("Spelling not yet calculated")__builtin_unreachable(); \
1710 } \
1711 break;
1712#include "clang/Basic/OpenCLImageTypes.def"
1713
1714 case DeclSpec::TST_error:
1715 Result = Context.IntTy;
1716 declarator.setInvalidType(true);
1717 break;
1718 }
1719
1720 // FIXME: we want resulting declarations to be marked invalid, but claiming
1721 // the type is invalid is too strong - e.g. it causes ActOnTypeName to return
1722 // a null type.
1723 if (Result->containsErrors())
1724 declarator.setInvalidType();
1725
1726 if (S.getLangOpts().OpenCL) {
1727 const auto &OpenCLOptions = S.getOpenCLOptions();
1728 bool IsOpenCLC30 = (S.getLangOpts().OpenCLVersion == 300);
1729 // OpenCL C v3.0 s6.3.3 - OpenCL image types require __opencl_c_images
1730 // support.
1731 // OpenCL C v3.0 s6.2.1 - OpenCL 3d image write types requires support
1732 // for OpenCL C 2.0, or OpenCL C 3.0 or newer and the
1733 // __opencl_c_3d_image_writes feature. OpenCL C v3.0 API s4.2 - For devices
1734 // that support OpenCL 3.0, cl_khr_3d_image_writes must be returned when and
1735 // only when the optional feature is supported
1736 if ((Result->isImageType() || Result->isSamplerT()) &&
1737 (IsOpenCLC30 &&
1738 !OpenCLOptions.isSupported("__opencl_c_images", S.getLangOpts()))) {
1739 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_opencl_requires_extension)
1740 << 0 << Result << "__opencl_c_images";
1741 declarator.setInvalidType();
1742 } else if (Result->isOCLImage3dWOType() &&
1743 !OpenCLOptions.isSupported("cl_khr_3d_image_writes",
1744 S.getLangOpts())) {
1745 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_opencl_requires_extension)
1746 << 0 << Result
1747 << (IsOpenCLC30
1748 ? "cl_khr_3d_image_writes and __opencl_c_3d_image_writes"
1749 : "cl_khr_3d_image_writes");
1750 declarator.setInvalidType();
1751 }
1752 }
1753
1754 bool IsFixedPointType = DS.getTypeSpecType() == DeclSpec::TST_accum ||
1755 DS.getTypeSpecType() == DeclSpec::TST_fract;
1756
1757 // Only fixed point types can be saturated
1758 if (DS.isTypeSpecSat() && !IsFixedPointType)
1759 S.Diag(DS.getTypeSpecSatLoc(), diag::err_invalid_saturation_spec)
1760 << DS.getSpecifierName(DS.getTypeSpecType(),
1761 Context.getPrintingPolicy());
1762
1763 // Handle complex types.
1764 if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) {
1765 if (S.getLangOpts().Freestanding)
1766 S.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
1767 Result = Context.getComplexType(Result);
1768 } else if (DS.isTypeAltiVecVector()) {
1769 unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(Result));
1770 assert(typeSize > 0 && "type size for vector must be greater than 0 bits")(static_cast<void> (0));
1771 VectorType::VectorKind VecKind = VectorType::AltiVecVector;
1772 if (DS.isTypeAltiVecPixel())
1773 VecKind = VectorType::AltiVecPixel;
1774 else if (DS.isTypeAltiVecBool())
1775 VecKind = VectorType::AltiVecBool;
1776 Result = Context.getVectorType(Result, 128/typeSize, VecKind);
1777 }
1778
1779 // FIXME: Imaginary.
1780 if (DS.getTypeSpecComplex() == DeclSpec::TSC_imaginary)
1781 S.Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported);
1782
1783 // Before we process any type attributes, synthesize a block literal
1784 // function declarator if necessary.
1785 if (declarator.getContext() == DeclaratorContext::BlockLiteral)
1786 maybeSynthesizeBlockSignature(state, Result);
1787
1788 // Apply any type attributes from the decl spec. This may cause the
1789 // list of type attributes to be temporarily saved while the type
1790 // attributes are pushed around.
1791 // pipe attributes will be handled later ( at GetFullTypeForDeclarator )
1792 if (!DS.isTypeSpecPipe())
1793 processTypeAttrs(state, Result, TAL_DeclSpec, DS.getAttributes());
1794
1795 // Apply const/volatile/restrict qualifiers to T.
1796 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
1797 // Warn about CV qualifiers on function types.
1798 // C99 6.7.3p8:
1799 // If the specification of a function type includes any type qualifiers,
1800 // the behavior is undefined.
1801 // C++11 [dcl.fct]p7:
1802 // The effect of a cv-qualifier-seq in a function declarator is not the
1803 // same as adding cv-qualification on top of the function type. In the
1804 // latter case, the cv-qualifiers are ignored.
1805 if (Result->isFunctionType()) {
1806 diagnoseAndRemoveTypeQualifiers(
1807 S, DS, TypeQuals, Result, DeclSpec::TQ_const | DeclSpec::TQ_volatile,
1808 S.getLangOpts().CPlusPlus
1809 ? diag::warn_typecheck_function_qualifiers_ignored
1810 : diag::warn_typecheck_function_qualifiers_unspecified);
1811 // No diagnostic for 'restrict' or '_Atomic' applied to a
1812 // function type; we'll diagnose those later, in BuildQualifiedType.
1813 }
1814
1815 // C++11 [dcl.ref]p1:
1816 // Cv-qualified references are ill-formed except when the
1817 // cv-qualifiers are introduced through the use of a typedef-name
1818 // or decltype-specifier, in which case the cv-qualifiers are ignored.
1819 //
1820 // There don't appear to be any other contexts in which a cv-qualified
1821 // reference type could be formed, so the 'ill-formed' clause here appears
1822 // to never happen.
1823 if (TypeQuals && Result->isReferenceType()) {
1824 diagnoseAndRemoveTypeQualifiers(
1825 S, DS, TypeQuals, Result,
1826 DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_atomic,
1827 diag::warn_typecheck_reference_qualifiers);
1828 }
1829
1830 // C90 6.5.3 constraints: "The same type qualifier shall not appear more
1831 // than once in the same specifier-list or qualifier-list, either directly
1832 // or via one or more typedefs."
1833 if (!S.getLangOpts().C99 && !S.getLangOpts().CPlusPlus
1834 && TypeQuals & Result.getCVRQualifiers()) {
1835 if (TypeQuals & DeclSpec::TQ_const && Result.isConstQualified()) {
1836 S.Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec)
1837 << "const";
1838 }
1839
1840 if (TypeQuals & DeclSpec::TQ_volatile && Result.isVolatileQualified()) {
1841 S.Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec)
1842 << "volatile";
1843 }
1844
1845 // C90 doesn't have restrict nor _Atomic, so it doesn't force us to
1846 // produce a warning in this case.
1847 }
1848
1849 QualType Qualified = S.BuildQualifiedType(Result, DeclLoc, TypeQuals, &DS);
1850
1851 // If adding qualifiers fails, just use the unqualified type.
1852 if (Qualified.isNull())
1853 declarator.setInvalidType(true);
1854 else
1855 Result = Qualified;
1856 }
1857
1858 assert(!Result.isNull() && "This function should not return a null type")(static_cast<void> (0));
1859 return Result;
1860}
1861
1862static std::string getPrintableNameForEntity(DeclarationName Entity) {
1863 if (Entity)
1864 return Entity.getAsString();
1865
1866 return "type name";
1867}
1868
1869QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc,
1870 Qualifiers Qs, const DeclSpec *DS) {
1871 if (T.isNull())
1872 return QualType();
1873
1874 // Ignore any attempt to form a cv-qualified reference.
1875 if (T->isReferenceType()) {
1876 Qs.removeConst();
1877 Qs.removeVolatile();
1878 }
1879
1880 // Enforce C99 6.7.3p2: "Types other than pointer types derived from
1881 // object or incomplete types shall not be restrict-qualified."
1882 if (Qs.hasRestrict()) {
1883 unsigned DiagID = 0;
1884 QualType ProblemTy;
1885
1886 if (T->isAnyPointerType() || T->isReferenceType() ||
1887 T->isMemberPointerType()) {
1888 QualType EltTy;
1889 if (T->isObjCObjectPointerType())
1890 EltTy = T;
1891 else if (const MemberPointerType *PTy = T->getAs<MemberPointerType>())
1892 EltTy = PTy->getPointeeType();
1893 else
1894 EltTy = T->getPointeeType();
1895
1896 // If we have a pointer or reference, the pointee must have an object
1897 // incomplete type.
1898 if (!EltTy->isIncompleteOrObjectType()) {
1899 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1900 ProblemTy = EltTy;
1901 }
1902 } else if (!T->isDependentType()) {
1903 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1904 ProblemTy = T;
1905 }
1906
1907 if (DiagID) {
1908 Diag(DS ? DS->getRestrictSpecLoc() : Loc, DiagID) << ProblemTy;
1909 Qs.removeRestrict();
1910 }
1911 }
1912
1913 return Context.getQualifiedType(T, Qs);
1914}
1915
1916QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc,
1917 unsigned CVRAU, const DeclSpec *DS) {
1918 if (T.isNull())
1919 return QualType();
1920
1921 // Ignore any attempt to form a cv-qualified reference.
1922 if (T->isReferenceType())
1923 CVRAU &=
1924 ~(DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_atomic);
1925
1926 // Convert from DeclSpec::TQ to Qualifiers::TQ by just dropping TQ_atomic and
1927 // TQ_unaligned;
1928 unsigned CVR = CVRAU & ~(DeclSpec::TQ_atomic | DeclSpec::TQ_unaligned);
1929
1930 // C11 6.7.3/5:
1931 // If the same qualifier appears more than once in the same
1932 // specifier-qualifier-list, either directly or via one or more typedefs,
1933 // the behavior is the same as if it appeared only once.
1934 //
1935 // It's not specified what happens when the _Atomic qualifier is applied to
1936 // a type specified with the _Atomic specifier, but we assume that this
1937 // should be treated as if the _Atomic qualifier appeared multiple times.
1938 if (CVRAU & DeclSpec::TQ_atomic && !T->isAtomicType()) {
1939 // C11 6.7.3/5:
1940 // If other qualifiers appear along with the _Atomic qualifier in a
1941 // specifier-qualifier-list, the resulting type is the so-qualified
1942 // atomic type.
1943 //
1944 // Don't need to worry about array types here, since _Atomic can't be
1945 // applied to such types.
1946 SplitQualType Split = T.getSplitUnqualifiedType();
1947 T = BuildAtomicType(QualType(Split.Ty, 0),
1948 DS ? DS->getAtomicSpecLoc() : Loc);
1949 if (T.isNull())
1950 return T;
1951 Split.Quals.addCVRQualifiers(CVR);
1952 return BuildQualifiedType(T, Loc, Split.Quals);
1953 }
1954
1955 Qualifiers Q = Qualifiers::fromCVRMask(CVR);
1956 Q.setUnaligned(CVRAU & DeclSpec::TQ_unaligned);
1957 return BuildQualifiedType(T, Loc, Q, DS);
1958}
1959
1960/// Build a paren type including \p T.
1961QualType Sema::BuildParenType(QualType T) {
1962 return Context.getParenType(T);
1963}
1964
1965/// Given that we're building a pointer or reference to the given
1966static QualType inferARCLifetimeForPointee(Sema &S, QualType type,
1967 SourceLocation loc,
1968 bool isReference) {
1969 // Bail out if retention is unrequired or already specified.
1970 if (!type->isObjCLifetimeType() ||
1971 type.getObjCLifetime() != Qualifiers::OCL_None)
1972 return type;
1973
1974 Qualifiers::ObjCLifetime implicitLifetime = Qualifiers::OCL_None;
1975
1976 // If the object type is const-qualified, we can safely use
1977 // __unsafe_unretained. This is safe (because there are no read
1978 // barriers), and it'll be safe to coerce anything but __weak* to
1979 // the resulting type.
1980 if (type.isConstQualified()) {
1981 implicitLifetime = Qualifiers::OCL_ExplicitNone;
1982
1983 // Otherwise, check whether the static type does not require
1984 // retaining. This currently only triggers for Class (possibly
1985 // protocol-qualifed, and arrays thereof).
1986 } else if (type->isObjCARCImplicitlyUnretainedType()) {
1987 implicitLifetime = Qualifiers::OCL_ExplicitNone;
1988
1989 // If we are in an unevaluated context, like sizeof, skip adding a
1990 // qualification.
1991 } else if (S.isUnevaluatedContext()) {
1992 return type;
1993
1994 // If that failed, give an error and recover using __strong. __strong
1995 // is the option most likely to prevent spurious second-order diagnostics,
1996 // like when binding a reference to a field.
1997 } else {
1998 // These types can show up in private ivars in system headers, so
1999 // we need this to not be an error in those cases. Instead we
2000 // want to delay.
2001 if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
2002 S.DelayedDiagnostics.add(
2003 sema::DelayedDiagnostic::makeForbiddenType(loc,
2004 diag::err_arc_indirect_no_ownership, type, isReference));
2005 } else {
2006 S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;
2007 }
2008 implicitLifetime = Qualifiers::OCL_Strong;
2009 }
2010 assert(implicitLifetime && "didn't infer any lifetime!")(static_cast<void> (0));
2011
2012 Qualifiers qs;
2013 qs.addObjCLifetime(implicitLifetime);
2014 return S.Context.getQualifiedType(type, qs);
2015}
2016
2017static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy){
2018 std::string Quals = FnTy->getMethodQuals().getAsString();
2019
2020 switch (FnTy->getRefQualifier()) {
2021 case RQ_None:
2022 break;
2023
2024 case RQ_LValue:
2025 if (!Quals.empty())
2026 Quals += ' ';
2027 Quals += '&';
2028 break;
2029
2030 case RQ_RValue:
2031 if (!Quals.empty())
2032 Quals += ' ';
2033 Quals += "&&";
2034 break;
2035 }
2036
2037 return Quals;
2038}
2039
2040namespace {
2041/// Kinds of declarator that cannot contain a qualified function type.
2042///
2043/// C++98 [dcl.fct]p4 / C++11 [dcl.fct]p6:
2044/// a function type with a cv-qualifier or a ref-qualifier can only appear
2045/// at the topmost level of a type.
2046///
2047/// Parens and member pointers are permitted. We don't diagnose array and
2048/// function declarators, because they don't allow function types at all.
2049///
2050/// The values of this enum are used in diagnostics.
2051enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
2052} // end anonymous namespace
2053
2054/// Check whether the type T is a qualified function type, and if it is,
2055/// diagnose that it cannot be contained within the given kind of declarator.
2056static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc,
2057 QualifiedFunctionKind QFK) {
2058 // Does T refer to a function type with a cv-qualifier or a ref-qualifier?
2059 const FunctionProtoType *FPT = T->getAs<FunctionProtoType>();
2060 if (!FPT ||
2061 (FPT->getMethodQuals().empty() && FPT->getRefQualifier() == RQ_None))
2062 return false;
2063
2064 S.Diag(Loc, diag::err_compound_qualified_function_type)
2065 << QFK << isa<FunctionType>(T.IgnoreParens()) << T
2066 << getFunctionQualifiersAsString(FPT);
2067 return true;
2068}
2069
2070bool Sema::CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc) {
2071 const FunctionProtoType *FPT = T->getAs<FunctionProtoType>();
2072 if (!FPT ||
2073 (FPT->getMethodQuals().empty() && FPT->getRefQualifier() == RQ_None))
2074 return false;
2075
2076 Diag(Loc, diag::err_qualified_function_typeid)
2077 << T << getFunctionQualifiersAsString(FPT);
2078 return true;
2079}
2080
2081// Helper to deduce addr space of a pointee type in OpenCL mode.
2082static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType) {
2083 if (!PointeeType->isUndeducedAutoType() && !PointeeType->isDependentType() &&
2084 !PointeeType->isSamplerT() &&
2085 !PointeeType.hasAddressSpace())
2086 PointeeType = S.getASTContext().getAddrSpaceQualType(
2087 PointeeType, S.getLangOpts().OpenCLGenericAddressSpace
2088 ? LangAS::opencl_generic
2089 : LangAS::opencl_private);
2090 return PointeeType;
2091}
2092
2093/// Build a pointer type.
2094///
2095/// \param T The type to which we'll be building a pointer.
2096///
2097/// \param Loc The location of the entity whose type involves this
2098/// pointer type or, if there is no such entity, the location of the
2099/// type that will have pointer type.
2100///
2101/// \param Entity The name of the entity that involves the pointer
2102/// type, if known.
2103///
2104/// \returns A suitable pointer type, if there are no
2105/// errors. Otherwise, returns a NULL type.
2106QualType Sema::BuildPointerType(QualType T,
2107 SourceLocation Loc, DeclarationName Entity) {
2108 if (T->isReferenceType()) {
2109 // C++ 8.3.2p4: There shall be no ... pointers to references ...
2110 Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
2111 << getPrintableNameForEntity(Entity) << T;
2112 return QualType();
2113 }
2114
2115 if (T->isFunctionType() && getLangOpts().OpenCL &&
2116 !getOpenCLOptions().isAvailableOption("__cl_clang_function_pointers",
2117 getLangOpts())) {
2118 Diag(Loc, diag::err_opencl_function_pointer) << /*pointer*/ 0;
2119 return QualType();
2120 }
2121
2122 if (checkQualifiedFunction(*this, T, Loc, QFK_Pointer))
2123 return QualType();
2124
2125 assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType")(static_cast<void> (0));
2126
2127 // In ARC, it is forbidden to build pointers to unqualified pointers.
2128 if (getLangOpts().ObjCAutoRefCount)
2129 T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ false);
2130
2131 if (getLangOpts().OpenCL)
2132 T = deduceOpenCLPointeeAddrSpace(*this, T);
2133
2134 // Build the pointer type.
2135 return Context.getPointerType(T);
2136}
2137
2138/// Build a reference type.
2139///
2140/// \param T The type to which we'll be building a reference.
2141///
2142/// \param Loc The location of the entity whose type involves this
2143/// reference type or, if there is no such entity, the location of the
2144/// type that will have reference type.
2145///
2146/// \param Entity The name of the entity that involves the reference
2147/// type, if known.
2148///
2149/// \returns A suitable reference type, if there are no
2150/// errors. Otherwise, returns a NULL type.
2151QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue,
2152 SourceLocation Loc,
2153 DeclarationName Entity) {
2154 assert(Context.getCanonicalType(T) != Context.OverloadTy &&(static_cast<void> (0))
2155 "Unresolved overloaded function type")(static_cast<void> (0));
2156
2157 // C++0x [dcl.ref]p6:
2158 // If a typedef (7.1.3), a type template-parameter (14.3.1), or a
2159 // decltype-specifier (7.1.6.2) denotes a type TR that is a reference to a
2160 // type T, an attempt to create the type "lvalue reference to cv TR" creates
2161 // the type "lvalue reference to T", while an attempt to create the type
2162 // "rvalue reference to cv TR" creates the type TR.
2163 bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>();
2164
2165 // C++ [dcl.ref]p4: There shall be no references to references.
2166 //
2167 // According to C++ DR 106, references to references are only
2168 // diagnosed when they are written directly (e.g., "int & &"),
2169 // but not when they happen via a typedef:
2170 //
2171 // typedef int& intref;
2172 // typedef intref& intref2;
2173 //
2174 // Parser::ParseDeclaratorInternal diagnoses the case where
2175 // references are written directly; here, we handle the
2176 // collapsing of references-to-references as described in C++0x.
2177 // DR 106 and 540 introduce reference-collapsing into C++98/03.
2178
2179 // C++ [dcl.ref]p1:
2180 // A declarator that specifies the type "reference to cv void"
2181 // is ill-formed.
2182 if (T->isVoidType()) {
2183 Diag(Loc, diag::err_reference_to_void);
2184 return QualType();
2185 }
2186
2187 if (checkQualifiedFunction(*this, T, Loc, QFK_Reference))
2188 return QualType();
2189
2190 if (T->isFunctionType() && getLangOpts().OpenCL &&
2191 !getOpenCLOptions().isAvailableOption("__cl_clang_function_pointers",
2192 getLangOpts())) {
2193 Diag(Loc, diag::err_opencl_function_pointer) << /*reference*/ 1;
2194 return QualType();
2195 }
2196
2197 // In ARC, it is forbidden to build references to unqualified pointers.
2198 if (getLangOpts().ObjCAutoRefCount)
2199 T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ true);
2200
2201 if (getLangOpts().OpenCL)
2202 T = deduceOpenCLPointeeAddrSpace(*this, T);
2203
2204 // Handle restrict on references.
2205 if (LValueRef)
2206 return Context.getLValueReferenceType(T, SpelledAsLValue);
2207 return Context.getRValueReferenceType(T);
2208}
2209
2210/// Build a Read-only Pipe type.
2211///
2212/// \param T The type to which we'll be building a Pipe.
2213///
2214/// \param Loc We do not use it for now.
2215///
2216/// \returns A suitable pipe type, if there are no errors. Otherwise, returns a
2217/// NULL type.
2218QualType Sema::BuildReadPipeType(QualType T, SourceLocation Loc) {
2219 return Context.getReadPipeType(T);
2220}
2221
2222/// Build a Write-only Pipe type.
2223///
2224/// \param T The type to which we'll be building a Pipe.
2225///
2226/// \param Loc We do not use it for now.
2227///
2228/// \returns A suitable pipe type, if there are no errors. Otherwise, returns a
2229/// NULL type.
2230QualType Sema::BuildWritePipeType(QualType T, SourceLocation Loc) {
2231 return Context.getWritePipeType(T);
2232}
2233
2234/// Build a extended int type.
2235///
2236/// \param IsUnsigned Boolean representing the signedness of the type.
2237///
2238/// \param BitWidth Size of this int type in bits, or an expression representing
2239/// that.
2240///
2241/// \param Loc Location of the keyword.
2242QualType Sema::BuildExtIntType(bool IsUnsigned, Expr *BitWidth,
2243 SourceLocation Loc) {
2244 if (BitWidth->isInstantiationDependent())
2245 return Context.getDependentExtIntType(IsUnsigned, BitWidth);
2246
2247 llvm::APSInt Bits(32);
2248 ExprResult ICE =
2249 VerifyIntegerConstantExpression(BitWidth, &Bits, /*FIXME*/ AllowFold);
2250
2251 if (ICE.isInvalid())
2252 return QualType();
2253
2254 int64_t NumBits = Bits.getSExtValue();
2255 if (!IsUnsigned && NumBits < 2) {
2256 Diag(Loc, diag::err_ext_int_bad_size) << 0;
2257 return QualType();
2258 }
2259
2260 if (IsUnsigned && NumBits < 1) {
2261 Diag(Loc, diag::err_ext_int_bad_size) << 1;
2262 return QualType();
2263 }
2264
2265 if (NumBits > llvm::IntegerType::MAX_INT_BITS) {
2266 Diag(Loc, diag::err_ext_int_max_size) << IsUnsigned
2267 << llvm::IntegerType::MAX_INT_BITS;
2268 return QualType();
2269 }
2270
2271 return Context.getExtIntType(IsUnsigned, NumBits);
2272}
2273
2274/// Check whether the specified array bound can be evaluated using the relevant
2275/// language rules. If so, returns the possibly-converted expression and sets
2276/// SizeVal to the size. If not, but the expression might be a VLA bound,
2277/// returns ExprResult(). Otherwise, produces a diagnostic and returns
2278/// ExprError().
2279static ExprResult checkArraySize(Sema &S, Expr *&ArraySize,
2280 llvm::APSInt &SizeVal, unsigned VLADiag,
2281 bool VLAIsError) {
2282 if (S.getLangOpts().CPlusPlus14 &&
2283 (VLAIsError ||
2284 !ArraySize->getType()->isIntegralOrUnscopedEnumerationType())) {
2285 // C++14 [dcl.array]p1:
2286 // The constant-expression shall be a converted constant expression of
2287 // type std::size_t.
2288 //
2289 // Don't apply this rule if we might be forming a VLA: in that case, we
2290 // allow non-constant expressions and constant-folding. We only need to use
2291 // the converted constant expression rules (to properly convert the source)
2292 // when the source expression is of class type.
2293 return S.CheckConvertedConstantExpression(
2294 ArraySize, S.Context.getSizeType(), SizeVal, Sema::CCEK_ArrayBound);
2295 }
2296
2297 // If the size is an ICE, it certainly isn't a VLA. If we're in a GNU mode
2298 // (like gnu99, but not c99) accept any evaluatable value as an extension.
2299 class VLADiagnoser : public Sema::VerifyICEDiagnoser {
2300 public:
2301 unsigned VLADiag;
2302 bool VLAIsError;
2303 bool IsVLA = false;
2304
2305 VLADiagnoser(unsigned VLADiag, bool VLAIsError)
2306 : VLADiag(VLADiag), VLAIsError(VLAIsError) {}
2307
2308 Sema::SemaDiagnosticBuilder diagnoseNotICEType(Sema &S, SourceLocation Loc,
2309 QualType T) override {
2310 return S.Diag(Loc, diag::err_array_size_non_int) << T;
2311 }
2312
2313 Sema::SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
2314 SourceLocation Loc) override {
2315 IsVLA = !VLAIsError;
2316 return S.Diag(Loc, VLADiag);
2317 }
2318
2319 Sema::SemaDiagnosticBuilder diagnoseFold(Sema &S,
2320 SourceLocation Loc) override {
2321 return S.Diag(Loc, diag::ext_vla_folded_to_constant);
2322 }
2323 } Diagnoser(VLADiag, VLAIsError);
2324
2325 ExprResult R =
2326 S.VerifyIntegerConstantExpression(ArraySize, &SizeVal, Diagnoser);
2327 if (Diagnoser.IsVLA)
2328 return ExprResult();
2329 return R;
2330}
2331
2332/// Build an array type.
2333///
2334/// \param T The type of each element in the array.
2335///
2336/// \param ASM C99 array size modifier (e.g., '*', 'static').
2337///
2338/// \param ArraySize Expression describing the size of the array.
2339///
2340/// \param Brackets The range from the opening '[' to the closing ']'.
2341///
2342/// \param Entity The name of the entity that involves the array
2343/// type, if known.
2344///
2345/// \returns A suitable array type, if there are no errors. Otherwise,
2346/// returns a NULL type.
2347QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
2348 Expr *ArraySize, unsigned Quals,
2349 SourceRange Brackets, DeclarationName Entity) {
2350
2351 SourceLocation Loc = Brackets.getBegin();
2352 if (getLangOpts().CPlusPlus) {
2353 // C++ [dcl.array]p1:
2354 // T is called the array element type; this type shall not be a reference
2355 // type, the (possibly cv-qualified) type void, a function type or an
2356 // abstract class type.
2357 //
2358 // C++ [dcl.array]p3:
2359 // When several "array of" specifications are adjacent, [...] only the
2360 // first of the constant expressions that specify the bounds of the arrays
2361 // may be omitted.
2362 //
2363 // Note: function types are handled in the common path with C.
2364 if (T->isReferenceType()) {
2365 Diag(Loc, diag::err_illegal_decl_array_of_references)
2366 << getPrintableNameForEntity(Entity) << T;
2367 return QualType();
2368 }
2369
2370 if (T->isVoidType() || T->isIncompleteArrayType()) {
2371 Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 0 << T;
2372 return QualType();
2373 }
2374
2375 if (RequireNonAbstractType(Brackets.getBegin(), T,
2376 diag::err_array_of_abstract_type))
2377 return QualType();
2378
2379 // Mentioning a member pointer type for an array type causes us to lock in
2380 // an inheritance model, even if it's inside an unused typedef.
2381 if (Context.getTargetInfo().getCXXABI().isMicrosoft())
2382 if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
2383 if (!MPTy->getClass()->isDependentType())
2384 (void)isCompleteType(Loc, T);
2385
2386 } else {
2387 // C99 6.7.5.2p1: If the element type is an incomplete or function type,
2388 // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
2389 if (RequireCompleteSizedType(Loc, T,
2390 diag::err_array_incomplete_or_sizeless_type))
2391 return QualType();
2392 }
2393
2394 if (T->isSizelessType()) {
2395 Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 1 << T;
2396 return QualType();
2397 }
2398
2399 if (T->isFunctionType()) {
2400 Diag(Loc, diag::err_illegal_decl_array_of_functions)
2401 << getPrintableNameForEntity(Entity) << T;
2402 return QualType();
2403 }
2404
2405 if (const RecordType *EltTy = T->getAs<RecordType>()) {
2406 // If the element type is a struct or union that contains a variadic
2407 // array, accept it as a GNU extension: C99 6.7.2.1p2.
2408 if (EltTy->getDecl()->hasFlexibleArrayMember())
2409 Diag(Loc, diag::ext_flexible_array_in_array) << T;
2410 } else if (T->isObjCObjectType()) {
2411 Diag(Loc, diag::err_objc_array_of_interfaces) << T;
2412 return QualType();
2413 }
2414
2415 // Do placeholder conversions on the array size expression.
2416 if (ArraySize && ArraySize->hasPlaceholderType()) {
2417 ExprResult Result = CheckPlaceholderExpr(ArraySize);
2418 if (Result.isInvalid()) return QualType();
2419 ArraySize = Result.get();
2420 }
2421
2422 // Do lvalue-to-rvalue conversions on the array size expression.
2423 if (ArraySize && !ArraySize->isPRValue()) {
2424 ExprResult Result = DefaultLvalueConversion(ArraySize);
2425 if (Result.isInvalid())
2426 return QualType();
2427
2428 ArraySize = Result.get();
2429 }
2430
2431 // C99 6.7.5.2p1: The size expression shall have integer type.
2432 // C++11 allows contextual conversions to such types.
2433 if (!getLangOpts().CPlusPlus11 &&
2434 ArraySize && !ArraySize->isTypeDependent() &&
2435 !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {
2436 Diag(ArraySize->getBeginLoc(), diag::err_array_size_non_int)
2437 << ArraySize->getType() << ArraySize->getSourceRange();
2438 return QualType();
2439 }
2440
2441 // VLAs always produce at least a -Wvla diagnostic, sometimes an error.
2442 unsigned VLADiag;
2443 bool VLAIsError;
2444 if (getLangOpts().OpenCL) {
2445 // OpenCL v1.2 s6.9.d: variable length arrays are not supported.
2446 VLADiag = diag::err_opencl_vla;
2447 VLAIsError = true;
2448 } else if (getLangOpts().C99) {
2449 VLADiag = diag::warn_vla_used;
2450 VLAIsError = false;
2451 } else if (isSFINAEContext()) {
2452 VLADiag = diag::err_vla_in_sfinae;
2453 VLAIsError = true;
2454 } else {
2455 VLADiag = diag::ext_vla;
2456 VLAIsError = false;
2457 }
2458
2459 llvm::APSInt ConstVal(Context.getTypeSize(Context.getSizeType()));
2460 if (!ArraySize) {
2461 if (ASM == ArrayType::Star) {
2462 Diag(Loc, VLADiag);
2463 if (VLAIsError)
2464 return QualType();
2465
2466 T = Context.getVariableArrayType(T, nullptr, ASM, Quals, Brackets);
2467 } else {
2468 T = Context.getIncompleteArrayType(T, ASM, Quals);
2469 }
2470 } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) {
2471 T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets);
2472 } else {
2473 ExprResult R =
2474 checkArraySize(*this, ArraySize, ConstVal, VLADiag, VLAIsError);
2475 if (R.isInvalid())
2476 return QualType();
2477
2478 if (!R.isUsable()) {
2479 // C99: an array with a non-ICE size is a VLA. We accept any expression
2480 // that we can fold to a non-zero positive value as a non-VLA as an
2481 // extension.
2482 T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets);
2483 } else if (!T->isDependentType() && !T->isIncompleteType() &&
2484 !T->isConstantSizeType()) {
2485 // C99: an array with an element type that has a non-constant-size is a
2486 // VLA.
2487 // FIXME: Add a note to explain why this isn't a VLA.
2488 Diag(Loc, VLADiag);
2489 if (VLAIsError)
2490 return QualType();
2491 T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets);
2492 } else {
2493 // C99 6.7.5.2p1: If the expression is a constant expression, it shall
2494 // have a value greater than zero.
2495 // In C++, this follows from narrowing conversions being disallowed.
2496 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2497 if (Entity)
2498 Diag(ArraySize->getBeginLoc(), diag::err_decl_negative_array_size)
2499 << getPrintableNameForEntity(Entity)
2500 << ArraySize->getSourceRange();
2501 else
2502 Diag(ArraySize->getBeginLoc(),
2503 diag::err_typecheck_negative_array_size)
2504 << ArraySize->getSourceRange();
2505 return QualType();
2506 }
2507 if (ConstVal == 0) {
2508 // GCC accepts zero sized static arrays. We allow them when
2509 // we're not in a SFINAE context.
2510 Diag(ArraySize->getBeginLoc(),
2511 isSFINAEContext() ? diag::err_typecheck_zero_array_size
2512 : diag::ext_typecheck_zero_array_size)
2513 << ArraySize->getSourceRange();
2514 }
2515
2516 // Is the array too large?
2517 unsigned ActiveSizeBits =
2518 (!T->isDependentType() && !T->isVariablyModifiedType() &&
2519 !T->isIncompleteType() && !T->isUndeducedType())
2520 ? ConstantArrayType::getNumAddressingBits(Context, T, ConstVal)
2521 : ConstVal.getActiveBits();
2522 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
2523 Diag(ArraySize->getBeginLoc(), diag::err_array_too_large)
2524 << toString(ConstVal, 10) << ArraySize->getSourceRange();
2525 return QualType();
2526 }
2527
2528 T = Context.getConstantArrayType(T, ConstVal, ArraySize, ASM, Quals);
2529 }
2530 }
2531
2532 if (T->isVariableArrayType() && !Context.getTargetInfo().isVLASupported()) {
2533 // CUDA device code and some other targets don't support VLAs.
2534 targetDiag(Loc, (getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
2535 ? diag::err_cuda_vla
2536 : diag::err_vla_unsupported)
2537 << ((getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
2538 ? CurrentCUDATarget()
2539 : CFT_InvalidTarget);
2540 }
2541
2542 // If this is not C99, diagnose array size modifiers on non-VLAs.
2543 if (!getLangOpts().C99 && !T->isVariableArrayType() &&
2544 (ASM != ArrayType::Normal || Quals != 0)) {
2545 Diag(Loc, getLangOpts().CPlusPlus ? diag::err_c99_array_usage_cxx
2546 : diag::ext_c99_array_usage)
2547 << ASM;
2548 }
2549
2550 // OpenCL v2.0 s6.12.5 - Arrays of blocks are not supported.
2551 // OpenCL v2.0 s6.16.13.1 - Arrays of pipe type are not supported.
2552 // OpenCL v2.0 s6.9.b - Arrays of image/sampler type are not supported.
2553 if (getLangOpts().OpenCL) {
2554 const QualType ArrType = Context.getBaseElementType(T);
2555 if (ArrType->isBlockPointerType() || ArrType->isPipeType() ||
2556 ArrType->isSamplerT() || ArrType->isImageType()) {
2557 Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
2558 return QualType();
2559 }
2560 }
2561
2562 return T;
2563}
2564
2565QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr,
2566 SourceLocation AttrLoc) {
2567 // The base type must be integer (not Boolean or enumeration) or float, and
2568 // can't already be a vector.
2569 if ((!CurType->isDependentType() &&
2570 (!CurType->isBuiltinType() || CurType->isBooleanType() ||
2571 (!CurType->isIntegerType() && !CurType->isRealFloatingType()))) ||
2572 CurType->isArrayType()) {
2573 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2574 return QualType();
2575 }
2576
2577 if (SizeExpr->isTypeDependent() || SizeExpr->isValueDependent())
2578 return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc,
2579 VectorType::GenericVector);
2580
2581 Optional<llvm::APSInt> VecSize = SizeExpr->getIntegerConstantExpr(Context);
2582 if (!VecSize) {
2583 Diag(AttrLoc, diag::err_attribute_argument_type)
2584 << "vector_size" << AANT_ArgumentIntegerConstant
2585 << SizeExpr->getSourceRange();
2586 return QualType();
2587 }
2588
2589 if (CurType->isDependentType())
2590 return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc,
2591 VectorType::GenericVector);
2592
2593 // vecSize is specified in bytes - convert to bits.
2594 if (!VecSize->isIntN(61)) {
2595 // Bit size will overflow uint64.
2596 Diag(AttrLoc, diag::err_attribute_size_too_large)
2597 << SizeExpr->getSourceRange() << "vector";
2598 return QualType();
2599 }
2600 uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;
2601 unsigned TypeSize = static_cast<unsigned>(Context.getTypeSize(CurType));
2602
2603 if (VectorSizeBits == 0) {
2604 Diag(AttrLoc, diag::err_attribute_zero_size)
2605 << SizeExpr->getSourceRange() << "vector";
2606 return QualType();
2607 }
2608
2609 if (VectorSizeBits % TypeSize) {
2610 Diag(AttrLoc, diag::err_attribute_invalid_size)
2611 << SizeExpr->getSourceRange();
2612 return QualType();
2613 }
2614
2615 if (VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {
2616 Diag(AttrLoc, diag::err_attribute_size_too_large)
2617 << SizeExpr->getSourceRange() << "vector";
2618 return QualType();
2619 }
2620
2621 return Context.getVectorType(CurType, VectorSizeBits / TypeSize,
2622 VectorType::GenericVector);
2623}
2624
2625/// Build an ext-vector type.
2626///
2627/// Run the required checks for the extended vector type.
2628QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize,
2629 SourceLocation AttrLoc) {
2630 // Unlike gcc's vector_size attribute, we do not allow vectors to be defined
2631 // in conjunction with complex types (pointers, arrays, functions, etc.).
2632 //
2633 // Additionally, OpenCL prohibits vectors of booleans (they're considered a
2634 // reserved data type under OpenCL v2.0 s6.1.4), we don't support selects
2635 // on bitvectors, and we have no well-defined ABI for bitvectors, so vectors
2636 // of bool aren't allowed.
2637 if ((!T->isDependentType() && !T->isIntegerType() &&
2638 !T->isRealFloatingType()) ||
2639 T->isBooleanType()) {
2640 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
2641 return QualType();
2642 }
2643
2644 if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) {
2645 Optional<llvm::APSInt> vecSize = ArraySize->getIntegerConstantExpr(Context);
2646 if (!vecSize) {
2647 Diag(AttrLoc, diag::err_attribute_argument_type)
2648 << "ext_vector_type" << AANT_ArgumentIntegerConstant
2649 << ArraySize->getSourceRange();
2650 return QualType();
2651 }
2652
2653 if (!vecSize->isIntN(32)) {
2654 Diag(AttrLoc, diag::err_attribute_size_too_large)
2655 << ArraySize->getSourceRange() << "vector";
2656 return QualType();
2657 }
2658 // Unlike gcc's vector_size attribute, the size is specified as the
2659 // number of elements, not the number of bytes.
2660 unsigned vectorSize = static_cast<unsigned>(vecSize->getZExtValue());
2661
2662 if (vectorSize == 0) {
2663 Diag(AttrLoc, diag::err_attribute_zero_size)
2664 << ArraySize->getSourceRange() << "vector";
2665 return QualType();
2666 }
2667
2668 return Context.getExtVectorType(T, vectorSize);
2669 }
2670
2671 return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc);
2672}
2673
2674QualType Sema::BuildMatrixType(QualType ElementTy, Expr *NumRows, Expr *NumCols,
2675 SourceLocation AttrLoc) {
2676 assert(Context.getLangOpts().MatrixTypes &&(static_cast<void> (0))
2677 "Should never build a matrix type when it is disabled")(static_cast<void> (0));
2678
2679 // Check element type, if it is not dependent.
2680 if (!ElementTy->isDependentType() &&
2681 !MatrixType::isValidElementType(ElementTy)) {
2682 Diag(AttrLoc, diag::err_attribute_invalid_matrix_type) << ElementTy;
2683 return QualType();
2684 }
2685
2686 if (NumRows->isTypeDependent() || NumCols->isTypeDependent() ||
2687 NumRows->isValueDependent() || NumCols->isValueDependent())
2688 return Context.getDependentSizedMatrixType(ElementTy, NumRows, NumCols,
2689 AttrLoc);
2690
2691 Optional<llvm::APSInt> ValueRows = NumRows->getIntegerConstantExpr(Context);
2692 Optional<llvm::APSInt> ValueColumns =
2693 NumCols->getIntegerConstantExpr(Context);
2694
2695 auto const RowRange = NumRows->getSourceRange();
2696 auto const ColRange = NumCols->getSourceRange();
2697
2698 // Both are row and column expressions are invalid.
2699 if (!ValueRows && !ValueColumns) {
2700 Diag(AttrLoc, diag::err_attribute_argument_type)
2701 << "matrix_type" << AANT_ArgumentIntegerConstant << RowRange
2702 << ColRange;
2703 return QualType();
2704 }
2705
2706 // Only the row expression is invalid.
2707 if (!ValueRows) {
2708 Diag(AttrLoc, diag::err_attribute_argument_type)
2709 << "matrix_type" << AANT_ArgumentIntegerConstant << RowRange;
2710 return QualType();
2711 }
2712
2713 // Only the column expression is invalid.
2714 if (!ValueColumns) {
2715 Diag(AttrLoc, diag::err_attribute_argument_type)
2716 << "matrix_type" << AANT_ArgumentIntegerConstant << ColRange;
2717 return QualType();
2718 }
2719
2720 // Check the matrix dimensions.
2721 unsigned MatrixRows = static_cast<unsigned>(ValueRows->getZExtValue());
2722 unsigned MatrixColumns = static_cast<unsigned>(ValueColumns->getZExtValue());
2723 if (MatrixRows == 0 && MatrixColumns == 0) {
2724 Diag(AttrLoc, diag::err_attribute_zero_size)
2725 << "matrix" << RowRange << ColRange;
2726 return QualType();
2727 }
2728 if (MatrixRows == 0) {
2729 Diag(AttrLoc, diag::err_attribute_zero_size) << "matrix" << RowRange;
2730 return QualType();
2731 }
2732 if (MatrixColumns == 0) {
2733 Diag(AttrLoc, diag::err_attribute_zero_size) << "matrix" << ColRange;
2734 return QualType();
2735 }
2736 if (!ConstantMatrixType::isDimensionValid(MatrixRows)) {
2737 Diag(AttrLoc, diag::err_attribute_size_too_large)
2738 << RowRange << "matrix row";
2739 return QualType();
2740 }
2741 if (!ConstantMatrixType::isDimensionValid(MatrixColumns)) {
2742 Diag(AttrLoc, diag::err_attribute_size_too_large)
2743 << ColRange << "matrix column";
2744 return QualType();
2745 }
2746 return Context.getConstantMatrixType(ElementTy, MatrixRows, MatrixColumns);
2747}
2748
2749bool Sema::CheckFunctionReturnType(QualType T, SourceLocation Loc) {
2750 if (T->isArrayType() || T->isFunctionType()) {
2751 Diag(Loc, diag::err_func_returning_array_function)
2752 << T->isFunctionType() << T;
2753 return true;
2754 }
2755
2756 // Functions cannot return half FP.
2757 if (T->isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2758 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2759 FixItHint::CreateInsertion(Loc, "*");
2760 return true;
2761 }
2762
2763 // Methods cannot return interface types. All ObjC objects are
2764 // passed by reference.
2765 if (T->isObjCObjectType()) {
2766 Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value)
2767 << 0 << T << FixItHint::CreateInsertion(Loc, "*");
2768 return true;
2769 }
2770
2771 if (T.hasNonTrivialToPrimitiveDestructCUnion() ||
2772 T.hasNonTrivialToPrimitiveCopyCUnion())
2773 checkNonTrivialCUnion(T, Loc, NTCUC_FunctionReturn,
2774 NTCUK_Destruct|NTCUK_Copy);
2775
2776 // C++2a [dcl.fct]p12:
2777 // A volatile-qualified return type is deprecated
2778 if (T.isVolatileQualified() && getLangOpts().CPlusPlus20)
2779 Diag(Loc, diag::warn_deprecated_volatile_return) << T;
2780
2781 return false;
2782}
2783
2784/// Check the extended parameter information. Most of the necessary
2785/// checking should occur when applying the parameter attribute; the
2786/// only other checks required are positional restrictions.
2787static void checkExtParameterInfos(Sema &S, ArrayRef<QualType> paramTypes,
2788 const FunctionProtoType::ExtProtoInfo &EPI,
2789 llvm::function_ref<SourceLocation(unsigned)> getParamLoc) {
2790 assert(EPI.ExtParameterInfos && "shouldn't get here without param infos")(static_cast<void> (0));
2791
2792 bool emittedError = false;
2793 auto actualCC = EPI.ExtInfo.getCC();
2794 enum class RequiredCC { OnlySwift, SwiftOrSwiftAsync };
2795 auto checkCompatible = [&](unsigned paramIndex, RequiredCC required) {
2796 bool isCompatible =
2797 (required == RequiredCC::OnlySwift)
2798 ? (actualCC == CC_Swift)
2799 : (actualCC == CC_Swift || actualCC == CC_SwiftAsync);
2800 if (isCompatible || emittedError)
2801 return;
2802 S.Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2803 << getParameterABISpelling(EPI.ExtParameterInfos[paramIndex].getABI())
2804 << (required == RequiredCC::OnlySwift);
2805 emittedError = true;
2806 };
2807 for (size_t paramIndex = 0, numParams = paramTypes.size();
2808 paramIndex != numParams; ++paramIndex) {
2809 switch (EPI.ExtParameterInfos[paramIndex].getABI()) {
2810 // Nothing interesting to check for orindary-ABI parameters.
2811 case ParameterABI::Ordinary:
2812 continue;
2813
2814 // swift_indirect_result parameters must be a prefix of the function
2815 // arguments.
2816 case ParameterABI::SwiftIndirectResult:
2817 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2818 if (paramIndex != 0 &&
2819 EPI.ExtParameterInfos[paramIndex - 1].getABI()
2820 != ParameterABI::SwiftIndirectResult) {
2821 S.Diag(getParamLoc(paramIndex),
2822 diag::err_swift_indirect_result_not_first);
2823 }
2824 continue;
2825
2826 case ParameterABI::SwiftContext:
2827 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2828 continue;
2829
2830 // SwiftAsyncContext is not limited to swiftasynccall functions.
2831 case ParameterABI::SwiftAsyncContext:
2832 continue;
2833
2834 // swift_error parameters must be preceded by a swift_context parameter.
2835 case ParameterABI::SwiftErrorResult:
2836 checkCompatible(paramIndex, RequiredCC::OnlySwift);
2837 if (paramIndex == 0 ||
2838 EPI.ExtParameterInfos[paramIndex - 1].getABI() !=
2839 ParameterABI::SwiftContext) {
2840 S.Diag(getParamLoc(paramIndex),
2841 diag::err_swift_error_result_not_after_swift_context);
2842 }
2843 continue;
2844 }
2845 llvm_unreachable("bad ABI kind")__builtin_unreachable();
2846 }
2847}
2848
2849QualType Sema::BuildFunctionType(QualType T,
2850 MutableArrayRef<QualType> ParamTypes,
2851 SourceLocation Loc, DeclarationName Entity,
2852 const FunctionProtoType::ExtProtoInfo &EPI) {
2853 bool Invalid = false;
2854
2855 Invalid |= CheckFunctionReturnType(T, Loc);
2856
2857 for (unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2858 // FIXME: Loc is too inprecise here, should use proper locations for args.
2859 QualType ParamType = Context.getAdjustedParameterType(ParamTypes[Idx]);
2860 if (ParamType->isVoidType()) {
2861 Diag(Loc, diag::err_param_with_void_type);
2862 Invalid = true;
2863 } else if (ParamType->isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2864 // Disallow half FP arguments.
2865 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2866 FixItHint::CreateInsertion(Loc, "*");
2867 Invalid = true;
2868 }
2869
2870 // C++2a [dcl.fct]p4:
2871 // A parameter with volatile-qualified type is deprecated
2872 if (ParamType.isVolatileQualified() && getLangOpts().CPlusPlus20)
2873 Diag(Loc, diag::warn_deprecated_volatile_param) << ParamType;
2874
2875 ParamTypes[Idx] = ParamType;
2876 }
2877
2878 if (EPI.ExtParameterInfos) {
2879 checkExtParameterInfos(*this, ParamTypes, EPI,
2880 [=](unsigned i) { return Loc; });
2881 }
2882
2883 if (EPI.ExtInfo.getProducesResult()) {
2884 // This is just a warning, so we can't fail to build if we see it.
2885 checkNSReturnsRetainedReturnType(Loc, T);
2886 }
2887
2888 if (Invalid)
2889 return QualType();
2890
2891 return Context.getFunctionType(T, ParamTypes, EPI);
2892}
2893
2894/// Build a member pointer type \c T Class::*.
2895///
2896/// \param T the type to which the member pointer refers.
2897/// \param Class the class type into which the member pointer points.
2898/// \param Loc the location where this type begins
2899/// \param Entity the name of the entity that will have this member pointer type
2900///
2901/// \returns a member pointer type, if successful, or a NULL type if there was
2902/// an error.
2903QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
2904 SourceLocation Loc,
2905 DeclarationName Entity) {
2906 // Verify that we're not building a pointer to pointer to function with
2907 // exception specification.
2908 if (CheckDistantExceptionSpec(T)) {
2909 Diag(Loc, diag::err_distant_exception_spec);
2910 return QualType();
2911 }
2912
2913 // C++ 8.3.3p3: A pointer to member shall not point to ... a member
2914 // with reference type, or "cv void."
2915 if (T->isReferenceType()) {
2916 Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
2917 << getPrintableNameForEntity(Entity) << T;
2918 return QualType();
2919 }
2920
2921 if (T->isVoidType()) {
2922 Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
2923 << getPrintableNameForEntity(Entity);
2924 return QualType();
2925 }
2926
2927 if (!Class->isDependentType() && !Class->isRecordType()) {
2928 Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
2929 return QualType();
2930 }
2931
2932 if (T->isFunctionType() && getLangOpts().OpenCL &&
2933 !getOpenCLOptions().isAvailableOption("__cl_clang_function_pointers",
2934 getLangOpts())) {
2935 Diag(Loc, diag::err_opencl_function_pointer) << /*pointer*/ 0;
2936 return QualType();
2937 }
2938
2939 // Adjust the default free function calling convention to the default method
2940 // calling convention.
2941 bool IsCtorOrDtor =
2942 (Entity.getNameKind() == DeclarationName::CXXConstructorName) ||
2943 (Entity.getNameKind() == DeclarationName::CXXDestructorName);
2944 if (T->isFunctionType())
2945 adjustMemberFunctionCC(T, /*IsStatic=*/false, IsCtorOrDtor, Loc);
2946
2947 return Context.getMemberPointerType(T, Class.getTypePtr());
2948}
2949
2950/// Build a block pointer type.
2951///
2952/// \param T The type to which we'll be building a block pointer.
2953///
2954/// \param Loc The source location, used for diagnostics.
2955///
2956/// \param Entity The name of the entity that involves the block pointer
2957/// type, if known.
2958///
2959/// \returns A suitable block pointer type, if there are no
2960/// errors. Otherwise, returns a NULL type.
2961QualType Sema::BuildBlockPointerType(QualType T,
2962 SourceLocation Loc,
2963 DeclarationName Entity) {
2964 if (!T->isFunctionType()) {
2965 Diag(Loc, diag::err_nonfunction_block_type);
2966 return QualType();
2967 }
2968
2969 if (checkQualifiedFunction(*this, T, Loc, QFK_BlockPointer))
2970 return QualType();
2971
2972 if (getLangOpts().OpenCL)
2973 T = deduceOpenCLPointeeAddrSpace(*this, T);
2974
2975 return Context.getBlockPointerType(T);
2976}
2977
2978QualType Sema::GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo) {
2979 QualType QT = Ty.get();
2980 if (QT.isNull()) {
33
Calling 'QualType::isNull'
39
Returning from 'QualType::isNull'
40
Taking false branch
2981 if (TInfo) *TInfo = nullptr;
2982 return QualType();
2983 }
2984
2985 TypeSourceInfo *DI = nullptr;
41
'DI' initialized to a null pointer value
2986 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
42
Assuming 'LIT' is null
43
Taking false branch
2987 QT = LIT->getType();
2988 DI = LIT->getTypeSourceInfo();
2989 }
2990
2991 if (TInfo
43.1
'TInfo' is non-null
43.1
'TInfo' is non-null
43.1
'TInfo' is non-null
43.1
'TInfo' is non-null
43.1
'TInfo' is non-null
) *TInfo = DI;
44
Taking true branch
45
Null pointer value stored to 'TInfo'
2992 return QT;
2993}
2994
2995static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state,
2996 Qualifiers::ObjCLifetime ownership,
2997 unsigned chunkIndex);
2998
2999/// Given that this is the declaration of a parameter under ARC,
3000/// attempt to infer attributes and such for pointer-to-whatever
3001/// types.
3002static void inferARCWriteback(TypeProcessingState &state,
3003 QualType &declSpecType) {
3004 Sema &S = state.getSema();
3005 Declarator &declarator = state.getDeclarator();
3006
3007 // TODO: should we care about decl qualifiers?
3008
3009 // Check whether the declarator has the expected form. We walk
3010 // from the inside out in order to make the block logic work.
3011 unsigned outermostPointerIndex = 0;
3012 bool isBlockPointer = false;
3013 unsigned numPointers = 0;
3014 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
3015 unsigned chunkIndex = i;
3016 DeclaratorChunk &chunk = declarator.getTypeObject(chunkIndex);
3017 switch (chunk.Kind) {
3018 case DeclaratorChunk::Paren:
3019 // Ignore parens.
3020 break;
3021
3022 case DeclaratorChunk::Reference:
3023 case DeclaratorChunk::Pointer:
3024 // Count the number of pointers. Treat references
3025 // interchangeably as pointers; if they're mis-ordered, normal
3026 // type building will discover that.
3027 outermostPointerIndex = chunkIndex;
3028 numPointers++;
3029 break;
3030
3031 case DeclaratorChunk::BlockPointer:
3032 // If we have a pointer to block pointer, that's an acceptable
3033 // indirect reference; anything else is not an application of
3034 // the rules.
3035 if (numPointers != 1) return;
3036 numPointers++;
3037 outermostPointerIndex = chunkIndex;
3038 isBlockPointer = true;
3039
3040 // We don't care about pointer structure in return values here.
3041 goto done;
3042
3043 case DeclaratorChunk::Array: // suppress if written (id[])?
3044 case DeclaratorChunk::Function:
3045 case DeclaratorChunk::MemberPointer:
3046 case DeclaratorChunk::Pipe:
3047 return;
3048 }
3049 }
3050 done:
3051
3052 // If we have *one* pointer, then we want to throw the qualifier on
3053 // the declaration-specifiers, which means that it needs to be a
3054 // retainable object type.
3055 if (numPointers == 1) {
3056 // If it's not a retainable object type, the rule doesn't apply.
3057 if (!declSpecType->isObjCRetainableType()) return;
3058
3059 // If it already has lifetime, don't do anything.
3060 if (declSpecType.getObjCLifetime()) return;
3061
3062 // Otherwise, modify the type in-place.
3063 Qualifiers qs;
3064
3065 if (declSpecType->isObjCARCImplicitlyUnretainedType())
3066 qs.addObjCLifetime(Qualifiers::OCL_ExplicitNone);
3067 else
3068 qs.addObjCLifetime(Qualifiers::OCL_Autoreleasing);
3069 declSpecType = S.Context.getQualifiedType(declSpecType, qs);
3070
3071 // If we have *two* pointers, then we want to throw the qualifier on
3072 // the outermost pointer.
3073 } else if (numPointers == 2) {
3074 // If we don't have a block pointer, we need to check whether the
3075 // declaration-specifiers gave us something that will turn into a
3076 // retainable object pointer after we slap the first pointer on it.
3077 if (!isBlockPointer && !declSpecType->isObjCObjectType())
3078 return;
3079
3080 // Look for an explicit lifetime attribute there.
3081 DeclaratorChunk &chunk = declarator.getTypeObject(outermostPointerIndex);
3082 if (chunk.Kind != DeclaratorChunk::Pointer &&
3083 chunk.Kind != DeclaratorChunk::BlockPointer)
3084 return;
3085 for (const ParsedAttr &AL : chunk.getAttrs())
3086 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
3087 return;
3088
3089 transferARCOwnershipToDeclaratorChunk(state, Qualifiers::OCL_Autoreleasing,
3090 outermostPointerIndex);
3091
3092 // Any other number of pointers/references does not trigger the rule.
3093 } else return;
3094
3095 // TODO: mark whether we did this inference?
3096}
3097
3098void Sema::diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
3099 SourceLocation FallbackLoc,
3100 SourceLocation ConstQualLoc,
3101 SourceLocation VolatileQualLoc,
3102 SourceLocation RestrictQualLoc,
3103 SourceLocation AtomicQualLoc,
3104 SourceLocation UnalignedQualLoc) {
3105 if (!Quals)
3106 return;
3107
3108 struct Qual {
3109 const char *Name;
3110 unsigned Mask;
3111 SourceLocation Loc;
3112 } const QualKinds[5] = {
3113 { "const", DeclSpec::TQ_const, ConstQualLoc },
3114 { "volatile", DeclSpec::TQ_volatile, VolatileQualLoc },
3115 { "restrict", DeclSpec::TQ_restrict, RestrictQualLoc },
3116 { "__unaligned", DeclSpec::TQ_unaligned, UnalignedQualLoc },
3117 { "_Atomic", DeclSpec::TQ_atomic, AtomicQualLoc }
3118 };
3119
3120 SmallString<32> QualStr;
3121 unsigned NumQuals = 0;
3122 SourceLocation Loc;
3123 FixItHint FixIts[5];
3124
3125 // Build a string naming the redundant qualifiers.
3126 for (auto &E : QualKinds) {
3127 if (Quals & E.Mask) {
3128 if (!QualStr.empty()) QualStr += ' ';
3129 QualStr += E.Name;
3130
3131 // If we have a location for the qualifier, offer a fixit.
3132 SourceLocation QualLoc = E.Loc;
3133 if (QualLoc.isValid()) {
3134 FixIts[NumQuals] = FixItHint::CreateRemoval(QualLoc);
3135 if (Loc.isInvalid() ||
3136 getSourceManager().isBeforeInTranslationUnit(QualLoc, Loc))
3137 Loc = QualLoc;
3138 }
3139
3140 ++NumQuals;
3141 }
3142 }
3143
3144 Diag(Loc.isInvalid() ? FallbackLoc : Loc, DiagID)
3145 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
3146}
3147
3148// Diagnose pointless type qualifiers on the return type of a function.
3149static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy,
3150 Declarator &D,
3151 unsigned FunctionChunkIndex) {
3152 const DeclaratorChunk::FunctionTypeInfo &FTI =
3153 D.getTypeObject(FunctionChunkIndex).Fun;
3154 if (FTI.hasTrailingReturnType()) {
3155 S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
3156 RetTy.getLocalCVRQualifiers(),
3157 FTI.getTrailingReturnTypeLoc());
3158 return;
3159 }
3160
3161 for (unsigned OuterChunkIndex = FunctionChunkIndex + 1,
3162 End = D.getNumTypeObjects();
3163 OuterChunkIndex != End; ++OuterChunkIndex) {
3164 DeclaratorChunk &OuterChunk = D.getTypeObject(OuterChunkIndex);
3165 switch (OuterChunk.Kind) {
3166 case DeclaratorChunk::Paren:
3167 continue;
3168
3169 case DeclaratorChunk::Pointer: {
3170 DeclaratorChunk::PointerTypeInfo &PTI = OuterChunk.Ptr;
3171 S.diagnoseIgnoredQualifiers(
3172 diag::warn_qual_return_type,
3173 PTI.TypeQuals,
3174 SourceLocation(),
3175 PTI.ConstQualLoc,
3176 PTI.VolatileQualLoc,
3177 PTI.RestrictQualLoc,
3178 PTI.AtomicQualLoc,
3179 PTI.UnalignedQualLoc);
3180 return;
3181 }
3182
3183 case DeclaratorChunk::Function:
3184 case DeclaratorChunk::BlockPointer:
3185 case DeclaratorChunk::Reference:
3186 case DeclaratorChunk::Array:
3187 case DeclaratorChunk::MemberPointer:
3188 case DeclaratorChunk::Pipe:
3189 // FIXME: We can't currently provide an accurate source location and a
3190 // fix-it hint for these.
3191 unsigned AtomicQual = RetTy->isAtomicType() ? DeclSpec::TQ_atomic : 0;
3192 S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
3193 RetTy.getCVRQualifiers() | AtomicQual,
3194 D.getIdentifierLoc());
3195 return;
3196 }
3197
3198 llvm_unreachable("unknown declarator chunk kind")__builtin_unreachable();
3199 }
3200
3201 // If the qualifiers come from a conversion function type, don't diagnose
3202 // them -- they're not necessarily redundant, since such a conversion
3203 // operator can be explicitly called as "x.operator const int()".
3204 if (D.getName().getKind() == UnqualifiedIdKind::IK_ConversionFunctionId)
3205 return;
3206
3207 // Just parens all the way out to the decl specifiers. Diagnose any qualifiers
3208 // which are present there.
3209 S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
3210 D.getDeclSpec().getTypeQualifiers(),
3211 D.getIdentifierLoc(),
3212 D.getDeclSpec().getConstSpecLoc(),
3213 D.getDeclSpec().getVolatileSpecLoc(),
3214 D.getDeclSpec().getRestrictSpecLoc(),
3215 D.getDeclSpec().getAtomicSpecLoc(),
3216 D.getDeclSpec().getUnalignedSpecLoc());
3217}
3218
3219static std::pair<QualType, TypeSourceInfo *>
3220InventTemplateParameter(TypeProcessingState &state, QualType T,
3221 TypeSourceInfo *TrailingTSI, AutoType *Auto,
3222 InventedTemplateParameterInfo &Info) {
3223 Sema &S = state.getSema();
3224 Declarator &D = state.getDeclarator();
3225
3226 const unsigned TemplateParameterDepth = Info.AutoTemplateParameterDepth;
3227 const unsigned AutoParameterPosition = Info.TemplateParams.size();
3228 const bool IsParameterPack = D.hasEllipsis();
3229
3230 // If auto is mentioned in a lambda parameter or abbreviated function
3231 // template context, convert it to a template parameter type.
3232
3233 // Create the TemplateTypeParmDecl here to retrieve the corresponding
3234 // template parameter type. Template parameters are temporarily added
3235 // to the TU until the associated TemplateDecl is created.
3236 TemplateTypeParmDecl *InventedTemplateParam =
3237 TemplateTypeParmDecl::Create(
3238 S.Context, S.Context.getTranslationUnitDecl(),
3239 /*KeyLoc=*/D.getDeclSpec().getTypeSpecTypeLoc(),
3240 /*NameLoc=*/D.getIdentifierLoc(),
3241 TemplateParameterDepth, AutoParameterPosition,
3242 S.InventAbbreviatedTemplateParameterTypeName(
3243 D.getIdentifier(), AutoParameterPosition), false,
3244 IsParameterPack, /*HasTypeConstraint=*/Auto->isConstrained());
3245 InventedTemplateParam->setImplicit();
3246 Info.TemplateParams.push_back(InventedTemplateParam);
3247
3248 // Attach type constraints to the new parameter.
3249 if (Auto->isConstrained()) {
3250 if (TrailingTSI) {
3251 // The 'auto' appears in a trailing return type we've already built;
3252 // extract its type constraints to attach to the template parameter.
3253 AutoTypeLoc AutoLoc = TrailingTSI->getTypeLoc().getContainedAutoTypeLoc();
3254 TemplateArgumentListInfo TAL(AutoLoc.getLAngleLoc(), AutoLoc.getRAngleLoc());
3255 bool Invalid = false;
3256 for (unsigned Idx = 0; Idx < AutoLoc.getNumArgs(); ++Idx) {
3257 if (D.getEllipsisLoc().isInvalid() && !Invalid &&
3258 S.DiagnoseUnexpandedParameterPack(AutoLoc.getArgLoc(Idx),
3259 Sema::UPPC_TypeConstraint))
3260 Invalid = true;
3261 TAL.addArgument(AutoLoc.getArgLoc(Idx));
3262 }
3263
3264 if (!Invalid) {
3265 S.AttachTypeConstraint(
3266 AutoLoc.getNestedNameSpecifierLoc(), AutoLoc.getConceptNameInfo(),
3267 AutoLoc.getNamedConcept(),
3268 AutoLoc.hasExplicitTemplateArgs() ? &TAL : nullptr,
3269 InventedTemplateParam, D.getEllipsisLoc());
3270 }
3271 } else {
3272 // The 'auto' appears in the decl-specifiers; we've not finished forming
3273 // TypeSourceInfo for it yet.
3274 TemplateIdAnnotation *TemplateId = D.getDeclSpec().getRepAsTemplateId();
3275 TemplateArgumentListInfo TemplateArgsInfo;
3276 bool Invalid = false;
3277 if (TemplateId->LAngleLoc.isValid()) {
3278 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
3279 TemplateId->NumArgs);
3280 S.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
3281
3282 if (D.getEllipsisLoc().isInvalid()) {
3283 for (TemplateArgumentLoc Arg : TemplateArgsInfo.arguments()) {
3284 if (S.DiagnoseUnexpandedParameterPack(Arg,
3285 Sema::UPPC_TypeConstraint)) {
3286 Invalid = true;
3287 break;
3288 }
3289 }
3290 }
3291 }
3292 if (!Invalid) {
3293 S.AttachTypeConstraint(
3294 D.getDeclSpec().getTypeSpecScope().getWithLocInContext(S.Context),
3295 DeclarationNameInfo(DeclarationName(TemplateId->Name),
3296 TemplateId->TemplateNameLoc),
3297 cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl()),
3298 TemplateId->LAngleLoc.isValid() ? &TemplateArgsInfo : nullptr,
3299 InventedTemplateParam, D.getEllipsisLoc());
3300 }
3301 }
3302 }
3303
3304 // Replace the 'auto' in the function parameter with this invented
3305 // template type parameter.
3306 // FIXME: Retain some type sugar to indicate that this was written
3307 // as 'auto'?
3308 QualType Replacement(InventedTemplateParam->getTypeForDecl(), 0);
3309 QualType NewT = state.ReplaceAutoType(T, Replacement);
3310 TypeSourceInfo *NewTSI =
3311 TrailingTSI ? S.ReplaceAutoTypeSourceInfo(TrailingTSI, Replacement)
3312 : nullptr;
3313 return {NewT, NewTSI};
3314}
3315
3316static TypeSourceInfo *
3317GetTypeSourceInfoForDeclarator(TypeProcessingState &State,
3318 QualType T, TypeSourceInfo *ReturnTypeInfo);
3319
3320static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
3321 TypeSourceInfo *&ReturnTypeInfo) {
3322 Sema &SemaRef = state.getSema();
3323 Declarator &D = state.getDeclarator();
3324 QualType T;
3325 ReturnTypeInfo = nullptr;
3326
3327 // The TagDecl owned by the DeclSpec.
3328 TagDecl *OwnedTagDecl = nullptr;
3329
3330 switch (D.getName().getKind()) {
3331 case UnqualifiedIdKind::IK_ImplicitSelfParam:
3332 case UnqualifiedIdKind::IK_OperatorFunctionId:
3333 case UnqualifiedIdKind::IK_Identifier:
3334 case UnqualifiedIdKind::IK_LiteralOperatorId:
3335 case UnqualifiedIdKind::IK_TemplateId:
3336 T = ConvertDeclSpecToType(state);
3337
3338 if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) {
3339 OwnedTagDecl = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
3340 // Owned declaration is embedded in declarator.
3341 OwnedTagDecl->setEmbeddedInDeclarator(true);
3342 }
3343 break;
3344
3345 case UnqualifiedIdKind::IK_ConstructorName:
3346 case UnqualifiedIdKind::IK_ConstructorTemplateId:
3347 case UnqualifiedIdKind::IK_DestructorName:
3348 // Constructors and destructors don't have return types. Use
3349 // "void" instead.
3350 T = SemaRef.Context.VoidTy;
3351 processTypeAttrs(state, T, TAL_DeclSpec,
3352 D.getMutableDeclSpec().getAttributes());
3353 break;
3354
3355 case UnqualifiedIdKind::IK_DeductionGuideName:
3356 // Deduction guides have a trailing return type and no type in their
3357 // decl-specifier sequence. Use a placeholder return type for now.
3358 T = SemaRef.Context.DependentTy;
3359 break;
3360
3361 case UnqualifiedIdKind::IK_ConversionFunctionId:
3362 // The result type of a conversion function is the type that it
3363 // converts to.
3364 T = SemaRef.GetTypeFromParser(D.getName().ConversionFunctionId,
3365 &ReturnTypeInfo);
3366 break;
3367 }
3368
3369 if (!D.getAttributes().empty())
3370 distributeTypeAttrsFromDeclarator(state, T);
3371
3372 // Find the deduced type in this type. Look in the trailing return type if we
3373 // have one, otherwise in the DeclSpec type.
3374 // FIXME: The standard wording doesn't currently describe this.
3375 DeducedType *Deduced = T->getContainedDeducedType();
3376 bool DeducedIsTrailingReturnType = false;
3377 if (Deduced && isa<AutoType>(Deduced) && D.hasTrailingReturnType()) {
3378 QualType T = SemaRef.GetTypeFromParser(D.getTrailingReturnType());
3379 Deduced = T.isNull() ? nullptr : T->getContainedDeducedType();
3380 DeducedIsTrailingReturnType = true;
3381 }
3382
3383 // C++11 [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context.
3384 if (Deduced) {
3385 AutoType *Auto = dyn_cast<AutoType>(Deduced);
3386 int Error = -1;
3387
3388 // Is this a 'auto' or 'decltype(auto)' type (as opposed to __auto_type or
3389 // class template argument deduction)?
3390 bool IsCXXAutoType =
3391 (Auto && Auto->getKeyword() != AutoTypeKeyword::GNUAutoType);
3392 bool IsDeducedReturnType = false;
3393
3394 switch (D.getContext()) {
3395 case DeclaratorContext::LambdaExpr:
3396 // Declared return type of a lambda-declarator is implicit and is always
3397 // 'auto'.
3398 break;
3399 case DeclaratorContext::ObjCParameter:
3400 case DeclaratorContext::ObjCResult:
3401 Error = 0;
3402 break;
3403 case DeclaratorContext::RequiresExpr:
3404 Error = 22;
3405 break;
3406 case DeclaratorContext::Prototype:
3407 case DeclaratorContext::LambdaExprParameter: {
3408 InventedTemplateParameterInfo *Info = nullptr;
3409 if (D.getContext() == DeclaratorContext::Prototype) {
3410 // With concepts we allow 'auto' in function parameters.
3411 if (!SemaRef.getLangOpts().CPlusPlus20 || !Auto ||
3412 Auto->getKeyword() != AutoTypeKeyword::Auto) {
3413 Error = 0;
3414 break;
3415 } else if (!SemaRef.getCurScope()->isFunctionDeclarationScope()) {
3416 Error = 21;
3417 break;
3418 }
3419
3420 Info = &SemaRef.InventedParameterInfos.back();
3421 } else {
3422 // In C++14, generic lambdas allow 'auto' in their parameters.
3423 if (!SemaRef.getLangOpts().CPlusPlus14 || !Auto ||
3424 Auto->getKeyword() != AutoTypeKeyword::Auto) {
3425 Error = 16;
3426 break;
3427 }
3428 Info = SemaRef.getCurLambda();
3429 assert(Info && "No LambdaScopeInfo on the stack!")(static_cast<void> (0));
3430 }
3431
3432 // We'll deal with inventing template parameters for 'auto' in trailing
3433 // return types when we pick up the trailing return type when processing
3434 // the function chunk.
3435 if (!DeducedIsTrailingReturnType)
3436 T = InventTemplateParameter(state, T, nullptr, Auto, *Info).first;
3437 break;
3438 }
3439 case DeclaratorContext::Member: {
3440 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
3441 D.isFunctionDeclarator())
3442 break;
3443 bool Cxx = SemaRef.getLangOpts().CPlusPlus;
3444 if (isa<ObjCContainerDecl>(SemaRef.CurContext)) {
3445 Error = 6; // Interface member.
3446 } else {
3447 switch (cast<TagDecl>(SemaRef.CurContext)->getTagKind()) {
3448 case TTK_Enum: llvm_unreachable("unhandled tag kind")__builtin_unreachable();
3449 case TTK_Struct: Error = Cxx ? 1 : 2; /* Struct member */ break;
3450 case TTK_Union: Error = Cxx ? 3 : 4; /* Union member */ break;
3451 case TTK_Class: Error = 5; /* Class member */ break;
3452 case TTK_Interface: Error = 6; /* Interface member */ break;
3453 }
3454 }
3455 if (D.getDeclSpec().isFriendSpecified())
3456 Error = 20; // Friend type
3457 break;
3458 }
3459 case DeclaratorContext::CXXCatch:
3460 case DeclaratorContext::ObjCCatch:
3461 Error = 7; // Exception declaration
3462 break;
3463 case DeclaratorContext::TemplateParam:
3464 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3465 !SemaRef.getLangOpts().CPlusPlus20)
3466 Error = 19; // Template parameter (until C++20)
3467 else if (!SemaRef.getLangOpts().CPlusPlus17)
3468 Error = 8; // Template parameter (until C++17)
3469 break;
3470 case DeclaratorContext::BlockLiteral:
3471 Error = 9; // Block literal
3472 break;
3473 case DeclaratorContext::TemplateArg:
3474 // Within a template argument list, a deduced template specialization
3475 // type will be reinterpreted as a template template argument.
3476 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3477 !D.getNumTypeObjects() &&
3478 D.getDeclSpec().getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier)
3479 break;
3480 LLVM_FALLTHROUGH[[gnu::fallthrough]];
3481 case DeclaratorContext::TemplateTypeArg:
3482 Error = 10; // Template type argument
3483 break;
3484 case DeclaratorContext::AliasDecl:
3485 case DeclaratorContext::AliasTemplate:
3486 Error = 12; // Type alias
3487 break;
3488 case DeclaratorContext::TrailingReturn:
3489 case DeclaratorContext::TrailingReturnVar:
3490 if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3491 Error = 13; // Function return type
3492 IsDeducedReturnType = true;
3493 break;
3494 case DeclaratorContext::ConversionId:
3495 if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3496 Error = 14; // conversion-type-id
3497 IsDeducedReturnType = true;
3498 break;
3499 case DeclaratorContext::FunctionalCast:
3500 if (isa<DeducedTemplateSpecializationType>(Deduced))
3501 break;
3502 LLVM_FALLTHROUGH[[gnu::fallthrough]];
3503 case DeclaratorContext::TypeName:
3504 Error = 15; // Generic
3505 break;
3506 case DeclaratorContext::File:
3507 case DeclaratorContext::Block:
3508 case DeclaratorContext::ForInit:
3509 case DeclaratorContext::SelectionInit:
3510 case DeclaratorContext::Condition:
3511 // FIXME: P0091R3 (erroneously) does not permit class template argument
3512 // deduction in conditions, for-init-statements, and other declarations
3513 // that are not simple-declarations.
3514 break;
3515 case DeclaratorContext::CXXNew:
3516 // FIXME: P0091R3 does not permit class template argument deduction here,
3517 // but we follow GCC and allow it anyway.
3518 if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
3519 Error = 17; // 'new' type
3520 break;
3521 case DeclaratorContext::KNRTypeList:
3522 Error = 18; // K&R function parameter
3523 break;
3524 }
3525
3526 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
3527 Error = 11;
3528
3529 // In Objective-C it is an error to use 'auto' on a function declarator
3530 // (and everywhere for '__auto_type').
3531 if (D.isFunctionDeclarator() &&
3532 (!SemaRef.getLangOpts().CPlusPlus11 || !IsCXXAutoType))
3533 Error = 13;
3534
3535 SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc();
3536 if (D.getName().getKind() == UnqualifiedIdKind::IK_ConversionFunctionId)
3537 AutoRange = D.getName().getSourceRange();
3538
3539 if (Error != -1) {
3540 unsigned Kind;
3541 if (Auto) {
3542 switch (Auto->getKeyword()) {
3543 case AutoTypeKeyword::Auto: Kind = 0; break;
3544 case AutoTypeKeyword::DecltypeAuto: Kind = 1; break;
3545 case AutoTypeKeyword::GNUAutoType: Kind = 2; break;
3546 }
3547 } else {
3548 assert(isa<DeducedTemplateSpecializationType>(Deduced) &&(static_cast<void> (0))
3549 "unknown auto type")(static_cast<void> (0));
3550 Kind = 3;
3551 }
3552
3553 auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
3554 TemplateName TN = DTST ? DTST->getTemplateName() : TemplateName();
3555
3556 SemaRef.Diag(AutoRange.getBegin(), diag::err_auto_not_allowed)
3557 << Kind << Error << (int)SemaRef.getTemplateNameKindForDiagnostics(TN)
3558 << QualType(Deduced, 0) << AutoRange;
3559 if (auto *TD = TN.getAsTemplateDecl())
3560 SemaRef.Diag(TD->getLocation(), diag::note_template_decl_here);
3561
3562 T = SemaRef.Context.IntTy;
3563 D.setInvalidType(true);
3564 } else if (Auto && D.getContext() != DeclaratorContext::LambdaExpr) {
3565 // If there was a trailing return type, we already got
3566 // warn_cxx98_compat_trailing_return_type in the parser.
3567 SemaRef.Diag(AutoRange.getBegin(),
3568 D.getContext() == DeclaratorContext::LambdaExprParameter
3569 ? diag::warn_cxx11_compat_generic_lambda
3570 : IsDeducedReturnType
3571 ? diag::warn_cxx11_compat_deduced_return_type
3572 : diag::warn_cxx98_compat_auto_type_specifier)
3573 << AutoRange;
3574 }
3575 }
3576
3577 if (SemaRef.getLangOpts().CPlusPlus &&
3578 OwnedTagDecl && OwnedTagDecl->isCompleteDefinition()) {
3579 // Check the contexts where C++ forbids the declaration of a new class
3580 // or enumeration in a type-specifier-seq.
3581 unsigned DiagID = 0;
3582 switch (D.getContext()) {
3583 case DeclaratorContext::TrailingReturn:
3584 case DeclaratorContext::TrailingReturnVar:
3585 // Class and enumeration definitions are syntactically not allowed in
3586 // trailing return types.
3587 llvm_unreachable("parser should not have allowed this")__builtin_unreachable();
3588 break;
3589 case DeclaratorContext::File:
3590 case DeclaratorContext::Member:
3591 case DeclaratorContext::Block:
3592 case DeclaratorContext::ForInit:
3593 case DeclaratorContext::SelectionInit:
3594 case DeclaratorContext::BlockLiteral:
3595 case DeclaratorContext::LambdaExpr:
3596 // C++11 [dcl.type]p3:
3597 // A type-specifier-seq shall not define a class or enumeration unless
3598 // it appears in the type-id of an alias-declaration (7.1.3) that is not
3599 // the declaration of a template-declaration.
3600 case DeclaratorContext::AliasDecl:
3601 break;
3602 case DeclaratorContext::AliasTemplate:
3603 DiagID = diag::err_type_defined_in_alias_template;
3604 break;
3605 case DeclaratorContext::TypeName:
3606 case DeclaratorContext::FunctionalCast:
3607 case DeclaratorContext::ConversionId:
3608 case DeclaratorContext::TemplateParam:
3609 case DeclaratorContext::CXXNew:
3610 case DeclaratorContext::CXXCatch:
3611 case DeclaratorContext::ObjCCatch:
3612 case DeclaratorContext::TemplateArg:
3613 case DeclaratorContext::TemplateTypeArg:
3614 DiagID = diag::err_type_defined_in_type_specifier;
3615 break;
3616 case DeclaratorContext::Prototype:
3617 case DeclaratorContext::LambdaExprParameter:
3618 case DeclaratorContext::ObjCParameter:
3619 case DeclaratorContext::ObjCResult:
3620 case DeclaratorContext::KNRTypeList:
3621 case DeclaratorContext::RequiresExpr:
3622 // C++ [dcl.fct]p6:
3623 // Types shall not be defined in return or parameter types.
3624 DiagID = diag::err_type_defined_in_param_type;
3625 break;
3626 case DeclaratorContext::Condition:
3627 // C++ 6.4p2:
3628 // The type-specifier-seq shall not contain typedef and shall not declare
3629 // a new class or enumeration.
3630 DiagID = diag::err_type_defined_in_condition;
3631 break;
3632 }
3633
3634 if (DiagID != 0) {
3635 SemaRef.Diag(OwnedTagDecl->getLocation(), DiagID)
3636 << SemaRef.Context.getTypeDeclType(OwnedTagDecl);
3637 D.setInvalidType(true);
3638 }
3639 }
3640
3641 assert(!T.isNull() && "This function should not return a null type")(static_cast<void> (0));
3642 return T;
3643}
3644
3645/// Produce an appropriate diagnostic for an ambiguity between a function
3646/// declarator and a C++ direct-initializer.
3647static void warnAboutAmbiguousFunction(Sema &S, Declarator &D,
3648 DeclaratorChunk &DeclType, QualType RT) {
3649 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
3650 assert(FTI.isAmbiguous && "no direct-initializer / function ambiguity")(static_cast<void> (0));
3651
3652 // If the return type is void there is no ambiguity.
3653 if (RT->isVoidType())
3654 return;
3655
3656 // An initializer for a non-class type can have at most one argument.
3657 if (!RT->isRecordType() && FTI.NumParams > 1)
3658 return;
3659
3660 // An initializer for a reference must have exactly one argument.
3661 if (RT->isReferenceType() && FTI.NumParams != 1)
3662 return;
3663
3664 // Only warn if this declarator is declaring a function at block scope, and
3665 // doesn't have a storage class (such as 'extern') specified.
3666 if (!D.isFunctionDeclarator() ||
3667 D.getFunctionDefinitionKind() != FunctionDefinitionKind::Declaration ||
3668 !S.CurContext->isFunctionOrMethod() ||
3669 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_unspecified)
3670 return;
3671
3672 // Inside a condition, a direct initializer is not permitted. We allow one to
3673 // be parsed in order to give better diagnostics in condition parsing.
3674 if (D.getContext() == DeclaratorContext::Condition)
3675 return;
3676
3677 SourceRange ParenRange(DeclType.Loc, DeclType.EndLoc);
3678
3679 S.Diag(DeclType.Loc,
3680 FTI.NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3681 : diag::warn_empty_parens_are_function_decl)
3682 << ParenRange;
3683
3684 // If the declaration looks like:
3685 // T var1,
3686 // f();
3687 // and name lookup finds a function named 'f', then the ',' was
3688 // probably intended to be a ';'.
3689 if (!D.isFirstDeclarator() && D.getIdentifier()) {
3690 FullSourceLoc Comma(D.getCommaLoc(), S.SourceMgr);
3691 FullSourceLoc Name(D.getIdentifierLoc(), S.SourceMgr);
3692 if (Comma.getFileID() != Name.getFileID() ||
3693 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3694 LookupResult Result(S, D.getIdentifier(), SourceLocation(),
3695 Sema::LookupOrdinaryName);
3696 if (S.LookupName(Result, S.getCurScope()))
3697 S.Diag(D.getCommaLoc(), diag::note_empty_parens_function_call)
3698 << FixItHint::CreateReplacement(D.getCommaLoc(), ";")
3699 << D.getIdentifier();
3700 Result.suppressDiagnostics();
3701 }
3702 }
3703
3704 if (FTI.NumParams > 0) {
3705 // For a declaration with parameters, eg. "T var(T());", suggest adding
3706 // parens around the first parameter to turn the declaration into a
3707 // variable declaration.
3708 SourceRange Range = FTI.Params[0].Param->getSourceRange();
3709 SourceLocation B = Range.getBegin();
3710 SourceLocation E = S.getLocForEndOfToken(Range.getEnd());
3711 // FIXME: Maybe we should suggest adding braces instead of parens
3712 // in C++11 for classes that don't have an initializer_list constructor.
3713 S.Diag(B, diag::note_additional_parens_for_variable_declaration)
3714 << FixItHint::CreateInsertion(B, "(")
3715 << FixItHint::CreateInsertion(E, ")");
3716 } else {
3717 // For a declaration without parameters, eg. "T var();", suggest replacing
3718 // the parens with an initializer to turn the declaration into a variable
3719 // declaration.
3720 const CXXRecordDecl *RD = RT->getAsCXXRecordDecl();
3721
3722 // Empty parens mean value-initialization, and no parens mean
3723 // default initialization. These are equivalent if the default
3724 // constructor is user-provided or if zero-initialization is a
3725 // no-op.
3726 if (RD && RD->hasDefinition() &&
3727 (RD->isEmpty() || RD->hasUserProvidedDefaultConstructor()))
3728 S.Diag(DeclType.Loc, diag::note_empty_parens_default_ctor)
3729 << FixItHint::CreateRemoval(ParenRange);
3730 else {
3731 std::string Init =
3732 S.getFixItZeroInitializerForType(RT, ParenRange.getBegin());
3733 if (Init.empty() && S.LangOpts.CPlusPlus11)
3734 Init = "{}";
3735 if (!Init.empty())
3736 S.Diag(DeclType.Loc, diag::note_empty_parens_zero_initialize)
3737 << FixItHint::CreateReplacement(ParenRange, Init);
3738 }
3739 }
3740}
3741
3742/// Produce an appropriate diagnostic for a declarator with top-level
3743/// parentheses.
3744static void warnAboutRedundantParens(Sema &S, Declarator &D, QualType T) {
3745 DeclaratorChunk &Paren = D.getTypeObject(D.getNumTypeObjects() - 1);
3746 assert(Paren.Kind == DeclaratorChunk::Paren &&(static_cast<void> (0))
3747 "do not have redundant top-level parentheses")(static_cast<void> (0));
3748
3749 // This is a syntactic check; we're not interested in cases that arise
3750 // during template instantiation.
3751 if (S.inTemplateInstantiation())
3752 return;
3753
3754 // Check whether this could be intended to be a construction of a temporary
3755 // object in C++ via a function-style cast.
3756 bool CouldBeTemporaryObject =
3757 S.getLangOpts().CPlusPlus && D.isExpressionContext() &&
3758 !D.isInvalidType() && D.getIdentifier() &&
3759 D.getDeclSpec().getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3760 (T->isRecordType() || T->isDependentType()) &&
3761 D.getDeclSpec().getTypeQualifiers() == 0 && D.isFirstDeclarator();
3762
3763 bool StartsWithDeclaratorId = true;
3764 for (auto &C : D.type_objects()) {
3765 switch (C.Kind) {
3766 case DeclaratorChunk::Paren:
3767 if (&C == &Paren)
3768 continue;
3769 LLVM_FALLTHROUGH[[gnu::fallthrough]];
3770 case DeclaratorChunk::Pointer:
3771 StartsWithDeclaratorId = false;
3772 continue;
3773
3774 case DeclaratorChunk::Array:
3775 if (!C.Arr.NumElts)
3776 CouldBeTemporaryObject = false;
3777 continue;
3778
3779 case DeclaratorChunk::Reference:
3780 // FIXME: Suppress the warning here if there is no initializer; we're
3781 // going to give an error anyway.
3782 // We assume that something like 'T (&x) = y;' is highly likely to not
3783 // be intended to be a temporary object.
3784 CouldBeTemporaryObject = false;
3785 StartsWithDeclaratorId = false;
3786 continue;
3787
3788 case DeclaratorChunk::Function:
3789 // In a new-type-id, function chunks require parentheses.
3790 if (D.getContext() == DeclaratorContext::CXXNew)
3791 return;
3792 // FIXME: "A(f())" deserves a vexing-parse warning, not just a
3793 // redundant-parens warning, but we don't know whether the function
3794 // chunk was syntactically valid as an expression here.
3795 CouldBeTemporaryObject = false;
3796 continue;
3797
3798 case DeclaratorChunk::BlockPointer:
3799 case DeclaratorChunk::MemberPointer:
3800 case DeclaratorChunk::Pipe:
3801 // These cannot appear in expressions.
3802 CouldBeTemporaryObject = false;
3803 StartsWithDeclaratorId = false;
3804 continue;
3805 }
3806 }
3807
3808 // FIXME: If there is an initializer, assume that this is not intended to be
3809 // a construction of a temporary object.
3810
3811 // Check whether the name has already been declared; if not, this is not a
3812 // function-style cast.
3813 if (CouldBeTemporaryObject) {
3814 LookupResult Result(S, D.getIdentifier(), SourceLocation(),
3815 Sema::LookupOrdinaryName);
3816 if (!S.LookupName(Result, S.getCurScope()))
3817 CouldBeTemporaryObject = false;
3818 Result.suppressDiagnostics();
3819 }
3820
3821 SourceRange ParenRange(Paren.Loc, Paren.EndLoc);
3822
3823 if (!CouldBeTemporaryObject) {
3824 // If we have A (::B), the parentheses affect the meaning of the program.
3825 // Suppress the warning in that case. Don't bother looking at the DeclSpec
3826 // here: even (e.g.) "int ::x" is visually ambiguous even though it's
3827 // formally unambiguous.
3828 if (StartsWithDeclaratorId && D.getCXXScopeSpec().isValid()) {
3829 for (NestedNameSpecifier *NNS = D.getCXXScopeSpec().getScopeRep(); NNS;
3830 NNS = NNS->getPrefix()) {
3831 if (NNS->getKind() == NestedNameSpecifier::Global)
3832 return;
3833 }
3834 }
3835
3836 S.Diag(Paren.Loc, diag::warn_redundant_parens_around_declarator)
3837 << ParenRange << FixItHint::CreateRemoval(Paren.Loc)
3838 << FixItHint::CreateRemoval(Paren.EndLoc);
3839 return;
3840 }
3841
3842 S.Diag(Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3843 << ParenRange << D.getIdentifier();
3844 auto *RD = T->getAsCXXRecordDecl();
3845 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3846 S.Diag(Paren.Loc, diag::note_raii_guard_add_name)
3847 << FixItHint::CreateInsertion(Paren.Loc, " varname") << T
3848 << D.getIdentifier();
3849 // FIXME: A cast to void is probably a better suggestion in cases where it's
3850 // valid (when there is no initializer and we're not in a condition).
3851 S.Diag(D.getBeginLoc(), diag::note_function_style_cast_add_parentheses)
3852 << FixItHint::CreateInsertion(D.getBeginLoc(), "(")
3853 << FixItHint::CreateInsertion(S.getLocForEndOfToken(D.getEndLoc()), ")");
3854 S.Diag(Paren.Loc, diag::note_remove_parens_for_variable_declaration)
3855 << FixItHint::CreateRemoval(Paren.Loc)
3856 << FixItHint::CreateRemoval(Paren.EndLoc);
3857}
3858
3859/// Helper for figuring out the default CC for a function declarator type. If
3860/// this is the outermost chunk, then we can determine the CC from the
3861/// declarator context. If not, then this could be either a member function
3862/// type or normal function type.
3863static CallingConv getCCForDeclaratorChunk(
3864 Sema &S, Declarator &D, const ParsedAttributesView &AttrList,
3865 const DeclaratorChunk::FunctionTypeInfo &FTI, unsigned ChunkIndex) {
3866 assert(D.getTypeObject(ChunkIndex).Kind == DeclaratorChunk::Function)(static_cast<void> (0));
3867
3868 // Check for an explicit CC attribute.
3869 for (const ParsedAttr &AL : AttrList) {
3870 switch (AL.getKind()) {
3871 CALLING_CONV_ATTRS_CASELISTcase ParsedAttr::AT_CDecl: case ParsedAttr::AT_FastCall: case
ParsedAttr::AT_StdCall: case ParsedAttr::AT_ThisCall: case ParsedAttr
::AT_RegCall: case ParsedAttr::AT_Pascal: case ParsedAttr::AT_SwiftCall
: case ParsedAttr::AT_SwiftAsyncCall: case ParsedAttr::AT_VectorCall
: case ParsedAttr::AT_AArch64VectorPcs: case ParsedAttr::AT_MSABI
: case ParsedAttr::AT_SysVABI: case ParsedAttr::AT_Pcs: case ParsedAttr
::AT_IntelOclBicc: case ParsedAttr::AT_PreserveMost: case ParsedAttr
::AT_PreserveAll
: {
3872 // Ignore attributes that don't validate or can't apply to the
3873 // function type. We'll diagnose the failure to apply them in
3874 // handleFunctionTypeAttr.
3875 CallingConv CC;
3876 if (!S.CheckCallingConvAttr(AL, CC) &&
3877 (!FTI.isVariadic || supportsVariadicCall(CC))) {
3878 return CC;
3879 }
3880 break;
3881 }
3882
3883 default:
3884 break;
3885 }
3886 }
3887
3888 bool IsCXXInstanceMethod = false;
3889
3890 if (S.getLangOpts().CPlusPlus) {
3891 // Look inwards through parentheses to see if this chunk will form a
3892 // member pointer type or if we're the declarator. Any type attributes
3893 // between here and there will override the CC we choose here.
3894 unsigned I = ChunkIndex;
3895 bool FoundNonParen = false;
3896 while (I && !FoundNonParen) {
3897 --I;
3898 if (D.getTypeObject(I).Kind != DeclaratorChunk::Paren)
3899 FoundNonParen = true;
3900 }
3901
3902 if (FoundNonParen) {
3903 // If we're not the declarator, we're a regular function type unless we're
3904 // in a member pointer.
3905 IsCXXInstanceMethod =
3906 D.getTypeObject(I).Kind == DeclaratorChunk::MemberPointer;
3907 } else if (D.getContext() == DeclaratorContext::LambdaExpr) {
3908 // This can only be a call operator for a lambda, which is an instance
3909 // method.
3910 IsCXXInstanceMethod = true;
3911 } else {
3912 // We're the innermost decl chunk, so must be a function declarator.
3913 assert(D.isFunctionDeclarator())(static_cast<void> (0));
3914
3915 // If we're inside a record, we're declaring a method, but it could be
3916 // explicitly or implicitly static.
3917 IsCXXInstanceMethod =
3918 D.isFirstDeclarationOfMember() &&
3919 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
3920 !D.isStaticMember();
3921 }
3922 }
3923
3924 CallingConv CC = S.Context.getDefaultCallingConvention(FTI.isVariadic,
3925 IsCXXInstanceMethod);
3926
3927 // Attribute AT_OpenCLKernel affects the calling convention for SPIR
3928 // and AMDGPU targets, hence it cannot be treated as a calling
3929 // convention attribute. This is the simplest place to infer
3930 // calling convention for OpenCL kernels.
3931 if (S.getLangOpts().OpenCL) {
3932 for (const ParsedAttr &AL : D.getDeclSpec().getAttributes()) {
3933 if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
3934 CC = CC_OpenCLKernel;
3935 break;
3936 }
3937 }
3938 }
3939
3940 return CC;
3941}
3942
3943namespace {
3944 /// A simple notion of pointer kinds, which matches up with the various
3945 /// pointer declarators.
3946 enum class SimplePointerKind {
3947 Pointer,
3948 BlockPointer,
3949 MemberPointer,
3950 Array,
3951 };
3952} // end anonymous namespace
3953
3954IdentifierInfo *Sema::getNullabilityKeyword(NullabilityKind nullability) {
3955 switch (nullability) {
3956 case NullabilityKind::NonNull:
3957 if (!Ident__Nonnull)
3958 Ident__Nonnull = PP.getIdentifierInfo("_Nonnull");
3959 return Ident__Nonnull;
3960
3961 case NullabilityKind::Nullable:
3962 if (!Ident__Nullable)
3963 Ident__Nullable = PP.getIdentifierInfo("_Nullable");
3964 return Ident__Nullable;
3965
3966 case NullabilityKind::NullableResult:
3967 if (!Ident__Nullable_result)
3968 Ident__Nullable_result = PP.getIdentifierInfo("_Nullable_result");
3969 return Ident__Nullable_result;
3970
3971 case NullabilityKind::Unspecified:
3972 if (!Ident__Null_unspecified)
3973 Ident__Null_unspecified = PP.getIdentifierInfo("_Null_unspecified");
3974 return Ident__Null_unspecified;
3975 }
3976 llvm_unreachable("Unknown nullability kind.")__builtin_unreachable();
3977}
3978
3979/// Retrieve the identifier "NSError".
3980IdentifierInfo *Sema::getNSErrorIdent() {
3981 if (!Ident_NSError)
3982 Ident_NSError = PP.getIdentifierInfo("NSError");
3983
3984 return Ident_NSError;
3985}
3986
3987/// Check whether there is a nullability attribute of any kind in the given
3988/// attribute list.
3989static bool hasNullabilityAttr(const ParsedAttributesView &attrs) {
3990 for (const ParsedAttr &AL : attrs) {
3991 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
3992 AL.getKind() == ParsedAttr::AT_TypeNullable ||
3993 AL.getKind() == ParsedAttr::AT_TypeNullableResult ||
3994 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
3995 return true;
3996 }
3997
3998 return false;
3999}
4000
4001namespace {
4002 /// Describes the kind of a pointer a declarator describes.
4003 enum class PointerDeclaratorKind {
4004 // Not a pointer.
4005 NonPointer,
4006 // Single-level pointer.
4007 SingleLevelPointer,
4008 // Multi-level pointer (of any pointer kind).
4009 MultiLevelPointer,
4010 // CFFooRef*
4011 MaybePointerToCFRef,
4012 // CFErrorRef*
4013 CFErrorRefPointer,
4014 // NSError**
4015 NSErrorPointerPointer,
4016 };
4017
4018 /// Describes a declarator chunk wrapping a pointer that marks inference as
4019 /// unexpected.
4020 // These values must be kept in sync with diagnostics.
4021 enum class PointerWrappingDeclaratorKind {
4022 /// Pointer is top-level.
4023 None = -1,
4024 /// Pointer is an array element.
4025 Array = 0,
4026 /// Pointer is the referent type of a C++ reference.
4027 Reference = 1
4028 };
4029} // end anonymous namespace
4030
4031/// Classify the given declarator, whose type-specified is \c type, based on
4032/// what kind of pointer it refers to.
4033///
4034/// This is used to determine the default nullability.
4035static PointerDeclaratorKind
4036classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator,
4037 PointerWrappingDeclaratorKind &wrappingKind) {
4038 unsigned numNormalPointers = 0;
4039
4040 // For any dependent type, we consider it a non-pointer.
4041 if (type->isDependentType())
4042 return PointerDeclaratorKind::NonPointer;
4043
4044 // Look through the declarator chunks to identify pointers.
4045 for (unsigned i = 0, n = declarator.getNumTypeObjects(); i != n; ++i) {
4046 DeclaratorChunk &chunk = declarator.getTypeObject(i);
4047 switch (chunk.Kind) {
4048 case DeclaratorChunk::Array:
4049 if (numNormalPointers == 0)
4050 wrappingKind = PointerWrappingDeclaratorKind::Array;
4051 break;
4052
4053 case DeclaratorChunk::Function:
4054 case DeclaratorChunk::Pipe:
4055 break;
4056
4057 case DeclaratorChunk::BlockPointer:
4058 case DeclaratorChunk::MemberPointer:
4059 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
4060 : PointerDeclaratorKind::SingleLevelPointer;
4061
4062 case DeclaratorChunk::Paren:
4063 break;
4064
4065 case DeclaratorChunk::Reference:
4066 if (numNormalPointers == 0)
4067 wrappingKind = PointerWrappingDeclaratorKind::Reference;
4068 break;
4069
4070 case DeclaratorChunk::Pointer:
4071 ++numNormalPointers;
4072 if (numNormalPointers > 2)
4073 return PointerDeclaratorKind::MultiLevelPointer;
4074 break;
4075 }
4076 }
4077
4078 // Then, dig into the type specifier itself.
4079 unsigned numTypeSpecifierPointers = 0;
4080 do {
4081 // Decompose normal pointers.
4082 if (auto ptrType = type->getAs<PointerType>()) {
4083 ++numNormalPointers;
4084
4085 if (numNormalPointers > 2)
4086 return PointerDeclaratorKind::MultiLevelPointer;
4087
4088 type = ptrType->getPointeeType();
4089 ++numTypeSpecifierPointers;
4090 continue;
4091 }
4092
4093 // Decompose block pointers.
4094 if (type->getAs<BlockPointerType>()) {
4095 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
4096 : PointerDeclaratorKind::SingleLevelPointer;
4097 }
4098
4099 // Decompose member pointers.
4100 if (type->getAs<MemberPointerType>()) {
4101 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
4102 : PointerDeclaratorKind::SingleLevelPointer;
4103 }
4104
4105 // Look at Objective-C object pointers.
4106 if (auto objcObjectPtr = type->getAs<ObjCObjectPointerType>()) {
4107 ++numNormalPointers;
4108 ++numTypeSpecifierPointers;
4109
4110 // If this is NSError**, report that.
4111 if (auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
4112 if (objcClassDecl->getIdentifier() == S.getNSErrorIdent() &&
4113 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
4114 return PointerDeclaratorKind::NSErrorPointerPointer;
4115 }
4116 }
4117
4118 break;
4119 }
4120
4121 // Look at Objective-C class types.
4122 if (auto objcClass = type->getAs<ObjCInterfaceType>()) {
4123 if (objcClass->getInterface()->getIdentifier() == S.getNSErrorIdent()) {
4124 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
4125 return PointerDeclaratorKind::NSErrorPointerPointer;
4126 }
4127
4128 break;
4129 }
4130
4131 // If at this point we haven't seen a pointer, we won't see one.
4132 if (numNormalPointers == 0)
4133 return PointerDeclaratorKind::NonPointer;
4134
4135 if (auto recordType = type->getAs<RecordType>()) {
4136 RecordDecl *recordDecl = recordType->getDecl();
4137
4138 // If this is CFErrorRef*, report it as such.
4139 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2 &&
4140 S.isCFError(recordDecl)) {
4141 return PointerDeclaratorKind::CFErrorRefPointer;
4142 }
4143 break;
4144 }
4145
4146 break;
4147 } while (true);
4148
4149 switch (numNormalPointers) {
4150 case 0:
4151 return PointerDeclaratorKind::NonPointer;
4152
4153 case 1:
4154 return PointerDeclaratorKind::SingleLevelPointer;
4155
4156 case 2:
4157 return PointerDeclaratorKind::MaybePointerToCFRef;
4158
4159 default:
4160 return PointerDeclaratorKind::MultiLevelPointer;
4161 }
4162}
4163
4164bool Sema::isCFError(RecordDecl *RD) {
4165 // If we already know about CFError, test it directly.
4166 if (CFError)
4167 return CFError == RD;
4168
4169 // Check whether this is CFError, which we identify based on its bridge to
4170 // NSError. CFErrorRef used to be declared with "objc_bridge" but is now
4171 // declared with "objc_bridge_mutable", so look for either one of the two
4172 // attributes.
4173 if (RD->getTagKind() == TTK_Struct) {
4174 IdentifierInfo *bridgedType = nullptr;
4175 if (auto bridgeAttr = RD->getAttr<ObjCBridgeAttr>())
4176 bridgedType = bridgeAttr->getBridgedType();
4177 else if (auto bridgeAttr = RD->getAttr<ObjCBridgeMutableAttr>())
4178 bridgedType = bridgeAttr->getBridgedType();
4179
4180 if (bridgedType == getNSErrorIdent()) {
4181 CFError = RD;
4182 return true;
4183 }
4184 }
4185
4186 return false;
4187}
4188
4189static FileID getNullabilityCompletenessCheckFileID(Sema &S,
4190 SourceLocation loc) {
4191 // If we're anywhere in a function, method, or closure context, don't perform
4192 // completeness checks.
4193 for (DeclContext *ctx = S.CurContext; ctx; ctx = ctx->getParent()) {
4194 if (ctx->isFunctionOrMethod())
4195 return FileID();
4196
4197 if (ctx->isFileContext())
4198 break;
4199 }
4200
4201 // We only care about the expansion location.
4202 loc = S.SourceMgr.getExpansionLoc(loc);
4203 FileID file = S.SourceMgr.getFileID(loc);
4204 if (file.isInvalid())
4205 return FileID();
4206
4207 // Retrieve file information.
4208 bool invalid = false;
4209 const SrcMgr::SLocEntry &sloc = S.SourceMgr.getSLocEntry(file, &invalid);
4210 if (invalid || !sloc.isFile())
4211 return FileID();
4212
4213 // We don't want to perform completeness checks on the main file or in
4214 // system headers.
4215 const SrcMgr::FileInfo &fileInfo = sloc.getFile();
4216 if (fileInfo.getIncludeLoc().isInvalid())
4217 return FileID();
4218 if (fileInfo.getFileCharacteristic() != SrcMgr::C_User &&
4219 S.Diags.getSuppressSystemWarnings()) {
4220 return FileID();
4221 }
4222
4223 return file;
4224}
4225
4226/// Creates a fix-it to insert a C-style nullability keyword at \p pointerLoc,
4227/// taking into account whitespace before and after.
4228template <typename DiagBuilderT>
4229static void fixItNullability(Sema &S, DiagBuilderT &Diag,
4230 SourceLocation PointerLoc,
4231 NullabilityKind Nullability) {
4232 assert(PointerLoc.isValid())(static_cast<void> (0));
4233 if (PointerLoc.isMacroID())
4234 return;
4235
4236 SourceLocation FixItLoc = S.getLocForEndOfToken(PointerLoc);
4237 if (!FixItLoc.isValid() || FixItLoc == PointerLoc)
4238 return;
4239
4240 const char *NextChar = S.SourceMgr.getCharacterData(FixItLoc);
4241 if (!NextChar)
4242 return;
4243
4244 SmallString<32> InsertionTextBuf{" "};
4245 InsertionTextBuf += getNullabilitySpelling(Nullability);
4246 InsertionTextBuf += " ";
4247 StringRef InsertionText = InsertionTextBuf.str();
4248
4249 if (isWhitespace(*NextChar)) {
4250 InsertionText = InsertionText.drop_back();
4251 } else if (NextChar[-1] == '[') {
4252 if (NextChar[0] == ']')
4253 InsertionText = InsertionText.drop_back().drop_front();
4254 else
4255 InsertionText = InsertionText.drop_front();
4256 } else if (!isIdentifierBody(NextChar[0], /*allow dollar*/true) &&
4257 !isIdentifierBody(NextChar[-1], /*allow dollar*/true)) {
4258 InsertionText = InsertionText.drop_back().drop_front();
4259 }
4260
4261 Diag << FixItHint::CreateInsertion(FixItLoc, InsertionText);
4262}
4263
4264static void emitNullabilityConsistencyWarning(Sema &S,
4265 SimplePointerKind PointerKind,
4266 SourceLocation PointerLoc,
4267 SourceLocation PointerEndLoc) {
4268 assert(PointerLoc.isValid())(static_cast<void> (0));
4269
4270 if (PointerKind == SimplePointerKind::Array) {
4271 S.Diag(PointerLoc, diag::warn_nullability_missing_array);
4272 } else {
4273 S.Diag(PointerLoc, diag::warn_nullability_missing)
4274 << static_cast<unsigned>(PointerKind);
4275 }
4276
4277 auto FixItLoc = PointerEndLoc.isValid() ? PointerEndLoc : PointerLoc;
4278 if (FixItLoc.isMacroID())
4279 return;
4280
4281 auto addFixIt = [&](NullabilityKind Nullability) {
4282 auto Diag = S.Diag(FixItLoc, diag::note_nullability_fix_it);
4283 Diag << static_cast<unsigned>(Nullability);
4284 Diag << static_cast<unsigned>(PointerKind);
4285 fixItNullability(S, Diag, FixItLoc, Nullability);
4286 };
4287 addFixIt(NullabilityKind::Nullable);
4288 addFixIt(NullabilityKind::NonNull);
4289}
4290
4291/// Complains about missing nullability if the file containing \p pointerLoc
4292/// has other uses of nullability (either the keywords or the \c assume_nonnull
4293/// pragma).
4294///
4295/// If the file has \e not seen other uses of nullability, this particular
4296/// pointer is saved for possible later diagnosis. See recordNullabilitySeen().
4297static void
4298checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind,
4299 SourceLocation pointerLoc,
4300 SourceLocation pointerEndLoc = SourceLocation()) {
4301 // Determine which file we're performing consistency checking for.
4302 FileID file = getNullabilityCompletenessCheckFileID(S, pointerLoc);
4303 if (file.isInvalid())
4304 return;
4305
4306 // If we haven't seen any type nullability in this file, we won't warn now
4307 // about anything.
4308 FileNullability &fileNullability = S.NullabilityMap[file];
4309 if (!fileNullability.SawTypeNullability) {
4310 // If this is the first pointer declarator in the file, and the appropriate
4311 // warning is on, record it in case we need to diagnose it retroactively.
4312 diag::kind diagKind;
4313 if (pointerKind == SimplePointerKind::Array)
4314 diagKind = diag::warn_nullability_missing_array;
4315 else
4316 diagKind = diag::warn_nullability_missing;
4317
4318 if (fileNullability.PointerLoc.isInvalid() &&
4319 !S.Context.getDiagnostics().isIgnored(diagKind, pointerLoc)) {
4320 fileNullability.PointerLoc = pointerLoc;
4321 fileNullability.PointerEndLoc = pointerEndLoc;
4322 fileNullability.PointerKind = static_cast<unsigned>(pointerKind);
4323 }
4324
4325 return;
4326 }
4327
4328 // Complain about missing nullability.
4329 emitNullabilityConsistencyWarning(S, pointerKind, pointerLoc, pointerEndLoc);
4330}
4331
4332/// Marks that a nullability feature has been used in the file containing
4333/// \p loc.
4334///
4335/// If this file already had pointer types in it that were missing nullability,
4336/// the first such instance is retroactively diagnosed.
4337///
4338/// \sa checkNullabilityConsistency
4339static void recordNullabilitySeen(Sema &S, SourceLocation loc) {
4340 FileID file = getNullabilityCompletenessCheckFileID(S, loc);
4341 if (file.isInvalid())
4342 return;
4343
4344 FileNullability &fileNullability = S.NullabilityMap[file];
4345 if (fileNullability.SawTypeNullability)
4346 return;
4347 fileNullability.SawTypeNullability = true;
4348
4349 // If we haven't seen any type nullability before, now we have. Retroactively
4350 // diagnose the first unannotated pointer, if there was one.
4351 if (fileNullability.PointerLoc.isInvalid())
4352 return;
4353
4354 auto kind = static_cast<SimplePointerKind>(fileNullability.PointerKind);
4355 emitNullabilityConsistencyWarning(S, kind, fileNullability.PointerLoc,
4356 fileNullability.PointerEndLoc);
4357}
4358
4359/// Returns true if any of the declarator chunks before \p endIndex include a
4360/// level of indirection: array, pointer, reference, or pointer-to-member.
4361///
4362/// Because declarator chunks are stored in outer-to-inner order, testing
4363/// every chunk before \p endIndex is testing all chunks that embed the current
4364/// chunk as part of their type.
4365///
4366/// It is legal to pass the result of Declarator::getNumTypeObjects() as the
4367/// end index, in which case all chunks are tested.
4368static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex) {
4369 unsigned i = endIndex;
4370 while (i != 0) {
4371 // Walk outwards along the declarator chunks.
4372 --i;
4373 const DeclaratorChunk &DC = D.getTypeObject(i);
4374 switch (DC.Kind) {
4375 case DeclaratorChunk::Paren:
4376 break;
4377 case DeclaratorChunk::Array:
4378 case DeclaratorChunk::Pointer:
4379 case DeclaratorChunk::Reference:
4380 case DeclaratorChunk::MemberPointer:
4381 return true;
4382 case DeclaratorChunk::Function:
4383 case DeclaratorChunk::BlockPointer:
4384 case DeclaratorChunk::Pipe:
4385 // These are invalid anyway, so just ignore.
4386 break;
4387 }
4388 }
4389 return false;
4390}
4391
4392static bool IsNoDerefableChunk(DeclaratorChunk Chunk) {
4393 return (Chunk.Kind == DeclaratorChunk::Pointer ||
4394 Chunk.Kind == DeclaratorChunk::Array);
4395}
4396
4397template<typename AttrT>
4398static AttrT *createSimpleAttr(ASTContext &Ctx, ParsedAttr &AL) {
4399 AL.setUsedAsTypeAttr();
4400 return ::new (Ctx) AttrT(Ctx, AL);
4401}
4402
4403static Attr *createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr,
4404 NullabilityKind NK) {
4405 switch (NK) {
4406 case NullabilityKind::NonNull:
4407 return createSimpleAttr<TypeNonNullAttr>(Ctx, Attr);
4408
4409 case NullabilityKind::Nullable:
4410 return createSimpleAttr<TypeNullableAttr>(Ctx, Attr);
4411
4412 case NullabilityKind::NullableResult:
4413 return createSimpleAttr<TypeNullableResultAttr>(Ctx, Attr);
4414
4415 case NullabilityKind::Unspecified:
4416 return createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx, Attr);
4417 }
4418 llvm_unreachable("unknown NullabilityKind")__builtin_unreachable();
4419}
4420
4421// Diagnose whether this is a case with the multiple addr spaces.
4422// Returns true if this is an invalid case.
4423// ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "No type shall be qualified
4424// by qualifiers for two or more different address spaces."
4425static bool DiagnoseMultipleAddrSpaceAttributes(Sema &S, LangAS ASOld,
4426 LangAS ASNew,
4427 SourceLocation AttrLoc) {
4428 if (ASOld != LangAS::Default) {
4429 if (ASOld != ASNew) {
4430 S.Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
4431 return true;
4432 }
4433 // Emit a warning if they are identical; it's likely unintended.
4434 S.Diag(AttrLoc,
4435 diag::warn_attribute_address_multiple_identical_qualifiers);
4436 }
4437 return false;
4438}
4439
4440static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
4441 QualType declSpecType,
4442 TypeSourceInfo *TInfo) {
4443 // The TypeSourceInfo that this function returns will not be a null type.
4444 // If there is an error, this function will fill in a dummy type as fallback.
4445 QualType T = declSpecType;
4446 Declarator &D = state.getDeclarator();
4447 Sema &S = state.getSema();
4448 ASTContext &Context = S.Context;
4449 const LangOptions &LangOpts = S.getLangOpts();
4450
4451 // The name we're declaring, if any.
4452 DeclarationName Name;
4453 if (D.getIdentifier())
4454 Name = D.getIdentifier();
4455
4456 // Does this declaration declare a typedef-name?
4457 bool IsTypedefName =
4458 D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef ||
1
Assuming the condition is false
4459 D.getContext() == DeclaratorContext::AliasDecl ||
2
Assuming the condition is false
4460 D.getContext() == DeclaratorContext::AliasTemplate;
3
Assuming the condition is false
4461
4462 // Does T refer to a function type with a cv-qualifier or a ref-qualifier?
4463 bool IsQualifiedFunction = T->isFunctionProtoType() &&
4464 (!T->castAs<FunctionProtoType>()->getMethodQuals().empty() ||
4465 T->castAs<FunctionProtoType>()->getRefQualifier() != RQ_None);
4466
4467 // If T is 'decltype(auto)', the only declarators we can have are parens
4468 // and at most one function declarator if this is a function declaration.
4469 // If T is a deduced class template specialization type, we can have no
4470 // declarator chunks at all.
4471 if (auto *DT
4.1
'DT' is null
4.1
'DT' is null
4.1
'DT' is null
4.1
'DT' is null
4.1
'DT' is null
= T->getAs<DeducedType>()) {
4
Assuming the object is not a 'DeducedType'
5
Taking false branch
4472 const AutoType *AT = T->getAs<AutoType>();
4473 bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
4474 if ((AT && AT->isDecltypeAuto()) || IsClassTemplateDeduction) {
4475 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
4476 unsigned Index = E - I - 1;
4477 DeclaratorChunk &DeclChunk = D.getTypeObject(Index);
4478 unsigned DiagId = IsClassTemplateDeduction
4479 ? diag::err_deduced_class_template_compound_type
4480 : diag::err_decltype_auto_compound_type;
4481 unsigned DiagKind = 0;
4482 switch (DeclChunk.Kind) {
4483 case DeclaratorChunk::Paren:
4484 // FIXME: Rejecting this is a little silly.
4485 if (IsClassTemplateDeduction) {
4486 DiagKind = 4;
4487 break;
4488 }
4489 continue;
4490 case DeclaratorChunk::Function: {
4491 if (IsClassTemplateDeduction) {
4492 DiagKind = 3;
4493 break;
4494 }
4495 unsigned FnIndex;
4496 if (D.isFunctionDeclarationContext() &&
4497 D.isFunctionDeclarator(FnIndex) && FnIndex == Index)
4498 continue;
4499 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
4500 break;
4501 }
4502 case DeclaratorChunk::Pointer:
4503 case DeclaratorChunk::BlockPointer:
4504 case DeclaratorChunk::MemberPointer:
4505 DiagKind = 0;
4506 break;
4507 case DeclaratorChunk::Reference:
4508 DiagKind = 1;
4509 break;
4510 case DeclaratorChunk::Array:
4511 DiagKind = 2;
4512 break;
4513 case DeclaratorChunk::Pipe:
4514 break;
4515 }
4516
4517 S.Diag(DeclChunk.Loc, DiagId) << DiagKind;
4518 D.setInvalidType(true);
4519 break;
4520 }
4521 }
4522 }
4523
4524 // Determine whether we should infer _Nonnull on pointer types.
4525 Optional<NullabilityKind> inferNullability;
4526 bool inferNullabilityCS = false;
4527 bool inferNullabilityInnerOnly = false;
4528 bool inferNullabilityInnerOnlyComplete = false;
4529
4530 // Are we in an assume-nonnull region?
4531 bool inAssumeNonNullRegion = false;
4532 SourceLocation assumeNonNullLoc = S.PP.getPragmaAssumeNonNullLoc();
4533 if (assumeNonNullLoc.isValid()) {
6
Taking false branch
4534 inAssumeNonNullRegion = true;
4535 recordNullabilitySeen(S, assumeNonNullLoc);
4536 }
4537
4538 // Whether to complain about missing nullability specifiers or not.
4539 enum {
4540 /// Never complain.
4541 CAMN_No,
4542 /// Complain on the inner pointers (but not the outermost
4543 /// pointer).
4544 CAMN_InnerPointers,
4545 /// Complain about any pointers that don't have nullability
4546 /// specified or inferred.
4547 CAMN_Yes
4548 } complainAboutMissingNullability = CAMN_No;
4549 unsigned NumPointersRemaining = 0;
4550 auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
4551
4552 if (IsTypedefName
6.1
'IsTypedefName' is false
6.1
'IsTypedefName' is false
6.1
'IsTypedefName' is false
6.1
'IsTypedefName' is false
6.1
'IsTypedefName' is false
) {
7
Taking false branch
4553 // For typedefs, we do not infer any nullability (the default),
4554 // and we only complain about missing nullability specifiers on
4555 // inner pointers.
4556 complainAboutMissingNullability = CAMN_InnerPointers;
4557
4558 if (T->canHaveNullability(/*ResultIfUnknown*/false) &&
4559 !T->getNullability(S.Context)) {
4560 // Note that we allow but don't require nullability on dependent types.
4561 ++NumPointersRemaining;
4562 }
4563
4564 for (unsigned i = 0, n = D.getNumTypeObjects(); i != n; ++i) {
4565 DeclaratorChunk &chunk = D.getTypeObject(i);
4566 switch (chunk.Kind) {
4567 case DeclaratorChunk::Array:
4568 case DeclaratorChunk::Function:
4569 case DeclaratorChunk::Pipe:
4570 break;
4571
4572 case DeclaratorChunk::BlockPointer:
4573 case DeclaratorChunk::MemberPointer:
4574 ++NumPointersRemaining;
4575 break;
4576
4577 case DeclaratorChunk::Paren:
4578 case DeclaratorChunk::Reference:
4579 continue;
4580
4581 case DeclaratorChunk::Pointer:
4582 ++NumPointersRemaining;
4583 continue;
4584 }
4585 }
4586 } else {
4587 bool isFunctionOrMethod = false;
4588 switch (auto context = state.getDeclarator().getContext()) {
8
Control jumps to 'case Block:' at line 4671
4589 case DeclaratorContext::ObjCParameter:
4590 case DeclaratorContext::ObjCResult:
4591 case DeclaratorContext::Prototype:
4592 case DeclaratorContext::TrailingReturn:
4593 case DeclaratorContext::TrailingReturnVar:
4594 isFunctionOrMethod = true;
4595 LLVM_FALLTHROUGH[[gnu::fallthrough]];
4596
4597 case DeclaratorContext::Member:
4598 if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) {
4599 complainAboutMissingNullability = CAMN_No;
4600 break;
4601 }
4602
4603 // Weak properties are inferred to be nullable.
4604 if (state.getDeclarator().isObjCWeakProperty() && inAssumeNonNullRegion) {
4605 inferNullability = NullabilityKind::Nullable;
4606 break;
4607 }
4608
4609 LLVM_FALLTHROUGH[[gnu::fallthrough]];
4610
4611 case DeclaratorContext::File:
4612 case DeclaratorContext::KNRTypeList: {
4613 complainAboutMissingNullability = CAMN_Yes;
4614
4615 // Nullability inference depends on the type and declarator.
4616 auto wrappingKind = PointerWrappingDeclaratorKind::None;
4617 switch (classifyPointerDeclarator(S, T, D, wrappingKind)) {
4618 case PointerDeclaratorKind::NonPointer:
4619 case PointerDeclaratorKind::MultiLevelPointer:
4620 // Cannot infer nullability.
4621 break;
4622
4623 case PointerDeclaratorKind::SingleLevelPointer:
4624 // Infer _Nonnull if we are in an assumes-nonnull region.
4625 if (inAssumeNonNullRegion) {
4626 complainAboutInferringWithinChunk = wrappingKind;
4627 inferNullability = NullabilityKind::NonNull;
4628 inferNullabilityCS = (context == DeclaratorContext::ObjCParameter ||
4629 context == DeclaratorContext::ObjCResult);
4630 }
4631 break;
4632
4633 case PointerDeclaratorKind::CFErrorRefPointer:
4634 case PointerDeclaratorKind::NSErrorPointerPointer:
4635 // Within a function or method signature, infer _Nullable at both
4636 // levels.
4637 if (isFunctionOrMethod && inAssumeNonNullRegion)
4638 inferNullability = NullabilityKind::Nullable;
4639 break;
4640
4641 case PointerDeclaratorKind::MaybePointerToCFRef:
4642 if (isFunctionOrMethod) {
4643 // On pointer-to-pointer parameters marked cf_returns_retained or
4644 // cf_returns_not_retained, if the outer pointer is explicit then
4645 // infer the inner pointer as _Nullable.
4646 auto hasCFReturnsAttr =
4647 [](const ParsedAttributesView &AttrList) -> bool {
4648 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4649 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4650 };
4651 if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) {
4652 if (hasCFReturnsAttr(D.getAttributes()) ||
4653 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4654 hasCFReturnsAttr(D.getDeclSpec().getAttributes())) {
4655 inferNullability = NullabilityKind::Nullable;
4656 inferNullabilityInnerOnly = true;
4657 }
4658 }
4659 }
4660 break;
4661 }
4662 break;
4663 }
4664
4665 case DeclaratorContext::ConversionId:
4666 complainAboutMissingNullability = CAMN_Yes;
4667 break;
4668
4669 case DeclaratorContext::AliasDecl:
4670 case DeclaratorContext::AliasTemplate:
4671 case DeclaratorContext::Block:
4672 case DeclaratorContext::BlockLiteral:
4673 case DeclaratorContext::Condition:
4674 case DeclaratorContext::CXXCatch:
4675 case DeclaratorContext::CXXNew:
4676 case DeclaratorContext::ForInit:
4677 case DeclaratorContext::SelectionInit:
4678 case DeclaratorContext::LambdaExpr:
4679 case DeclaratorContext::LambdaExprParameter:
4680 case DeclaratorContext::ObjCCatch:
4681 case DeclaratorContext::TemplateParam:
4682 case DeclaratorContext::TemplateArg:
4683 case DeclaratorContext::TemplateTypeArg:
4684 case DeclaratorContext::TypeName:
4685 case DeclaratorContext::FunctionalCast:
4686 case DeclaratorContext::RequiresExpr:
4687 // Don't infer in these contexts.
4688 break;
9
Execution continues on line 4693
4689 }
4690 }
4691
4692 // Local function that returns true if its argument looks like a va_list.
4693 auto isVaList = [&S](QualType T) -> bool {
4694 auto *typedefTy = T->getAs<TypedefType>();
4695 if (!typedefTy)
4696 return false;
4697 TypedefDecl *vaListTypedef = S.Context.getBuiltinVaListDecl();
4698 do {
4699 if (typedefTy->getDecl() == vaListTypedef)
4700 return true;
4701 if (auto *name = typedefTy->getDecl()->getIdentifier())
4702 if (name->isStr("va_list"))
4703 return true;
4704 typedefTy = typedefTy->desugar()->getAs<TypedefType>();
4705 } while (typedefTy);
4706 return false;
4707 };
4708
4709 // Local function that checks the nullability for a given pointer declarator.
4710 // Returns true if _Nonnull was inferred.
4711 auto inferPointerNullability =
4712 [&](SimplePointerKind pointerKind, SourceLocation pointerLoc,
4713 SourceLocation pointerEndLoc,
4714 ParsedAttributesView &attrs, AttributePool &Pool) -> ParsedAttr * {
4715 // We've seen a pointer.
4716 if (NumPointersRemaining > 0)
4717 --NumPointersRemaining;
4718
4719 // If a nullability attribute is present, there's nothing to do.
4720 if (hasNullabilityAttr(attrs))
4721 return nullptr;
4722
4723 // If we're supposed to infer nullability, do so now.
4724 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4725 ParsedAttr::Syntax syntax = inferNullabilityCS
4726 ? ParsedAttr::AS_ContextSensitiveKeyword
4727 : ParsedAttr::AS_Keyword;
4728 ParsedAttr *nullabilityAttr = Pool.create(
4729 S.getNullabilityKeyword(*inferNullability), SourceRange(pointerLoc),
4730 nullptr, SourceLocation(), nullptr, 0, syntax);
4731
4732 attrs.addAtEnd(nullabilityAttr);
4733
4734 if (inferNullabilityCS) {
4735 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4736 ->setObjCDeclQualifier(ObjCDeclSpec::DQ_CSNullability);
4737 }
4738
4739 if (pointerLoc.isValid() &&
4740 complainAboutInferringWithinChunk !=
4741 PointerWrappingDeclaratorKind::None) {
4742 auto Diag =
4743 S.Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4744 Diag << static_cast<int>(complainAboutInferringWithinChunk);
4745 fixItNullability(S, Diag, pointerLoc, NullabilityKind::NonNull);
4746 }
4747
4748 if (inferNullabilityInnerOnly)
4749 inferNullabilityInnerOnlyComplete = true;
4750 return nullabilityAttr;
4751 }
4752
4753 // If we're supposed to complain about missing nullability, do so
4754 // now if it's truly missing.
4755 switch (complainAboutMissingNullability) {
4756 case CAMN_No:
4757 break;
4758
4759 case CAMN_InnerPointers:
4760 if (NumPointersRemaining == 0)
4761 break;
4762 LLVM_FALLTHROUGH[[gnu::fallthrough]];
4763
4764 case CAMN_Yes:
4765 checkNullabilityConsistency(S, pointerKind, pointerLoc, pointerEndLoc);
4766 }
4767 return nullptr;
4768 };
4769
4770 // If the type itself could have nullability but does not, infer pointer
4771 // nullability and perform consistency checking.
4772 if (S.CodeSynthesisContexts.empty()) {
10
Taking false branch
4773 if (T->canHaveNullability(/*ResultIfUnknown*/false) &&
4774 !T->getNullability(S.Context)) {
4775 if (isVaList(T)) {
4776 // Record that we've seen a pointer, but do nothing else.
4777 if (NumPointersRemaining > 0)
4778 --NumPointersRemaining;
4779 } else {
4780 SimplePointerKind pointerKind = SimplePointerKind::Pointer;
4781 if (T->isBlockPointerType())
4782 pointerKind = SimplePointerKind::BlockPointer;
4783 else if (T->isMemberPointerType())
4784 pointerKind = SimplePointerKind::MemberPointer;
4785
4786 if (auto *attr = inferPointerNullability(
4787 pointerKind, D.getDeclSpec().getTypeSpecTypeLoc(),
4788 D.getDeclSpec().getEndLoc(),
4789 D.getMutableDeclSpec().getAttributes(),
4790 D.getMutableDeclSpec().getAttributePool())) {
4791 T = state.getAttributedType(
4792 createNullabilityAttr(Context, *attr, *inferNullability), T, T);
4793 }
4794 }
4795 }
4796
4797 if (complainAboutMissingNullability == CAMN_Yes &&
4798 T->isArrayType() && !T->getNullability(S.Context) && !isVaList(T) &&
4799 D.isPrototypeContext() &&
4800 !hasOuterPointerLikeChunk(D, D.getNumTypeObjects())) {
4801 checkNullabilityConsistency(S, SimplePointerKind::Array,
4802 D.getDeclSpec().getTypeSpecTypeLoc());
4803 }
4804 }
4805
4806 bool ExpectNoDerefChunk =
4807 state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
4808
4809 // Walk the DeclTypeInfo, building the recursive type as we go.
4810 // DeclTypeInfos are ordered from the identifier out, which is
4811 // opposite of what we want :).
4812 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
11
Assuming 'i' is equal to 'e'
12
Loop condition is false. Execution continues on line 5496
4813 unsigned chunkIndex = e - i - 1;
4814 state.setCurrentChunkIndex(chunkIndex);
4815 DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex);
4816 IsQualifiedFunction &= DeclType.Kind == DeclaratorChunk::Paren;
4817 switch (DeclType.Kind) {
4818 case DeclaratorChunk::Paren:
4819 if (i == 0)
4820 warnAboutRedundantParens(S, D, T);
4821 T = S.BuildParenType(T);
4822 break;
4823 case DeclaratorChunk::BlockPointer:
4824 // If blocks are disabled, emit an error.
4825 if (!LangOpts.Blocks)
4826 S.Diag(DeclType.Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4827
4828 // Handle pointer nullability.
4829 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.Loc,
4830 DeclType.EndLoc, DeclType.getAttrs(),
4831 state.getDeclarator().getAttributePool());
4832
4833 T = S.BuildBlockPointerType(T, D.getIdentifierLoc(), Name);
4834 if (DeclType.Cls.TypeQuals || LangOpts.OpenCL) {
4835 // OpenCL v2.0, s6.12.5 - Block variable declarations are implicitly
4836 // qualified with const.
4837 if (LangOpts.OpenCL)
4838 DeclType.Cls.TypeQuals |= DeclSpec::TQ_const;
4839 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Cls.TypeQuals);
4840 }
4841 break;
4842 case DeclaratorChunk::Pointer:
4843 // Verify that we're not building a pointer to pointer to function with
4844 // exception specification.
4845 if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4846 S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4847 D.setInvalidType(true);
4848 // Build the type anyway.
4849 }
4850
4851 // Handle pointer nullability
4852 inferPointerNullability(SimplePointerKind::Pointer, DeclType.Loc,
4853 DeclType.EndLoc, DeclType.getAttrs(),
4854 state.getDeclarator().getAttributePool());
4855
4856 if (LangOpts.ObjC && T->getAs<ObjCObjectType>()) {
4857 T = Context.getObjCObjectPointerType(T);
4858 if (DeclType.Ptr.TypeQuals)
4859 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
4860 break;
4861 }
4862
4863 // OpenCL v2.0 s6.9b - Pointer to image/sampler cannot be used.
4864 // OpenCL v2.0 s6.13.16.1 - Pointer to pipe cannot be used.
4865 // OpenCL v2.0 s6.12.5 - Pointers to Blocks are not allowed.
4866 if (LangOpts.OpenCL) {
4867 if (T->isImageType() || T->isSamplerT() || T->isPipeType() ||
4868 T->isBlockPointerType()) {
4869 S.Diag(D.getIdentifierLoc(), diag::err_opencl_pointer_to_type) << T;
4870 D.setInvalidType(true);
4871 }
4872 }
4873
4874 T = S.BuildPointerType(T, DeclType.Loc, Name);
4875 if (DeclType.Ptr.TypeQuals)
4876 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
4877 break;
4878 case DeclaratorChunk::Reference: {
4879 // Verify that we're not building a reference to pointer to function with
4880 // exception specification.
4881 if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4882 S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4883 D.setInvalidType(true);
4884 // Build the type anyway.
4885 }
4886 T = S.BuildReferenceType(T, DeclType.Ref.LValueRef, DeclType.Loc, Name);
4887
4888 if (DeclType.Ref.HasRestrict)
4889 T = S.BuildQualifiedType(T, DeclType.Loc, Qualifiers::Restrict);
4890 break;
4891 }
4892 case DeclaratorChunk::Array: {
4893 // Verify that we're not building an array of pointers to function with
4894 // exception specification.
4895 if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4896 S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4897 D.setInvalidType(true);
4898 // Build the type anyway.
4899 }
4900 DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
4901 Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
4902 ArrayType::ArraySizeModifier ASM;
4903 if (ATI.isStar)
4904 ASM = ArrayType::Star;
4905 else if (ATI.hasStatic)
4906 ASM = ArrayType::Static;
4907 else
4908 ASM = ArrayType::Normal;
4909 if (ASM == ArrayType::Star && !D.isPrototypeContext()) {
4910 // FIXME: This check isn't quite right: it allows star in prototypes
4911 // for function definitions, and disallows some edge cases detailed
4912 // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html
4913 S.Diag(DeclType.Loc, diag::err_array_star_outside_prototype);
4914 ASM = ArrayType::Normal;
4915 D.setInvalidType(true);
4916 }
4917
4918 // C99 6.7.5.2p1: The optional type qualifiers and the keyword static
4919 // shall appear only in a declaration of a function parameter with an
4920 // array type, ...
4921 if (ASM == ArrayType::Static || ATI.TypeQuals) {
4922 if (!(D.isPrototypeContext() ||
4923 D.getContext() == DeclaratorContext::KNRTypeList)) {
4924 S.Diag(DeclType.Loc, diag::err_array_static_outside_prototype) <<
4925 (ASM == ArrayType::Static ? "'static'" : "type qualifier");
4926 // Remove the 'static' and the type qualifiers.
4927 if (ASM == ArrayType::Static)
4928 ASM = ArrayType::Normal;
4929 ATI.TypeQuals = 0;
4930 D.setInvalidType(true);
4931 }
4932
4933 // C99 6.7.5.2p1: ... and then only in the outermost array type
4934 // derivation.
4935 if (hasOuterPointerLikeChunk(D, chunkIndex)) {
4936 S.Diag(DeclType.Loc, diag::err_array_static_not_outermost) <<
4937 (ASM == ArrayType::Static ? "'static'" : "type qualifier");
4938 if (ASM == ArrayType::Static)
4939 ASM = ArrayType::Normal;
4940 ATI.TypeQuals = 0;
4941 D.setInvalidType(true);
4942 }
4943 }
4944 const AutoType *AT = T->getContainedAutoType();
4945 // Allow arrays of auto if we are a generic lambda parameter.
4946 // i.e. [](auto (&array)[5]) { return array[0]; }; OK
4947 if (AT && D.getContext() != DeclaratorContext::LambdaExprParameter) {
4948 // We've already diagnosed this for decltype(auto).
4949 if (!AT->isDecltypeAuto())
4950 S.Diag(DeclType.Loc, diag::err_illegal_decl_array_of_auto)
4951 << getPrintableNameForEntity(Name) << T;
4952 T = QualType();
4953 break;
4954 }
4955
4956 // Array parameters can be marked nullable as well, although it's not
4957 // necessary if they're marked 'static'.
4958 if (complainAboutMissingNullability == CAMN_Yes &&
4959 !hasNullabilityAttr(DeclType.getAttrs()) &&
4960 ASM != ArrayType::Static &&
4961 D.isPrototypeContext() &&
4962 !hasOuterPointerLikeChunk(D, chunkIndex)) {
4963 checkNullabilityConsistency(S, SimplePointerKind::Array, DeclType.Loc);
4964 }
4965
4966 T = S.BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals,
4967 SourceRange(DeclType.Loc, DeclType.EndLoc), Name);
4968 break;
4969 }
4970 case DeclaratorChunk::Function: {
4971 // If the function declarator has a prototype (i.e. it is not () and
4972 // does not have a K&R-style identifier list), then the arguments are part
4973 // of the type, otherwise the argument list is ().
4974 DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
4975 IsQualifiedFunction =
4976 FTI.hasMethodTypeQualifiers() || FTI.hasRefQualifier();
4977
4978 // Check for auto functions and trailing return type and adjust the
4979 // return type accordingly.
4980 if (!D.isInvalidType()) {
4981 // trailing-return-type is only required if we're declaring a function,
4982 // and not, for instance, a pointer to a function.
4983 if (D.getDeclSpec().hasAutoTypeSpec() &&
4984 !FTI.hasTrailingReturnType() && chunkIndex == 0) {
4985 if (!S.getLangOpts().CPlusPlus14) {
4986 S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(),
4987 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto
4988 ? diag::err_auto_missing_trailing_return
4989 : diag::err_deduced_return_type);
4990 T = Context.IntTy;
4991 D.setInvalidType(true);
4992 } else {
4993 S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(),
4994 diag::warn_cxx11_compat_deduced_return_type);
4995 }
4996 } else if (FTI.hasTrailingReturnType()) {
4997 // T must be exactly 'auto' at this point. See CWG issue 681.
4998 if (isa<ParenType>(T)) {
4999 S.Diag(D.getBeginLoc(), diag::err_trailing_return_in_parens)
5000 << T << D.getSourceRange();
5001 D.setInvalidType(true);
5002 } else if (D.getName().getKind() ==
5003 UnqualifiedIdKind::IK_DeductionGuideName) {
5004 if (T != Context.DependentTy) {
5005 S.Diag(D.getDeclSpec().getBeginLoc(),
5006 diag::err_deduction_guide_with_complex_decl)
5007 << D.getSourceRange();
5008 D.setInvalidType(true);
5009 }
5010 } else if (D.getContext() != DeclaratorContext::LambdaExpr &&
5011 (T.hasQualifiers() || !isa<AutoType>(T) ||
5012 cast<AutoType>(T)->getKeyword() !=
5013 AutoTypeKeyword::Auto ||
5014 cast<AutoType>(T)->isConstrained())) {
5015 S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(),
5016 diag::err_trailing_return_without_auto)
5017 << T << D.getDeclSpec().getSourceRange();
5018 D.setInvalidType(true);
5019 }
5020 T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo);
5021 if (T.isNull()) {
5022 // An error occurred parsing the trailing return type.
5023 T = Context.IntTy;
5024 D.setInvalidType(true);
5025 } else if (AutoType *Auto = T->getContainedAutoType()) {
5026 // If the trailing return type contains an `auto`, we may need to
5027 // invent a template parameter for it, for cases like
5028 // `auto f() -> C auto` or `[](auto (*p) -> auto) {}`.
5029 InventedTemplateParameterInfo *InventedParamInfo = nullptr;
5030 if (D.getContext() == DeclaratorContext::Prototype)
5031 InventedParamInfo = &S.InventedParameterInfos.back();
5032 else if (D.getContext() == DeclaratorContext::LambdaExprParameter)
5033 InventedParamInfo = S.getCurLambda();
5034 if (InventedParamInfo) {
5035 std::tie(T, TInfo) = InventTemplateParameter(
5036 state, T, TInfo, Auto, *InventedParamInfo);
5037 }
5038 }
5039 } else {
5040 // This function type is not the type of the entity being declared,
5041 // so checking the 'auto' is not the responsibility of this chunk.
5042 }
5043 }
5044
5045 // C99 6.7.5.3p1: The return type may not be a function or array type.
5046 // For conversion functions, we'll diagnose this particular error later.
5047 if (!D.isInvalidType() && (T->isArrayType() || T->isFunctionType()) &&
5048 (D.getName().getKind() !=
5049 UnqualifiedIdKind::IK_ConversionFunctionId)) {
5050 unsigned diagID = diag::err_func_returning_array_function;
5051 // Last processing chunk in block context means this function chunk
5052 // represents the block.
5053 if (chunkIndex == 0 &&
5054 D.getContext() == DeclaratorContext::BlockLiteral)
5055 diagID = diag::err_block_returning_array_function;
5056 S.Diag(DeclType.Loc, diagID) << T->isFunctionType() << T;
5057 T = Context.IntTy;
5058 D.setInvalidType(true);
5059 }
5060
5061 // Do not allow returning half FP value.
5062 // FIXME: This really should be in BuildFunctionType.
5063 if (T->isHalfType()) {
5064 if (S.getLangOpts().OpenCL) {
5065 if (!S.getOpenCLOptions().isAvailableOption("cl_khr_fp16",
5066 S.getLangOpts())) {
5067 S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return)
5068 << T << 0 /*pointer hint*/;
5069 D.setInvalidType(true);
5070 }
5071 } else if (!S.getLangOpts().HalfArgsAndReturns) {
5072 S.Diag(D.getIdentifierLoc(),
5073 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
5074 D.setInvalidType(true);
5075 }
5076 }
5077
5078 if (LangOpts.OpenCL) {
5079 // OpenCL v2.0 s6.12.5 - A block cannot be the return value of a
5080 // function.
5081 if (T->isBlockPointerType() || T->isImageType() || T->isSamplerT() ||
5082 T->isPipeType()) {
5083 S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return)
5084 << T << 1 /*hint off*/;
5085 D.setInvalidType(true);
5086 }
5087 // OpenCL doesn't support variadic functions and blocks
5088 // (s6.9.e and s6.12.5 OpenCL v2.0) except for printf.
5089 // We also allow here any toolchain reserved identifiers.
5090 if (FTI.isVariadic &&
5091 !S.getOpenCLOptions().isAvailableOption(
5092 "__cl_clang_variadic_functions", S.getLangOpts()) &&
5093 !(D.getIdentifier() &&
5094 ((D.getIdentifier()->getName() == "printf" &&
5095 LangOpts.getOpenCLCompatibleVersion() >= 120) ||
5096 D.getIdentifier()->getName().startswith("__")))) {
5097 S.Diag(D.getIdentifierLoc(), diag::err_opencl_variadic_function);
5098 D.setInvalidType(true);
5099 }
5100 }
5101
5102 // Methods cannot return interface types. All ObjC objects are
5103 // passed by reference.
5104 if (T->isObjCObjectType()) {
5105 SourceLocation DiagLoc, FixitLoc;
5106 if (TInfo) {
5107 DiagLoc = TInfo->getTypeLoc().getBeginLoc();
5108 FixitLoc = S.getLocForEndOfToken(TInfo->getTypeLoc().getEndLoc());
5109 } else {
5110 DiagLoc = D.getDeclSpec().getTypeSpecTypeLoc();
5111 FixitLoc = S.getLocForEndOfToken(D.getDeclSpec().getEndLoc());
5112 }
5113 S.Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
5114 << 0 << T
5115 << FixItHint::CreateInsertion(FixitLoc, "*");
5116
5117 T = Context.getObjCObjectPointerType(T);
5118 if (TInfo) {
5119 TypeLocBuilder TLB;
5120 TLB.pushFullCopy(TInfo->getTypeLoc());
5121 ObjCObjectPointerTypeLoc TLoc = TLB.push<ObjCObjectPointerTypeLoc>(T);
5122 TLoc.setStarLoc(FixitLoc);
5123 TInfo = TLB.getTypeSourceInfo(Context, T);
5124 }
5125
5126 D.setInvalidType(true);
5127 }
5128
5129 // cv-qualifiers on return types are pointless except when the type is a
5130 // class type in C++.
5131 if ((T.getCVRQualifiers() || T->isAtomicType()) &&
5132 !(S.getLangOpts().CPlusPlus &&
5133 (T->isDependentType() || T->isRecordType()))) {
5134 if (T->isVoidType() && !S.getLangOpts().CPlusPlus &&
5135 D.getFunctionDefinitionKind() ==
5136 FunctionDefinitionKind::Definition) {
5137 // [6.9.1/3] qualified void return is invalid on a C
5138 // function definition. Apparently ok on declarations and
5139 // in C++ though (!)
5140 S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T;
5141 } else
5142 diagnoseRedundantReturnTypeQualifiers(S, T, D, chunkIndex);
5143
5144 // C++2a [dcl.fct]p12:
5145 // A volatile-qualified return type is deprecated
5146 if (T.isVolatileQualified() && S.getLangOpts().CPlusPlus20)
5147 S.Diag(DeclType.Loc, diag::warn_deprecated_volatile_return) << T;
5148 }
5149
5150 // Objective-C ARC ownership qualifiers are ignored on the function
5151 // return type (by type canonicalization). Complain if this attribute
5152 // was written here.
5153 if (T.getQualifiers().hasObjCLifetime()) {
5154 SourceLocation AttrLoc;
5155 if (chunkIndex + 1 < D.getNumTypeObjects()) {
5156 DeclaratorChunk ReturnTypeChunk = D.getTypeObject(chunkIndex + 1);
5157 for (const ParsedAttr &AL : ReturnTypeChunk.getAttrs()) {
5158 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5159 AttrLoc = AL.getLoc();
5160 break;
5161 }
5162 }
5163 }
5164 if (AttrLoc.isInvalid()) {
5165 for (const ParsedAttr &AL : D.getDeclSpec().getAttributes()) {
5166 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5167 AttrLoc = AL.getLoc();
5168 break;
5169 }
5170 }
5171 }
5172
5173 if (AttrLoc.isValid()) {
5174 // The ownership attributes are almost always written via
5175 // the predefined
5176 // __strong/__weak/__autoreleasing/__unsafe_unretained.
5177 if (AttrLoc.isMacroID())
5178 AttrLoc =
5179 S.SourceMgr.getImmediateExpansionRange(AttrLoc).getBegin();
5180
5181 S.Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
5182 << T.getQualifiers().getObjCLifetime();
5183 }
5184 }
5185
5186 if (LangOpts.CPlusPlus && D.getDeclSpec().hasTagDefinition()) {
5187 // C++ [dcl.fct]p6:
5188 // Types shall not be defined in return or parameter types.
5189 TagDecl *Tag = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
5190 S.Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
5191 << Context.getTypeDeclType(Tag);
5192 }
5193
5194 // Exception specs are not allowed in typedefs. Complain, but add it
5195 // anyway.
5196 if (IsTypedefName && FTI.getExceptionSpecType() && !LangOpts.CPlusPlus17)
5197 S.Diag(FTI.getExceptionSpecLocBeg(),
5198 diag::err_exception_spec_in_typedef)
5199 << (D.getContext() == DeclaratorContext::AliasDecl ||
5200 D.getContext() == DeclaratorContext::AliasTemplate);
5201
5202 // If we see "T var();" or "T var(T());" at block scope, it is probably
5203 // an attempt to initialize a variable, not a function declaration.
5204 if (FTI.isAmbiguous)
5205 warnAboutAmbiguousFunction(S, D, DeclType, T);
5206
5207 FunctionType::ExtInfo EI(
5208 getCCForDeclaratorChunk(S, D, DeclType.getAttrs(), FTI, chunkIndex));
5209
5210 if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.CPlusPlus
5211 && !LangOpts.OpenCL) {
5212 // Simple void foo(), where the incoming T is the result type.
5213 T = Context.getFunctionNoProtoType(T, EI);
5214 } else {
5215 // We allow a zero-parameter variadic function in C if the
5216 // function is marked with the "overloadable" attribute. Scan
5217 // for this attribute now.
5218 if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus)
5219 if (!D.getAttributes().hasAttribute(ParsedAttr::AT_Overloadable))
5220 S.Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_param);
5221
5222 if (FTI.NumParams && FTI.Params[0].Param == nullptr) {
5223 // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function
5224 // definition.
5225 S.Diag(FTI.Params[0].IdentLoc,
5226 diag::err_ident_list_in_fn_declaration);
5227 D.setInvalidType(true);
5228 // Recover by creating a K&R-style function type.
5229 T = Context.getFunctionNoProtoType(T, EI);
5230 break;
5231 }
5232
5233 FunctionProtoType::ExtProtoInfo EPI;
5234 EPI.ExtInfo = EI;
5235 EPI.Variadic = FTI.isVariadic;
5236 EPI.EllipsisLoc = FTI.getEllipsisLoc();
5237 EPI.HasTrailingReturn = FTI.hasTrailingReturnType();
5238 EPI.TypeQuals.addCVRUQualifiers(
5239 FTI.MethodQualifiers ? FTI.MethodQualifiers->getTypeQualifiers()
5240 : 0);
5241 EPI.RefQualifier = !FTI.hasRefQualifier()? RQ_None
5242 : FTI.RefQualifierIsLValueRef? RQ_LValue
5243 : RQ_RValue;
5244
5245 // Otherwise, we have a function with a parameter list that is
5246 // potentially variadic.
5247 SmallVector<QualType, 16> ParamTys;
5248 ParamTys.reserve(FTI.NumParams);
5249
5250 SmallVector<FunctionProtoType::ExtParameterInfo, 16>
5251 ExtParameterInfos(FTI.NumParams);
5252 bool HasAnyInterestingExtParameterInfos = false;
5253
5254 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
5255 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
5256 QualType ParamTy = Param->getType();
5257 assert(!ParamTy.isNull() && "Couldn't parse type?")(static_cast<void> (0));
5258
5259 // Look for 'void'. void is allowed only as a single parameter to a
5260 // function with no other parameters (C99 6.7.5.3p10). We record
5261 // int(void) as a FunctionProtoType with an empty parameter list.
5262 if (ParamTy->isVoidType()) {
5263 // If this is something like 'float(int, void)', reject it. 'void'
5264 // is an incomplete type (C99 6.2.5p19) and function decls cannot
5265 // have parameters of incomplete type.
5266 if (FTI.NumParams != 1 || FTI.isVariadic) {
5267 S.Diag(FTI.Params[i].IdentLoc, diag::err_void_only_param);
5268 ParamTy = Context.IntTy;
5269 Param->setType(ParamTy);
5270 } else if (FTI.Params[i].Ident) {
5271 // Reject, but continue to parse 'int(void abc)'.
5272 S.Diag(FTI.Params[i].IdentLoc, diag::err_param_with_void_type);
5273 ParamTy = Context.IntTy;
5274 Param->setType(ParamTy);
5275 } else {
5276 // Reject, but continue to parse 'float(const void)'.
5277 if (ParamTy.hasQualifiers())
5278 S.Diag(DeclType.Loc, diag::err_void_param_qualified);
5279
5280 // Do not add 'void' to the list.
5281 break;
5282 }
5283 } else if (ParamTy->isHalfType()) {
5284 // Disallow half FP parameters.
5285 // FIXME: This really should be in BuildFunctionType.
5286 if (S.getLangOpts().OpenCL) {
5287 if (!S.getOpenCLOptions().isAvailableOption("cl_khr_fp16",
5288 S.getLangOpts())) {
5289 S.Diag(Param->getLocation(), diag::err_opencl_invalid_param)
5290 << ParamTy << 0;
5291 D.setInvalidType();
5292 Param->setInvalidDecl();
5293 }
5294 } else if (!S.getLangOpts().HalfArgsAndReturns) {
5295 S.Diag(Param->getLocation(),
5296 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
5297 D.setInvalidType();
5298 }
5299 } else if (!FTI.hasPrototype) {
5300 if (ParamTy->isPromotableIntegerType()) {
5301 ParamTy = Context.getPromotedIntegerType(ParamTy);
5302 Param->setKNRPromoted(true);
5303 } else if (const BuiltinType* BTy = ParamTy->getAs<BuiltinType>()) {
5304 if (BTy->getKind() == BuiltinType::Float) {
5305 ParamTy = Context.DoubleTy;
5306 Param->setKNRPromoted(true);
5307 }
5308 }
5309 } else if (S.getLangOpts().OpenCL && ParamTy->isBlockPointerType()) {
5310 // OpenCL 2.0 s6.12.5: A block cannot be a parameter of a function.
5311 S.Diag(Param->getLocation(), diag::err_opencl_invalid_param)
5312 << ParamTy << 1 /*hint off*/;
5313 D.setInvalidType();
5314 }
5315
5316 if (LangOpts.ObjCAutoRefCount && Param->hasAttr<NSConsumedAttr>()) {
5317 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(true);
5318 HasAnyInterestingExtParameterInfos = true;
5319 }
5320
5321 if (auto attr = Param->getAttr<ParameterABIAttr>()) {
5322 ExtParameterInfos[i] =
5323 ExtParameterInfos[i].withABI(attr->getABI());
5324 HasAnyInterestingExtParameterInfos = true;
5325 }
5326
5327 if (Param->hasAttr<PassObjectSizeAttr>()) {
5328 ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
5329 HasAnyInterestingExtParameterInfos = true;
5330 }
5331
5332 if (Param->hasAttr<NoEscapeAttr>()) {
5333 ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(true);
5334 HasAnyInterestingExtParameterInfos = true;
5335 }
5336
5337 ParamTys.push_back(ParamTy);
5338 }
5339
5340 if (HasAnyInterestingExtParameterInfos) {
5341 EPI.ExtParameterInfos = ExtParameterInfos.data();
5342 checkExtParameterInfos(S, ParamTys, EPI,
5343 [&](unsigned i) { return FTI.Params[i].Param->getLocation(); });
5344 }
5345
5346 SmallVector<QualType, 4> Exceptions;
5347 SmallVector<ParsedType, 2> DynamicExceptions;
5348 SmallVector<SourceRange, 2> DynamicExceptionRanges;
5349 Expr *NoexceptExpr = nullptr;
5350
5351 if (FTI.getExceptionSpecType() == EST_Dynamic) {
5352 // FIXME: It's rather inefficient to have to split into two vectors
5353 // here.
5354 unsigned N = FTI.getNumExceptions();
5355 DynamicExceptions.reserve(N);
5356 DynamicExceptionRanges.reserve(N);
5357 for (unsigned I = 0; I != N; ++I) {
5358 DynamicExceptions.push_back(FTI.Exceptions[I].Ty);
5359 DynamicExceptionRanges.push_back(FTI.Exceptions[I].Range);
5360 }
5361 } else if (isComputedNoexcept(FTI.getExceptionSpecType())) {
5362 NoexceptExpr = FTI.NoexceptExpr;
5363 }
5364
5365 S.checkExceptionSpecification(D.isFunctionDeclarationContext(),
5366 FTI.getExceptionSpecType(),
5367 DynamicExceptions,
5368 DynamicExceptionRanges,
5369 NoexceptExpr,
5370 Exceptions,
5371 EPI.ExceptionSpec);
5372
5373 // FIXME: Set address space from attrs for C++ mode here.
5374 // OpenCLCPlusPlus: A class member function has an address space.
5375 auto IsClassMember = [&]() {
5376 return (!state.getDeclarator().getCXXScopeSpec().isEmpty() &&
5377 state.getDeclarator()
5378 .getCXXScopeSpec()
5379 .getScopeRep()
5380 ->getKind() == NestedNameSpecifier::TypeSpec) ||
5381 state.getDeclarator().getContext() ==
5382 DeclaratorContext::Member ||
5383 state.getDeclarator().getContext() ==
5384 DeclaratorContext::LambdaExpr;
5385 };
5386
5387 if (state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {
5388 LangAS ASIdx = LangAS::Default;
5389 // Take address space attr if any and mark as invalid to avoid adding
5390 // them later while creating QualType.
5391 if (FTI.MethodQualifiers)
5392 for (ParsedAttr &attr : FTI.MethodQualifiers->getAttributes()) {
5393 LangAS ASIdxNew = attr.asOpenCLLangAS();
5394 if (DiagnoseMultipleAddrSpaceAttributes(S, ASIdx, ASIdxNew,
5395 attr.getLoc()))
5396 D.setInvalidType(true);
5397 else
5398 ASIdx = ASIdxNew;
5399 }
5400 // If a class member function's address space is not set, set it to
5401 // __generic.
5402 LangAS AS =
5403 (ASIdx == LangAS::Default ? S.getDefaultCXXMethodAddrSpace()
5404 : ASIdx);
5405 EPI.TypeQuals.addAddressSpace(AS);
5406 }
5407 T = Context.getFunctionType(T, ParamTys, EPI);
5408 }
5409 break;
5410 }
5411 case DeclaratorChunk::MemberPointer: {
5412 // The scope spec must refer to a class, or be dependent.
5413 CXXScopeSpec &SS = DeclType.Mem.Scope();
5414 QualType ClsType;
5415
5416 // Handle pointer nullability.
5417 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.Loc,
5418 DeclType.EndLoc, DeclType.getAttrs(),
5419 state.getDeclarator().getAttributePool());
5420
5421 if (SS.isInvalid()) {
5422 // Avoid emitting extra errors if we already errored on the scope.
5423 D.setInvalidType(true);
5424 } else if (S.isDependentScopeSpecifier(SS) ||
5425 dyn_cast_or_null<CXXRecordDecl>(S.computeDeclContext(SS))) {
5426 NestedNameSpecifier *NNS = SS.getScopeRep();
5427 NestedNameSpecifier *NNSPrefix = NNS->getPrefix();
5428 switch (NNS->getKind()) {
5429 case NestedNameSpecifier::Identifier:
5430 ClsType = Context.getDependentNameType(ETK_None, NNSPrefix,
5431 NNS->getAsIdentifier());
5432 break;
5433
5434 case NestedNameSpecifier::Namespace:
5435 case NestedNameSpecifier::NamespaceAlias:
5436 case NestedNameSpecifier::Global:
5437 case NestedNameSpecifier::Super:
5438 llvm_unreachable("Nested-name-specifier must name a type")__builtin_unreachable();
5439
5440 case NestedNameSpecifier::TypeSpec:
5441 case NestedNameSpecifier::TypeSpecWithTemplate:
5442 ClsType = QualType(NNS->getAsType(), 0);
5443 // Note: if the NNS has a prefix and ClsType is a nondependent
5444 // TemplateSpecializationType, then the NNS prefix is NOT included
5445 // in ClsType; hence we wrap ClsType into an ElaboratedType.
5446 // NOTE: in particular, no wrap occurs if ClsType already is an
5447 // Elaborated, DependentName, or DependentTemplateSpecialization.
5448 if (NNSPrefix && isa<TemplateSpecializationType>(NNS->getAsType()))
5449 ClsType = Context.getElaboratedType(ETK_None, NNSPrefix, ClsType);
5450 break;
5451 }
5452 } else {
5453 S.Diag(DeclType.Mem.Scope().getBeginLoc(),
5454 diag::err_illegal_decl_mempointer_in_nonclass)
5455 << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
5456 << DeclType.Mem.Scope().getRange();
5457 D.setInvalidType(true);
5458 }
5459
5460 if (!ClsType.isNull())
5461 T = S.BuildMemberPointerType(T, ClsType, DeclType.Loc,
5462 D.getIdentifier());
5463 if (T.isNull()) {
5464 T = Context.IntTy;
5465 D.setInvalidType(true);
5466 } else if (DeclType.Mem.TypeQuals) {
5467 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Mem.TypeQuals);
5468 }
5469 break;
5470 }
5471
5472 case DeclaratorChunk::Pipe: {
5473 T = S.BuildReadPipeType(T, DeclType.Loc);
5474 processTypeAttrs(state, T, TAL_DeclSpec,
5475 D.getMutableDeclSpec().getAttributes());
5476 break;
5477 }
5478 }
5479
5480 if (T.isNull()) {
5481 D.setInvalidType(true);
5482 T = Context.IntTy;
5483 }
5484
5485 // See if there are any attributes on this declarator chunk.
5486 processTypeAttrs(state, T, TAL_DeclChunk, DeclType.getAttrs());
5487
5488 if (DeclType.Kind != DeclaratorChunk::Paren) {
5489 if (ExpectNoDerefChunk && !IsNoDerefableChunk(DeclType))
5490 S.Diag(DeclType.Loc, diag::warn_noderef_on_non_pointer_or_array);
5491
5492 ExpectNoDerefChunk = state.didParseNoDeref();
5493 }
5494 }
5495
5496 if (ExpectNoDerefChunk)
13
Assuming 'ExpectNoDerefChunk' is false
5497 S.Diag(state.getDeclarator().getBeginLoc(),
5498 diag::warn_noderef_on_non_pointer_or_array);
5499
5500 // GNU warning -Wstrict-prototypes
5501 // Warn if a function declaration is without a prototype.
5502 // This warning is issued for all kinds of unprototyped function
5503 // declarations (i.e. function type typedef, function pointer etc.)
5504 // C99 6.7.5.3p14:
5505 // The empty list in a function declarator that is not part of a definition
5506 // of that function specifies that no information about the number or types
5507 // of the parameters is supplied.
5508 if (!LangOpts.CPlusPlus &&
14
Assuming field 'CPlusPlus' is not equal to 0
5509 D.getFunctionDefinitionKind() == FunctionDefinitionKind::Declaration) {
5510 bool IsBlock = false;
5511 for (const DeclaratorChunk &DeclType : D.type_objects()) {
5512 switch (DeclType.Kind) {
5513 case DeclaratorChunk::BlockPointer:
5514 IsBlock = true;
5515 break;
5516 case DeclaratorChunk::Function: {
5517 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
5518 // We supress the warning when there's no LParen location, as this
5519 // indicates the declaration was an implicit declaration, which gets
5520 // warned about separately via -Wimplicit-function-declaration.
5521 if (FTI.NumParams == 0 && !FTI.isVariadic && FTI.getLParenLoc().isValid())
5522 S.Diag(DeclType.Loc, diag::warn_strict_prototypes)
5523 << IsBlock
5524 << FixItHint::CreateInsertion(FTI.getRParenLoc(), "void");
5525 IsBlock = false;
5526 break;
5527 }
5528 default:
5529 break;
5530 }
5531 }
5532 }
5533
5534 assert(!T.isNull() && "T must not be null after this point")(static_cast<void> (0));
5535
5536 if (LangOpts.CPlusPlus
14.1
Field 'CPlusPlus' is not equal to 0
14.1
Field 'CPlusPlus' is not equal to 0
14.1
Field 'CPlusPlus' is not equal to 0
14.1
Field 'CPlusPlus' is not equal to 0
14.1
Field 'CPlusPlus' is not equal to 0
&& T->isFunctionType()) {
15
Taking false branch
5537 const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>();
5538 assert(FnTy && "Why oh why is there not a FunctionProtoType here?")(static_cast<void> (0));
5539
5540 // C++ 8.3.5p4:
5541 // A cv-qualifier-seq shall only be part of the function type
5542 // for a nonstatic member function, the function type to which a pointer
5543 // to member refers, or the top-level function type of a function typedef
5544 // declaration.
5545 //
5546 // Core issue 547 also allows cv-qualifiers on function types that are
5547 // top-level template type arguments.
5548 enum { NonMember, Member, DeductionGuide } Kind = NonMember;
5549 if (D.getName().getKind() == UnqualifiedIdKind::IK_DeductionGuideName)
5550 Kind = DeductionGuide;
5551 else if (!D.getCXXScopeSpec().isSet()) {
5552 if ((D.getContext() == DeclaratorContext::Member ||
5553 D.getContext() == DeclaratorContext::LambdaExpr) &&
5554 !D.getDeclSpec().isFriendSpecified())
5555 Kind = Member;
5556 } else {
5557 DeclContext *DC = S.computeDeclContext(D.getCXXScopeSpec());
5558 if (!DC || DC->isRecord())
5559 Kind = Member;
5560 }
5561
5562 // C++11 [dcl.fct]p6 (w/DR1417):
5563 // An attempt to specify a function type with a cv-qualifier-seq or a
5564 // ref-qualifier (including by typedef-name) is ill-formed unless it is:
5565 // - the function type for a non-static member function,
5566 // - the function type to which a pointer to member refers,
5567 // - the top-level function type of a function typedef declaration or
5568 // alias-declaration,
5569 // - the type-id in the default argument of a type-parameter, or
5570 // - the type-id of a template-argument for a type-parameter
5571 //
5572 // FIXME: Checking this here is insufficient. We accept-invalid on:
5573 //
5574 // template<typename T> struct S { void f(T); };
5575 // S<int() const> s;
5576 //
5577 // ... for instance.
5578 if (IsQualifiedFunction &&
5579 !(Kind == Member &&
5580 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) &&
5581 !IsTypedefName && D.getContext() != DeclaratorContext::TemplateArg &&
5582 D.getContext() != DeclaratorContext::TemplateTypeArg) {
5583 SourceLocation Loc = D.getBeginLoc();
5584 SourceRange RemovalRange;
5585 unsigned I;
5586 if (D.isFunctionDeclarator(I)) {
5587 SmallVector<SourceLocation, 4> RemovalLocs;
5588 const DeclaratorChunk &Chunk = D.getTypeObject(I);
5589 assert(Chunk.Kind == DeclaratorChunk::Function)(static_cast<void> (0));
5590
5591 if (Chunk.Fun.hasRefQualifier())
5592 RemovalLocs.push_back(Chunk.Fun.getRefQualifierLoc());
5593
5594 if (Chunk.Fun.hasMethodTypeQualifiers())
5595 Chunk.Fun.MethodQualifiers->forEachQualifier(
5596 [&](DeclSpec::TQ TypeQual, StringRef QualName,
5597 SourceLocation SL) { RemovalLocs.push_back(SL); });
5598
5599 if (!RemovalLocs.empty()) {
5600 llvm::sort(RemovalLocs,
5601 BeforeThanCompare<SourceLocation>(S.getSourceManager()));
5602 RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back());
5603 Loc = RemovalLocs.front();
5604 }
5605 }
5606
5607 S.Diag(Loc, diag::err_invalid_qualified_function_type)
5608 << Kind << D.isFunctionDeclarator() << T
5609 << getFunctionQualifiersAsString(FnTy)
5610 << FixItHint::CreateRemoval(RemovalRange);
5611
5612 // Strip the cv-qualifiers and ref-qualifiers from the type.
5613 FunctionProtoType::ExtProtoInfo EPI = FnTy->getExtProtoInfo();
5614 EPI.TypeQuals.removeCVRQualifiers();
5615 EPI.RefQualifier = RQ_None;
5616
5617 T = Context.getFunctionType(FnTy->getReturnType(), FnTy->getParamTypes(),
5618 EPI);
5619 // Rebuild any parens around the identifier in the function type.
5620 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
5621 if (D.getTypeObject(i).Kind != DeclaratorChunk::Paren)
5622 break;
5623 T = S.BuildParenType(T);
5624 }
5625 }
5626 }
5627
5628 // Apply any undistributed attributes from the declarator.
5629 processTypeAttrs(state, T, TAL_DeclName, D.getAttributes());
5630
5631 // Diagnose any ignored type attributes.
5632 state.diagnoseIgnoredTypeAttrs(T);
5633
5634 // C++0x [dcl.constexpr]p9:
5635 // A constexpr specifier used in an object declaration declares the object
5636 // as const.
5637 if (D.getDeclSpec().getConstexprSpecifier() == ConstexprSpecKind::Constexpr &&
16
Assuming the condition is false
5638 T->isObjectType())
5639 T.addConst();
5640
5641 // C++2a [dcl.fct]p4:
5642 // A parameter with volatile-qualified type is deprecated
5643 if (T.isVolatileQualified() && S.getLangOpts().CPlusPlus20 &&
17
Assuming the condition is false
5644 (D.getContext() == DeclaratorContext::Prototype ||
5645 D.getContext() == DeclaratorContext::LambdaExprParameter))
5646 S.Diag(D.getIdentifierLoc(), diag::warn_deprecated_volatile_param) << T;
5647
5648 // If there was an ellipsis in the declarator, the declaration declares a
5649 // parameter pack whose type may be a pack expansion type.
5650 if (D.hasEllipsis()) {
18
Taking false branch
5651 // C++0x [dcl.fct]p13:
5652 // A declarator-id or abstract-declarator containing an ellipsis shall
5653 // only be used in a parameter-declaration. Such a parameter-declaration
5654 // is a parameter pack (14.5.3). [...]
5655 switch (D.getContext()) {
5656 case DeclaratorContext::Prototype:
5657 case DeclaratorContext::LambdaExprParameter:
5658 case DeclaratorContext::RequiresExpr:
5659 // C++0x [dcl.fct]p13:
5660 // [...] When it is part of a parameter-declaration-clause, the
5661 // parameter pack is a function parameter pack (14.5.3). The type T
5662 // of the declarator-id of the function parameter pack shall contain
5663 // a template parameter pack; each template parameter pack in T is
5664 // expanded by the function parameter pack.
5665 //
5666 // We represent function parameter packs as function parameters whose
5667 // type is a pack expansion.
5668 if (!T->containsUnexpandedParameterPack() &&
5669 (!LangOpts.CPlusPlus20 || !T->getContainedAutoType())) {
5670 S.Diag(D.getEllipsisLoc(),
5671 diag::err_function_parameter_pack_without_parameter_packs)
5672 << T << D.getSourceRange();
5673 D.setEllipsisLoc(SourceLocation());
5674 } else {
5675 T = Context.getPackExpansionType(T, None, /*ExpectPackInType=*/false);
5676 }
5677 break;
5678 case DeclaratorContext::TemplateParam:
5679 // C++0x [temp.param]p15:
5680 // If a template-parameter is a [...] is a parameter-declaration that
5681 // declares a parameter pack (8.3.5), then the template-parameter is a
5682 // template parameter pack (14.5.3).
5683 //
5684 // Note: core issue 778 clarifies that, if there are any unexpanded
5685 // parameter packs in the type of the non-type template parameter, then
5686 // it expands those parameter packs.
5687 if (T->containsUnexpandedParameterPack())
5688 T = Context.getPackExpansionType(T, None);
5689 else
5690 S.Diag(D.getEllipsisLoc(),
5691 LangOpts.CPlusPlus11
5692 ? diag::warn_cxx98_compat_variadic_templates
5693 : diag::ext_variadic_templates);
5694 break;
5695
5696 case DeclaratorContext::File:
5697 case DeclaratorContext::KNRTypeList:
5698 case DeclaratorContext::ObjCParameter: // FIXME: special diagnostic here?
5699 case DeclaratorContext::ObjCResult: // FIXME: special diagnostic here?
5700 case DeclaratorContext::TypeName:
5701 case DeclaratorContext::FunctionalCast:
5702 case DeclaratorContext::CXXNew:
5703 case DeclaratorContext::AliasDecl:
5704 case DeclaratorContext::AliasTemplate:
5705 case DeclaratorContext::Member:
5706 case DeclaratorContext::Block:
5707 case DeclaratorContext::ForInit:
5708 case DeclaratorContext::SelectionInit:
5709 case DeclaratorContext::Condition:
5710 case DeclaratorContext::CXXCatch:
5711 case DeclaratorContext::ObjCCatch:
5712 case DeclaratorContext::BlockLiteral:
5713 case DeclaratorContext::LambdaExpr:
5714 case DeclaratorContext::ConversionId:
5715 case DeclaratorContext::TrailingReturn:
5716 case DeclaratorContext::TrailingReturnVar:
5717 case DeclaratorContext::TemplateArg:
5718 case DeclaratorContext::TemplateTypeArg:
5719 // FIXME: We may want to allow parameter packs in block-literal contexts
5720 // in the future.
5721 S.Diag(D.getEllipsisLoc(),
5722 diag::err_ellipsis_in_declarator_not_parameter);
5723 D.setEllipsisLoc(SourceLocation());
5724 break;
5725 }
5726 }
5727
5728 assert(!T.isNull() && "T must not be null at the end of this function")(static_cast<void> (0));
5729 if (D.isInvalidType())
19
Taking false branch
5730 return Context.getTrivialTypeSourceInfo(T);
5731
5732 return GetTypeSourceInfoForDeclarator(state, T, TInfo);
20
Calling 'GetTypeSourceInfoForDeclarator'
5733}
5734
5735/// GetTypeForDeclarator - Convert the type for the specified
5736/// declarator to Type instances.
5737///
5738/// The result of this call will never be null, but the associated
5739/// type may be a null type if there's an unrecoverable error.
5740TypeSourceInfo *Sema::GetTypeForDeclarator(Declarator &D, Scope *S) {
5741 // Determine the type of the declarator. Not all forms of declarator
5742 // have a type.
5743
5744 TypeProcessingState state(*this, D);
5745
5746 TypeSourceInfo *ReturnTypeInfo = nullptr;
5747 QualType T = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
5748 if (D.isPrototypeContext() && getLangOpts().ObjCAutoRefCount)
5749 inferARCWriteback(state, T);
5750
5751 return GetFullTypeForDeclarator(state, T, ReturnTypeInfo);
5752}
5753
5754static void transferARCOwnershipToDeclSpec(Sema &S,
5755 QualType &declSpecTy,
5756 Qualifiers::ObjCLifetime ownership) {
5757 if (declSpecTy->isObjCRetainableType() &&
5758 declSpecTy.getObjCLifetime() == Qualifiers::OCL_None) {
5759 Qualifiers qs;
5760 qs.addObjCLifetime(ownership);
5761 declSpecTy = S.Context.getQualifiedType(declSpecTy, qs);
5762 }
5763}
5764
5765static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state,
5766 Qualifiers::ObjCLifetime ownership,
5767 unsigned chunkIndex) {
5768 Sema &S = state.getSema();
5769 Declarator &D = state.getDeclarator();
5770
5771 // Look for an explicit lifetime attribute.
5772 DeclaratorChunk &chunk = D.getTypeObject(chunkIndex);
5773 if (chunk.getAttrs().hasAttribute(ParsedAttr::AT_ObjCOwnership))
5774 return;
5775
5776 const char *attrStr = nullptr;
5777 switch (ownership) {
5778 case Qualifiers::OCL_None: llvm_unreachable("no ownership!")__builtin_unreachable();
5779 case Qualifiers::OCL_ExplicitNone: attrStr = "none"; break;
5780 case Qualifiers::OCL_Strong: attrStr = "strong"; break;
5781 case Qualifiers::OCL_Weak: attrStr = "weak"; break;
5782 case Qualifiers::OCL_Autoreleasing: attrStr = "autoreleasing"; break;
5783 }
5784
5785 IdentifierLoc *Arg = new (S.Context) IdentifierLoc;
5786 Arg->Ident = &S.Context.Idents.get(attrStr);
5787 Arg->Loc = SourceLocation();
5788
5789 ArgsUnion Args(Arg);
5790
5791 // If there wasn't one, add one (with an invalid source location
5792 // so that we don't make an AttributedType for it).
5793 ParsedAttr *attr = D.getAttributePool().create(
5794 &S.Context.Idents.get("objc_ownership"), SourceLocation(),
5795 /*scope*/ nullptr, SourceLocation(),
5796 /*args*/ &Args, 1, ParsedAttr::AS_GNU);
5797 chunk.getAttrs().addAtEnd(attr);
5798 // TODO: mark whether we did this inference?
5799}
5800
5801/// Used for transferring ownership in casts resulting in l-values.
5802static void transferARCOwnership(TypeProcessingState &state,
5803 QualType &declSpecTy,
5804 Qualifiers::ObjCLifetime ownership) {
5805 Sema &S = state.getSema();
5806 Declarator &D = state.getDeclarator();
5807
5808 int inner = -1;
5809 bool hasIndirection = false;
5810 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
5811 DeclaratorChunk &chunk = D.getTypeObject(i);
5812 switch (chunk.Kind) {
5813 case DeclaratorChunk::Paren:
5814 // Ignore parens.
5815 break;
5816
5817 case DeclaratorChunk::Array:
5818 case DeclaratorChunk::Reference:
5819 case DeclaratorChunk::Pointer:
5820 if (inner != -1)
5821 hasIndirection = true;
5822 inner = i;
5823 break;
5824
5825 case DeclaratorChunk::BlockPointer:
5826 if (inner != -1)
5827 transferARCOwnershipToDeclaratorChunk(state, ownership, i);
5828 return;
5829
5830 case DeclaratorChunk::Function:
5831 case DeclaratorChunk::MemberPointer:
5832 case DeclaratorChunk::Pipe:
5833 return;
5834 }
5835 }
5836
5837 if (inner == -1)
5838 return;
5839
5840 DeclaratorChunk &chunk = D.getTypeObject(inner);
5841 if (chunk.Kind == DeclaratorChunk::Pointer) {
5842 if (declSpecTy->isObjCRetainableType())
5843 return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership);
5844 if (declSpecTy->isObjCObjectType() && hasIndirection)
5845 return transferARCOwnershipToDeclaratorChunk(state, ownership, inner);
5846 } else {
5847 assert(chunk.Kind == DeclaratorChunk::Array ||(static_cast<void> (0))
5848 chunk.Kind == DeclaratorChunk::Reference)(static_cast<void> (0));
5849 return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership);
5850 }
5851}
5852
5853TypeSourceInfo *Sema::GetTypeForDeclaratorCast(Declarator &D, QualType FromTy) {
5854 TypeProcessingState state(*this, D);
5855
5856 TypeSourceInfo *ReturnTypeInfo = nullptr;
5857 QualType declSpecTy = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
5858
5859 if (getLangOpts().ObjC) {
5860 Qualifiers::ObjCLifetime ownership = Context.getInnerObjCOwnership(FromTy);
5861 if (ownership != Qualifiers::OCL_None)
5862 transferARCOwnership(state, declSpecTy, ownership);
5863 }
5864
5865 return GetFullTypeForDeclarator(state, declSpecTy, ReturnTypeInfo);
5866}
5867
5868static void fillAttributedTypeLoc(AttributedTypeLoc TL,
5869 TypeProcessingState &State) {
5870 TL.setAttr(State.takeAttrForAttributedType(TL.getTypePtr()));
5871}
5872
5873namespace {
5874 class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> {
5875 Sema &SemaRef;
5876 ASTContext &Context;
5877 TypeProcessingState &State;
5878 const DeclSpec &DS;
5879
5880 public:
5881 TypeSpecLocFiller(Sema &S, ASTContext &Context, TypeProcessingState &State,
5882 const DeclSpec &DS)
5883 : SemaRef(S), Context(Context), State(State), DS(DS) {}
5884
5885 void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5886 Visit(TL.getModifiedLoc());
5887 fillAttributedTypeLoc(TL, State);
5888 }
5889 void VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
5890 Visit(TL.getInnerLoc());
5891 TL.setExpansionLoc(
5892 State.getExpansionLocForMacroQualifiedType(TL.getTypePtr()));
5893 }
5894 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5895 Visit(TL.getUnqualifiedLoc());
5896 }
5897 void VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5898 TL.setNameLoc(DS.getTypeSpecTypeLoc());
5899 }
5900 void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5901 TL.setNameLoc(DS.getTypeSpecTypeLoc());
5902 // FIXME. We should have DS.getTypeSpecTypeEndLoc(). But, it requires
5903 // addition field. What we have is good enough for dispay of location
5904 // of 'fixit' on interface name.
5905 TL.setNameEndLoc(DS.getEndLoc());
5906 }
5907 void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5908 TypeSourceInfo *RepTInfo = nullptr;
5909 Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo);
5910 TL.copy(RepTInfo->getTypeLoc());
5911 }
5912 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5913 TypeSourceInfo *RepTInfo = nullptr;
5914 Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo);
5915 TL.copy(RepTInfo->getTypeLoc());
5916 }
5917 void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
5918 TypeSourceInfo *TInfo = nullptr;
5919 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5920
5921 // If we got no declarator info from previous Sema routines,
5922 // just fill with the typespec loc.
5923 if (!TInfo) {
5924 TL.initialize(Context, DS.getTypeSpecTypeNameLoc());
5925 return;
5926 }
5927
5928 TypeLoc OldTL = TInfo->getTypeLoc();
5929 if (TInfo->getType()->getAs<ElaboratedType>()) {
5930 ElaboratedTypeLoc ElabTL = OldTL.castAs<ElaboratedTypeLoc>();
5931 TemplateSpecializationTypeLoc NamedTL = ElabTL.getNamedTypeLoc()
5932 .castAs<TemplateSpecializationTypeLoc>();
5933 TL.copy(NamedTL);
5934 } else {
5935 TL.copy(OldTL.castAs<TemplateSpecializationTypeLoc>());
5936 assert(TL.getRAngleLoc() == OldTL.castAs<TemplateSpecializationTypeLoc>().getRAngleLoc())(static_cast<void> (0));
5937 }
5938
5939 }
5940 void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5941 assert(DS.getTypeSpecType() == DeclSpec::TST_typeofExpr)(static_cast<void> (0));
5942 TL.setTypeofLoc(DS.getTypeSpecTypeLoc());
5943 TL.setParensRange(DS.getTypeofParensRange());
5944 }
5945 void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5946 assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType)(static_cast<void> (0));
5947 TL.setTypeofLoc(DS.getTypeSpecTypeLoc());
5948 TL.setParensRange(DS.getTypeofParensRange());
5949 assert(DS.getRepAsType())(static_cast<void> (0));
5950 TypeSourceInfo *TInfo = nullptr;
5951 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5952 TL.setUnderlyingTInfo(TInfo);
5953 }
5954 void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5955 // FIXME: This holds only because we only have one unary transform.
5956 assert(DS.getTypeSpecType() == DeclSpec::TST_underlyingType)(static_cast<void> (0));
5957 TL.setKWLoc(DS.getTypeSpecTypeLoc());
5958 TL.setParensRange(DS.getTypeofParensRange());
5959 assert(DS.getRepAsType())(static_cast<void> (0));
5960 TypeSourceInfo *TInfo = nullptr;
5961 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5962 TL.setUnderlyingTInfo(TInfo);
5963 }
5964 void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5965 // By default, use the source location of the type specifier.
5966 TL.setBuiltinLoc(DS.getTypeSpecTypeLoc());
5967 if (TL.needsExtraLocalData()) {
5968 // Set info for the written builtin specifiers.
5969 TL.getWrittenBuiltinSpecs() = DS.getWrittenBuiltinSpecs();
5970 // Try to have a meaningful source location.
5971 if (TL.getWrittenSignSpec() != TypeSpecifierSign::Unspecified)
5972 TL.expandBuiltinRange(DS.getTypeSpecSignLoc());
5973 if (TL.getWrittenWidthSpec() != TypeSpecifierWidth::Unspecified)
5974 TL.expandBuiltinRange(DS.getTypeSpecWidthRange());
5975 }
5976 }
5977 void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5978 ElaboratedTypeKeyword Keyword
5979 = TypeWithKeyword::getKeywordForTypeSpec(DS.getTypeSpecType());
5980 if (DS.getTypeSpecType() == TST_typename) {
5981 TypeSourceInfo *TInfo = nullptr;
5982 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5983 if (TInfo) {
5984 TL.copy(TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>());
5985 return;
5986 }
5987 }
5988 TL.setElaboratedKeywordLoc(Keyword != ETK_None
5989 ? DS.getTypeSpecTypeLoc()
5990 : SourceLocation());
5991 const CXXScopeSpec& SS = DS.getTypeSpecScope();
5992 TL.setQualifierLoc(SS.getWithLocInContext(Context));
5993 Visit(TL.getNextTypeLoc().getUnqualifiedLoc());
5994 }
5995 void VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5996 assert(DS.getTypeSpecType() == TST_typename)(static_cast<void> (0));
5997 TypeSourceInfo *TInfo = nullptr;
5998 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5999 assert(TInfo)(static_cast<void> (0));
6000 TL.copy(TInfo->getTypeLoc().castAs<DependentNameTypeLoc>());
6001 }
6002 void VisitDependentTemplateSpecializationTypeLoc(
6003 DependentTemplateSpecializationTypeLoc TL) {
6004 assert(DS.getTypeSpecType() == TST_typename)(static_cast<void> (0));
6005 TypeSourceInfo *TInfo = nullptr;
6006 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
6007 assert(TInfo)(static_cast<void> (0));
6008 TL.copy(
6009 TInfo->getTypeLoc().castAs<DependentTemplateSpecializationTypeLoc>());
6010 }
6011 void VisitAutoTypeLoc(AutoTypeLoc TL) {
6012 assert(DS.getTypeSpecType() == TST_auto ||(static_cast<void> (0))
6013 DS.getTypeSpecType() == TST_decltype_auto ||(static_cast<void> (0))
6014 DS.getTypeSpecType() == TST_auto_type ||(static_cast<void> (0))
6015 DS.getTypeSpecType() == TST_unspecified)(static_cast<void> (0));
6016 TL.setNameLoc(DS.getTypeSpecTypeLoc());
6017 if (!DS.isConstrainedAuto())
6018 return;
6019 TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
6020 if (!TemplateId)
6021 return;
6022 if (DS.getTypeSpecScope().isNotEmpty())
6023 TL.setNestedNameSpecifierLoc(
6024 DS.getTypeSpecScope().getWithLocInContext(Context));
6025 else
6026 TL.setNestedNameSpecifierLoc(NestedNameSpecifierLoc());
6027 TL.setTemplateKWLoc(TemplateId->TemplateKWLoc);
6028 TL.setConceptNameLoc(TemplateId->TemplateNameLoc);
6029 TL.setFoundDecl(nullptr);
6030 TL.setLAngleLoc(TemplateId->LAngleLoc);
6031 TL.setRAngleLoc(TemplateId->RAngleLoc);
6032 if (TemplateId->NumArgs == 0)
6033 return;
6034 TemplateArgumentListInfo TemplateArgsInfo;
6035 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
6036 TemplateId->NumArgs);
6037 SemaRef.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
6038 for (unsigned I = 0; I < TemplateId->NumArgs; ++I)
6039 TL.setArgLocInfo(I, TemplateArgsInfo.arguments()[I].getLocInfo());
6040 }
6041 void VisitTagTypeLoc(TagTypeLoc TL) {
6042 TL.setNameLoc(DS.getTypeSpecTypeNameLoc());
6043 }
6044 void VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6045 // An AtomicTypeLoc can come from either an _Atomic(...) type specifier
6046 // or an _Atomic qualifier.
6047 if (DS.getTypeSpecType() == DeclSpec::TST_atomic) {
30
Assuming the condition is true
31
Taking true branch
6048 TL.setKWLoc(DS.getTypeSpecTypeLoc());
6049 TL.setParensRange(DS.getTypeofParensRange());
6050
6051 TypeSourceInfo *TInfo = nullptr;
6052 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
32
Calling 'Sema::GetTypeFromParser'
46
Returning from 'Sema::GetTypeFromParser'
6053 assert(TInfo)(static_cast<void> (0));
6054 TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc());
47
Called C++ object pointer is null
6055 } else {
6056 TL.setKWLoc(DS.getAtomicSpecLoc());
6057 // No parens, to indicate this was spelled as an _Atomic qualifier.
6058 TL.setParensRange(SourceRange());
6059 Visit(TL.getValueLoc());
6060 }
6061 }
6062
6063 void VisitPipeTypeLoc(PipeTypeLoc TL) {
6064 TL.setKWLoc(DS.getTypeSpecTypeLoc());
6065
6066 TypeSourceInfo *TInfo = nullptr;
6067 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
6068 TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc());
6069 }
6070
6071 void VisitExtIntTypeLoc(ExtIntTypeLoc TL) {
6072 TL.setNameLoc(DS.getTypeSpecTypeLoc());
6073 }
6074
6075 void VisitDependentExtIntTypeLoc(DependentExtIntTypeLoc TL) {
6076 TL.setNameLoc(DS.getTypeSpecTypeLoc());
6077 }
6078
6079 void VisitTypeLoc(TypeLoc TL) {
6080 // FIXME: add other typespec types and change this to an assert.
6081 TL.initialize(Context, DS.getTypeSpecTypeLoc());
6082 }
6083 };
6084
6085 class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> {
6086 ASTContext &Context;
6087 TypeProcessingState &State;
6088 const DeclaratorChunk &Chunk;
6089
6090 public:
6091 DeclaratorLocFiller(ASTContext &Context, TypeProcessingState &State,
6092 const DeclaratorChunk &Chunk)
6093 : Context(Context), State(State), Chunk(Chunk) {}
6094
6095 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6096 llvm_unreachable("qualified type locs not expected here!")__builtin_unreachable();
6097 }
6098 void VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6099 llvm_unreachable("decayed type locs not expected here!")__builtin_unreachable();
6100 }
6101
6102 void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6103 fillAttributedTypeLoc(TL, State);
6104 }
6105 void VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6106 // nothing
6107 }
6108 void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6109 assert(Chunk.Kind == DeclaratorChunk::BlockPointer)(static_cast<void> (0));
6110 TL.setCaretLoc(Chunk.Loc);
6111 }
6112 void VisitPointerTypeLoc(PointerTypeLoc TL) {
6113 assert(Chunk.Kind == DeclaratorChunk::Pointer)(static_cast<void> (0));
6114 TL.setStarLoc(Chunk.Loc);
6115 }
6116 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6117 assert(Chunk.Kind == DeclaratorChunk::Pointer)(static_cast<void> (0));
6118 TL.setStarLoc(Chunk.Loc);
6119 }
6120 void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6121 assert(Chunk.Kind == DeclaratorChunk::MemberPointer)(static_cast<void> (0));
6122 const CXXScopeSpec& SS = Chunk.Mem.Scope();
6123 NestedNameSpecifierLoc NNSLoc = SS.getWithLocInContext(Context);
6124
6125 const Type* ClsTy = TL.getClass();
6126 QualType ClsQT = QualType(ClsTy, 0);
6127 TypeSourceInfo *ClsTInfo = Context.CreateTypeSourceInfo(ClsQT, 0);
6128 // Now copy source location info into the type loc component.
6129 TypeLoc ClsTL = ClsTInfo->getTypeLoc();
6130 switch (NNSLoc.getNestedNameSpecifier()->getKind()) {
6131 case NestedNameSpecifier::Identifier:
6132 assert(isa<DependentNameType>(ClsTy) && "Unexpected TypeLoc")(static_cast<void> (0));
6133 {
6134 DependentNameTypeLoc DNTLoc = ClsTL.castAs<DependentNameTypeLoc>();
6135 DNTLoc.setElaboratedKeywordLoc(SourceLocation());
6136 DNTLoc.setQualifierLoc(NNSLoc.getPrefix());
6137 DNTLoc.setNameLoc(NNSLoc.getLocalBeginLoc());
6138 }
6139 break;
6140
6141 case NestedNameSpecifier::TypeSpec:
6142 case NestedNameSpecifier::TypeSpecWithTemplate:
6143 if (isa<ElaboratedType>(ClsTy)) {
6144 ElaboratedTypeLoc ETLoc = ClsTL.castAs<ElaboratedTypeLoc>();
6145 ETLoc.setElaboratedKeywordLoc(SourceLocation());
6146 ETLoc.setQualifierLoc(NNSLoc.getPrefix());
6147 TypeLoc NamedTL = ETLoc.getNamedTypeLoc();
6148 NamedTL.initializeFullCopy(NNSLoc.getTypeLoc());
6149 } else {
6150 ClsTL.initializeFullCopy(NNSLoc.getTypeLoc());
6151 }
6152 break;
6153
6154 case NestedNameSpecifier::Namespace:
6155 case NestedNameSpecifier::NamespaceAlias:
6156 case NestedNameSpecifier::Global:
6157 case NestedNameSpecifier::Super:
6158 llvm_unreachable("Nested-name-specifier must name a type")__builtin_unreachable();
6159 }
6160
6161 // Finally fill in MemberPointerLocInfo fields.
6162 TL.setStarLoc(Chunk.Mem.StarLoc);
6163 TL.setClassTInfo(ClsTInfo);
6164 }
6165 void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6166 assert(Chunk.Kind == DeclaratorChunk::Reference)(static_cast<void> (0));
6167 // 'Amp' is misleading: this might have been originally
6168 /// spelled with AmpAmp.
6169 TL.setAmpLoc(Chunk.Loc);
6170 }
6171 void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6172 assert(Chunk.Kind == DeclaratorChunk::Reference)(static_cast<void> (0));
6173 assert(!Chunk.Ref.LValueRef)(static_cast<void> (0));
6174 TL.setAmpAmpLoc(Chunk.Loc);
6175 }
6176 void VisitArrayTypeLoc(ArrayTypeLoc TL) {
6177 assert(Chunk.Kind == DeclaratorChunk::Array)(static_cast<void> (0));
6178 TL.setLBracketLoc(Chunk.Loc);
6179 TL.setRBracketLoc(Chunk.EndLoc);
6180 TL.setSizeExpr(static_cast<Expr*>(Chunk.Arr.NumElts));
6181 }
6182 void VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6183 assert(Chunk.Kind == DeclaratorChunk::Function)(static_cast<void> (0));
6184 TL.setLocalRangeBegin(Chunk.Loc);
6185 TL.setLocalRangeEnd(Chunk.EndLoc);
6186
6187 const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.Fun;
6188 TL.setLParenLoc(FTI.getLParenLoc());
6189 TL.setRParenLoc(FTI.getRParenLoc());
6190 for (unsigned i = 0, e = TL.getNumParams(), tpi = 0; i != e; ++i) {
6191 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
6192 TL.setParam(tpi++, Param);
6193 }
6194 TL.setExceptionSpecRange(FTI.getExceptionSpecRange());
6195 }
6196 void VisitParenTypeLoc(ParenTypeLoc TL) {
6197 assert(Chunk.Kind == DeclaratorChunk::Paren)(static_cast<void> (0));
6198 TL.setLParenLoc(Chunk.Loc);
6199 TL.setRParenLoc(Chunk.EndLoc);
6200 }
6201 void VisitPipeTypeLoc(PipeTypeLoc TL) {
6202 assert(Chunk.Kind == DeclaratorChunk::Pipe)(static_cast<void> (0));
6203 TL.setKWLoc(Chunk.Loc);
6204 }
6205 void VisitExtIntTypeLoc(ExtIntTypeLoc TL) {
6206 TL.setNameLoc(Chunk.Loc);
6207 }
6208 void VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
6209 TL.setExpansionLoc(Chunk.Loc);
6210 }
6211 void VisitVectorTypeLoc(VectorTypeLoc TL) { TL.setNameLoc(Chunk.Loc); }
6212 void VisitDependentVectorTypeLoc(DependentVectorTypeLoc TL) {
6213 TL.setNameLoc(Chunk.Loc);
6214 }
6215 void VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6216 TL.setNameLoc(Chunk.Loc);
6217 }
6218 void
6219 VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) {
6220 TL.setNameLoc(Chunk.Loc);
6221 }
6222
6223 void VisitTypeLoc(TypeLoc TL) {
6224 llvm_unreachable("unsupported TypeLoc kind in declarator!")__builtin_unreachable();
6225 }
6226 };
6227} // end anonymous namespace
6228
6229static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk) {
6230 SourceLocation Loc;
6231 switch (Chunk.Kind) {
6232 case DeclaratorChunk::Function:
6233 case DeclaratorChunk::Array:
6234 case DeclaratorChunk::Paren:
6235 case DeclaratorChunk::Pipe:
6236 llvm_unreachable("cannot be _Atomic qualified")__builtin_unreachable();
6237
6238 case DeclaratorChunk::Pointer:
6239 Loc = Chunk.Ptr.AtomicQualLoc;
6240 break;
6241
6242 case DeclaratorChunk::BlockPointer:
6243 case DeclaratorChunk::Reference:
6244 case DeclaratorChunk::MemberPointer:
6245 // FIXME: Provide a source location for the _Atomic keyword.
6246 break;
6247 }
6248
6249 ATL.setKWLoc(Loc);
6250 ATL.setParensRange(SourceRange());
6251}
6252
6253static void
6254fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL,
6255 const ParsedAttributesView &Attrs) {
6256 for (const ParsedAttr &AL : Attrs) {
6257 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
6258 DASTL.setAttrNameLoc(AL.getLoc());
6259 DASTL.setAttrExprOperand(AL.getArgAsExpr(0));
6260 DASTL.setAttrOperandParensRange(SourceRange());
6261 return;
6262 }
6263 }
6264
6265 llvm_unreachable(__builtin_unreachable()
6266 "no address_space attribute found at the expected location!")__builtin_unreachable();
6267}
6268
6269static void fillMatrixTypeLoc(MatrixTypeLoc MTL,
6270 const ParsedAttributesView &Attrs) {
6271 for (const ParsedAttr &AL : Attrs) {
6272 if (AL.getKind() == ParsedAttr::AT_MatrixType) {
6273 MTL.setAttrNameLoc(AL.getLoc());
6274 MTL.setAttrRowOperand(AL.getArgAsExpr(0));
6275 MTL.setAttrColumnOperand(AL.getArgAsExpr(1));
6276 MTL.setAttrOperandParensRange(SourceRange());
6277 return;
6278 }
6279 }
6280
6281 llvm_unreachable("no matrix_type attribute found at the expected location!")__builtin_unreachable();
6282}
6283
6284/// Create and instantiate a TypeSourceInfo with type source information.
6285///
6286/// \param T QualType referring to the type as written in source code.
6287///
6288/// \param ReturnTypeInfo For declarators whose return type does not show
6289/// up in the normal place in the declaration specifiers (such as a C++
6290/// conversion function), this pointer will refer to a type source information
6291/// for that return type.
6292static TypeSourceInfo *
6293GetTypeSourceInfoForDeclarator(TypeProcessingState &State,
6294 QualType T, TypeSourceInfo *ReturnTypeInfo) {
6295 Sema &S = State.getSema();
6296 Declarator &D = State.getDeclarator();
6297
6298 TypeSourceInfo *TInfo = S.Context.CreateTypeSourceInfo(T);
6299 UnqualTypeLoc CurrTL = TInfo->getTypeLoc().getUnqualifiedLoc();
6300
6301 // Handle parameter packs whose type is a pack expansion.
6302 if (isa<PackExpansionType>(T)) {
21
Assuming 'T' is not a 'PackExpansionType'
22
Taking false branch
6303 CurrTL.castAs<PackExpansionTypeLoc>().setEllipsisLoc(D.getEllipsisLoc());
6304 CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc();
6305 }
6306
6307 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
23
Assuming 'i' is equal to 'e'
24
Loop condition is false. Execution continues on line 6345
6308 // An AtomicTypeLoc might be produced by an atomic qualifier in this
6309 // declarator chunk.
6310 if (AtomicTypeLoc ATL = CurrTL.getAs<AtomicTypeLoc>()) {
6311 fillAtomicQualLoc(ATL, D.getTypeObject(i));
6312 CurrTL = ATL.getValueLoc().getUnqualifiedLoc();
6313 }
6314
6315 while (MacroQualifiedTypeLoc TL = CurrTL.getAs<MacroQualifiedTypeLoc>()) {
6316 TL.setExpansionLoc(
6317 State.getExpansionLocForMacroQualifiedType(TL.getTypePtr()));
6318 CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc();
6319 }
6320
6321 while (AttributedTypeLoc TL = CurrTL.getAs<AttributedTypeLoc>()) {
6322 fillAttributedTypeLoc(TL, State);
6323 CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc();
6324 }
6325
6326 while (DependentAddressSpaceTypeLoc TL =
6327 CurrTL.getAs<DependentAddressSpaceTypeLoc>()) {
6328 fillDependentAddressSpaceTypeLoc(TL, D.getTypeObject(i).getAttrs());
6329 CurrTL = TL.getPointeeTypeLoc().getUnqualifiedLoc();
6330 }
6331
6332 if (MatrixTypeLoc TL = CurrTL.getAs<MatrixTypeLoc>())
6333 fillMatrixTypeLoc(TL, D.getTypeObject(i).getAttrs());
6334
6335 // FIXME: Ordering here?
6336 while (AdjustedTypeLoc TL = CurrTL.getAs<AdjustedTypeLoc>())
6337 CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc();
6338
6339 DeclaratorLocFiller(S.Context, State, D.getTypeObject(i)).Visit(CurrTL);
6340 CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc();
6341 }
6342
6343 // If we have different source information for the return type, use
6344 // that. This really only applies to C++ conversion functions.
6345 if (ReturnTypeInfo) {
25
Assuming 'ReturnTypeInfo' is null
26
Taking false branch
6346 TypeLoc TL = ReturnTypeInfo->getTypeLoc();
6347 assert(TL.getFullDataSize() == CurrTL.getFullDataSize())(static_cast<void> (0));
6348 memcpy(CurrTL.getOpaqueData(), TL.getOpaqueData(), TL.getFullDataSize());
6349 } else {
6350 TypeSpecLocFiller(S, S.Context, State, D.getDeclSpec()).Visit(CurrTL);
27
Calling 'TypeLocVisitor::Visit'
6351 }
6352
6353 return TInfo;
6354}
6355
6356/// Create a LocInfoType to hold the given QualType and TypeSourceInfo.
6357ParsedType Sema::CreateParsedType(QualType T, TypeSourceInfo *TInfo) {
6358 // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser
6359 // and Sema during declaration parsing. Try deallocating/caching them when
6360 // it's appropriate, instead of allocating them and keeping them around.
6361 LocInfoType *LocT = (LocInfoType*)BumpAlloc.Allocate(sizeof(LocInfoType),
6362 TypeAlignment);
6363 new (LocT) LocInfoType(T, TInfo);
6364 assert(LocT->getTypeClass() != T->getTypeClass() &&(static_cast<void> (0))
6365 "LocInfoType's TypeClass conflicts with an existing Type class")(static_cast<void> (0));
6366 return ParsedType::make(QualType(LocT, 0));
6367}
6368
6369void LocInfoType::getAsStringInternal(std::string &Str,
6370 const PrintingPolicy &Policy) const {
6371 llvm_unreachable("LocInfoType leaked into the type system; an opaque TypeTy*"__builtin_unreachable()
6372 " was used directly instead of getting the QualType through"__builtin_unreachable()
6373 " GetTypeFromParser")__builtin_unreachable();
6374}
6375
6376TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
6377 // C99 6.7.6: Type names have no identifier. This is already validated by
6378 // the parser.
6379 assert(D.getIdentifier() == nullptr &&(static_cast<void> (0))
6380 "Type name should have no identifier!")(static_cast<void> (0));
6381
6382 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
6383 QualType T = TInfo->getType();
6384 if (D.isInvalidType())
6385 return true;
6386
6387 // Make sure there are no unused decl attributes on the declarator.
6388 // We don't want to do this for ObjC parameters because we're going
6389 // to apply them to the actual parameter declaration.
6390 // Likewise, we don't want to do this for alias declarations, because
6391 // we are actually going to build a declaration from this eventually.
6392 if (D.getContext() != DeclaratorContext::ObjCParameter &&
6393 D.getContext() != DeclaratorContext::AliasDecl &&
6394 D.getContext() != DeclaratorContext::AliasTemplate)
6395 checkUnusedDeclAttributes(D);
6396
6397 if (getLangOpts().CPlusPlus) {
6398 // Check that there are no default arguments (C++ only).
6399 CheckExtraCXXDefaultArguments(D);
6400 }
6401
6402 return CreateParsedType(T, TInfo);
6403}
6404
6405ParsedType Sema::ActOnObjCInstanceType(SourceLocation Loc) {
6406 QualType T = Context.getObjCInstanceType();
6407 TypeSourceInfo *TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
6408 return CreateParsedType(T, TInfo);
6409}
6410
6411//===----------------------------------------------------------------------===//
6412// Type Attribute Processing
6413//===----------------------------------------------------------------------===//
6414
6415/// Build an AddressSpace index from a constant expression and diagnose any
6416/// errors related to invalid address_spaces. Returns true on successfully
6417/// building an AddressSpace index.
6418static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx,
6419 const Expr *AddrSpace,
6420 SourceLocation AttrLoc) {
6421 if (!AddrSpace->isValueDependent()) {
6422 Optional<llvm::APSInt> OptAddrSpace =
6423 AddrSpace->getIntegerConstantExpr(S.Context);
6424 if (!OptAddrSpace) {
6425 S.Diag(AttrLoc, diag::err_attribute_argument_type)
6426 << "'address_space'" << AANT_ArgumentIntegerConstant
6427 << AddrSpace->getSourceRange();
6428 return false;
6429 }
6430 llvm::APSInt &addrSpace = *OptAddrSpace;
6431
6432 // Bounds checking.
6433 if (addrSpace.isSigned()) {
6434 if (addrSpace.isNegative()) {
6435 S.Diag(AttrLoc, diag::err_attribute_address_space_negative)
6436 << AddrSpace->getSourceRange();
6437 return false;
6438 }
6439 addrSpace.setIsSigned(false);
6440 }
6441
6442 llvm::APSInt max(addrSpace.getBitWidth());
6443 max =
6444 Qualifiers::MaxAddressSpace - (unsigned)LangAS::FirstTargetAddressSpace;
6445
6446 if (addrSpace > max) {
6447 S.Diag(AttrLoc, diag::err_attribute_address_space_too_high)
6448 << (unsigned)max.getZExtValue() << AddrSpace->getSourceRange();
6449 return false;
6450 }
6451
6452 ASIdx =
6453 getLangASFromTargetAS(static_cast<unsigned>(addrSpace.getZExtValue()));
6454 return true;
6455 }
6456
6457 // Default value for DependentAddressSpaceTypes
6458 ASIdx = LangAS::Default;
6459 return true;
6460}
6461
6462/// BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression
6463/// is uninstantiated. If instantiated it will apply the appropriate address
6464/// space to the type. This function allows dependent template variables to be
6465/// used in conjunction with the address_space attribute
6466QualType Sema::BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
6467 SourceLocation AttrLoc) {
6468 if (!AddrSpace->isValueDependent()) {
6469 if (DiagnoseMultipleAddrSpaceAttributes(*this, T.getAddressSpace(), ASIdx,
6470 AttrLoc))
6471 return QualType();
6472
6473 return Context.getAddrSpaceQualType(T, ASIdx);
6474 }
6475
6476 // A check with similar intentions as checking if a type already has an
6477 // address space except for on a dependent types, basically if the
6478 // current type is already a DependentAddressSpaceType then its already
6479 // lined up to have another address space on it and we can't have
6480 // multiple address spaces on the one pointer indirection
6481 if (T->getAs<DependentAddressSpaceType>()) {
6482 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
6483 return QualType();
6484 }
6485
6486 return Context.getDependentAddressSpaceType(T, AddrSpace, AttrLoc);
6487}
6488
6489QualType Sema::BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
6490 SourceLocation AttrLoc) {
6491 LangAS ASIdx;
6492 if (!BuildAddressSpaceIndex(*this, ASIdx, AddrSpace, AttrLoc))
6493 return QualType();
6494 return BuildAddressSpaceAttr(T, ASIdx, AddrSpace, AttrLoc);
6495}
6496
6497/// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
6498/// specified type. The attribute contains 1 argument, the id of the address
6499/// space for the type.
6500static void HandleAddressSpaceTypeAttribute(QualType &Type,
6501 const ParsedAttr &Attr,
6502 TypeProcessingState &State) {
6503 Sema &S = State.getSema();
6504
6505 // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "A function type shall not be
6506 // qualified by an address-space qualifier."
6507 if (Type->isFunctionType()) {
6508 S.Diag(Attr.getLoc(), diag::err_attribute_address_function_type);
6509 Attr.setInvalid();
6510 return;
6511 }
6512
6513 LangAS ASIdx;
6514 if (Attr.getKind() == ParsedAttr::AT_AddressSpace) {
6515
6516 // Check the attribute arguments.
6517 if (Attr.getNumArgs() != 1) {
6518 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
6519 << 1;
6520 Attr.setInvalid();
6521 return;
6522 }
6523
6524 Expr *ASArgExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
6525 LangAS ASIdx;
6526 if (!BuildAddressSpaceIndex(S, ASIdx, ASArgExpr, Attr.getLoc())) {
6527 Attr.setInvalid();
6528 return;
6529 }
6530
6531 ASTContext &Ctx = S.Context;
6532 auto *ASAttr =
6533 ::new (Ctx) AddressSpaceAttr(Ctx, Attr, static_cast<unsigned>(ASIdx));
6534
6535 // If the expression is not value dependent (not templated), then we can
6536 // apply the address space qualifiers just to the equivalent type.
6537 // Otherwise, we make an AttributedType with the modified and equivalent
6538 // type the same, and wrap it in a DependentAddressSpaceType. When this
6539 // dependent type is resolved, the qualifier is added to the equivalent type
6540 // later.
6541 QualType T;
6542 if (!ASArgExpr->isValueDependent()) {
6543 QualType EquivType =
6544 S.BuildAddressSpaceAttr(Type, ASIdx, ASArgExpr, Attr.getLoc());
6545 if (EquivType.isNull()) {
6546 Attr.setInvalid();
6547 return;
6548 }
6549 T = State.getAttributedType(ASAttr, Type, EquivType);
6550 } else {
6551 T = State.getAttributedType(ASAttr, Type, Type);
6552 T = S.BuildAddressSpaceAttr(T, ASIdx, ASArgExpr, Attr.getLoc());
6553 }
6554
6555 if (!T.isNull())
6556 Type = T;
6557 else
6558 Attr.setInvalid();
6559 } else {
6560 // The keyword-based type attributes imply which address space to use.
6561 ASIdx = S.getLangOpts().SYCLIsDevice ? Attr.asSYCLLangAS()
6562 : Attr.asOpenCLLangAS();
6563
6564 if (ASIdx == LangAS::Default)
6565 llvm_unreachable("Invalid address space")__builtin_unreachable();
6566
6567 if (DiagnoseMultipleAddrSpaceAttributes(S, Type.getAddressSpace(), ASIdx,
6568 Attr.getLoc())) {
6569 Attr.setInvalid();
6570 return;
6571 }
6572
6573 Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
6574 }
6575}
6576
6577/// handleObjCOwnershipTypeAttr - Process an objc_ownership
6578/// attribute on the specified type.
6579///
6580/// Returns 'true' if the attribute was handled.
6581static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state,
6582 ParsedAttr &attr, QualType &type) {
6583 bool NonObjCPointer = false;
6584
6585 if (!type->isDependentType() && !type->isUndeducedType()) {
6586 if (const PointerType *ptr = type->getAs<PointerType>()) {
6587 QualType pointee = ptr->getPointeeType();
6588 if (pointee->isObjCRetainableType() || pointee->isPointerType())
6589 return false;
6590 // It is important not to lose the source info that there was an attribute
6591 // applied to non-objc pointer. We will create an attributed type but
6592 // its type will be the same as the original type.
6593 NonObjCPointer = true;
6594 } else if (!type->isObjCRetainableType()) {
6595 return false;
6596 }
6597
6598 // Don't accept an ownership attribute in the declspec if it would
6599 // just be the return type of a block pointer.
6600 if (state.isProcessingDeclSpec()) {
6601 Declarator &D = state.getDeclarator();
6602 if (maybeMovePastReturnType(D, D.getNumTypeObjects(),
6603 /*onlyBlockPointers=*/true))
6604 return false;
6605 }
6606 }
6607
6608 Sema &S = state.getSema();
6609 SourceLocation AttrLoc = attr.getLoc();
6610 if (AttrLoc.isMacroID())
6611 AttrLoc =
6612 S.getSourceManager().getImmediateExpansionRange(AttrLoc).getBegin();
6613
6614 if (!attr.isArgIdent(0)) {
6615 S.Diag(AttrLoc, diag::err_attribute_argument_type) << attr
6616 << AANT_ArgumentString;
6617 attr.setInvalid();
6618 return true;
6619 }
6620
6621 IdentifierInfo *II = attr.getArgAsIdent(0)->Ident;
6622 Qualifiers::ObjCLifetime lifetime;
6623 if (II->isStr("none"))
6624 lifetime = Qualifiers::OCL_ExplicitNone;
6625 else if (II->isStr("strong"))
6626 lifetime = Qualifiers::OCL_Strong;
6627 else if (II->isStr("weak"))
6628 lifetime = Qualifiers::OCL_Weak;
6629 else if (II->isStr("autoreleasing"))
6630 lifetime = Qualifiers::OCL_Autoreleasing;
6631 else {
6632 S.Diag(AttrLoc, diag::warn_attribute_type_not_supported) << attr << II;
6633 attr.setInvalid();
6634 return true;
6635 }
6636
6637 // Just ignore lifetime attributes other than __weak and __unsafe_unretained
6638 // outside of ARC mode.
6639 if (!S.getLangOpts().ObjCAutoRefCount &&
6640 lifetime != Qualifiers::OCL_Weak &&
6641 lifetime != Qualifiers::OCL_ExplicitNone) {
6642 return true;
6643 }
6644
6645 SplitQualType underlyingType = type.split();
6646
6647 // Check for redundant/conflicting ownership qualifiers.
6648 if (Qualifiers::ObjCLifetime previousLifetime
6649 = type.getQualifiers().getObjCLifetime()) {
6650 // If it's written directly, that's an error.
6651 if (S.Context.hasDirectOwnershipQualifier(type)) {
6652 S.Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
6653 << type;
6654 return true;
6655 }
6656
6657 // Otherwise, if the qualifiers actually conflict, pull sugar off
6658 // and remove the ObjCLifetime qualifiers.
6659 if (previousLifetime != lifetime) {
6660 // It's possible to have multiple local ObjCLifetime qualifiers. We
6661 // can't stop after we reach a type that is directly qualified.
6662 const Type *prevTy = nullptr;
6663 while (!prevTy || prevTy != underlyingType.Ty) {
6664 prevTy = underlyingType.Ty;
6665 underlyingType = underlyingType.getSingleStepDesugaredType();
6666 }
6667 underlyingType.Quals.removeObjCLifetime();
6668 }
6669 }
6670
6671 underlyingType.Quals.addObjCLifetime(lifetime);
6672
6673 if (NonObjCPointer) {
6674 StringRef name = attr.getAttrName()->getName();
6675 switch (lifetime) {
6676 case Qualifiers::OCL_None:
6677 case Qualifiers::OCL_ExplicitNone:
6678 break;
6679 case Qualifiers::OCL_Strong: name = "__strong"; break;
6680 case Qualifiers::OCL_Weak: name = "__weak"; break;
6681 case Qualifiers::OCL_Autoreleasing: name = "__autoreleasing"; break;
6682 }
6683 S.Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
6684 << TDS_ObjCObjOrBlock << type;
6685 }
6686
6687 // Don't actually add the __unsafe_unretained qualifier in non-ARC files,
6688 // because having both 'T' and '__unsafe_unretained T' exist in the type
6689 // system causes unfortunate widespread consistency problems. (For example,
6690 // they're not considered compatible types, and we mangle them identicially
6691 // as template arguments.) These problems are all individually fixable,
6692 // but it's easier to just not add the qualifier and instead sniff it out
6693 // in specific places using isObjCInertUnsafeUnretainedType().
6694 //
6695 // Doing this does means we miss some trivial consistency checks that
6696 // would've triggered in ARC, but that's better than trying to solve all
6697 // the coexistence problems with __unsafe_unretained.
6698 if (!S.getLangOpts().ObjCAutoRefCount &&
6699 lifetime == Qualifiers::OCL_ExplicitNone) {
6700 type = state.getAttributedType(
6701 createSimpleAttr<ObjCInertUnsafeUnretainedAttr>(S.Context, attr),
6702 type, type);
6703 return true;
6704 }
6705
6706 QualType origType = type;
6707 if (!NonObjCPointer)
6708 type = S.Context.getQualifiedType(underlyingType);
6709
6710 // If we have a valid source location for the attribute, use an
6711 // AttributedType instead.
6712 if (AttrLoc.isValid()) {
6713 type = state.getAttributedType(::new (S.Context)
6714 ObjCOwnershipAttr(S.Context, attr, II),
6715 origType, type);
6716 }
6717
6718 auto diagnoseOrDelay = [](Sema &S, SourceLocation loc,
6719 unsigned diagnostic, QualType type) {
6720 if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
6721 S.DelayedDiagnostics.add(
6722 sema::DelayedDiagnostic::makeForbiddenType(
6723 S.getSourceManager().getExpansionLoc(loc),
6724 diagnostic, type, /*ignored*/ 0));
6725 } else {
6726 S.Diag(loc, diagnostic);
6727 }
6728 };
6729
6730 // Sometimes, __weak isn't allowed.
6731 if (lifetime == Qualifiers::OCL_Weak &&
6732 !S.getLangOpts().ObjCWeak && !NonObjCPointer) {
6733
6734 // Use a specialized diagnostic if the runtime just doesn't support them.
6735 unsigned diagnostic =
6736 (S.getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
6737 : diag::err_arc_weak_no_runtime);
6738
6739 // In any case, delay the diagnostic until we know what we're parsing.
6740 diagnoseOrDelay(S, AttrLoc, diagnostic, type);
6741
6742 attr.setInvalid();
6743 return true;
6744 }
6745
6746 // Forbid __weak for class objects marked as
6747 // objc_arc_weak_reference_unavailable
6748 if (lifetime == Qualifiers::OCL_Weak) {
6749 if (const ObjCObjectPointerType *ObjT =
6750 type->getAs<ObjCObjectPointerType>()) {
6751 if (ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl()) {
6752 if (Class->isArcWeakrefUnavailable()) {
6753 S.Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
6754 S.Diag(ObjT->getInterfaceDecl()->getLocation(),
6755 diag::note_class_declared);
6756 }
6757 }
6758 }
6759 }
6760
6761 return true;
6762}
6763
6764/// handleObjCGCTypeAttr - Process the __attribute__((objc_gc)) type
6765/// attribute on the specified type. Returns true to indicate that
6766/// the attribute was handled, false to indicate that the type does
6767/// not permit the attribute.
6768static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
6769 QualType &type) {
6770 Sema &S = state.getSema();
6771
6772 // Delay if this isn't some kind of pointer.
6773 if (!type->isPointerType() &&
6774 !type->isObjCObjectPointerType() &&
6775 !type->isBlockPointerType())
6776 return false;
6777
6778 if (type.getObjCGCAttr() != Qualifiers::GCNone) {
6779 S.Diag(attr.getLoc(), diag::err_attribute_multiple_objc_gc);
6780 attr.setInvalid();
6781 return true;
6782 }
6783
6784 // Check the attribute arguments.
6785 if (!attr.isArgIdent(0)) {
6786 S.Diag(attr.getLoc(), diag::err_attribute_argument_type)
6787 << attr << AANT_ArgumentString;
6788 attr.setInvalid();
6789 return true;
6790 }
6791 Qualifiers::GC GCAttr;
6792 if (attr.getNumArgs() > 1) {
6793 S.Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << attr
6794 << 1;
6795 attr.setInvalid();
6796 return true;
6797 }
6798
6799 IdentifierInfo *II = attr.getArgAsIdent(0)->Ident;
6800 if (II->isStr("weak"))
6801 GCAttr = Qualifiers::Weak;
6802 else if (II->isStr("strong"))
6803 GCAttr = Qualifiers::Strong;
6804 else {
6805 S.Diag(attr.getLoc(), diag::warn_attribute_type_not_supported)
6806 << attr << II;
6807 attr.setInvalid();
6808 return true;
6809 }
6810
6811 QualType origType = type;
6812 type = S.Context.getObjCGCQualType(origType, GCAttr);
6813
6814 // Make an attributed type to preserve the source information.
6815 if (attr.getLoc().isValid())
6816 type = state.getAttributedType(
6817 ::new (S.Context) ObjCGCAttr(S.Context, attr, II), origType, type);
6818
6819 return true;
6820}
6821
6822namespace {
6823 /// A helper class to unwrap a type down to a function for the
6824 /// purposes of applying attributes there.
6825 ///
6826 /// Use:
6827 /// FunctionTypeUnwrapper unwrapped(SemaRef, T);
6828 /// if (unwrapped.isFunctionType()) {
6829 /// const FunctionType *fn = unwrapped.get();
6830 /// // change fn somehow
6831 /// T = unwrapped.wrap(fn);
6832 /// }
6833 struct FunctionTypeUnwrapper {
6834 enum WrapKind {
6835 Desugar,
6836 Attributed,
6837 Parens,
6838 Array,
6839 Pointer,
6840 BlockPointer,
6841 Reference,
6842 MemberPointer,
6843 MacroQualified,
6844 };
6845
6846 QualType Original;
6847 const FunctionType *Fn;
6848 SmallVector<unsigned char /*WrapKind*/, 8> Stack;
6849
6850 FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) {
6851 while (true) {
6852 const Type *Ty = T.getTypePtr();
6853 if (isa<FunctionType>(Ty)) {
6854 Fn = cast<FunctionType>(Ty);
6855 return;
6856 } else if (isa<ParenType>(Ty)) {
6857 T = cast<ParenType>(Ty)->getInnerType();
6858 Stack.push_back(Parens);
6859 } else if (isa<ConstantArrayType>(Ty) || isa<VariableArrayType>(Ty) ||
6860 isa<IncompleteArrayType>(Ty)) {
6861 T = cast<ArrayType>(Ty)->getElementType();
6862 Stack.push_back(Array);
6863 } else if (isa<PointerType>(Ty)) {
6864 T = cast<PointerType>(Ty)->getPointeeType();
6865 Stack.push_back(Pointer);
6866 } else if (isa<BlockPointerType>(Ty)) {
6867 T = cast<BlockPointerType>(Ty)->getPointeeType();
6868 Stack.push_back(BlockPointer);
6869 } else if (isa<MemberPointerType>(Ty)) {
6870 T = cast<MemberPointerType>(Ty)->getPointeeType();
6871 Stack.push_back(MemberPointer);
6872 } else if (isa<ReferenceType>(Ty)) {
6873 T = cast<ReferenceType>(Ty)->getPointeeType();
6874 Stack.push_back(Reference);
6875 } else if (isa<AttributedType>(Ty)) {
6876 T = cast<AttributedType>(Ty)->getEquivalentType();
6877 Stack.push_back(Attributed);
6878 } else if (isa<MacroQualifiedType>(Ty)) {
6879 T = cast<MacroQualifiedType>(Ty)->getUnderlyingType();
6880 Stack.push_back(MacroQualified);
6881 } else {
6882 const Type *DTy = Ty->getUnqualifiedDesugaredType();
6883 if (Ty == DTy) {
6884 Fn = nullptr;
6885 return;
6886 }
6887
6888 T = QualType(DTy, 0);
6889 Stack.push_back(Desugar);
6890 }
6891 }
6892 }
6893
6894 bool isFunctionType() const { return (Fn != nullptr); }
6895 const FunctionType *get() const { return Fn; }
6896
6897 QualType wrap(Sema &S, const FunctionType *New) {
6898 // If T wasn't modified from the unwrapped type, do nothing.
6899 if (New == get()) return Original;
6900
6901 Fn = New;
6902 return wrap(S.Context, Original, 0);
6903 }
6904
6905 private:
6906 QualType wrap(ASTContext &C, QualType Old, unsigned I) {
6907 if (I == Stack.size())
6908 return C.getQualifiedType(Fn, Old.getQualifiers());
6909
6910 // Build up the inner type, applying the qualifiers from the old
6911 // type to the new type.
6912 SplitQualType SplitOld = Old.split();
6913
6914 // As a special case, tail-recurse if there are no qualifiers.
6915 if (SplitOld.Quals.empty())
6916 return wrap(C, SplitOld.Ty, I);
6917 return C.getQualifiedType(wrap(C, SplitOld.Ty, I), SplitOld.Quals);
6918 }
6919
6920 QualType wrap(ASTContext &C, const Type *Old, unsigned I) {
6921 if (I == Stack.size()) return QualType(Fn, 0);
6922
6923 switch (static_cast<WrapKind>(Stack[I++])) {
6924 case Desugar:
6925 // This is the point at which we potentially lose source
6926 // information.
6927 return wrap(C, Old->getUnqualifiedDesugaredType(), I);
6928
6929 case Attributed:
6930 return wrap(C, cast<AttributedType>(Old)->getEquivalentType(), I);
6931
6932 case Parens: {
6933 QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
6934 return C.getParenType(New);
6935 }
6936
6937 case MacroQualified:
6938 return wrap(C, cast<MacroQualifiedType>(Old)->getUnderlyingType(), I);
6939
6940 case Array: {
6941 if (const auto *CAT = dyn_cast<ConstantArrayType>(Old)) {
6942 QualType New = wrap(C, CAT->getElementType(), I);
6943 return C.getConstantArrayType(New, CAT->getSize(), CAT->getSizeExpr(),
6944 CAT->getSizeModifier(),
6945 CAT->getIndexTypeCVRQualifiers());
6946 }
6947
6948 if (const auto *VAT = dyn_cast<VariableArrayType>(Old)) {
6949 QualType New = wrap(C, VAT->getElementType(), I);
6950 return C.getVariableArrayType(
6951 New, VAT->getSizeExpr(), VAT->getSizeModifier(),
6952 VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
6953 }
6954
6955 const auto *IAT = cast<IncompleteArrayType>(Old);
6956 QualType New = wrap(C, IAT->getElementType(), I);
6957 return C.getIncompleteArrayType(New, IAT->getSizeModifier(),
6958 IAT->getIndexTypeCVRQualifiers());
6959 }
6960
6961 case Pointer: {
6962 QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I);
6963 return C.getPointerType(New);
6964 }
6965
6966 case BlockPointer: {
6967 QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I);
6968 return C.getBlockPointerType(New);
6969 }
6970
6971 case MemberPointer: {
6972 const MemberPointerType *OldMPT = cast<MemberPointerType>(Old);
6973 QualType New = wrap(C, OldMPT->getPointeeType(), I);
6974 return C.getMemberPointerType(New, OldMPT->getClass());
6975 }
6976
6977 case Reference: {
6978 const ReferenceType *OldRef = cast<ReferenceType>(Old);
6979 QualType New = wrap(C, OldRef->getPointeeType(), I);
6980 if (isa<LValueReferenceType>(OldRef))
6981 return C.getLValueReferenceType(New, OldRef->isSpelledAsLValue());
6982 else
6983 return C.getRValueReferenceType(New);
6984 }
6985 }
6986
6987 llvm_unreachable("unknown wrapping kind")__builtin_unreachable();
6988 }
6989 };
6990} // end anonymous namespace
6991
6992static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State,
6993 ParsedAttr &PAttr, QualType &Type) {
6994 Sema &S = State.getSema();
6995
6996 Attr *A;
6997 switch (PAttr.getKind()) {
6998 default: llvm_unreachable("Unknown attribute kind")__builtin_unreachable();
6999 case ParsedAttr::AT_Ptr32:
7000 A = createSimpleAttr<Ptr32Attr>(S.Context, PAttr);
7001 break;
7002 case ParsedAttr::AT_Ptr64:
7003 A = createSimpleAttr<Ptr64Attr>(S.Context, PAttr);
7004 break;
7005 case ParsedAttr::AT_SPtr:
7006 A = createSimpleAttr<SPtrAttr>(S.Context, PAttr);
7007 break;
7008 case ParsedAttr::AT_UPtr:
7009 A = createSimpleAttr<UPtrAttr>(S.Context, PAttr);
7010 break;
7011 }
7012
7013 std::bitset<attr::LastAttr> Attrs;
7014 attr::Kind NewAttrKind = A->getKind();
7015 QualType Desugared = Type;
7016 const AttributedType *AT = dyn_cast<AttributedType>(Type);
7017 while (AT) {
7018 Attrs[AT->getAttrKind()] = true;
7019 Desugared = AT->getModifiedType();
7020 AT = dyn_cast<AttributedType>(Desugared);
7021 }
7022
7023 // You cannot specify duplicate type attributes, so if the attribute has
7024 // already been applied, flag it.
7025 if (Attrs[NewAttrKind]) {
7026 S.Diag(PAttr.getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7027 return true;
7028 }
7029 Attrs[NewAttrKind] = true;
7030
7031 // You cannot have both __sptr and __uptr on the same type, nor can you
7032 // have __ptr32 and __ptr64.
7033 if (Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {
7034 S.Diag(PAttr.getLoc(), diag::err_attributes_are_not_compatible)
7035 << "'__ptr32'"
7036 << "'__ptr64'";
7037 return true;
7038 } else if (Attrs[attr::SPtr] && Attrs[attr::UPtr]) {
7039 S.Diag(PAttr.getLoc(), diag::err_attributes_are_not_compatible)
7040 << "'__sptr'"
7041 << "'__uptr'";
7042 return true;
7043 }
7044
7045 // Pointer type qualifiers can only operate on pointer types, but not
7046 // pointer-to-member types.
7047 //
7048 // FIXME: Should we really be disallowing this attribute if there is any
7049 // type sugar between it and the pointer (other than attributes)? Eg, this
7050 // disallows the attribute on a parenthesized pointer.
7051 // And if so, should we really allow *any* type attribute?
7052 if (!isa<PointerType>(Desugared)) {
7053 if (Type->isMemberPointerType())
7054 S.Diag(PAttr.getLoc(), diag::err_attribute_no_member_pointers) << PAttr;
7055 else
7056 S.Diag(PAttr.getLoc(), diag::err_attribute_pointers_only) << PAttr << 0;
7057 return true;
7058 }
7059
7060 // Add address space to type based on its attributes.
7061 LangAS ASIdx = LangAS::Default;
7062 uint64_t PtrWidth = S.Context.getTargetInfo().getPointerWidth(0);
7063 if (PtrWidth == 32) {
7064 if (Attrs[attr::Ptr64])
7065 ASIdx = LangAS::ptr64;
7066 else if (Attrs[attr::UPtr])
7067 ASIdx = LangAS::ptr32_uptr;
7068 } else if (PtrWidth == 64 && Attrs[attr::Ptr32]) {
7069 if (Attrs[attr::UPtr])
7070 ASIdx = LangAS::ptr32_uptr;
7071 else
7072 ASIdx = LangAS::ptr32_sptr;
7073 }
7074
7075 QualType Pointee = Type->getPointeeType();
7076 if (ASIdx != LangAS::Default)
7077 Pointee = S.Context.getAddrSpaceQualType(
7078 S.Context.removeAddrSpaceQualType(Pointee), ASIdx);
7079 Type = State.getAttributedType(A, Type, S.Context.getPointerType(Pointee));
7080 return false;
7081}
7082
7083/// Map a nullability attribute kind to a nullability kind.
7084static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind) {
7085 switch (kind) {
7086 case ParsedAttr::AT_TypeNonNull:
7087 return NullabilityKind::NonNull;
7088
7089 case ParsedAttr::AT_TypeNullable:
7090 return NullabilityKind::Nullable;
7091
7092 case ParsedAttr::AT_TypeNullableResult:
7093 return NullabilityKind::NullableResult;
7094
7095 case ParsedAttr::AT_TypeNullUnspecified:
7096 return NullabilityKind::Unspecified;
7097
7098 default:
7099 llvm_unreachable("not a nullability attribute kind")__builtin_unreachable();
7100 }
7101}
7102
7103/// Applies a nullability type specifier to the given type, if possible.
7104///
7105/// \param state The type processing state.
7106///
7107/// \param type The type to which the nullability specifier will be
7108/// added. On success, this type will be updated appropriately.
7109///
7110/// \param attr The attribute as written on the type.
7111///
7112/// \param allowOnArrayType Whether to accept nullability specifiers on an
7113/// array type (e.g., because it will decay to a pointer).
7114///
7115/// \returns true if a problem has been diagnosed, false on success.
7116static bool checkNullabilityTypeSpecifier(TypeProcessingState &state,
7117 QualType &type,
7118 ParsedAttr &attr,
7119 bool allowOnArrayType) {
7120 Sema &S = state.getSema();
7121
7122 NullabilityKind nullability = mapNullabilityAttrKind(attr.getKind());
7123 SourceLocation nullabilityLoc = attr.getLoc();
7124 bool isContextSensitive = attr.isContextSensitiveKeywordAttribute();
7125
7126 recordNullabilitySeen(S, nullabilityLoc);
7127
7128 // Check for existing nullability attributes on the type.
7129 QualType desugared = type;
7130 while (auto attributed = dyn_cast<AttributedType>(desugared.getTypePtr())) {
7131 // Check whether there is already a null
7132 if (auto existingNullability = attributed->getImmediateNullability()) {
7133 // Duplicated nullability.
7134 if (nullability == *existingNullability) {
7135 S.Diag(nullabilityLoc, diag::warn_nullability_duplicate)
7136 << DiagNullabilityKind(nullability, isContextSensitive)
7137 << FixItHint::CreateRemoval(nullabilityLoc);
7138
7139 break;
7140 }
7141
7142 // Conflicting nullability.
7143 S.Diag(nullabilityLoc, diag::err_nullability_conflicting)
7144 << DiagNullabilityKind(nullability, isContextSensitive)
7145 << DiagNullabilityKind(*existingNullability, false);
7146 return true;
7147 }
7148
7149 desugared = attributed->getModifiedType();
7150 }
7151
7152 // If there is already a different nullability specifier, complain.
7153 // This (unlike the code above) looks through typedefs that might
7154 // have nullability specifiers on them, which means we cannot
7155 // provide a useful Fix-It.
7156 if (auto existingNullability = desugared->getNullability(S.Context)) {
7157 if (nullability != *existingNullability) {
7158 S.Diag(nullabilityLoc, diag::err_nullability_conflicting)
7159 << DiagNullabilityKind(nullability, isContextSensitive)
7160 << DiagNullabilityKind(*existingNullability, false);
7161
7162 // Try to find the typedef with the existing nullability specifier.
7163 if (auto typedefType = desugared->getAs<TypedefType>()) {
7164 TypedefNameDecl *typedefDecl = typedefType->getDecl();
7165 QualType underlyingType = typedefDecl->getUnderlyingType();
7166 if (auto typedefNullability
7167 = AttributedType::stripOuterNullability(underlyingType)) {
7168 if (*typedefNullability == *existingNullability) {
7169 S.Diag(typedefDecl->getLocation(), diag::note_nullability_here)
7170 << DiagNullabilityKind(*existingNullability, false);
7171 }
7172 }
7173 }
7174
7175 return true;
7176 }
7177 }
7178
7179 // If this definitely isn't a pointer type, reject the specifier.
7180 if (!desugared->canHaveNullability() &&
7181 !(allowOnArrayType && desugared->isArrayType())) {
7182 S.Diag(nullabilityLoc, diag::err_nullability_nonpointer)
7183 << DiagNullabilityKind(nullability, isContextSensitive) << type;
7184 return true;
7185 }
7186
7187 // For the context-sensitive keywords/Objective-C property
7188 // attributes, require that the type be a single-level pointer.
7189 if (isContextSensitive) {
7190 // Make sure that the pointee isn't itself a pointer type.
7191 const Type *pointeeType = nullptr;
7192 if (desugared->isArrayType())
7193 pointeeType = desugared->getArrayElementTypeNoTypeQual();
7194 else if (desugared->isAnyPointerType())
7195 pointeeType = desugared->getPointeeType().getTypePtr();
7196
7197 if (pointeeType && (pointeeType->isAnyPointerType() ||
7198 pointeeType->isObjCObjectPointerType() ||
7199 pointeeType->isMemberPointerType())) {
7200 S.Diag(nullabilityLoc, diag::err_nullability_cs_multilevel)
7201 << DiagNullabilityKind(nullability, true)
7202 << type;
7203 S.Diag(nullabilityLoc, diag::note_nullability_type_specifier)
7204 << DiagNullabilityKind(nullability, false)
7205 << type
7206 << FixItHint::CreateReplacement(nullabilityLoc,
7207 getNullabilitySpelling(nullability));
7208 return true;
7209 }
7210 }
7211
7212 // Form the attributed type.
7213 type = state.getAttributedType(
7214 createNullabilityAttr(S.Context, attr, nullability), type, type);
7215 return false;
7216}
7217
7218/// Check the application of the Objective-C '__kindof' qualifier to
7219/// the given type.
7220static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type,
7221 ParsedAttr &attr) {
7222 Sema &S = state.getSema();
7223
7224 if (isa<ObjCTypeParamType>(type)) {
7225 // Build the attributed type to record where __kindof occurred.
7226 type = state.getAttributedType(
7227 createSimpleAttr<ObjCKindOfAttr>(S.Context, attr), type, type);
7228 return false;
7229 }
7230
7231 // Find out if it's an Objective-C object or object pointer type;
7232 const ObjCObjectPointerType *ptrType = type->getAs<ObjCObjectPointerType>();
7233 const ObjCObjectType *objType = ptrType ? ptrType->getObjectType()
7234 : type->getAs<ObjCObjectType>();
7235
7236 // If not, we can't apply __kindof.
7237 if (!objType) {
7238 // FIXME: Handle dependent types that aren't yet object types.
7239 S.Diag(attr.getLoc(), diag::err_objc_kindof_nonobject)
7240 << type;
7241 return true;
7242 }
7243
7244 // Rebuild the "equivalent" type, which pushes __kindof down into
7245 // the object type.
7246 // There is no need to apply kindof on an unqualified id type.
7247 QualType equivType = S.Context.getObjCObjectType(
7248 objType->getBaseType(), objType->getTypeArgsAsWritten(),
7249 objType->getProtocols(),
7250 /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true);
7251
7252 // If we started with an object pointer type, rebuild it.
7253 if (ptrType) {
7254 equivType = S.Context.getObjCObjectPointerType(equivType);
7255 if (auto nullability = type->getNullability(S.Context)) {
7256 // We create a nullability attribute from the __kindof attribute.
7257 // Make sure that will make sense.
7258 assert(attr.getAttributeSpellingListIndex() == 0 &&(static_cast<void> (0))
7259 "multiple spellings for __kindof?")(static_cast<void> (0));
7260 Attr *A = createNullabilityAttr(S.Context, attr, *nullability);
7261 A->setImplicit(true);
7262 equivType = state.getAttributedType(A, equivType, equivType);
7263 }
7264 }
7265
7266 // Build the attributed type to record where __kindof occurred.
7267 type = state.getAttributedType(
7268 createSimpleAttr<ObjCKindOfAttr>(S.Context, attr), type, equivType);
7269 return false;
7270}
7271
7272/// Distribute a nullability type attribute that cannot be applied to
7273/// the type specifier to a pointer, block pointer, or member pointer
7274/// declarator, complaining if necessary.
7275///
7276/// \returns true if the nullability annotation was distributed, false
7277/// otherwise.
7278static bool distributeNullabilityTypeAttr(TypeProcessingState &state,
7279 QualType type, ParsedAttr &attr) {
7280 Declarator &declarator = state.getDeclarator();
7281
7282 /// Attempt to move the attribute to the specified chunk.
7283 auto moveToChunk = [&](DeclaratorChunk &chunk, bool inFunction) -> bool {
7284 // If there is already a nullability attribute there, don't add
7285 // one.
7286 if (hasNullabilityAttr(chunk.getAttrs()))
7287 return false;
7288
7289 // Complain about the nullability qualifier being in the wrong
7290 // place.
7291 enum {
7292 PK_Pointer,
7293 PK_BlockPointer,
7294 PK_MemberPointer,
7295 PK_FunctionPointer,
7296 PK_MemberFunctionPointer,
7297 } pointerKind
7298 = chunk.Kind == DeclaratorChunk::Pointer ? (inFunction ? PK_FunctionPointer
7299 : PK_Pointer)
7300 : chunk.Kind == DeclaratorChunk::BlockPointer ? PK_BlockPointer
7301 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
7302
7303 auto diag = state.getSema().Diag(attr.getLoc(),
7304 diag::warn_nullability_declspec)
7305 << DiagNullabilityKind(mapNullabilityAttrKind(attr.getKind()),
7306 attr.isContextSensitiveKeywordAttribute())
7307 << type
7308 << static_cast<unsigned>(pointerKind);
7309
7310 // FIXME: MemberPointer chunks don't carry the location of the *.
7311 if (chunk.Kind != DeclaratorChunk::MemberPointer) {
7312 diag << FixItHint::CreateRemoval(attr.getLoc())
7313 << FixItHint::CreateInsertion(
7314 state.getSema().getPreprocessor().getLocForEndOfToken(
7315 chunk.Loc),
7316 " " + attr.getAttrName()->getName().str() + " ");
7317 }
7318
7319 moveAttrFromListToList(attr, state.getCurrentAttributes(),
7320 chunk.getAttrs());
7321 return true;
7322 };
7323
7324 // Move it to the outermost pointer, member pointer, or block
7325 // pointer declarator.
7326 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
7327 DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
7328 switch (chunk.Kind) {
7329 case DeclaratorChunk::Pointer:
7330 case DeclaratorChunk::BlockPointer:
7331 case DeclaratorChunk::MemberPointer:
7332 return moveToChunk(chunk, false);
7333
7334 case DeclaratorChunk::Paren:
7335 case DeclaratorChunk::Array:
7336 continue;
7337
7338 case DeclaratorChunk::Function:
7339 // Try to move past the return type to a function/block/member
7340 // function pointer.
7341 if (DeclaratorChunk *dest = maybeMovePastReturnType(
7342 declarator, i,
7343 /*onlyBlockPointers=*/false)) {
7344 return moveToChunk(*dest, true);
7345 }
7346
7347 return false;
7348
7349 // Don't walk through these.
7350 case DeclaratorChunk::Reference:
7351 case DeclaratorChunk::Pipe:
7352 return false;
7353 }
7354 }
7355
7356 return false;
7357}
7358
7359static Attr *getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr) {
7360 assert(!Attr.isInvalid())(static_cast<void> (0));
7361 switch (Attr.getKind()) {
7362 default:
7363 llvm_unreachable("not a calling convention attribute")__builtin_unreachable();
7364 case ParsedAttr::AT_CDecl:
7365 return createSimpleAttr<CDeclAttr>(Ctx, Attr);
7366 case ParsedAttr::AT_FastCall:
7367 return createSimpleAttr<FastCallAttr>(Ctx, Attr);
7368 case ParsedAttr::AT_StdCall:
7369 return createSimpleAttr<StdCallAttr>(Ctx, Attr);
7370 case ParsedAttr::AT_ThisCall:
7371 return createSimpleAttr<ThisCallAttr>(Ctx, Attr);
7372 case ParsedAttr::AT_RegCall:
7373 return createSimpleAttr<RegCallAttr>(Ctx, Attr);
7374 case ParsedAttr::AT_Pascal:
7375 return createSimpleAttr<PascalAttr>(Ctx, Attr);
7376 case ParsedAttr::AT_SwiftCall:
7377 return createSimpleAttr<SwiftCallAttr>(Ctx, Attr);
7378 case ParsedAttr::AT_SwiftAsyncCall:
7379 return createSimpleAttr<SwiftAsyncCallAttr>(Ctx, Attr);
7380 case ParsedAttr::AT_VectorCall:
7381 return createSimpleAttr<VectorCallAttr>(Ctx, Attr);
7382 case ParsedAttr::AT_AArch64VectorPcs:
7383 return createSimpleAttr<AArch64VectorPcsAttr>(Ctx, Attr);
7384 case ParsedAttr::AT_Pcs: {
7385 // The attribute may have had a fixit applied where we treated an
7386 // identifier as a string literal. The contents of the string are valid,
7387 // but the form may not be.
7388 StringRef Str;
7389 if (Attr.isArgExpr(0))
7390 Str = cast<StringLiteral>(Attr.getArgAsExpr(0))->getString();
7391 else
7392 Str = Attr.getArgAsIdent(0)->Ident->getName();
7393 PcsAttr::PCSType Type;
7394 if (!PcsAttr::ConvertStrToPCSType(Str, Type))
7395 llvm_unreachable("already validated the attribute")__builtin_unreachable();
7396 return ::new (Ctx) PcsAttr(Ctx, Attr, Type);
7397 }
7398 case ParsedAttr::AT_IntelOclBicc:
7399 return createSimpleAttr<IntelOclBiccAttr>(Ctx, Attr);
7400 case ParsedAttr::AT_MSABI:
7401 return createSimpleAttr<MSABIAttr>(Ctx, Attr);
7402 case ParsedAttr::AT_SysVABI:
7403 return createSimpleAttr<SysVABIAttr>(Ctx, Attr);
7404 case ParsedAttr::AT_PreserveMost:
7405 return createSimpleAttr<PreserveMostAttr>(Ctx, Attr);
7406 case ParsedAttr::AT_PreserveAll:
7407 return createSimpleAttr<PreserveAllAttr>(Ctx, Attr);
7408 }
7409 llvm_unreachable("unexpected attribute kind!")__builtin_unreachable();
7410}
7411
7412/// Process an individual function attribute. Returns true to
7413/// indicate that the attribute was handled, false if it wasn't.
7414static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
7415 QualType &type) {
7416 Sema &S = state.getSema();
7417
7418 FunctionTypeUnwrapper unwrapped(S, type);
7419
7420 if (attr.getKind() == ParsedAttr::AT_NoReturn) {
7421 if (S.CheckAttrNoArgs(attr))
7422 return true;
7423
7424 // Delay if this is not a function type.
7425 if (!unwrapped.isFunctionType())
7426 return false;
7427
7428 // Otherwise we can process right away.
7429 FunctionType::ExtInfo EI = unwrapped.get()->getExtInfo().withNoReturn(true);
7430 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
7431 return true;
7432 }
7433
7434 if (attr.getKind() == ParsedAttr::AT_CmseNSCall) {
7435 // Delay if this is not a function type.
7436 if (!unwrapped.isFunctionType())
7437 return false;
7438
7439 // Ignore if we don't have CMSE enabled.
7440 if (!S.getLangOpts().Cmse) {
7441 S.Diag(attr.getLoc(), diag::warn_attribute_ignored) << attr;
7442 attr.setInvalid();
7443 return true;
7444 }
7445
7446 // Otherwise we can process right away.
7447 FunctionType::ExtInfo EI =
7448 unwrapped.get()->getExtInfo().withCmseNSCall(true);
7449 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
7450 return true;
7451 }
7452
7453 // ns_returns_retained is not always a type attribute, but if we got
7454 // here, we're treating it as one right now.
7455 if (attr.getKind() == ParsedAttr::AT_NSReturnsRetained) {
7456 if (attr.getNumArgs()) return true;
7457
7458 // Delay if this is not a function type.
7459 if (!unwrapped.isFunctionType())
7460 return false;
7461
7462 // Check whether the return type is reasonable.
7463 if (S.checkNSReturnsRetainedReturnType(attr.getLoc(),
7464 unwrapped.get()->getReturnType()))
7465 return true;
7466
7467 // Only actually change the underlying type in ARC builds.
7468 QualType origType = type;
7469 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
7470 FunctionType::ExtInfo EI
7471 = unwrapped.get()->getExtInfo().withProducesResult(true);
7472 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
7473 }
7474 type = state.getAttributedType(
7475 createSimpleAttr<NSReturnsRetainedAttr>(S.Context, attr),
7476 origType, type);
7477 return true;
7478 }
7479
7480 if (attr.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
7481 if (S.CheckAttrTarget(attr) || S.CheckAttrNoArgs(attr))
7482 return true;
7483
7484 // Delay if this is not a function type.
7485 if (!unwrapped.isFunctionType())
7486 return false;
7487
7488 FunctionType::ExtInfo EI =
7489 unwrapped.get()->getExtInfo().withNoCallerSavedRegs(true);
7490 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
7491 return true;
7492 }
7493
7494 if (attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
7495 if (!S.getLangOpts().CFProtectionBranch) {
7496 S.Diag(attr.getLoc(), diag::warn_nocf_check_attribute_ignored);
7497 attr.setInvalid();
7498 return true;
7499 }
7500
7501 if (S.CheckAttrTarget(attr) || S.CheckAttrNoArgs(attr))
7502 return true;
7503
7504 // If this is not a function type, warning will be asserted by subject
7505 // check.
7506 if (!unwrapped.isFunctionType())
7507 return true;
7508
7509 FunctionType::ExtInfo EI =
7510 unwrapped.get()->getExtInfo().withNoCfCheck(true);
7511 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
7512 return true;
7513 }
7514
7515 if (attr.getKind() == ParsedAttr::AT_Regparm) {
7516 unsigned value;
7517 if (S.CheckRegparmAttr(attr, value))
7518 return true;
7519
7520 // Delay if this is not a function type.
7521 if (!unwrapped.isFunctionType())
7522 return false;
7523
7524 // Diagnose regparm with fastcall.
7525 const FunctionType *fn = unwrapped.get();
7526 CallingConv CC = fn->getCallConv();
7527 if (CC == CC_X86FastCall) {
7528 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
7529 << FunctionType::getNameForCallConv(CC)
7530 << "regparm";
7531 attr.setInvalid();
7532 return true;
7533 }
7534
7535 FunctionType::ExtInfo EI =
7536 unwrapped.get()->getExtInfo().withRegParm(value);
7537 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
7538 return true;
7539 }
7540
7541 if (attr.getKind() == ParsedAttr::AT_NoThrow) {
7542 // Delay if this is not a function type.
7543 if (!unwrapped.isFunctionType())
7544 return false;
7545
7546 if (S.CheckAttrNoArgs(attr)) {
7547 attr.setInvalid();
7548 return true;
7549 }
7550
7551 // Otherwise we can process right away.
7552 auto *Proto = unwrapped.get()->castAs<FunctionProtoType>();
7553
7554 // MSVC ignores nothrow if it is in conflict with an explicit exception
7555 // specification.
7556 if (Proto->hasExceptionSpec()) {
7557 switch (Proto->getExceptionSpecType()) {
7558 case EST_None:
7559 llvm_unreachable("This doesn't have an exception spec!")__builtin_unreachable();
7560
7561 case EST_DynamicNone:
7562 case EST_BasicNoexcept:
7563 case EST_NoexceptTrue:
7564 case EST_NoThrow:
7565 // Exception spec doesn't conflict with nothrow, so don't warn.
7566 LLVM_FALLTHROUGH[[gnu::fallthrough]];
7567 case EST_Unparsed:
7568 case EST_Uninstantiated:
7569 case EST_DependentNoexcept:
7570 case EST_Unevaluated:
7571 // We don't have enough information to properly determine if there is a
7572 // conflict, so suppress the warning.
7573 break;
7574 case EST_Dynamic:
7575 case EST_MSAny:
7576 case EST_NoexceptFalse:
7577 S.Diag(attr.getLoc(), diag::warn_nothrow_attribute_ignored);
7578 break;
7579 }
7580 return true;
7581 }
7582
7583 type = unwrapped.wrap(
7584 S, S.Context
7585 .getFunctionTypeWithExceptionSpec(
7586 QualType{Proto, 0},
7587 FunctionProtoType::ExceptionSpecInfo{EST_NoThrow})
7588 ->getAs<FunctionType>());
7589 return true;
7590 }
7591
7592 // Delay if the type didn't work out to a function.
7593 if (!unwrapped.isFunctionType()) return false;
7594
7595 // Otherwise, a calling convention.
7596 CallingConv CC;
7597 if (S.CheckCallingConvAttr(attr, CC))
7598 return true;
7599
7600 const FunctionType *fn = unwrapped.get();
7601 CallingConv CCOld = fn->getCallConv();
7602 Attr *CCAttr = getCCTypeAttr(S.Context, attr);
7603
7604 if (CCOld != CC) {
7605 // Error out on when there's already an attribute on the type
7606 // and the CCs don't match.
7607 if (S.getCallingConvAttributedType(type)) {
7608 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
7609 << FunctionType::getNameForCallConv(CC)
7610 << FunctionType::getNameForCallConv(CCOld);
7611 attr.setInvalid();
7612 return true;
7613 }
7614 }
7615
7616 // Diagnose use of variadic functions with calling conventions that
7617 // don't support them (e.g. because they're callee-cleanup).
7618 // We delay warning about this on unprototyped function declarations
7619 // until after redeclaration checking, just in case we pick up a
7620 // prototype that way. And apparently we also "delay" warning about
7621 // unprototyped function types in general, despite not necessarily having
7622 // much ability to diagnose it later.
7623 if (!supportsVariadicCall(CC)) {
7624 const FunctionProtoType *FnP = dyn_cast<FunctionProtoType>(fn);
7625 if (FnP && FnP->isVariadic()) {
7626 // stdcall and fastcall are ignored with a warning for GCC and MS
7627 // compatibility.
7628 if (CC == CC_X86StdCall || CC == CC_X86FastCall)
7629 return S.Diag(attr.getLoc(), diag::warn_cconv_unsupported)
7630 << FunctionType::getNameForCallConv(CC)
7631 << (int)Sema::CallingConventionIgnoredReason::VariadicFunction;
7632
7633 attr.setInvalid();
7634 return S.Diag(attr.getLoc(), diag::err_cconv_varargs)
7635 << FunctionType::getNameForCallConv(CC);
7636 }
7637 }
7638
7639 // Also diagnose fastcall with regparm.
7640 if (CC == CC_X86FastCall && fn->getHasRegParm()) {
7641 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
7642 << "regparm" << FunctionType::getNameForCallConv(CC_X86FastCall);
7643 attr.setInvalid();
7644 return true;
7645 }
7646
7647 // Modify the CC from the wrapped function type, wrap it all back, and then
7648 // wrap the whole thing in an AttributedType as written. The modified type
7649 // might have a different CC if we ignored the attribute.
7650 QualType Equivalent;
7651 if (CCOld == CC) {
7652 Equivalent = type;
7653 } else {
7654 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
7655 Equivalent =
7656 unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
7657 }
7658 type = state.getAttributedType(CCAttr, type, Equivalent);
7659 return true;
7660}
7661
7662bool Sema::hasExplicitCallingConv(QualType T) {
7663 const AttributedType *AT;
7664
7665 // Stop if we'd be stripping off a typedef sugar node to reach the
7666 // AttributedType.
7667 while ((AT = T->getAs<AttributedType>()) &&
7668 AT->getAs<TypedefType>() == T->getAs<TypedefType>()) {
7669 if (AT->isCallingConv())
7670 return true;
7671 T = AT->getModifiedType();
7672 }
7673 return false;
7674}
7675
7676void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
7677 SourceLocation Loc) {
7678 FunctionTypeUnwrapper Unwrapped(*this, T);
7679 const FunctionType *FT = Unwrapped.get();
7680 bool IsVariadic = (isa<FunctionProtoType>(FT) &&
7681 cast<FunctionProtoType>(FT)->isVariadic());
7682 CallingConv CurCC = FT->getCallConv();
7683 CallingConv ToCC = Context.getDefaultCallingConvention(IsVariadic, !IsStatic);
7684
7685 if (CurCC == ToCC)
7686 return;
7687
7688 // MS compiler ignores explicit calling convention attributes on structors. We
7689 // should do the same.
7690 if (Context.getTargetInfo().getCXXABI().isMicrosoft() && IsCtorOrDtor) {
7691 // Issue a warning on ignored calling convention -- except of __stdcall.
7692 // Again, this is what MS compiler does.
7693 if (CurCC != CC_X86StdCall)
7694 Diag(Loc, diag::warn_cconv_unsupported)
7695 << FunctionType::getNameForCallConv(CurCC)
7696 << (int)Sema::CallingConventionIgnoredReason::ConstructorDestructor;
7697 // Default adjustment.
7698 } else {
7699 // Only adjust types with the default convention. For example, on Windows
7700 // we should adjust a __cdecl type to __thiscall for instance methods, and a
7701 // __thiscall type to __cdecl for static methods.
7702 CallingConv DefaultCC =
7703 Context.getDefaultCallingConvention(IsVariadic, IsStatic);
7704
7705 if (CurCC != DefaultCC || DefaultCC == ToCC)
7706 return;
7707
7708 if (hasExplicitCallingConv(T))
7709 return;
7710 }
7711
7712 FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(ToCC));
7713 QualType Wrapped = Unwrapped.wrap(*this, FT);
7714 T = Context.getAdjustedType(T, Wrapped);
7715}
7716
7717/// HandleVectorSizeAttribute - this attribute is only applicable to integral
7718/// and float scalars, although arrays, pointers, and function return values are
7719/// allowed in conjunction with this construct. Aggregates with this attribute
7720/// are invalid, even if they are of the same size as a corresponding scalar.
7721/// The raw attribute should contain precisely 1 argument, the vector size for
7722/// the variable, measured in bytes. If curType and rawAttr are well formed,
7723/// this routine will return a new vector type.
7724static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr,
7725 Sema &S) {
7726 // Check the attribute arguments.
7727 if (Attr.getNumArgs() != 1) {
7728 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
7729 << 1;
7730 Attr.setInvalid();
7731 return;
7732 }
7733
7734 Expr *SizeExpr = Attr.getArgAsExpr(0);
7735 QualType T = S.BuildVectorType(CurType, SizeExpr, Attr.getLoc());
7736 if (!T.isNull())
7737 CurType = T;
7738 else
7739 Attr.setInvalid();
7740}
7741
7742/// Process the OpenCL-like ext_vector_type attribute when it occurs on
7743/// a type.
7744static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr,
7745 Sema &S) {
7746 // check the attribute arguments.
7747 if (Attr.getNumArgs() != 1) {
7748 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
7749 << 1;
7750 return;
7751 }
7752
7753 Expr *SizeExpr = Attr.getArgAsExpr(0);
7754 QualType T = S.BuildExtVectorType(CurType, SizeExpr, Attr.getLoc());
7755 if (!T.isNull())
7756 CurType = T;
7757}
7758
7759static bool isPermittedNeonBaseType(QualType &Ty,
7760 VectorType::VectorKind VecKind, Sema &S) {
7761 const BuiltinType *BTy = Ty->getAs<BuiltinType>();
7762 if (!BTy)
7763 return false;
7764
7765 llvm::Triple Triple = S.Context.getTargetInfo().getTriple();
7766
7767 // Signed poly is mathematically wrong, but has been baked into some ABIs by
7768 // now.
7769 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
7770 Triple.getArch() == llvm::Triple::aarch64_32 ||
7771 Triple.getArch() == llvm::Triple::aarch64_be;
7772 if (VecKind == VectorType::NeonPolyVector) {
7773 if (IsPolyUnsigned) {
7774 // AArch64 polynomial vectors are unsigned.
7775 return BTy->getKind() == BuiltinType::UChar ||
7776 BTy->getKind() == BuiltinType::UShort ||
7777 BTy->getKind() == BuiltinType::ULong ||
7778 BTy->getKind() == BuiltinType::ULongLong;
7779 } else {
7780 // AArch32 polynomial vectors are signed.
7781 return BTy->getKind() == BuiltinType::SChar ||
7782 BTy->getKind() == BuiltinType::Short ||
7783 BTy->getKind() == BuiltinType::LongLong;
7784 }
7785 }
7786
7787 // Non-polynomial vector types: the usual suspects are allowed, as well as
7788 // float64_t on AArch64.
7789 if ((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&
7790 BTy->getKind() == BuiltinType::Double)
7791 return true;
7792
7793 return BTy->getKind() == BuiltinType::SChar ||
7794 BTy->getKind() == BuiltinType::UChar ||
7795 BTy->getKind() == BuiltinType::Short ||
7796 BTy->getKind() == BuiltinType::UShort ||
7797 BTy->getKind() == BuiltinType::Int ||
7798 BTy->getKind() == BuiltinType::UInt ||
7799 BTy->getKind() == BuiltinType::Long ||
7800 BTy->getKind() == BuiltinType::ULong ||
7801 BTy->getKind() == BuiltinType::LongLong ||
7802 BTy->getKind() == BuiltinType::ULongLong ||
7803 BTy->getKind() == BuiltinType::Float ||
7804 BTy->getKind() == BuiltinType::Half ||
7805 BTy->getKind() == BuiltinType::BFloat16;
7806}
7807
7808static bool verifyValidIntegerConstantExpr(Sema &S, const ParsedAttr &Attr,
7809 llvm::APSInt &Result) {
7810 const auto *AttrExpr = Attr.getArgAsExpr(0);
7811 if (!AttrExpr->isTypeDependent() && !AttrExpr->isValueDependent()) {
7812 if (Optional<llvm::APSInt> Res =
7813 AttrExpr->getIntegerConstantExpr(S.Context)) {
7814 Result = *Res;
7815 return true;
7816 }
7817 }
7818 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
7819 << Attr << AANT_ArgumentIntegerConstant << AttrExpr->getSourceRange();
7820 Attr.setInvalid();
7821 return false;
7822}
7823
7824/// HandleNeonVectorTypeAttr - The "neon_vector_type" and
7825/// "neon_polyvector_type" attributes are used to create vector types that
7826/// are mangled according to ARM's ABI. Otherwise, these types are identical
7827/// to those created with the "vector_size" attribute. Unlike "vector_size"
7828/// the argument to these Neon attributes is the number of vector elements,
7829/// not the vector size in bytes. The vector width and element type must
7830/// match one of the standard Neon vector types.
7831static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr,
7832 Sema &S, VectorType::VectorKind VecKind) {
7833 // Target must have NEON (or MVE, whose vectors are similar enough
7834 // not to need a separate attribute)
7835 if (!S.Context.getTargetInfo().hasFeature("neon") &&
7836 !S.Context.getTargetInfo().hasFeature("mve")) {
7837 S.Diag(Attr.getLoc(), diag::err_attribute_unsupported)
7838 << Attr << "'neon' or 'mve'";
7839 Attr.setInvalid();
7840 return;
7841 }
7842 // Check the attribute arguments.
7843 if (Attr.getNumArgs() != 1) {
7844 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
7845 << 1;
7846 Attr.setInvalid();
7847 return;
7848 }
7849 // The number of elements must be an ICE.
7850 llvm::APSInt numEltsInt(32);
7851 if (!verifyValidIntegerConstantExpr(S, Attr, numEltsInt))
7852 return;
7853
7854 // Only certain element types are supported for Neon vectors.
7855 if (!isPermittedNeonBaseType(CurType, VecKind, S)) {
7856 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
7857 Attr.setInvalid();
7858 return;
7859 }
7860
7861 // The total size of the vector must be 64 or 128 bits.
7862 unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType));
7863 unsigned numElts = static_cast<unsigned>(numEltsInt.getZExtValue());
7864 unsigned vecSize = typeSize * numElts;
7865 if (vecSize != 64 && vecSize != 128) {
7866 S.Diag(Attr.getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
7867 Attr.setInvalid();
7868 return;
7869 }
7870
7871 CurType = S.Context.getVectorType(CurType, numElts, VecKind);
7872}
7873
7874/// HandleArmSveVectorBitsTypeAttr - The "arm_sve_vector_bits" attribute is
7875/// used to create fixed-length versions of sizeless SVE types defined by
7876/// the ACLE, such as svint32_t and svbool_t.
7877static void HandleArmSveVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr,
7878 Sema &S) {
7879 // Target must have SVE.
7880 if (!S.Context.getTargetInfo().hasFeature("sve")) {
7881 S.Diag(Attr.getLoc(), diag::err_attribute_unsupported) << Attr << "'sve'";
7882 Attr.setInvalid();
7883 return;
7884 }
7885
7886 // Attribute is unsupported if '-msve-vector-bits=<bits>' isn't specified.
7887 if (!S.getLangOpts().ArmSveVectorBits) {
7888 S.Diag(Attr.getLoc(), diag::err_attribute_arm_feature_sve_bits_unsupported)
7889 << Attr;
7890 Attr.setInvalid();
7891 return;
7892 }
7893
7894 // Check the attribute arguments.
7895 if (Attr.getNumArgs() != 1) {
7896 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
7897 << Attr << 1;
7898 Attr.setInvalid();
7899 return;
7900 }
7901
7902 // The vector size must be an integer constant expression.
7903 llvm::APSInt SveVectorSizeInBits(32);
7904 if (!verifyValidIntegerConstantExpr(S, Attr, SveVectorSizeInBits))
7905 return;
7906
7907 unsigned VecSize = static_cast<unsigned>(SveVectorSizeInBits.getZExtValue());
7908
7909 // The attribute vector size must match -msve-vector-bits.
7910 if (VecSize != S.getLangOpts().ArmSveVectorBits) {
7911 S.Diag(Attr.getLoc(), diag::err_attribute_bad_sve_vector_size)
7912 << VecSize << S.getLangOpts().ArmSveVectorBits;
7913 Attr.setInvalid();
7914 return;
7915 }
7916
7917 // Attribute can only be attached to a single SVE vector or predicate type.
7918 if (!CurType->isVLSTBuiltinType()) {
7919 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_sve_type)
7920 << Attr << CurType;
7921 Attr.setInvalid();
7922 return;
7923 }
7924
7925 const auto *BT = CurType->castAs<BuiltinType>();
7926
7927 QualType EltType = CurType->getSveEltType(S.Context);
7928 unsigned TypeSize = S.Context.getTypeSize(EltType);
7929 VectorType::VectorKind VecKind = VectorType::SveFixedLengthDataVector;
7930 if (BT->getKind() == BuiltinType::SveBool) {
7931 // Predicates are represented as i8.
7932 VecSize /= S.Context.getCharWidth() * S.Context.getCharWidth();
7933 VecKind = VectorType::SveFixedLengthPredicateVector;
7934 } else
7935 VecSize /= TypeSize;
7936 CurType = S.Context.getVectorType(EltType, VecSize, VecKind);
7937}
7938
7939static void HandleArmMveStrictPolymorphismAttr(TypeProcessingState &State,
7940 QualType &CurType,
7941 ParsedAttr &Attr) {
7942 const VectorType *VT = dyn_cast<VectorType>(CurType);
7943 if (!VT || VT->getVectorKind() != VectorType::NeonVector) {
7944 State.getSema().Diag(Attr.getLoc(),
7945 diag::err_attribute_arm_mve_polymorphism);
7946 Attr.setInvalid();
7947 return;
7948 }
7949
7950 CurType =
7951 State.getAttributedType(createSimpleAttr<ArmMveStrictPolymorphismAttr>(
7952 State.getSema().Context, Attr),
7953 CurType, CurType);
7954}
7955
7956/// Handle OpenCL Access Qualifier Attribute.
7957static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr,
7958 Sema &S) {
7959 // OpenCL v2.0 s6.6 - Access qualifier can be used only for image and pipe type.
7960 if (!(CurType->isImageType() || CurType->isPipeType())) {
7961 S.Diag(Attr.getLoc(), diag::err_opencl_invalid_access_qualifier);
7962 Attr.setInvalid();
7963 return;
7964 }
7965
7966 if (const TypedefType* TypedefTy = CurType->getAs<TypedefType>()) {
7967 QualType BaseTy = TypedefTy->desugar();
7968
7969 std::string PrevAccessQual;
7970 if (BaseTy->isPipeType()) {
7971 if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
7972 OpenCLAccessAttr *Attr =
7973 TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
7974 PrevAccessQual = Attr->getSpelling();
7975 } else {
7976 PrevAccessQual = "read_only";
7977 }
7978 } else if (const BuiltinType* ImgType = BaseTy->getAs<BuiltinType>()) {
7979
7980 switch (ImgType->getKind()) {
7981 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7982 case BuiltinType::Id: \
7983 PrevAccessQual = #Access; \
7984 break;
7985 #include "clang/Basic/OpenCLImageTypes.def"
7986 default:
7987 llvm_unreachable("Unable to find corresponding image type.")__builtin_unreachable();
7988 }
7989 } else {
7990 llvm_unreachable("unexpected type")__builtin_unreachable();
7991 }
7992 StringRef AttrName = Attr.getAttrName()->getName();
7993 if (PrevAccessQual == AttrName.ltrim("_")) {
7994 // Duplicated qualifiers
7995 S.Diag(Attr.getLoc(), diag::warn_duplicate_declspec)
7996 << AttrName << Attr.getRange();
7997 } else {
7998 // Contradicting qualifiers
7999 S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers);
8000 }
8001
8002 S.Diag(TypedefTy->getDecl()->getBeginLoc(),
8003 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
8004 } else if (CurType->isPipeType()) {
8005 if (Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
8006 QualType ElemType = CurType->castAs<PipeType>()->getElementType();
8007 CurType = S.Context.getWritePipeType(ElemType);
8008 }
8009 }
8010}
8011
8012/// HandleMatrixTypeAttr - "matrix_type" attribute, like ext_vector_type
8013static void HandleMatrixTypeAttr(QualType &CurType, const ParsedAttr &Attr,
8014 Sema &S) {
8015 if (!S.getLangOpts().MatrixTypes) {
8016 S.Diag(Attr.getLoc(), diag::err_builtin_matrix_disabled);
8017 return;
8018 }
8019
8020 if (Attr.getNumArgs() != 2) {
8021 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
8022 << Attr << 2;
8023 return;
8024 }
8025
8026 Expr *RowsExpr = Attr.getArgAsExpr(0);
8027 Expr *ColsExpr = Attr.getArgAsExpr(1);
8028 QualType T = S.BuildMatrixType(CurType, RowsExpr, ColsExpr, Attr.getLoc());
8029 if (!T.isNull())
8030 CurType = T;
8031}
8032
8033static void HandleLifetimeBoundAttr(TypeProcessingState &State,
8034 QualType &CurType,
8035 ParsedAttr &Attr) {
8036 if (State.getDeclarator().isDeclarationOfFunction()) {
8037 CurType = State.getAttributedType(
8038 createSimpleAttr<LifetimeBoundAttr>(State.getSema().Context, Attr),
8039 CurType, CurType);
8040 }
8041}
8042
8043static bool isAddressSpaceKind(const ParsedAttr &attr) {
8044 auto attrKind = attr.getKind();
8045
8046 return attrKind == ParsedAttr::AT_AddressSpace ||
8047 attrKind == ParsedAttr::AT_OpenCLPrivateAddressSpace ||
8048 attrKind == ParsedAttr::AT_OpenCLGlobalAddressSpace ||
8049 attrKind == ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace ||
8050 attrKind == ParsedAttr::AT_OpenCLGlobalHostAddressSpace ||
8051 attrKind == ParsedAttr::AT_OpenCLLocalAddressSpace ||
8052 attrKind == ParsedAttr::AT_OpenCLConstantAddressSpace ||
8053 attrKind == ParsedAttr::AT_OpenCLGenericAddressSpace;
8054}
8055
8056static void processTypeAttrs(TypeProcessingState &state, QualType &type,
8057 TypeAttrLocation TAL,
8058 ParsedAttributesView &attrs) {
8059 // Scan through and apply attributes to this type where it makes sense. Some
8060 // attributes (such as __address_space__, __vector_size__, etc) apply to the
8061 // type, but others can be present in the type specifiers even though they
8062 // apply to the decl. Here we apply type attributes and ignore the rest.
8063
8064 // This loop modifies the list pretty frequently, but we still need to make
8065 // sure we visit every element once. Copy the attributes list, and iterate
8066 // over that.
8067 ParsedAttributesView AttrsCopy{attrs};
8068
8069 state.setParsedNoDeref(false);
8070
8071 for (ParsedAttr &attr : AttrsCopy) {
8072
8073 // Skip attributes that were marked to be invalid.
8074 if (attr.isInvalid())
8075 continue;
8076
8077 if (attr.isStandardAttributeSyntax()) {
8078 // [[gnu::...]] attributes are treated as declaration attributes, so may
8079 // not appertain to a DeclaratorChunk. If we handle them as type
8080 // attributes, accept them in that position and diagnose the GCC
8081 // incompatibility.
8082 if (attr.isGNUScope()) {
8083 bool IsTypeAttr = attr.isTypeAttr();
8084 if (TAL == TAL_DeclChunk) {
8085 state.getSema().Diag(attr.getLoc(),
8086 IsTypeAttr
8087 ? diag::warn_gcc_ignores_type_attr
8088 : diag::warn_cxx11_gnu_attribute_on_type)
8089 << attr;
8090 if (!IsTypeAttr)
8091 continue;
8092 }
8093 } else if (TAL != TAL_DeclChunk && !isAddressSpaceKind(attr)) {
8094 // Otherwise, only consider type processing for a C++11 attribute if
8095 // it's actually been applied to a type.
8096 // We also allow C++11 address_space and
8097 // OpenCL language address space attributes to pass through.
8098 continue;
8099 }
8100 }
8101
8102 // If this is an attribute we can handle, do so now,
8103 // otherwise, add it to the FnAttrs list for rechaining.
8104 switch (attr.getKind()) {
8105 default:
8106 // A [[]] attribute on a declarator chunk must appertain to a type.
8107 if (attr.isStandardAttributeSyntax() && TAL == TAL_DeclChunk) {
8108 state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr)
8109 << attr;
8110 attr.setUsedAsTypeAttr();
8111 }
8112 break;
8113
8114 case ParsedAttr::UnknownAttribute:
8115 if (attr.isStandardAttributeSyntax() && TAL == TAL_DeclChunk)
8116 state.getSema().Diag(attr.getLoc(),
8117 diag::warn_unknown_attribute_ignored)
8118 << attr << attr.getRange();
8119 break;
8120
8121 case ParsedAttr::IgnoredAttribute:
8122 break;
8123
8124 case ParsedAttr::AT_MayAlias:
8125 // FIXME: This attribute needs to actually be handled, but if we ignore
8126 // it it breaks large amounts of Linux software.
8127 attr.setUsedAsTypeAttr();
8128 break;
8129 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
8130 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
8131 case ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:
8132 case ParsedAttr::AT_OpenCLGlobalHostAddressSpace:
8133 case ParsedAttr::AT_OpenCLLocalAddressSpace:
8134 case ParsedAttr::AT_OpenCLConstantAddressSpace:
8135 case ParsedAttr::AT_OpenCLGenericAddressSpace:
8136 case ParsedAttr::AT_AddressSpace:
8137 HandleAddressSpaceTypeAttribute(type, attr, state);
8138 attr.setUsedAsTypeAttr();
8139 break;
8140 OBJC_POINTER_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_ObjCGC: case ParsedAttr::AT_ObjCOwnership:
8141 if (!handleObjCPointerTypeAttr(state, attr, type))
8142 distributeObjCPointerTypeAttr(state, attr, type);
8143 attr.setUsedAsTypeAttr();
8144 break;
8145 case ParsedAttr::AT_VectorSize:
8146 HandleVectorSizeAttr(type, attr, state.getSema());
8147 attr.setUsedAsTypeAttr();
8148 break;
8149 case ParsedAttr::AT_ExtVectorType:
8150 HandleExtVectorTypeAttr(type, attr, state.getSema());
8151 attr.setUsedAsTypeAttr();
8152 break;
8153 case ParsedAttr::AT_NeonVectorType:
8154 HandleNeonVectorTypeAttr(type, attr, state.getSema(),
8155 VectorType::NeonVector);
8156 attr.setUsedAsTypeAttr();
8157 break;
8158 case ParsedAttr::AT_NeonPolyVectorType:
8159 HandleNeonVectorTypeAttr(type, attr, state.getSema(),
8160 VectorType::NeonPolyVector);
8161 attr.setUsedAsTypeAttr();
8162 break;
8163 case ParsedAttr::AT_ArmSveVectorBits:
8164 HandleArmSveVectorBitsTypeAttr(type, attr, state.getSema());
8165 attr.setUsedAsTypeAttr();
8166 break;
8167 case ParsedAttr::AT_ArmMveStrictPolymorphism: {
8168 HandleArmMveStrictPolymorphismAttr(state, type, attr);
8169 attr.setUsedAsTypeAttr();
8170 break;
8171 }
8172 case ParsedAttr::AT_OpenCLAccess:
8173 HandleOpenCLAccessAttr(type, attr, state.getSema());
8174 attr.setUsedAsTypeAttr();
8175 break;
8176 case ParsedAttr::AT_LifetimeBound:
8177 if (TAL == TAL_DeclChunk)
8178 HandleLifetimeBoundAttr(state, type, attr);
8179 break;
8180
8181 case ParsedAttr::AT_NoDeref: {
8182 ASTContext &Ctx = state.getSema().Context;
8183 type = state.getAttributedType(createSimpleAttr<NoDerefAttr>(Ctx, attr),
8184 type, type);
8185 attr.setUsedAsTypeAttr();
8186 state.setParsedNoDeref(true);
8187 break;
8188 }
8189
8190 case ParsedAttr::AT_MatrixType:
8191 HandleMatrixTypeAttr(type, attr, state.getSema());
8192 attr.setUsedAsTypeAttr();
8193 break;
8194
8195 MS_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_Ptr32: case ParsedAttr::AT_Ptr64: case ParsedAttr
::AT_SPtr: case ParsedAttr::AT_UPtr
:
8196 if (!handleMSPointerTypeQualifierAttr(state, attr, type))
8197 attr.setUsedAsTypeAttr();
8198 break;
8199
8200
8201 NULLABILITY_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_TypeNonNull: case ParsedAttr::AT_TypeNullable
: case ParsedAttr::AT_TypeNullableResult: case ParsedAttr::AT_TypeNullUnspecified
:
8202 // Either add nullability here or try to distribute it. We
8203 // don't want to distribute the nullability specifier past any
8204 // dependent type, because that complicates the user model.
8205 if (type->canHaveNullability() || type->isDependentType() ||
8206 type->isArrayType() ||
8207 !distributeNullabilityTypeAttr(state, type, attr)) {
8208 unsigned endIndex;
8209 if (TAL == TAL_DeclChunk)
8210 endIndex = state.getCurrentChunkIndex();
8211 else
8212 endIndex = state.getDeclarator().getNumTypeObjects();
8213 bool allowOnArrayType =
8214 state.getDeclarator().isPrototypeContext() &&
8215 !hasOuterPointerLikeChunk(state.getDeclarator(), endIndex);
8216 if (checkNullabilityTypeSpecifier(
8217 state,
8218 type,
8219 attr,
8220 allowOnArrayType)) {
8221 attr.setInvalid();
8222 }
8223
8224 attr.setUsedAsTypeAttr();
8225 }
8226 break;
8227
8228 case ParsedAttr::AT_ObjCKindOf:
8229 // '__kindof' must be part of the decl-specifiers.
8230 switch (TAL) {
8231 case TAL_DeclSpec:
8232 break;
8233
8234 case TAL_DeclChunk:
8235 case TAL_DeclName:
8236 state.getSema().Diag(attr.getLoc(),
8237 diag::err_objc_kindof_wrong_position)
8238 << FixItHint::CreateRemoval(attr.getLoc())
8239 << FixItHint::CreateInsertion(
8240 state.getDeclarator().getDeclSpec().getBeginLoc(),
8241 "__kindof ");
8242 break;
8243 }
8244
8245 // Apply it regardless.
8246 if (checkObjCKindOfType(state, type, attr))
8247 attr.setInvalid();
8248 break;
8249
8250 case ParsedAttr::AT_NoThrow:
8251 // Exception Specifications aren't generally supported in C mode throughout
8252 // clang, so revert to attribute-based handling for C.
8253 if (!state.getSema().getLangOpts().CPlusPlus)
8254 break;
8255 LLVM_FALLTHROUGH[[gnu::fallthrough]];
8256 FUNCTION_TYPE_ATTRS_CASELISTcase ParsedAttr::AT_NSReturnsRetained: case ParsedAttr::AT_NoReturn
: case ParsedAttr::AT_Regparm: case ParsedAttr::AT_CmseNSCall
: case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: case ParsedAttr
::AT_AnyX86NoCfCheck: case ParsedAttr::AT_CDecl: case ParsedAttr
::AT_FastCall: case ParsedAttr::AT_StdCall: case ParsedAttr::
AT_ThisCall: case ParsedAttr::AT_RegCall: case ParsedAttr::AT_Pascal
: case ParsedAttr::AT_SwiftCall: case ParsedAttr::AT_SwiftAsyncCall
: case ParsedAttr::AT_VectorCall: case ParsedAttr::AT_AArch64VectorPcs
: case ParsedAttr::AT_MSABI: case ParsedAttr::AT_SysVABI: case
ParsedAttr::AT_Pcs: case ParsedAttr::AT_IntelOclBicc: case ParsedAttr
::AT_PreserveMost: case ParsedAttr::AT_PreserveAll
:
8257 attr.setUsedAsTypeAttr();
8258
8259 // Never process function type attributes as part of the
8260 // declaration-specifiers.
8261 if (TAL == TAL_DeclSpec)
8262 distributeFunctionTypeAttrFromDeclSpec(state, attr, type);
8263
8264 // Otherwise, handle the possible delays.
8265 else if (!handleFunctionTypeAttr(state, attr, type))
8266 distributeFunctionTypeAttr(state, attr, type);
8267 break;
8268 case ParsedAttr::AT_AcquireHandle: {
8269 if (!type->isFunctionType())
8270 return;
8271
8272 if (attr.getNumArgs() != 1) {
8273 state.getSema().Diag(attr.getLoc(),
8274 diag::err_attribute_wrong_number_arguments)
8275 << attr << 1;
8276 attr.setInvalid();
8277 return;
8278 }
8279
8280 StringRef HandleType;
8281 if (!state.getSema().checkStringLiteralArgumentAttr(attr, 0, HandleType))
8282 return;
8283 type = state.getAttributedType(
8284 AcquireHandleAttr::Create(state.getSema().Context, HandleType, attr),
8285 type, type);
8286 attr.setUsedAsTypeAttr();
8287 break;
8288 }
8289 }
8290
8291 // Handle attributes that are defined in a macro. We do not want this to be
8292 // applied to ObjC builtin attributes.
8293 if (isa<AttributedType>(type) && attr.hasMacroIdentifier() &&
8294 !type.getQualifiers().hasObjCLifetime() &&
8295 !type.getQualifiers().hasObjCGCAttr() &&
8296 attr.getKind() != ParsedAttr::AT_ObjCGC &&
8297 attr.getKind() != ParsedAttr::AT_ObjCOwnership) {
8298 const IdentifierInfo *MacroII = attr.getMacroIdentifier();
8299 type = state.getSema().Context.getMacroQualifiedType(type, MacroII);
8300 state.setExpansionLocForMacroQualifiedType(
8301 cast<MacroQualifiedType>(type.getTypePtr()),
8302 attr.getMacroExpansionLoc());
8303 }
8304 }
8305
8306 if (!state.getSema().getLangOpts().OpenCL ||
8307 type.getAddressSpace() != LangAS::Default)
8308 return;
8309}
8310
8311void Sema::completeExprArrayBound(Expr *E) {
8312 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
8313 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
8314 if (isTemplateInstantiation(Var->getTemplateSpecializationKind())) {
8315 auto *Def = Var->getDefinition();
8316 if (!Def) {
8317 SourceLocation PointOfInstantiation = E->getExprLoc();
8318 runWithSufficientStackSpace(PointOfInstantiation, [&] {
8319 InstantiateVariableDefinition(PointOfInstantiation, Var);
8320 });
8321 Def = Var->getDefinition();
8322
8323 // If we don't already have a point of instantiation, and we managed
8324 // to instantiate a definition, this is the point of instantiation.
8325 // Otherwise, we don't request an end-of-TU instantiation, so this is
8326 // not a point of instantiation.
8327 // FIXME: Is this really the right behavior?
8328 if (Var->getPointOfInstantiation().isInvalid() && Def) {
8329 assert(Var->getTemplateSpecializationKind() ==(static_cast<void> (0))
8330 TSK_ImplicitInstantiation &&(static_cast<void> (0))
8331 "explicit instantiation with no point of instantiation")(static_cast<void> (0));
8332 Var->setTemplateSpecializationKind(
8333 Var->getTemplateSpecializationKind(), PointOfInstantiation);
8334 }
8335 }
8336
8337 // Update the type to the definition's type both here and within the
8338 // expression.
8339 if (Def) {
8340 DRE->setDecl(Def);
8341 QualType T = Def->getType();
8342 DRE->setType(T);
8343 // FIXME: Update the type on all intervening expressions.
8344 E->setType(T);
8345 }
8346
8347 // We still go on to try to complete the type independently, as it
8348 // may also require instantiations or diagnostics if it remains
8349 // incomplete.
8350 }
8351 }
8352 }
8353}
8354
8355QualType Sema::getCompletedType(Expr *E) {
8356 // Incomplete array types may be completed by the initializer attached to
8357 // their definitions. For static data members of class templates and for
8358 // variable templates, we need to instantiate the definition to get this
8359 // initializer and complete the type.
8360 if (E->getType()->isIncompleteArrayType())
8361 completeExprArrayBound(E);
8362
8363 // FIXME: Are there other cases which require instantiating something other
8364 // than the type to complete the type of an expression?
8365
8366 return E->getType();
8367}
8368
8369/// Ensure that the type of the given expression is complete.
8370///
8371/// This routine checks whether the expression \p E has a complete type. If the
8372/// expression refers to an instantiable construct, that instantiation is
8373/// performed as needed to complete its type. Furthermore
8374/// Sema::RequireCompleteType is called for the expression's type (or in the
8375/// case of a reference type, the referred-to type).
8376///
8377/// \param E The expression whose type is required to be complete.
8378/// \param Kind Selects which completeness rules should be applied.
8379/// \param Diagnoser The object that will emit a diagnostic if the type is
8380/// incomplete.
8381///
8382/// \returns \c true if the type of \p E is incomplete and diagnosed, \c false
8383/// otherwise.
8384bool Sema::RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
8385 TypeDiagnoser &Diagnoser) {
8386 return RequireCompleteType(E->getExprLoc(), getCompletedType(E), Kind,
8387 Diagnoser);
8388}
8389
8390bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) {
8391 BoundTypeDiagnoser<> Diagnoser(DiagID);
8392 return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
8393}
8394
8395/// Ensure that the type T is a complete type.
8396///
8397/// This routine checks whether the type @p T is complete in any
8398/// context where a complete type is required. If @p T is a complete
8399/// type, returns false. If @p T is a class template specialization,
8400/// this routine then attempts to perform class template
8401/// instantiation. If instantiation fails, or if @p T is incomplete
8402/// and cannot be completed, issues the diagnostic @p diag (giving it
8403/// the type @p T) and returns true.
8404///
8405/// @param Loc The location in the source that the incomplete type
8406/// diagnostic should refer to.
8407///
8408/// @param T The type that this routine is examining for completeness.
8409///
8410/// @param Kind Selects which completeness rules should be applied.
8411///
8412/// @returns @c true if @p T is incomplete and a diagnostic was emitted,
8413/// @c false otherwise.
8414bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
8415 CompleteTypeKind Kind,
8416 TypeDiagnoser &Diagnoser) {
8417 if (RequireCompleteTypeImpl(Loc, T, Kind, &Diagnoser))
8418 return true;
8419 if (const TagType *Tag = T->getAs<TagType>()) {
8420 if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
8421 Tag->getDecl()->setCompleteDefinitionRequired();
8422 Consumer.HandleTagDeclRequiredDefinition(Tag->getDecl());
8423 }
8424 }
8425 return false;
8426}
8427
8428bool Sema::hasStructuralCompatLayout(Decl *D, Decl *Suggested) {
8429 llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls;
8430 if (!Suggested)
8431 return false;
8432
8433 // FIXME: Add a specific mode for C11 6.2.7/1 in StructuralEquivalenceContext
8434 // and isolate from other C++ specific checks.
8435 StructuralEquivalenceContext Ctx(
8436 D->getASTContext(), Suggested->getASTContext(), NonEquivalentDecls,
8437 StructuralEquivalenceKind::Default,
8438 false /*StrictTypeSpelling*/, true /*Complain*/,
8439 true /*ErrorOnTagTypeMismatch*/);
8440 return Ctx.IsEquivalent(D, Suggested);
8441}
8442
8443/// Determine whether there is any declaration of \p D that was ever a
8444/// definition (perhaps before module merging) and is currently visible.
8445/// \param D The definition of the entity.
8446/// \param Suggested Filled in with the declaration that should be made visible
8447/// in order to provide a definition of this entity.
8448/// \param OnlyNeedComplete If \c true, we only need the type to be complete,
8449/// not defined. This only matters for enums with a fixed underlying
8450/// type, since in all other cases, a type is complete if and only if it
8451/// is defined.
8452bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
8453 bool OnlyNeedComplete) {
8454 // Easy case: if we don't have modules, all declarations are visible.
8455 if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility)
8456 return true;
8457
8458 // If this definition was instantiated from a template, map back to the
8459 // pattern from which it was instantiated.
8460 if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
8461 // We're in the middle of defining it; this definition should be treated
8462 // as visible.
8463 return true;
8464 } else if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
8465 if (auto *Pattern = RD->getTemplateInstantiationPattern())
8466 RD = Pattern;
8467 D = RD->getDefinition();
8468 } else if (auto *ED = dyn_cast<EnumDecl>(D)) {
8469 if (auto *Pattern = ED->getTemplateInstantiationPattern())
8470 ED = Pattern;
8471 if (OnlyNeedComplete && (ED->isFixed() || getLangOpts().MSVCCompat)) {
8472 // If the enum has a fixed underlying type, it may have been forward
8473 // declared. In -fms-compatibility, `enum Foo;` will also forward declare
8474 // the enum and assign it the underlying type of `int`. Since we're only
8475 // looking for a complete type (not a definition), any visible declaration
8476 // of it will do.
8477 *Suggested = nullptr;
8478 for (auto *Redecl : ED->redecls()) {
8479 if (isVisible(Redecl))
8480 return true;
8481 if (Redecl->isThisDeclarationADefinition() ||
8482 (Redecl->isCanonicalDecl() && !*Suggested))
8483 *Suggested = Redecl;
8484 }
8485 return false;
8486 }
8487 D = ED->getDefinition();
8488 } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {
8489 if (auto *Pattern = FD->getTemplateInstantiationPattern())
8490 FD = Pattern;
8491 D = FD->getDefinition();
8492 } else if (auto *VD = dyn_cast<VarDecl>(D)) {
8493 if (auto *Pattern = VD->getTemplateInstantiationPattern())
8494 VD = Pattern;
8495 D = VD->getDefinition();
8496 }
8497 assert(D && "missing definition for pattern of instantiated definition")(static_cast<void> (0));
8498
8499 *Suggested = D;
8500
8501 auto DefinitionIsVisible = [&] {
8502 // The (primary) definition might be in a visible module.
8503 if (isVisible(D))
8504 return true;
8505
8506 // A visible module might have a merged definition instead.
8507 if (D->isModulePrivate() ? hasMergedDefinitionInCurrentModule(D)
8508 : hasVisibleMergedDefinition(D)) {
8509 if (CodeSynthesisContexts.empty() &&
8510 !getLangOpts().ModulesLocalVisibility) {
8511 // Cache the fact that this definition is implicitly visible because
8512 // there is a visible merged definition.
8513 D->setVisibleDespiteOwningModule();
8514 }
8515 return true;
8516 }
8517
8518 return false;
8519 };
8520
8521 if (DefinitionIsVisible())
8522 return true;
8523
8524 // The external source may have additional definitions of this entity that are
8525 // visible, so complete the redeclaration chain now and ask again.
8526 if (auto *Source = Context.getExternalSource()) {
8527 Source->CompleteRedeclChain(D);
8528 return DefinitionIsVisible();
8529 }
8530
8531 return false;
8532}
8533
8534/// Locks in the inheritance model for the given class and all of its bases.
8535static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD) {
8536 RD = RD->getMostRecentNonInjectedDecl();
8537 if (!RD->hasAttr<MSInheritanceAttr>()) {
8538 MSInheritanceModel IM;
8539 bool BestCase = false;
8540 switch (S.MSPointerToMemberRepresentationMethod) {
8541 case LangOptions::PPTMK_BestCase:
8542 BestCase = true;
8543 IM = RD->calculateInheritanceModel();
8544 break;
8545 case LangOptions::PPTMK_FullGeneralitySingleInheritance:
8546 IM = MSInheritanceModel::Single;
8547 break;
8548 case LangOptions::PPTMK_FullGeneralityMultipleInheritance:
8549 IM = MSInheritanceModel::Multiple;
8550 break;
8551 case LangOptions::PPTMK_FullGeneralityVirtualInheritance:
8552 IM = MSInheritanceModel::Unspecified;
8553 break;
8554 }
8555
8556 SourceRange Loc = S.ImplicitMSInheritanceAttrLoc.isValid()
8557 ? S.ImplicitMSInheritanceAttrLoc
8558 : RD->getSourceRange();
8559 RD->addAttr(MSInheritanceAttr::CreateImplicit(
8560 S.getASTContext(), BestCase, Loc, AttributeCommonInfo::AS_Microsoft,
8561 MSInheritanceAttr::Spelling(IM)));
8562 S.Consumer.AssignInheritanceModel(RD);
8563 }
8564}
8565
8566/// The implementation of RequireCompleteType
8567bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
8568 CompleteTypeKind Kind,
8569 TypeDiagnoser *Diagnoser) {
8570 // FIXME: Add this assertion to make sure we always get instantiation points.
8571 // assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType");
8572 // FIXME: Add this assertion to help us flush out problems with
8573 // checking for dependent types and type-dependent expressions.
8574 //
8575 // assert(!T->isDependentType() &&
8576 // "Can't ask whether a dependent type is complete");
8577
8578 if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) {
8579 if (!MPTy->getClass()->isDependentType()) {
8580 if (getLangOpts().CompleteMemberPointers &&
8581 !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
8582 RequireCompleteType(Loc, QualType(MPTy->getClass(), 0), Kind,
8583 diag::err_memptr_incomplete))
8584 return true;
8585
8586 // We lock in the inheritance model once somebody has asked us to ensure
8587 // that a pointer-to-member type is complete.
8588 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
8589 (void)isCompleteType(Loc, QualType(MPTy->getClass(), 0));
8590 assignInheritanceModel(*this, MPTy->getMostRecentCXXRecordDecl());
8591 }
8592 }
8593 }
8594
8595 NamedDecl *Def = nullptr;
8596 bool AcceptSizeless = (Kind == CompleteTypeKind::AcceptSizeless);
8597 bool Incomplete = (T->isIncompleteType(&Def) ||
8598 (!AcceptSizeless && T->isSizelessBuiltinType()));
8599
8600 // Check that any necessary explicit specializations are visible. For an
8601 // enum, we just need the declaration, so don't check this.
8602 if (Def && !isa<EnumDecl>(Def))
8603 checkSpecializationVisibility(Loc, Def);
8604
8605 // If we have a complete type, we're done.
8606 if (!Incomplete) {
8607 // If we know about the definition but it is not visible, complain.
8608 NamedDecl *SuggestedDef = nullptr;
8609 if (Def &&
8610 !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) {
8611 // If the user is going to see an error here, recover by making the
8612 // definition visible.
8613 bool TreatAsComplete = Diagnoser && !isSFINAEContext();
8614 if (Diagnoser && SuggestedDef)
8615 diagnoseMissingImport(Loc, SuggestedDef, MissingImportKind::Definition,
8616 /*Recover*/TreatAsComplete);
8617 return !TreatAsComplete;
8618 } else if (Def && !TemplateInstCallbacks.empty()) {
8619 CodeSynthesisContext TempInst;
8620 TempInst.Kind = CodeSynthesisContext::Memoization;
8621 TempInst.Template = Def;
8622 TempInst.Entity = Def;
8623 TempInst.PointOfInstantiation = Loc;
8624 atTemplateBegin(TemplateInstCallbacks, *this, TempInst);
8625 atTemplateEnd(TemplateInstCallbacks, *this, TempInst);
8626 }
8627
8628 return false;
8629 }
8630
8631 TagDecl *Tag = dyn_cast_or_null<TagDecl>(Def);
8632 ObjCInterfaceDecl *IFace = dyn_cast_or_null<ObjCInterfaceDecl>(Def);
8633
8634 // Give the external source a chance to provide a definition of the type.
8635 // This is kept separate from completing the redeclaration chain so that
8636 // external sources such as LLDB can avoid synthesizing a type definition
8637 // unless it's actually needed.
8638 if (Tag || IFace) {
8639 // Avoid diagnosing invalid decls as incomplete.
8640 if (Def->isInvalidDecl())
8641 return true;
8642
8643 // Give the external AST source a chance to complete the type.
8644 if (auto *Source = Context.getExternalSource()) {
8645 if (Tag && Tag->hasExternalLexicalStorage())
8646 Source->CompleteType(Tag);
8647 if (IFace && IFace->hasExternalLexicalStorage())
8648 Source->CompleteType(IFace);
8649 // If the external source completed the type, go through the motions
8650 // again to ensure we're allowed to use the completed type.
8651 if (!T->isIncompleteType())
8652 return RequireCompleteTypeImpl(Loc, T, Kind, Diagnoser);
8653 }
8654 }
8655
8656 // If we have a class template specialization or a class member of a
8657 // class template specialization, or an array with known size of such,
8658 // try to instantiate it.
8659 if (auto *RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {
8660 bool Instantiated = false;
8661 bool Diagnosed = false;
8662 if (RD->isDependentContext()) {
8663 // Don't try to instantiate a dependent class (eg, a member template of
8664 // an instantiated class template specialization).
8665 // FIXME: Can this ever happen?
8666 } else if (auto *ClassTemplateSpec =
8667 dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
8668 if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) {
8669 runWithSufficientStackSpace(Loc, [&] {
8670 Diagnosed = InstantiateClassTemplateSpecialization(
8671 Loc, ClassTemplateSpec, TSK_ImplicitInstantiation,
8672 /*Complain=*/Diagnoser);
8673 });
8674 Instantiated = true;
8675 }
8676 } else {
8677 CXXRecordDecl *Pattern = RD->getInstantiatedFromMemberClass();
8678 if (!RD->isBeingDefined() && Pattern) {
8679 MemberSpecializationInfo *MSI = RD->getMemberSpecializationInfo();
8680 assert(MSI && "Missing member specialization information?")(static_cast<void> (0));
8681 // This record was instantiated from a class within a template.
8682 if (MSI->getTemplateSpecializationKind() !=
8683 TSK_ExplicitSpecialization) {
8684 runWithSufficientStackSpace(Loc, [&] {
8685 Diagnosed = InstantiateClass(Loc, RD, Pattern,
8686 getTemplateInstantiationArgs(RD),
8687 TSK_ImplicitInstantiation,
8688 /*Complain=*/Diagnoser);
8689 });
8690 Instantiated = true;
8691 }
8692 }
8693 }
8694
8695 if (Instantiated) {
8696 // Instantiate* might have already complained that the template is not
8697 // defined, if we asked it to.
8698 if (Diagnoser && Diagnosed)
8699 return true;
8700 // If we instantiated a definition, check that it's usable, even if
8701 // instantiation produced an error, so that repeated calls to this
8702 // function give consistent answers.
8703 if (!T->isIncompleteType())
8704 return RequireCompleteTypeImpl(Loc, T, Kind, Diagnoser);
8705 }
8706 }
8707
8708 // FIXME: If we didn't instantiate a definition because of an explicit
8709 // specialization declaration, check that it's visible.
8710
8711 if (!Diagnoser)
8712 return true;
8713
8714 Diagnoser->diagnose(*this, Loc, T);
8715
8716 // If the type was a forward declaration of a class/struct/union
8717 // type, produce a note.
8718 if (Tag && !Tag->isInvalidDecl() && !Tag->getLocation().isInvalid())
8719 Diag(Tag->getLocation(),
8720 Tag->isBeingDefined() ? diag::note_type_being_defined
8721 : diag::note_forward_declaration)
8722 << Context.getTagDeclType(Tag);
8723
8724 // If the Objective-C class was a forward declaration, produce a note.
8725 if (IFace && !IFace->isInvalidDecl() && !IFace->getLocation().isInvalid())
8726 Diag(IFace->getLocation(), diag::note_forward_class);
8727
8728 // If we have external information that we can use to suggest a fix,
8729 // produce a note.
8730 if (ExternalSource)
8731 ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T);
8732
8733 return true;
8734}
8735
8736bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
8737 CompleteTypeKind Kind, unsigned DiagID) {
8738 BoundTypeDiagnoser<> Diagnoser(DiagID);
8739 return RequireCompleteType(Loc, T, Kind, Diagnoser);
8740}
8741
8742/// Get diagnostic %select index for tag kind for
8743/// literal type diagnostic message.
8744/// WARNING: Indexes apply to particular diagnostics only!
8745///
8746/// \returns diagnostic %select index.
8747static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag) {
8748 switch (Tag) {
8749 case TTK_Struct: return 0;
8750 case TTK_Interface: return 1;
8751 case TTK_Class: return 2;
8752 default: llvm_unreachable("Invalid tag kind for literal type diagnostic!")__builtin_unreachable();
8753 }
8754}
8755
8756/// Ensure that the type T is a literal type.
8757///
8758/// This routine checks whether the type @p T is a literal type. If @p T is an
8759/// incomplete type, an attempt is made to complete it. If @p T is a literal
8760/// type, or @p AllowIncompleteType is true and @p T is an incomplete type,
8761/// returns false. Otherwise, this routine issues the diagnostic @p PD (giving
8762/// it the type @p T), along with notes explaining why the type is not a
8763/// literal type, and returns true.
8764///
8765/// @param Loc The location in the source that the non-literal type
8766/// diagnostic should refer to.
8767///
8768/// @param T The type that this routine is examining for literalness.
8769///
8770/// @param Diagnoser Emits a diagnostic if T is not a literal type.
8771///
8772/// @returns @c true if @p T is not a literal type and a diagnostic was emitted,
8773/// @c false otherwise.
8774bool Sema::RequireLiteralType(SourceLocation Loc, QualType T,
8775 TypeDiagnoser &Diagnoser) {
8776 assert(!T->isDependentType() && "type should not be dependent")(static_cast<void> (0));
8777
8778 QualType ElemType = Context.getBaseElementType(T);
8779 if ((isCompleteType(Loc, ElemType) || ElemType->isVoidType()) &&
8780 T->isLiteralType(Context))
8781 return false;
8782
8783 Diagnoser.diagnose(*this, Loc, T);
8784
8785 if (T->isVariableArrayType())
8786 return true;
8787
8788 const RecordType *RT = ElemType->getAs<RecordType>();
8789 if (!RT)
8790 return true;
8791
8792 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
8793
8794 // A partially-defined class type can't be a literal type, because a literal
8795 // class type must have a trivial destructor (which can't be checked until
8796 // the class definition is complete).
8797 if (RequireCompleteType(Loc, ElemType, diag::note_non_literal_incomplete, T))
8798 return true;
8799
8800 // [expr.prim.lambda]p3:
8801 // This class type is [not] a literal type.
8802 if (RD->isLambda() && !getLangOpts().CPlusPlus17) {
8803 Diag(RD->getLocation(), diag::note_non_literal_lambda);
8804 return true;
8805 }
8806
8807 // If the class has virtual base classes, then it's not an aggregate, and
8808 // cannot have any constexpr constructors or a trivial default constructor,
8809 // so is non-literal. This is better to diagnose than the resulting absence
8810 // of constexpr constructors.
8811 if (RD->getNumVBases()) {
8812 Diag(RD->getLocation(), diag::note_non_literal_virtual_base)
8813 << getLiteralDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases();
8814 for (const auto &I : RD->vbases())
8815 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
8816 << I.getSourceRange();
8817 } else if (!RD->isAggregate() && !RD->hasConstexprNonCopyMoveConstructor() &&
8818 !RD->hasTrivialDefaultConstructor()) {
8819 Diag(RD->getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
8820 } else if (RD->hasNonLiteralTypeFieldsOrBases()) {
8821 for (const auto &I : RD->bases()) {
8822 if (!I.getType()->isLiteralType(Context)) {
8823 Diag(I.getBeginLoc(), diag::note_non_literal_base_class)
8824 << RD << I.getType() << I.getSourceRange();
8825 return true;
8826 }
8827 }
8828 for (const auto *I : RD->fields()) {
8829 if (!I->getType()->isLiteralType(Context) ||
8830 I->getType().isVolatileQualified()) {
8831 Diag(I->getLocation(), diag::note_non_literal_field)
8832 << RD << I << I->getType()
8833 << I->getType().isVolatileQualified();
8834 return true;
8835 }
8836 }
8837 } else if (getLangOpts().CPlusPlus20 ? !RD->hasConstexprDestructor()
8838 : !RD->hasTrivialDestructor()) {
8839 // All fields and bases are of literal types, so have trivial or constexpr
8840 // destructors. If this class's destructor is non-trivial / non-constexpr,
8841 // it must be user-declared.
8842 CXXDestructorDecl *Dtor = RD->getDestructor();
8843 assert(Dtor && "class has literal fields and bases but no dtor?")(static_cast<void> (0));
8844 if (!Dtor)
8845 return true;
8846
8847 if (getLangOpts().CPlusPlus20) {
8848 Diag(Dtor->getLocation(), diag::note_non_literal_non_constexpr_dtor)
8849 << RD;
8850 } else {
8851 Diag(Dtor->getLocation(), Dtor->isUserProvided()
8852 ? diag::note_non_literal_user_provided_dtor
8853 : diag::note_non_literal_nontrivial_dtor)
8854 << RD;
8855 if (!Dtor->isUserProvided())
8856 SpecialMemberIsTrivial(Dtor, CXXDestructor, TAH_IgnoreTrivialABI,
8857 /*Diagnose*/ true);
8858 }
8859 }
8860
8861 return true;
8862}
8863
8864bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID) {
8865 BoundTypeDiagnoser<> Diagnoser(DiagID);
8866 return RequireLiteralType(Loc, T, Diagnoser);
8867}
8868
8869/// Retrieve a version of the type 'T' that is elaborated by Keyword, qualified
8870/// by the nested-name-specifier contained in SS, and that is (re)declared by
8871/// OwnedTagDecl, which is nullptr if this is not a (re)declaration.
8872QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword,
8873 const CXXScopeSpec &SS, QualType T,
8874 TagDecl *OwnedTagDecl) {
8875 if (T.isNull())
8876 return T;
8877 NestedNameSpecifier *NNS;
8878 if (SS.isValid())
8879 NNS = SS.getScopeRep();
8880 else {
8881 if (Keyword == ETK_None)
8882 return T;
8883 NNS = nullptr;
8884 }
8885 return Context.getElaboratedType(Keyword, NNS, T, OwnedTagDecl);
8886}
8887
8888QualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) {
8889 assert(!E->hasPlaceholderType() && "unexpected placeholder")(static_cast<void> (0));
8890
8891 if (!getLangOpts().CPlusPlus && E->refersToBitField())
8892 Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 2;
8893
8894 if (!E->isTypeDependent()) {
8895 QualType T = E->getType();
8896 if (const TagType *TT = T->getAs<TagType>())
8897 DiagnoseUseOfDecl(TT->getDecl(), E->getExprLoc());
8898 }
8899 return Context.getTypeOfExprType(E);
8900}
8901
8902/// getDecltypeForExpr - Given an expr, will return the decltype for
8903/// that expression, according to the rules in C++11
8904/// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18.
8905static QualType getDecltypeForExpr(Sema &S, Expr *E) {
8906 if (E->isTypeDependent())
8907 return S.Context.DependentTy;
8908
8909 Expr *IDExpr = E;
8910 if (auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(E))
8911 IDExpr = ImplCastExpr->getSubExpr();
8912
8913 // C++11 [dcl.type.simple]p4:
8914 // The type denoted by decltype(e) is defined as follows:
8915
8916 // C++20:
8917 // - if E is an unparenthesized id-expression naming a non-type
8918 // template-parameter (13.2), decltype(E) is the type of the
8919 // template-parameter after performing any necessary type deduction
8920 // Note that this does not pick up the implicit 'const' for a template
8921 // parameter object. This rule makes no difference before C++20 so we apply
8922 // it unconditionally.
8923 if (const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
8924 return SNTTPE->getParameterType(S.Context);
8925
8926 // - if e is an unparenthesized id-expression or an unparenthesized class
8927 // member access (5.2.5), decltype(e) is the type of the entity named
8928 // by e. If there is no such entity, or if e names a set of overloaded
8929 // functions, the program is ill-formed;
8930 //
8931 // We apply the same rules for Objective-C ivar and property references.
8932 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
8933 const ValueDecl *VD = DRE->getDecl();
8934 if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(VD))
8935 return TPO->getType().getUnqualifiedType();
8936 return VD->getType();
8937 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(IDExpr)) {
8938 if (const ValueDecl *VD = ME->getMemberDecl())
8939 if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
8940 return VD->getType();
8941 } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
8942 return IR->getDecl()->getType();
8943 } else if (const ObjCPropertyRefExpr *PR =
8944 dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
8945 if (PR->isExplicitProperty())
8946 return PR->getExplicitProperty()->getType();
8947 } else if (auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
8948 return PE->getType();
8949 }
8950
8951 // C++11 [expr.lambda.prim]p18:
8952 // Every occurrence of decltype((x)) where x is a possibly
8953 // parenthesized id-expression that names an entity of automatic
8954 // storage duration is treated as if x were transformed into an
8955 // access to a corresponding data member of the closure type that
8956 // would have been declared if x were an odr-use of the denoted
8957 // entity.
8958 using namespace sema;
8959 if (S.getCurLambda()) {
8960 if (isa<ParenExpr>(IDExpr)) {
8961 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(IDExpr->IgnoreParens())) {
8962 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
8963 QualType T = S.getCapturedDeclRefType(Var, DRE->getLocation());
8964 if (!T.isNull())
8965 return S.Context.getLValueReferenceType(T);
8966 }
8967 }
8968 }
8969 }
8970
8971 return S.Context.getReferenceQualifiedType(E);
8972}
8973
8974QualType Sema::BuildDecltypeType(Expr *E, SourceLocation Loc,
8975 bool AsUnevaluated) {
8976 assert(!E->hasPlaceholderType() && "unexpected placeholder")(static_cast<void> (0));
8977
8978 if (AsUnevaluated && CodeSynthesisContexts.empty() &&
8979 !E->isInstantiationDependent() && E->HasSideEffects(Context, false)) {
8980 // The expression operand for decltype is in an unevaluated expression
8981 // context, so side effects could result in unintended consequences.
8982 // Exclude instantiation-dependent expressions, because 'decltype' is often
8983 // used to build SFINAE gadgets.
8984 Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
8985 }
8986
8987 return Context.getDecltypeType(E, getDecltypeForExpr(*this, E));
8988}
8989
8990QualType Sema::BuildUnaryTransformType(QualType BaseType,
8991 UnaryTransformType::UTTKind UKind,
8992 SourceLocation Loc) {
8993 switch (UKind) {
8994 case UnaryTransformType::EnumUnderlyingType:
8995 if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) {
8996 Diag(Loc, diag::err_only_enums_have_underlying_types);
8997 return QualType();
8998 } else {
8999 QualType Underlying = BaseType;
9000 if (!BaseType->isDependentType()) {
9001 // The enum could be incomplete if we're parsing its definition or
9002 // recovering from an error.
9003 NamedDecl *FwdDecl = nullptr;
9004 if (BaseType->isIncompleteType(&FwdDecl)) {
9005 Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
9006 Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl;
9007 return QualType();
9008 }
9009
9010 EnumDecl *ED = BaseType->castAs<EnumType>()->getDecl();
9011 assert(ED && "EnumType has no EnumDecl")(static_cast<void> (0));
9012
9013 DiagnoseUseOfDecl(ED, Loc);
9014
9015 Underlying = ED->getIntegerType();
9016 assert(!Underlying.isNull())(static_cast<void> (0));
9017 }
9018 return Context.getUnaryTransformType(BaseType, Underlying,
9019 UnaryTransformType::EnumUnderlyingType);
9020 }
9021 }
9022 llvm_unreachable("unknown unary transform type")__builtin_unreachable();
9023}
9024
9025QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) {
9026 if (!T->isDependentType()) {
9027 // FIXME: It isn't entirely clear whether incomplete atomic types
9028 // are allowed or not; for simplicity, ban them for the moment.
9029 if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
9030 return QualType();
9031
9032 int DisallowedKind = -1;
9033 if (T->isArrayType())
9034 DisallowedKind = 1;
9035 else if (T->isFunctionType())
9036 DisallowedKind = 2;
9037 else if (T->isReferenceType())
9038 DisallowedKind = 3;
9039 else if (T->isAtomicType())
9040 DisallowedKind = 4;
9041 else if (T.hasQualifiers())
9042 DisallowedKind = 5;
9043 else if (T->isSizelessType())
9044 DisallowedKind = 6;
9045 else if (!T.isTriviallyCopyableType(Context))
9046 // Some other non-trivially-copyable type (probably a C++ class)
9047 DisallowedKind = 7;
9048 else if (T->isExtIntType()) {
9049 DisallowedKind = 8;
9050 }
9051
9052 if (DisallowedKind != -1) {
9053 Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind << T;
9054 return QualType();
9055 }
9056
9057 // FIXME: Do we need any handling for ARC here?
9058 }
9059
9060 // Build the pointer type.
9061 return Context.getAtomicType(T);
9062}

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include/clang/AST/TypeLocVisitor.h

1//===--- TypeLocVisitor.h - Visitor for TypeLoc subclasses ------*- 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// This file defines the TypeLocVisitor interface.
10//
11//===----------------------------------------------------------------------===//
12#ifndef LLVM_CLANG_AST_TYPELOCVISITOR_H
13#define LLVM_CLANG_AST_TYPELOCVISITOR_H
14
15#include "clang/AST/TypeLoc.h"
16#include "llvm/Support/ErrorHandling.h"
17
18namespace clang {
19
20#define DISPATCH(CLASSNAME) \
21 return static_cast<ImplClass*>(this)-> \
22 Visit##CLASSNAME(TyLoc.castAs<CLASSNAME>())
23
24template<typename ImplClass, typename RetTy=void>
25class TypeLocVisitor {
26public:
27 RetTy Visit(TypeLoc TyLoc) {
28 switch (TyLoc.getTypeLocClass()) {
29#define ABSTRACT_TYPELOC(CLASS, PARENT)
30#define TYPELOC(CLASS, PARENT) \
31 case TypeLoc::CLASS: DISPATCH(CLASS##TypeLoc);
32#include "clang/AST/TypeLocNodes.def"
33 }
34 llvm_unreachable("unexpected type loc class!")__builtin_unreachable();
35 }
36
37 RetTy Visit(UnqualTypeLoc TyLoc) {
38 switch (TyLoc.getTypeLocClass()) {
28
Control jumps to 'case Atomic:' at line 28
39#define ABSTRACT_TYPELOC(CLASS, PARENT)
40#define TYPELOC(CLASS, PARENT) \
41 case TypeLoc::CLASS: DISPATCH(CLASS##TypeLoc);
42#include "clang/AST/TypeLocNodes.def"
43 }
44 llvm_unreachable("unexpected type loc class!")__builtin_unreachable();
45 }
46
47#define TYPELOC(CLASS, PARENT) \
48 RetTy Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
49 DISPATCH(PARENT); \
50 }
51#include "clang/AST/TypeLocNodes.def"
52
53 RetTy VisitTypeLoc(TypeLoc TyLoc) { return RetTy(); }
54};
55
56#undef DISPATCH
57
58} // end namespace clang
59
60#endif // LLVM_CLANG_AST_TYPELOCVISITOR_H

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/include/clang/AST/TypeNodes.inc

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* An x-macro database of Clang type nodes *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#ifndef ABSTRACT_TYPE
10# define ABSTRACT_TYPE(Class, Base) TYPE(Class, Base)
11#endif
12#ifndef NON_CANONICAL_TYPE
13# define NON_CANONICAL_TYPE(Class, Base) TYPE(Class, Base)
14#endif
15#ifndef DEPENDENT_TYPE
16# define DEPENDENT_TYPE(Class, Base) TYPE(Class, Base)
17#endif
18#ifndef NON_CANONICAL_UNLESS_DEPENDENT_TYPE
19# define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) TYPE(Class, Base)
20#endif
21NON_CANONICAL_TYPE(Adjusted, Type)
22NON_CANONICAL_TYPE(Decayed, AdjustedType)
23ABSTRACT_TYPE(Array, Type)
24TYPE(ConstantArray, ArrayType)
25DEPENDENT_TYPE(DependentSizedArray, ArrayType)
26TYPE(IncompleteArray, ArrayType)
27TYPE(VariableArray, ArrayType)
28TYPE(Atomic, Type)
29
Calling 'TypeSpecLocFiller::VisitAtomicTypeLoc'
29NON_CANONICAL_TYPE(Attributed, Type)
30TYPE(BlockPointer, Type)
31TYPE(Builtin, Type)
32TYPE(Complex, Type)
33NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Decltype, Type)
34ABSTRACT_TYPE(Deduced, Type)
35TYPE(Auto, DeducedType)
36TYPE(DeducedTemplateSpecialization, DeducedType)
37DEPENDENT_TYPE(DependentAddressSpace, Type)
38DEPENDENT_TYPE(DependentExtInt, Type)
39DEPENDENT_TYPE(DependentName, Type)
40DEPENDENT_TYPE(DependentSizedExtVector, Type)
41DEPENDENT_TYPE(DependentTemplateSpecialization, Type)
42DEPENDENT_TYPE(DependentVector, Type)
43NON_CANONICAL_TYPE(Elaborated, Type)
44TYPE(ExtInt, Type)
45ABSTRACT_TYPE(Function, Type)
46TYPE(FunctionNoProto, FunctionType)
47TYPE(FunctionProto, FunctionType)
48DEPENDENT_TYPE(InjectedClassName, Type)
49NON_CANONICAL_TYPE(MacroQualified, Type)
50ABSTRACT_TYPE(Matrix, Type)
51TYPE(ConstantMatrix, MatrixType)
52DEPENDENT_TYPE(DependentSizedMatrix, MatrixType)
53TYPE(MemberPointer, Type)
54TYPE(ObjCObjectPointer, Type)
55TYPE(ObjCObject, Type)
56TYPE(ObjCInterface, ObjCObjectType)
57NON_CANONICAL_TYPE(ObjCTypeParam, Type)
58DEPENDENT_TYPE(PackExpansion, Type)
59NON_CANONICAL_TYPE(Paren, Type)
60TYPE(Pipe, Type)
61TYPE(Pointer, Type)
62ABSTRACT_TYPE(Reference, Type)
63TYPE(LValueReference, ReferenceType)
64TYPE(RValueReference, ReferenceType)
65DEPENDENT_TYPE(SubstTemplateTypeParmPack, Type)
66NON_CANONICAL_TYPE(SubstTemplateTypeParm, Type)
67ABSTRACT_TYPE(Tag, Type)
68TYPE(Enum, TagType)
69TYPE(Record, TagType)
70NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TemplateSpecialization, Type)
71DEPENDENT_TYPE(TemplateTypeParm, Type)
72NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOfExpr, Type)
73NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOf, Type)
74NON_CANONICAL_TYPE(Typedef, Type)
75NON_CANONICAL_UNLESS_DEPENDENT_TYPE(UnaryTransform, Type)
76DEPENDENT_TYPE(UnresolvedUsing, Type)
77TYPE(Vector, Type)
78TYPE(ExtVector, VectorType)
79#ifdef LAST_TYPE
80LAST_TYPE(ExtVector)
81#undef LAST_TYPE
82#endif
83#ifdef LEAF_TYPE
84LEAF_TYPE(Builtin)
85LEAF_TYPE(Enum)
86LEAF_TYPE(InjectedClassName)
87LEAF_TYPE(ObjCInterface)
88LEAF_TYPE(Record)
89LEAF_TYPE(TemplateTypeParm)
90#undef LEAF_TYPE
91#endif
92#undef TYPE
93#undef ABSTRACT_TYPE
94#undef ABSTRACT_TYPE
95#undef NON_CANONICAL_TYPE
96#undef DEPENDENT_TYPE
97#undef NON_CANONICAL_UNLESS_DEPENDENT_TYPE

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include/clang/AST/Type.h

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/DependenceFlags.h"
21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/TemplateName.h"
23#include "clang/Basic/AddressSpaces.h"
24#include "clang/Basic/AttrKinds.h"
25#include "clang/Basic/Diagnostic.h"
26#include "clang/Basic/ExceptionSpecificationType.h"
27#include "clang/Basic/LLVM.h"
28#include "clang/Basic/Linkage.h"
29#include "clang/Basic/PartialDiagnostic.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Basic/Visibility.h"
33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/APSInt.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/FoldingSet.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/Twine.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/PointerLikeTypeTraits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include "llvm/Support/type_traits.h"
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <cstring>
54#include <string>
55#include <type_traits>
56#include <utility>
57
58namespace clang {
59
60class ExtQuals;
61class QualType;
62class ConceptDecl;
63class TagDecl;
64class TemplateParameterList;
65class Type;
66
67enum {
68 TypeAlignmentInBits = 4,
69 TypeAlignment = 1 << TypeAlignmentInBits
70};
71
72namespace serialization {
73 template <class T> class AbstractTypeReader;
74 template <class T> class AbstractTypeWriter;
75}
76
77} // namespace clang
78
79namespace llvm {
80
81 template <typename T>
82 struct PointerLikeTypeTraits;
83 template<>
84 struct PointerLikeTypeTraits< ::clang::Type*> {
85 static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
86
87 static inline ::clang::Type *getFromVoidPointer(void *P) {
88 return static_cast< ::clang::Type*>(P);
89 }
90
91 static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
92 };
93
94 template<>
95 struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
96 static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
97
98 static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
99 return static_cast< ::clang::ExtQuals*>(P);
100 }
101
102 static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
103 };
104
105} // namespace llvm
106
107namespace clang {
108
109class ASTContext;
110template <typename> class CanQual;
111class CXXRecordDecl;
112class DeclContext;
113class EnumDecl;
114class Expr;
115class ExtQualsTypeCommonBase;
116class FunctionDecl;
117class IdentifierInfo;
118class NamedDecl;
119class ObjCInterfaceDecl;
120class ObjCProtocolDecl;
121class ObjCTypeParamDecl;
122struct PrintingPolicy;
123class RecordDecl;
124class Stmt;
125class TagDecl;
126class TemplateArgument;
127class TemplateArgumentListInfo;
128class TemplateArgumentLoc;
129class TemplateTypeParmDecl;
130class TypedefNameDecl;
131class UnresolvedUsingTypenameDecl;
132
133using CanQualType = CanQual<Type>;
134
135// Provide forward declarations for all of the *Type classes.
136#define TYPE(Class, Base) class Class##Type;
137#include "clang/AST/TypeNodes.inc"
138
139/// The collection of all-type qualifiers we support.
140/// Clang supports five independent qualifiers:
141/// * C99: const, volatile, and restrict
142/// * MS: __unaligned
143/// * Embedded C (TR18037): address spaces
144/// * Objective C: the GC attributes (none, weak, or strong)
145class Qualifiers {
146public:
147 enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
148 Const = 0x1,
149 Restrict = 0x2,
150 Volatile = 0x4,
151 CVRMask = Const | Volatile | Restrict
152 };
153
154 enum GC {
155 GCNone = 0,
156 Weak,
157 Strong
158 };
159
160 enum ObjCLifetime {
161 /// There is no lifetime qualification on this type.
162 OCL_None,
163
164 /// This object can be modified without requiring retains or
165 /// releases.
166 OCL_ExplicitNone,
167
168 /// Assigning into this object requires the old value to be
169 /// released and the new value to be retained. The timing of the
170 /// release of the old value is inexact: it may be moved to
171 /// immediately after the last known point where the value is
172 /// live.
173 OCL_Strong,
174
175 /// Reading or writing from this object requires a barrier call.
176 OCL_Weak,
177
178 /// Assigning into this object requires a lifetime extension.
179 OCL_Autoreleasing
180 };
181
182 enum {
183 /// The maximum supported address space number.
184 /// 23 bits should be enough for anyone.
185 MaxAddressSpace = 0x7fffffu,
186
187 /// The width of the "fast" qualifier mask.
188 FastWidth = 3,
189
190 /// The fast qualifier mask.
191 FastMask = (1 << FastWidth) - 1
192 };
193
194 /// Returns the common set of qualifiers while removing them from
195 /// the given sets.
196 static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
197 // If both are only CVR-qualified, bit operations are sufficient.
198 if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
199 Qualifiers Q;
200 Q.Mask = L.Mask & R.Mask;
201 L.Mask &= ~Q.Mask;
202 R.Mask &= ~Q.Mask;
203 return Q;
204 }
205
206 Qualifiers Q;
207 unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
208 Q.addCVRQualifiers(CommonCRV);
209 L.removeCVRQualifiers(CommonCRV);
210 R.removeCVRQualifiers(CommonCRV);
211
212 if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
213 Q.setObjCGCAttr(L.getObjCGCAttr());
214 L.removeObjCGCAttr();
215 R.removeObjCGCAttr();
216 }
217
218 if (L.getObjCLifetime() == R.getObjCLifetime()) {
219 Q.setObjCLifetime(L.getObjCLifetime());
220 L.removeObjCLifetime();
221 R.removeObjCLifetime();
222 }
223
224 if (L.getAddressSpace() == R.getAddressSpace()) {
225 Q.setAddressSpace(L.getAddressSpace());
226 L.removeAddressSpace();
227 R.removeAddressSpace();
228 }
229 return Q;
230 }
231
232 static Qualifiers fromFastMask(unsigned Mask) {
233 Qualifiers Qs;
234 Qs.addFastQualifiers(Mask);
235 return Qs;
236 }
237
238 static Qualifiers fromCVRMask(unsigned CVR) {
239 Qualifiers Qs;
240 Qs.addCVRQualifiers(CVR);
241 return Qs;
242 }
243
244 static Qualifiers fromCVRUMask(unsigned CVRU) {
245 Qualifiers Qs;
246 Qs.addCVRUQualifiers(CVRU);
247 return Qs;
248 }
249
250 // Deserialize qualifiers from an opaque representation.
251 static Qualifiers fromOpaqueValue(unsigned opaque) {
252 Qualifiers Qs;
253 Qs.Mask = opaque;
254 return Qs;
255 }
256
257 // Serialize these qualifiers into an opaque representation.
258 unsigned getAsOpaqueValue() const {
259 return Mask;
260 }
261
262 bool hasConst() const { return Mask & Const; }
263 bool hasOnlyConst() const { return Mask == Const; }
264 void removeConst() { Mask &= ~Const; }
265 void addConst() { Mask |= Const; }
266
267 bool hasVolatile() const { return Mask & Volatile; }
268 bool hasOnlyVolatile() const { return Mask == Volatile; }
269 void removeVolatile() { Mask &= ~Volatile; }
270 void addVolatile() { Mask |= Volatile; }
271
272 bool hasRestrict() const { return Mask & Restrict; }
273 bool hasOnlyRestrict() const { return Mask == Restrict; }
274 void removeRestrict() { Mask &= ~Restrict; }
275 void addRestrict() { Mask |= Restrict; }
276
277 bool hasCVRQualifiers() const { return getCVRQualifiers(); }
278 unsigned getCVRQualifiers() const { return Mask & CVRMask; }
279 unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }
280
281 void setCVRQualifiers(unsigned mask) {
282 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast<void> (0));
283 Mask = (Mask & ~CVRMask) | mask;
284 }
285 void removeCVRQualifiers(unsigned mask) {
286 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast<void> (0));
287 Mask &= ~mask;
288 }
289 void removeCVRQualifiers() {
290 removeCVRQualifiers(CVRMask);
291 }
292 void addCVRQualifiers(unsigned mask) {
293 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast<void> (0));
294 Mask |= mask;
295 }
296 void addCVRUQualifiers(unsigned mask) {
297 assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")(static_cast<void> (0));
298 Mask |= mask;
299 }
300
301 bool hasUnaligned() const { return Mask & UMask; }
302 void setUnaligned(bool flag) {
303 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
304 }
305 void removeUnaligned() { Mask &= ~UMask; }
306 void addUnaligned() { Mask |= UMask; }
307
308 bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
309 GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
310 void setObjCGCAttr(GC type) {
311 Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
312 }
313 void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
314 void addObjCGCAttr(GC type) {
315 assert(type)(static_cast<void> (0));
316 setObjCGCAttr(type);
317 }
318 Qualifiers withoutObjCGCAttr() const {
319 Qualifiers qs = *this;
320 qs.removeObjCGCAttr();
321 return qs;
322 }
323 Qualifiers withoutObjCLifetime() const {
324 Qualifiers qs = *this;
325 qs.removeObjCLifetime();
326 return qs;
327 }
328 Qualifiers withoutAddressSpace() const {
329 Qualifiers qs = *this;
330 qs.removeAddressSpace();
331 return qs;
332 }
333
334 bool hasObjCLifetime() const { return Mask & LifetimeMask; }
335 ObjCLifetime getObjCLifetime() const {
336 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
337 }
338 void setObjCLifetime(ObjCLifetime type) {
339 Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
340 }
341 void removeObjCLifetime() { setObjCLifetime(OCL_None); }
342 void addObjCLifetime(ObjCLifetime type) {
343 assert(type)(static_cast<void> (0));
344 assert(!hasObjCLifetime())(static_cast<void> (0));
345 Mask |= (type << LifetimeShift);
346 }
347
348 /// True if the lifetime is neither None or ExplicitNone.
349 bool hasNonTrivialObjCLifetime() const {
350 ObjCLifetime lifetime = getObjCLifetime();
351 return (lifetime > OCL_ExplicitNone);
352 }
353
354 /// True if the lifetime is either strong or weak.
355 bool hasStrongOrWeakObjCLifetime() const {
356 ObjCLifetime lifetime = getObjCLifetime();
357 return (lifetime == OCL_Strong || lifetime == OCL_Weak);
358 }
359
360 bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
361 LangAS getAddressSpace() const {
362 return static_cast<LangAS>(Mask >> AddressSpaceShift);
363 }
364 bool hasTargetSpecificAddressSpace() const {
365 return isTargetAddressSpace(getAddressSpace());
366 }
367 /// Get the address space attribute value to be printed by diagnostics.
368 unsigned getAddressSpaceAttributePrintValue() const {
369 auto Addr = getAddressSpace();
370 // This function is not supposed to be used with language specific
371 // address spaces. If that happens, the diagnostic message should consider
372 // printing the QualType instead of the address space value.
373 assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())(static_cast<void> (0));
374 if (Addr != LangAS::Default)
375 return toTargetAddressSpace(Addr);
376 // TODO: The diagnostic messages where Addr may be 0 should be fixed
377 // since it cannot differentiate the situation where 0 denotes the default
378 // address space or user specified __attribute__((address_space(0))).
379 return 0;
380 }
381 void setAddressSpace(LangAS space) {
382 assert((unsigned)space <= MaxAddressSpace)(static_cast<void> (0));
383 Mask = (Mask & ~AddressSpaceMask)
384 | (((uint32_t) space) << AddressSpaceShift);
385 }
386 void removeAddressSpace() { setAddressSpace(LangAS::Default); }
387 void addAddressSpace(LangAS space) {
388 assert(space != LangAS::Default)(static_cast<void> (0));
389 setAddressSpace(space);
390 }
391
392 // Fast qualifiers are those that can be allocated directly
393 // on a QualType object.
394 bool hasFastQualifiers() const { return getFastQualifiers(); }
395 unsigned getFastQualifiers() const { return Mask & FastMask; }
396 void setFastQualifiers(unsigned mask) {
397 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast<void> (0));
398 Mask = (Mask & ~FastMask) | mask;
399 }
400 void removeFastQualifiers(unsigned mask) {
401 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast<void> (0));
402 Mask &= ~mask;
403 }
404 void removeFastQualifiers() {
405 removeFastQualifiers(FastMask);
406 }
407 void addFastQualifiers(unsigned mask) {
408 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast<void> (0));
409 Mask |= mask;
410 }
411
412 /// Return true if the set contains any qualifiers which require an ExtQuals
413 /// node to be allocated.
414 bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
415 Qualifiers getNonFastQualifiers() const {
416 Qualifiers Quals = *this;
417 Quals.setFastQualifiers(0);
418 return Quals;
419 }
420
421 /// Return true if the set contains any qualifiers.
422 bool hasQualifiers() const { return Mask; }
423 bool empty() const { return !Mask; }
424
425 /// Add the qualifiers from the given set to this set.
426 void addQualifiers(Qualifiers Q) {
427 // If the other set doesn't have any non-boolean qualifiers, just
428 // bit-or it in.
429 if (!(Q.Mask & ~CVRMask))
430 Mask |= Q.Mask;
431 else {
432 Mask |= (Q.Mask & CVRMask);
433 if (Q.hasAddressSpace())
434 addAddressSpace(Q.getAddressSpace());
435 if (Q.hasObjCGCAttr())
436 addObjCGCAttr(Q.getObjCGCAttr());
437 if (Q.hasObjCLifetime())
438 addObjCLifetime(Q.getObjCLifetime());
439 }
440 }
441
442 /// Remove the qualifiers from the given set from this set.
443 void removeQualifiers(Qualifiers Q) {
444 // If the other set doesn't have any non-boolean qualifiers, just
445 // bit-and the inverse in.
446 if (!(Q.Mask & ~CVRMask))
447 Mask &= ~Q.Mask;
448 else {
449 Mask &= ~(Q.Mask & CVRMask);
450 if (getObjCGCAttr() == Q.getObjCGCAttr())
451 removeObjCGCAttr();
452 if (getObjCLifetime() == Q.getObjCLifetime())
453 removeObjCLifetime();
454 if (getAddressSpace() == Q.getAddressSpace())
455 removeAddressSpace();
456 }
457 }
458
459 /// Add the qualifiers from the given set to this set, given that
460 /// they don't conflict.
461 void addConsistentQualifiers(Qualifiers qs) {
462 assert(getAddressSpace() == qs.getAddressSpace() ||(static_cast<void> (0))
463 !hasAddressSpace() || !qs.hasAddressSpace())(static_cast<void> (0));
464 assert(getObjCGCAttr() == qs.getObjCGCAttr() ||(static_cast<void> (0))
465 !hasObjCGCAttr() || !qs.hasObjCGCAttr())(static_cast<void> (0));
466 assert(getObjCLifetime() == qs.getObjCLifetime() ||(static_cast<void> (0))
467 !hasObjCLifetime() || !qs.hasObjCLifetime())(static_cast<void> (0));
468 Mask |= qs.Mask;
469 }
470
471 /// Returns true if address space A is equal to or a superset of B.
472 /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
473 /// overlapping address spaces.
474 /// CL1.1 or CL1.2:
475 /// every address space is a superset of itself.
476 /// CL2.0 adds:
477 /// __generic is a superset of any address space except for __constant.
478 static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
479 // Address spaces must match exactly.
480 return A == B ||
481 // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
482 // for __constant can be used as __generic.
483 (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
484 // We also define global_device and global_host address spaces,
485 // to distinguish global pointers allocated on host from pointers
486 // allocated on device, which are a subset of __global.
487 (A == LangAS::opencl_global && (B == LangAS::opencl_global_device ||
488 B == LangAS::opencl_global_host)) ||
489 (A == LangAS::sycl_global && (B == LangAS::sycl_global_device ||
490 B == LangAS::sycl_global_host)) ||
491 // Consider pointer size address spaces to be equivalent to default.
492 ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
493 (isPtrSizeAddressSpace(B) || B == LangAS::Default)) ||
494 // Default is a superset of SYCL address spaces.
495 (A == LangAS::Default &&
496 (B == LangAS::sycl_private || B == LangAS::sycl_local ||
497 B == LangAS::sycl_global || B == LangAS::sycl_global_device ||
498 B == LangAS::sycl_global_host)) ||
499 // In HIP device compilation, any cuda address space is allowed
500 // to implicitly cast into the default address space.
501 (A == LangAS::Default &&
502 (B == LangAS::cuda_constant || B == LangAS::cuda_device ||
503 B == LangAS::cuda_shared));
504 }
505
506 /// Returns true if the address space in these qualifiers is equal to or
507 /// a superset of the address space in the argument qualifiers.
508 bool isAddressSpaceSupersetOf(Qualifiers other) const {
509 return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
510 }
511
512 /// Determines if these qualifiers compatibly include another set.
513 /// Generally this answers the question of whether an object with the other
514 /// qualifiers can be safely used as an object with these qualifiers.
515 bool compatiblyIncludes(Qualifiers other) const {
516 return isAddressSpaceSupersetOf(other) &&
517 // ObjC GC qualifiers can match, be added, or be removed, but can't
518 // be changed.
519 (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
520 !other.hasObjCGCAttr()) &&
521 // ObjC lifetime qualifiers must match exactly.
522 getObjCLifetime() == other.getObjCLifetime() &&
523 // CVR qualifiers may subset.
524 (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
525 // U qualifier may superset.
526 (!other.hasUnaligned() || hasUnaligned());
527 }
528
529 /// Determines if these qualifiers compatibly include another set of
530 /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
531 ///
532 /// One set of Objective-C lifetime qualifiers compatibly includes the other
533 /// if the lifetime qualifiers match, or if both are non-__weak and the
534 /// including set also contains the 'const' qualifier, or both are non-__weak
535 /// and one is None (which can only happen in non-ARC modes).
536 bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
537 if (getObjCLifetime() == other.getObjCLifetime())
538 return true;
539
540 if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
541 return false;
542
543 if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
544 return true;
545
546 return hasConst();
547 }
548
549 /// Determine whether this set of qualifiers is a strict superset of
550 /// another set of qualifiers, not considering qualifier compatibility.
551 bool isStrictSupersetOf(Qualifiers Other) const;
552
553 bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
554 bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
555
556 explicit operator bool() const { return hasQualifiers(); }
557
558 Qualifiers &operator+=(Qualifiers R) {
559 addQualifiers(R);
560 return *this;
561 }
562
563 // Union two qualifier sets. If an enumerated qualifier appears
564 // in both sets, use the one from the right.
565 friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
566 L += R;
567 return L;
568 }
569
570 Qualifiers &operator-=(Qualifiers R) {
571 removeQualifiers(R);
572 return *this;
573 }
574
575 /// Compute the difference between two qualifier sets.
576 friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
577 L -= R;
578 return L;
579 }
580
581 std::string getAsString() const;
582 std::string getAsString(const PrintingPolicy &Policy) const;
583
584 static std::string getAddrSpaceAsString(LangAS AS);
585
586 bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
587 void print(raw_ostream &OS, const PrintingPolicy &Policy,
588 bool appendSpaceIfNonEmpty = false) const;
589
590 void Profile(llvm::FoldingSetNodeID &ID) const {
591 ID.AddInteger(Mask);
592 }
593
594private:
595 // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31|
596 // |C R V|U|GCAttr|Lifetime|AddressSpace|
597 uint32_t Mask = 0;
598
599 static const uint32_t UMask = 0x8;
600 static const uint32_t UShift = 3;
601 static const uint32_t GCAttrMask = 0x30;
602 static const uint32_t GCAttrShift = 4;
603 static const uint32_t LifetimeMask = 0x1C0;
604 static const uint32_t LifetimeShift = 6;
605 static const uint32_t AddressSpaceMask =
606 ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
607 static const uint32_t AddressSpaceShift = 9;
608};
609
610/// A std::pair-like structure for storing a qualified type split
611/// into its local qualifiers and its locally-unqualified type.
612struct SplitQualType {
613 /// The locally-unqualified type.
614 const Type *Ty = nullptr;
615
616 /// The local qualifiers.
617 Qualifiers Quals;
618
619 SplitQualType() = default;
620 SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
621
622 SplitQualType getSingleStepDesugaredType() const; // end of this file
623
624 // Make std::tie work.
625 std::pair<const Type *,Qualifiers> asPair() const {
626 return std::pair<const Type *, Qualifiers>(Ty, Quals);
627 }
628
629 friend bool operator==(SplitQualType a, SplitQualType b) {
630 return a.Ty == b.Ty && a.Quals == b.Quals;
631 }
632 friend bool operator!=(SplitQualType a, SplitQualType b) {
633 return a.Ty != b.Ty || a.Quals != b.Quals;
634 }
635};
636
637/// The kind of type we are substituting Objective-C type arguments into.
638///
639/// The kind of substitution affects the replacement of type parameters when
640/// no concrete type information is provided, e.g., when dealing with an
641/// unspecialized type.
642enum class ObjCSubstitutionContext {
643 /// An ordinary type.
644 Ordinary,
645
646 /// The result type of a method or function.
647 Result,
648
649 /// The parameter type of a method or function.
650 Parameter,
651
652 /// The type of a property.
653 Property,
654
655 /// The superclass of a type.
656 Superclass,
657};
658
659/// A (possibly-)qualified type.
660///
661/// For efficiency, we don't store CV-qualified types as nodes on their
662/// own: instead each reference to a type stores the qualifiers. This
663/// greatly reduces the number of nodes we need to allocate for types (for
664/// example we only need one for 'int', 'const int', 'volatile int',
665/// 'const volatile int', etc).
666///
667/// As an added efficiency bonus, instead of making this a pair, we
668/// just store the two bits we care about in the low bits of the
669/// pointer. To handle the packing/unpacking, we make QualType be a
670/// simple wrapper class that acts like a smart pointer. A third bit
671/// indicates whether there are extended qualifiers present, in which
672/// case the pointer points to a special structure.
673class QualType {
674 friend class QualifierCollector;
675
676 // Thankfully, these are efficiently composable.
677 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
678 Qualifiers::FastWidth> Value;
679
680 const ExtQuals *getExtQualsUnsafe() const {
681 return Value.getPointer().get<const ExtQuals*>();
682 }
683
684 const Type *getTypePtrUnsafe() const {
685 return Value.getPointer().get<const Type*>();
686 }
687
688 const ExtQualsTypeCommonBase *getCommonPtr() const {
689 assert(!isNull() && "Cannot retrieve a NULL type pointer")(static_cast<void> (0));
690 auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
691 CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
692 return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
693 }
694
695public:
696 QualType() = default;
697 QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
698 QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
699
700 unsigned getLocalFastQualifiers() const { return Value.getInt(); }
701 void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
702
703 /// Retrieves a pointer to the underlying (unqualified) type.
704 ///
705 /// This function requires that the type not be NULL. If the type might be
706 /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
707 const Type *getTypePtr() const;
708
709 const Type *getTypePtrOrNull() const;
710
711 /// Retrieves a pointer to the name of the base type.
712 const IdentifierInfo *getBaseTypeIdentifier() const;
713
714 /// Divides a QualType into its unqualified type and a set of local
715 /// qualifiers.
716 SplitQualType split() const;
717
718 void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
719
720 static QualType getFromOpaquePtr(const void *Ptr) {
721 QualType T;
722 T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
723 return T;
724 }
725
726 const Type &operator*() const {
727 return *getTypePtr();
728 }
729
730 const Type *operator->() const {
731 return getTypePtr();
732 }
733
734 bool isCanonical() const;
735 bool isCanonicalAsParam() const;
736
737 /// Return true if this QualType doesn't point to a type yet.
738 bool isNull() const {
739 return Value.getPointer().isNull();
34
Calling 'PointerUnion::isNull'
37
Returning from 'PointerUnion::isNull'
38
Returning zero, which participates in a condition later
740 }
741
742 /// Determine whether this particular QualType instance has the
743 /// "const" qualifier set, without looking through typedefs that may have
744 /// added "const" at a different level.
745 bool isLocalConstQualified() const {
746 return (getLocalFastQualifiers() & Qualifiers::Const);
747 }
748
749 /// Determine whether this type is const-qualified.
750 bool isConstQualified() const;
751
752 /// Determine whether this particular QualType instance has the
753 /// "restrict" qualifier set, without looking through typedefs that may have
754 /// added "restrict" at a different level.
755 bool isLocalRestrictQualified() const {
756 return (getLocalFastQualifiers() & Qualifiers::Restrict);
757 }
758
759 /// Determine whether this type is restrict-qualified.
760 bool isRestrictQualified() const;
761
762 /// Determine whether this particular QualType instance has the
763 /// "volatile" qualifier set, without looking through typedefs that may have
764 /// added "volatile" at a different level.
765 bool isLocalVolatileQualified() const {
766 return (getLocalFastQualifiers() & Qualifiers::Volatile);
767 }
768
769 /// Determine whether this type is volatile-qualified.
770 bool isVolatileQualified() const;
771
772 /// Determine whether this particular QualType instance has any
773 /// qualifiers, without looking through any typedefs that might add
774 /// qualifiers at a different level.
775 bool hasLocalQualifiers() const {
776 return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
777 }
778
779 /// Determine whether this type has any qualifiers.
780 bool hasQualifiers() const;
781
782 /// Determine whether this particular QualType instance has any
783 /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
784 /// instance.
785 bool hasLocalNonFastQualifiers() const {
786 return Value.getPointer().is<const ExtQuals*>();
787 }
788
789 /// Retrieve the set of qualifiers local to this particular QualType
790 /// instance, not including any qualifiers acquired through typedefs or
791 /// other sugar.
792 Qualifiers getLocalQualifiers() const;
793
794 /// Retrieve the set of qualifiers applied to this type.
795 Qualifiers getQualifiers() const;
796
797 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
798 /// local to this particular QualType instance, not including any qualifiers
799 /// acquired through typedefs or other sugar.
800 unsigned getLocalCVRQualifiers() const {
801 return getLocalFastQualifiers();
802 }
803
804 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
805 /// applied to this type.
806 unsigned getCVRQualifiers() const;
807
808 bool isConstant(const ASTContext& Ctx) const {
809 return QualType::isConstant(*this, Ctx);
810 }
811
812 /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
813 bool isPODType(const ASTContext &Context) const;
814
815 /// Return true if this is a POD type according to the rules of the C++98
816 /// standard, regardless of the current compilation's language.
817 bool isCXX98PODType(const ASTContext &Context) const;
818
819 /// Return true if this is a POD type according to the more relaxed rules
820 /// of the C++11 standard, regardless of the current compilation's language.
821 /// (C++0x [basic.types]p9). Note that, unlike
822 /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
823 bool isCXX11PODType(const ASTContext &Context) const;
824
825 /// Return true if this is a trivial type per (C++0x [basic.types]p9)
826 bool isTrivialType(const ASTContext &Context) const;
827
828 /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
829 bool isTriviallyCopyableType(const ASTContext &Context) const;
830
831
832 /// Returns true if it is a class and it might be dynamic.
833 bool mayBeDynamicClass() const;
834
835 /// Returns true if it is not a class or if the class might not be dynamic.
836 bool mayBeNotDynamicClass() const;
837
838 // Don't promise in the API that anything besides 'const' can be
839 // easily added.
840
841 /// Add the `const` type qualifier to this QualType.
842 void addConst() {
843 addFastQualifiers(Qualifiers::Const);
844 }
845 QualType withConst() const {
846 return withFastQualifiers(Qualifiers::Const);
847 }
848
849 /// Add the `volatile` type qualifier to this QualType.
850 void addVolatile() {
851 addFastQualifiers(Qualifiers::Volatile);
852 }
853 QualType withVolatile() const {
854 return withFastQualifiers(Qualifiers::Volatile);
855 }
856
857 /// Add the `restrict` qualifier to this QualType.
858 void addRestrict() {
859 addFastQualifiers(Qualifiers::Restrict);
860 }
861 QualType withRestrict() const {
862 return withFastQualifiers(Qualifiers::Restrict);
863 }
864
865 QualType withCVRQualifiers(unsigned CVR) const {
866 return withFastQualifiers(CVR);
867 }
868
869 void addFastQualifiers(unsigned TQs) {
870 assert(!(TQs & ~Qualifiers::FastMask)(static_cast<void> (0))
871 && "non-fast qualifier bits set in mask!")(static_cast<void> (0));
872 Value.setInt(Value.getInt() | TQs);
873 }
874
875 void removeLocalConst();
876 void removeLocalVolatile();
877 void removeLocalRestrict();
878 void removeLocalCVRQualifiers(unsigned Mask);
879
880 void removeLocalFastQualifiers() { Value.setInt(0); }
881 void removeLocalFastQualifiers(unsigned Mask) {
882 assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")(static_cast<void> (0));
883 Value.setInt(Value.getInt() & ~Mask);
884 }
885
886 // Creates a type with the given qualifiers in addition to any
887 // qualifiers already on this type.
888 QualType withFastQualifiers(unsigned TQs) const {
889 QualType T = *this;
890 T.addFastQualifiers(TQs);
891 return T;
892 }
893
894 // Creates a type with exactly the given fast qualifiers, removing
895 // any existing fast qualifiers.
896 QualType withExactLocalFastQualifiers(unsigned TQs) const {
897 return withoutLocalFastQualifiers().withFastQualifiers(TQs);
898 }
899
900 // Removes fast qualifiers, but leaves any extended qualifiers in place.
901 QualType withoutLocalFastQualifiers() const {
902 QualType T = *this;
903 T.removeLocalFastQualifiers();
904 return T;
905 }
906
907 QualType getCanonicalType() const;
908
909 /// Return this type with all of the instance-specific qualifiers
910 /// removed, but without removing any qualifiers that may have been applied
911 /// through typedefs.
912 QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
913
914 /// Retrieve the unqualified variant of the given type,
915 /// removing as little sugar as possible.
916 ///
917 /// This routine looks through various kinds of sugar to find the
918 /// least-desugared type that is unqualified. For example, given:
919 ///
920 /// \code
921 /// typedef int Integer;
922 /// typedef const Integer CInteger;
923 /// typedef CInteger DifferenceType;
924 /// \endcode
925 ///
926 /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
927 /// desugar until we hit the type \c Integer, which has no qualifiers on it.
928 ///
929 /// The resulting type might still be qualified if it's sugar for an array
930 /// type. To strip qualifiers even from within a sugared array type, use
931 /// ASTContext::getUnqualifiedArrayType.
932 inline QualType getUnqualifiedType() const;
933
934 /// Retrieve the unqualified variant of the given type, removing as little
935 /// sugar as possible.
936 ///
937 /// Like getUnqualifiedType(), but also returns the set of
938 /// qualifiers that were built up.
939 ///
940 /// The resulting type might still be qualified if it's sugar for an array
941 /// type. To strip qualifiers even from within a sugared array type, use
942 /// ASTContext::getUnqualifiedArrayType.
943 inline SplitQualType getSplitUnqualifiedType() const;
944
945 /// Determine whether this type is more qualified than the other
946 /// given type, requiring exact equality for non-CVR qualifiers.
947 bool isMoreQualifiedThan(QualType Other) const;
948
949 /// Determine whether this type is at least as qualified as the other
950 /// given type, requiring exact equality for non-CVR qualifiers.
951 bool isAtLeastAsQualifiedAs(QualType Other) const;
952
953 QualType getNonReferenceType() const;
954
955 /// Determine the type of a (typically non-lvalue) expression with the
956 /// specified result type.
957 ///
958 /// This routine should be used for expressions for which the return type is
959 /// explicitly specified (e.g., in a cast or call) and isn't necessarily
960 /// an lvalue. It removes a top-level reference (since there are no
961 /// expressions of reference type) and deletes top-level cvr-qualifiers
962 /// from non-class types (in C++) or all types (in C).
963 QualType getNonLValueExprType(const ASTContext &Context) const;
964
965 /// Remove an outer pack expansion type (if any) from this type. Used as part
966 /// of converting the type of a declaration to the type of an expression that
967 /// references that expression. It's meaningless for an expression to have a
968 /// pack expansion type.
969 QualType getNonPackExpansionType() const;
970
971 /// Return the specified type with any "sugar" removed from
972 /// the type. This takes off typedefs, typeof's etc. If the outer level of
973 /// the type is already concrete, it returns it unmodified. This is similar
974 /// to getting the canonical type, but it doesn't remove *all* typedefs. For
975 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
976 /// concrete.
977 ///
978 /// Qualifiers are left in place.
979 QualType getDesugaredType(const ASTContext &Context) const {
980 return getDesugaredType(*this, Context);
981 }
982
983 SplitQualType getSplitDesugaredType() const {
984 return getSplitDesugaredType(*this);
985 }
986
987 /// Return the specified type with one level of "sugar" removed from
988 /// the type.
989 ///
990 /// This routine takes off the first typedef, typeof, etc. If the outer level
991 /// of the type is already concrete, it returns it unmodified.
992 QualType getSingleStepDesugaredType(const ASTContext &Context) const {
993 return getSingleStepDesugaredTypeImpl(*this, Context);
994 }
995
996 /// Returns the specified type after dropping any
997 /// outer-level parentheses.
998 QualType IgnoreParens() const {
999 if (isa<ParenType>(*this))
1000 return QualType::IgnoreParens(*this);
1001 return *this;
1002 }
1003
1004 /// Indicate whether the specified types and qualifiers are identical.
1005 friend bool operator==(const QualType &LHS, const QualType &RHS) {
1006 return LHS.Value == RHS.Value;
1007 }
1008 friend bool operator!=(const QualType &LHS, const QualType &RHS) {
1009 return LHS.Value != RHS.Value;
1010 }
1011 friend bool operator<(const QualType &LHS, const QualType &RHS) {
1012 return LHS.Value < RHS.Value;
1013 }
1014
1015 static std::string getAsString(SplitQualType split,
1016 const PrintingPolicy &Policy) {
1017 return getAsString(split.Ty, split.Quals, Policy);
1018 }
1019 static std::string getAsString(const Type *ty, Qualifiers qs,
1020 const PrintingPolicy &Policy);
1021
1022 std::string getAsString() const;
1023 std::string getAsString(const PrintingPolicy &Policy) const;
1024
1025 void print(raw_ostream &OS, const PrintingPolicy &Policy,
1026 const Twine &PlaceHolder = Twine(),
1027 unsigned Indentation = 0) const;
1028
1029 static void print(SplitQualType split, raw_ostream &OS,
1030 const PrintingPolicy &policy, const Twine &PlaceHolder,
1031 unsigned Indentation = 0) {
1032 return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
1033 }
1034
1035 static void print(const Type *ty, Qualifiers qs,
1036 raw_ostream &OS, const PrintingPolicy &policy,
1037 const Twine &PlaceHolder,
1038 unsigned Indentation = 0);
1039
1040 void getAsStringInternal(std::string &Str,
1041 const PrintingPolicy &Policy) const;
1042
1043 static void getAsStringInternal(SplitQualType split, std::string &out,
1044 const PrintingPolicy &policy) {
1045 return getAsStringInternal(split.Ty, split.Quals, out, policy);
1046 }
1047
1048 static void getAsStringInternal(const Type *ty, Qualifiers qs,
1049 std::string &out,
1050 const PrintingPolicy &policy);
1051
1052 class StreamedQualTypeHelper {
1053 const QualType &T;
1054 const PrintingPolicy &Policy;
1055 const Twine &PlaceHolder;
1056 unsigned Indentation;
1057
1058 public:
1059 StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
1060 const Twine &PlaceHolder, unsigned Indentation)
1061 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1062 Indentation(Indentation) {}
1063
1064 friend raw_ostream &operator<<(raw_ostream &OS,
1065 const StreamedQualTypeHelper &SQT) {
1066 SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1067 return OS;
1068 }
1069 };
1070
1071 StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
1072 const Twine &PlaceHolder = Twine(),
1073 unsigned Indentation = 0) const {
1074 return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
1075 }
1076
1077 void dump(const char *s) const;
1078 void dump() const;
1079 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
1080
1081 void Profile(llvm::FoldingSetNodeID &ID) const {
1082 ID.AddPointer(getAsOpaquePtr());
1083 }
1084
1085 /// Check if this type has any address space qualifier.
1086 inline bool hasAddressSpace() const;
1087
1088 /// Return the address space of this type.
1089 inline LangAS getAddressSpace() const;
1090
1091 /// Returns true if address space qualifiers overlap with T address space
1092 /// qualifiers.
1093 /// OpenCL C defines conversion rules for pointers to different address spaces
1094 /// and notion of overlapping address spaces.
1095 /// CL1.1 or CL1.2:
1096 /// address spaces overlap iff they are they same.
1097 /// OpenCL C v2.0 s6.5.5 adds:
1098 /// __generic overlaps with any address space except for __constant.
1099 bool isAddressSpaceOverlapping(QualType T) const {
1100 Qualifiers Q = getQualifiers();
1101 Qualifiers TQ = T.getQualifiers();
1102 // Address spaces overlap if at least one of them is a superset of another
1103 return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
1104 }
1105
1106 /// Returns gc attribute of this type.
1107 inline Qualifiers::GC getObjCGCAttr() const;
1108
1109 /// true when Type is objc's weak.
1110 bool isObjCGCWeak() const {
1111 return getObjCGCAttr() == Qualifiers::Weak;
1112 }
1113
1114 /// true when Type is objc's strong.
1115 bool isObjCGCStrong() const {
1116 return getObjCGCAttr() == Qualifiers::Strong;
1117 }
1118
1119 /// Returns lifetime attribute of this type.
1120 Qualifiers::ObjCLifetime getObjCLifetime() const {
1121 return getQualifiers().getObjCLifetime();
1122 }
1123
1124 bool hasNonTrivialObjCLifetime() const {
1125 return getQualifiers().hasNonTrivialObjCLifetime();
1126 }
1127
1128 bool hasStrongOrWeakObjCLifetime() const {
1129 return getQualifiers().hasStrongOrWeakObjCLifetime();
1130 }
1131
1132 // true when Type is objc's weak and weak is enabled but ARC isn't.
1133 bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;
1134
1135 enum PrimitiveDefaultInitializeKind {
1136 /// The type does not fall into any of the following categories. Note that
1137 /// this case is zero-valued so that values of this enum can be used as a
1138 /// boolean condition for non-triviality.
1139 PDIK_Trivial,
1140
1141 /// The type is an Objective-C retainable pointer type that is qualified
1142 /// with the ARC __strong qualifier.
1143 PDIK_ARCStrong,
1144
1145 /// The type is an Objective-C retainable pointer type that is qualified
1146 /// with the ARC __weak qualifier.
1147 PDIK_ARCWeak,
1148
1149 /// The type is a struct containing a field whose type is not PCK_Trivial.
1150 PDIK_Struct
1151 };
1152
1153 /// Functions to query basic properties of non-trivial C struct types.
1154
1155 /// Check if this is a non-trivial type that would cause a C struct
1156 /// transitively containing this type to be non-trivial to default initialize
1157 /// and return the kind.
1158 PrimitiveDefaultInitializeKind
1159 isNonTrivialToPrimitiveDefaultInitialize() const;
1160
1161 enum PrimitiveCopyKind {
1162 /// The type does not fall into any of the following categories. Note that
1163 /// this case is zero-valued so that values of this enum can be used as a
1164 /// boolean condition for non-triviality.
1165 PCK_Trivial,
1166
1167 /// The type would be trivial except that it is volatile-qualified. Types
1168 /// that fall into one of the other non-trivial cases may additionally be
1169 /// volatile-qualified.
1170 PCK_VolatileTrivial,
1171
1172 /// The type is an Objective-C retainable pointer type that is qualified
1173 /// with the ARC __strong qualifier.
1174 PCK_ARCStrong,
1175
1176 /// The type is an Objective-C retainable pointer type that is qualified
1177 /// with the ARC __weak qualifier.
1178 PCK_ARCWeak,
1179
1180 /// The type is a struct containing a field whose type is neither
1181 /// PCK_Trivial nor PCK_VolatileTrivial.
1182 /// Note that a C++ struct type does not necessarily match this; C++ copying
1183 /// semantics are too complex to express here, in part because they depend
1184 /// on the exact constructor or assignment operator that is chosen by
1185 /// overload resolution to do the copy.
1186 PCK_Struct
1187 };
1188
1189 /// Check if this is a non-trivial type that would cause a C struct
1190 /// transitively containing this type to be non-trivial to copy and return the
1191 /// kind.
1192 PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;
1193
1194 /// Check if this is a non-trivial type that would cause a C struct
1195 /// transitively containing this type to be non-trivial to destructively
1196 /// move and return the kind. Destructive move in this context is a C++-style
1197 /// move in which the source object is placed in a valid but unspecified state
1198 /// after it is moved, as opposed to a truly destructive move in which the
1199 /// source object is placed in an uninitialized state.
1200 PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;
1201
1202 enum DestructionKind {
1203 DK_none,
1204 DK_cxx_destructor,
1205 DK_objc_strong_lifetime,
1206 DK_objc_weak_lifetime,
1207 DK_nontrivial_c_struct
1208 };
1209
1210 /// Returns a nonzero value if objects of this type require
1211 /// non-trivial work to clean up after. Non-zero because it's
1212 /// conceivable that qualifiers (objc_gc(weak)?) could make
1213 /// something require destruction.
1214 DestructionKind isDestructedType() const {
1215 return isDestructedTypeImpl(*this);
1216 }
1217
1218 /// Check if this is or contains a C union that is non-trivial to
1219 /// default-initialize, which is a union that has a member that is non-trivial
1220 /// to default-initialize. If this returns true,
1221 /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
1222 bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;
1223
1224 /// Check if this is or contains a C union that is non-trivial to destruct,
1225 /// which is a union that has a member that is non-trivial to destruct. If
1226 /// this returns true, isDestructedType returns DK_nontrivial_c_struct.
1227 bool hasNonTrivialToPrimitiveDestructCUnion() const;
1228
1229 /// Check if this is or contains a C union that is non-trivial to copy, which
1230 /// is a union that has a member that is non-trivial to copy. If this returns
1231 /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
1232 bool hasNonTrivialToPrimitiveCopyCUnion() const;
1233
1234 /// Determine whether expressions of the given type are forbidden
1235 /// from being lvalues in C.
1236 ///
1237 /// The expression types that are forbidden to be lvalues are:
1238 /// - 'void', but not qualified void
1239 /// - function types
1240 ///
1241 /// The exact rule here is C99 6.3.2.1:
1242 /// An lvalue is an expression with an object type or an incomplete
1243 /// type other than void.
1244 bool isCForbiddenLValueType() const;
1245
1246 /// Substitute type arguments for the Objective-C type parameters used in the
1247 /// subject type.
1248 ///
1249 /// \param ctx ASTContext in which the type exists.
1250 ///
1251 /// \param typeArgs The type arguments that will be substituted for the
1252 /// Objective-C type parameters in the subject type, which are generally
1253 /// computed via \c Type::getObjCSubstitutions. If empty, the type
1254 /// parameters will be replaced with their bounds or id/Class, as appropriate
1255 /// for the context.
1256 ///
1257 /// \param context The context in which the subject type was written.
1258 ///
1259 /// \returns the resulting type.
1260 QualType substObjCTypeArgs(ASTContext &ctx,
1261 ArrayRef<QualType> typeArgs,
1262 ObjCSubstitutionContext context) const;
1263
1264 /// Substitute type arguments from an object type for the Objective-C type
1265 /// parameters used in the subject type.
1266 ///
1267 /// This operation combines the computation of type arguments for
1268 /// substitution (\c Type::getObjCSubstitutions) with the actual process of
1269 /// substitution (\c QualType::substObjCTypeArgs) for the convenience of
1270 /// callers that need to perform a single substitution in isolation.
1271 ///
1272 /// \param objectType The type of the object whose member type we're
1273 /// substituting into. For example, this might be the receiver of a message
1274 /// or the base of a property access.
1275 ///
1276 /// \param dc The declaration context from which the subject type was
1277 /// retrieved, which indicates (for example) which type parameters should
1278 /// be substituted.
1279 ///
1280 /// \param context The context in which the subject type was written.
1281 ///
1282 /// \returns the subject type after replacing all of the Objective-C type
1283 /// parameters with their corresponding arguments.
1284 QualType substObjCMemberType(QualType objectType,
1285 const DeclContext *dc,
1286 ObjCSubstitutionContext context) const;
1287
1288 /// Strip Objective-C "__kindof" types from the given type.
1289 QualType stripObjCKindOfType(const ASTContext &ctx) const;
1290
1291 /// Remove all qualifiers including _Atomic.
1292 QualType getAtomicUnqualifiedType() const;
1293
1294private:
1295 // These methods are implemented in a separate translation unit;
1296 // "static"-ize them to avoid creating temporary QualTypes in the
1297 // caller.
1298 static bool isConstant(QualType T, const ASTContext& Ctx);
1299 static QualType getDesugaredType(QualType T, const ASTContext &Context);
1300 static SplitQualType getSplitDesugaredType(QualType T);
1301 static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
1302 static QualType getSingleStepDesugaredTypeImpl(QualType type,
1303 const ASTContext &C);
1304 static QualType IgnoreParens(QualType T);
1305 static DestructionKind isDestructedTypeImpl(QualType type);
1306
1307 /// Check if \param RD is or contains a non-trivial C union.
1308 static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
1309 static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
1310 static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1311};
1312
1313} // namespace clang
1314
1315namespace llvm {
1316
1317/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1318/// to a specific Type class.
1319template<> struct simplify_type< ::clang::QualType> {
1320 using SimpleType = const ::clang::Type *;
1321
1322 static SimpleType getSimplifiedValue(::clang::QualType Val) {
1323 return Val.getTypePtr();
1324 }
1325};
1326
1327// Teach SmallPtrSet that QualType is "basically a pointer".
1328template<>
1329struct PointerLikeTypeTraits<clang::QualType> {
1330 static inline void *getAsVoidPointer(clang::QualType P) {
1331 return P.getAsOpaquePtr();
1332 }
1333
1334 static inline clang::QualType getFromVoidPointer(void *P) {
1335 return clang::QualType::getFromOpaquePtr(P);
1336 }
1337
1338 // Various qualifiers go in low bits.
1339 static constexpr int NumLowBitsAvailable = 0;
1340};
1341
1342} // namespace llvm
1343
1344namespace clang {
1345
1346/// Base class that is common to both the \c ExtQuals and \c Type
1347/// classes, which allows \c QualType to access the common fields between the
1348/// two.
1349class ExtQualsTypeCommonBase {
1350 friend class ExtQuals;
1351 friend class QualType;
1352 friend class Type;
1353
1354 /// The "base" type of an extended qualifiers type (\c ExtQuals) or
1355 /// a self-referential pointer (for \c Type).
1356 ///
1357 /// This pointer allows an efficient mapping from a QualType to its
1358 /// underlying type pointer.
1359 const Type *const BaseType;
1360
1361 /// The canonical type of this type. A QualType.
1362 QualType CanonicalType;
1363
1364 ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1365 : BaseType(baseType), CanonicalType(canon) {}
1366};
1367
1368/// We can encode up to four bits in the low bits of a
1369/// type pointer, but there are many more type qualifiers that we want
1370/// to be able to apply to an arbitrary type. Therefore we have this
1371/// struct, intended to be heap-allocated and used by QualType to
1372/// store qualifiers.
1373///
1374/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1375/// in three low bits on the QualType pointer; a fourth bit records whether
1376/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1377/// Objective-C GC attributes) are much more rare.
1378class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
1379 // NOTE: changing the fast qualifiers should be straightforward as
1380 // long as you don't make 'const' non-fast.
1381 // 1. Qualifiers:
1382 // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
1383 // Fast qualifiers must occupy the low-order bits.
1384 // b) Update Qualifiers::FastWidth and FastMask.
1385 // 2. QualType:
1386 // a) Update is{Volatile,Restrict}Qualified(), defined inline.
1387 // b) Update remove{Volatile,Restrict}, defined near the end of
1388 // this header.
1389 // 3. ASTContext:
1390 // a) Update get{Volatile,Restrict}Type.
1391
1392 /// The immutable set of qualifiers applied by this node. Always contains
1393 /// extended qualifiers.
1394 Qualifiers Quals;
1395
1396 ExtQuals *this_() { return this; }
1397
1398public:
1399 ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1400 : ExtQualsTypeCommonBase(baseType,
1401 canon.isNull() ? QualType(this_(), 0) : canon),
1402 Quals(quals) {
1403 assert(Quals.hasNonFastQualifiers()(static_cast<void> (0))
1404 && "ExtQuals created with no fast qualifiers")(static_cast<void> (0));
1405 assert(!Quals.hasFastQualifiers()(static_cast<void> (0))
1406 && "ExtQuals created with fast qualifiers")(static_cast<void> (0));
1407 }
1408
1409 Qualifiers getQualifiers() const { return Quals; }
1410
1411 bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
1412 Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
1413
1414 bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
1415 Qualifiers::ObjCLifetime getObjCLifetime() const {
1416 return Quals.getObjCLifetime();
1417 }
1418
1419 bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
1420 LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
1421
1422 const Type *getBaseType() const { return BaseType; }
1423
1424public:
1425 void Profile(llvm::FoldingSetNodeID &ID) const {
1426 Profile(ID, getBaseType(), Quals);
1427 }
1428
1429 static void Profile(llvm::FoldingSetNodeID &ID,
1430 const Type *BaseType,
1431 Qualifiers Quals) {
1432 assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")(static_cast<void> (0));
1433 ID.AddPointer(BaseType);
1434 Quals.Profile(ID);
1435 }
1436};
1437
1438/// The kind of C++11 ref-qualifier associated with a function type.
1439/// This determines whether a member function's "this" object can be an
1440/// lvalue, rvalue, or neither.
1441enum RefQualifierKind {
1442 /// No ref-qualifier was provided.
1443 RQ_None = 0,
1444
1445 /// An lvalue ref-qualifier was provided (\c &).
1446 RQ_LValue,
1447
1448 /// An rvalue ref-qualifier was provided (\c &&).
1449 RQ_RValue
1450};
1451
1452/// Which keyword(s) were used to create an AutoType.
1453enum class AutoTypeKeyword {
1454 /// auto
1455 Auto,
1456
1457 /// decltype(auto)
1458 DecltypeAuto,
1459
1460 /// __auto_type (GNU extension)
1461 GNUAutoType
1462};
1463
1464/// The base class of the type hierarchy.
1465///
1466/// A central concept with types is that each type always has a canonical
1467/// type. A canonical type is the type with any typedef names stripped out
1468/// of it or the types it references. For example, consider:
1469///
1470/// typedef int foo;
1471/// typedef foo* bar;
1472/// 'int *' 'foo *' 'bar'
1473///
1474/// There will be a Type object created for 'int'. Since int is canonical, its
1475/// CanonicalType pointer points to itself. There is also a Type for 'foo' (a
1476/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
1477/// there is a PointerType that represents 'int*', which, like 'int', is
1478/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
1479/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1480/// is also 'int*'.
1481///
1482/// Non-canonical types are useful for emitting diagnostics, without losing
1483/// information about typedefs being used. Canonical types are useful for type
1484/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1485/// about whether something has a particular form (e.g. is a function type),
1486/// because they implicitly, recursively, strip all typedefs out of a type.
1487///
1488/// Types, once created, are immutable.
1489///
1490class alignas(8) Type : public ExtQualsTypeCommonBase {
1491public:
1492 enum TypeClass {
1493#define TYPE(Class, Base) Class,
1494#define LAST_TYPE(Class) TypeLast = Class
1495#define ABSTRACT_TYPE(Class, Base)
1496#include "clang/AST/TypeNodes.inc"
1497 };
1498
1499private:
1500 /// Bitfields required by the Type class.
1501 class TypeBitfields {
1502 friend class Type;
1503 template <class T> friend class TypePropertyCache;
1504
1505 /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
1506 unsigned TC : 8;
1507
1508 /// Store information on the type dependency.
1509 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1510
1511 /// True if the cache (i.e. the bitfields here starting with
1512 /// 'Cache') is valid.
1513 mutable unsigned CacheValid : 1;
1514
1515 /// Linkage of this type.
1516 mutable unsigned CachedLinkage : 3;
1517
1518 /// Whether this type involves and local or unnamed types.
1519 mutable unsigned CachedLocalOrUnnamed : 1;
1520
1521 /// Whether this type comes from an AST file.
1522 mutable unsigned FromAST : 1;
1523
1524 bool isCacheValid() const {
1525 return CacheValid;
1526 }
1527
1528 Linkage getLinkage() const {
1529 assert(isCacheValid() && "getting linkage from invalid cache")(static_cast<void> (0));
1530 return static_cast<Linkage>(CachedLinkage);
1531 }
1532
1533 bool hasLocalOrUnnamedType() const {
1534 assert(isCacheValid() && "getting linkage from invalid cache")(static_cast<void> (0));
1535 return CachedLocalOrUnnamed;
1536 }
1537 };
1538 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1539
1540protected:
1541 // These classes allow subclasses to somewhat cleanly pack bitfields
1542 // into Type.
1543
1544 class ArrayTypeBitfields {
1545 friend class ArrayType;
1546
1547 unsigned : NumTypeBits;
1548
1549 /// CVR qualifiers from declarations like
1550 /// 'int X[static restrict 4]'. For function parameters only.
1551 unsigned IndexTypeQuals : 3;
1552
1553 /// Storage class qualifiers from declarations like
1554 /// 'int X[static restrict 4]'. For function parameters only.
1555 /// Actually an ArrayType::ArraySizeModifier.
1556 unsigned SizeModifier : 3;
1557 };
1558
1559 class ConstantArrayTypeBitfields {
1560 friend class ConstantArrayType;
1561
1562 unsigned : NumTypeBits + 3 + 3;
1563
1564 /// Whether we have a stored size expression.
1565 unsigned HasStoredSizeExpr : 1;
1566 };
1567
1568 class BuiltinTypeBitfields {
1569 friend class BuiltinType;
1570
1571 unsigned : NumTypeBits;
1572
1573 /// The kind (BuiltinType::Kind) of builtin type this is.
1574 unsigned Kind : 8;
1575 };
1576
1577 /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
1578 /// Only common bits are stored here. Additional uncommon bits are stored
1579 /// in a trailing object after FunctionProtoType.
1580 class FunctionTypeBitfields {
1581 friend class FunctionProtoType;
1582 friend class FunctionType;
1583
1584 unsigned : NumTypeBits;
1585
1586 /// Extra information which affects how the function is called, like
1587 /// regparm and the calling convention.
1588 unsigned ExtInfo : 13;
1589
1590 /// The ref-qualifier associated with a \c FunctionProtoType.
1591 ///
1592 /// This is a value of type \c RefQualifierKind.
1593 unsigned RefQualifier : 2;
1594
1595 /// Used only by FunctionProtoType, put here to pack with the
1596 /// other bitfields.
1597 /// The qualifiers are part of FunctionProtoType because...
1598 ///
1599 /// C++ 8.3.5p4: The return type, the parameter type list and the
1600 /// cv-qualifier-seq, [...], are part of the function type.
1601 unsigned FastTypeQuals : Qualifiers::FastWidth;
1602 /// Whether this function has extended Qualifiers.
1603 unsigned HasExtQuals : 1;
1604
1605 /// The number of parameters this function has, not counting '...'.
1606 /// According to [implimits] 8 bits should be enough here but this is
1607 /// somewhat easy to exceed with metaprogramming and so we would like to
1608 /// keep NumParams as wide as reasonably possible.
1609 unsigned NumParams : 16;
1610
1611 /// The type of exception specification this function has.
1612 unsigned ExceptionSpecType : 4;
1613
1614 /// Whether this function has extended parameter information.
1615 unsigned HasExtParameterInfos : 1;
1616
1617 /// Whether the function is variadic.
1618 unsigned Variadic : 1;
1619
1620 /// Whether this function has a trailing return type.
1621 unsigned HasTrailingReturn : 1;
1622 };
1623
1624 class ObjCObjectTypeBitfields {
1625 friend class ObjCObjectType;
1626
1627 unsigned : NumTypeBits;
1628
1629 /// The number of type arguments stored directly on this object type.
1630 unsigned NumTypeArgs : 7;
1631
1632 /// The number of protocols stored directly on this object type.
1633 unsigned NumProtocols : 6;
1634
1635 /// Whether this is a "kindof" type.
1636 unsigned IsKindOf : 1;
1637 };
1638
1639 class ReferenceTypeBitfields {
1640 friend class ReferenceType;
1641
1642 unsigned : NumTypeBits;
1643
1644 /// True if the type was originally spelled with an lvalue sigil.
1645 /// This is never true of rvalue references but can also be false
1646 /// on lvalue references because of C++0x [dcl.typedef]p9,
1647 /// as follows:
1648 ///
1649 /// typedef int &ref; // lvalue, spelled lvalue
1650 /// typedef int &&rvref; // rvalue
1651 /// ref &a; // lvalue, inner ref, spelled lvalue
1652 /// ref &&a; // lvalue, inner ref
1653 /// rvref &a; // lvalue, inner ref, spelled lvalue
1654 /// rvref &&a; // rvalue, inner ref
1655 unsigned SpelledAsLValue : 1;
1656
1657 /// True if the inner type is a reference type. This only happens
1658 /// in non-canonical forms.
1659 unsigned InnerRef : 1;
1660 };
1661
1662 class TypeWithKeywordBitfields {
1663 friend class TypeWithKeyword;
1664
1665 unsigned : NumTypeBits;
1666
1667 /// An ElaboratedTypeKeyword. 8 bits for efficient access.
1668 unsigned Keyword : 8;
1669 };
1670
1671 enum { NumTypeWithKeywordBits = 8 };
1672
1673 class ElaboratedTypeBitfields {
1674 friend class ElaboratedType;
1675
1676 unsigned : NumTypeBits;
1677 unsigned : NumTypeWithKeywordBits;
1678
1679 /// Whether the ElaboratedType has a trailing OwnedTagDecl.
1680 unsigned HasOwnedTagDecl : 1;
1681 };
1682
1683 class VectorTypeBitfields {
1684 friend class VectorType;
1685 friend class DependentVectorType;
1686
1687 unsigned : NumTypeBits;
1688
1689 /// The kind of vector, either a generic vector type or some
1690 /// target-specific vector type such as for AltiVec or Neon.
1691 unsigned VecKind : 3;
1692 /// The number of elements in the vector.
1693 uint32_t NumElements;
1694 };
1695
1696 class AttributedTypeBitfields {
1697 friend class AttributedType;
1698
1699 unsigned : NumTypeBits;
1700
1701 /// An AttributedType::Kind
1702 unsigned AttrKind : 32 - NumTypeBits;
1703 };
1704
1705 class AutoTypeBitfields {
1706 friend class AutoType;
1707
1708 unsigned : NumTypeBits;
1709
1710 /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
1711 /// or '__auto_type'? AutoTypeKeyword value.
1712 unsigned Keyword : 2;
1713
1714 /// The number of template arguments in the type-constraints, which is
1715 /// expected to be able to hold at least 1024 according to [implimits].
1716 /// However as this limit is somewhat easy to hit with template
1717 /// metaprogramming we'd prefer to keep it as large as possible.
1718 /// At the moment it has been left as a non-bitfield since this type
1719 /// safely fits in 64 bits as an unsigned, so there is no reason to
1720 /// introduce the performance impact of a bitfield.
1721 unsigned NumArgs;
1722 };
1723
1724 class SubstTemplateTypeParmPackTypeBitfields {
1725 friend class SubstTemplateTypeParmPackType;
1726
1727 unsigned : NumTypeBits;
1728
1729 /// The number of template arguments in \c Arguments, which is
1730 /// expected to be able to hold at least 1024 according to [implimits].
1731 /// However as this limit is somewhat easy to hit with template
1732 /// metaprogramming we'd prefer to keep it as large as possible.
1733 /// At the moment it has been left as a non-bitfield since this type
1734 /// safely fits in 64 bits as an unsigned, so there is no reason to
1735 /// introduce the performance impact of a bitfield.
1736 unsigned NumArgs;
1737 };
1738
1739 class TemplateSpecializationTypeBitfields {
1740 friend class TemplateSpecializationType;
1741
1742 unsigned : NumTypeBits;
1743
1744 /// Whether this template specialization type is a substituted type alias.
1745 unsigned TypeAlias : 1;
1746
1747 /// The number of template arguments named in this class template
1748 /// specialization, which is expected to be able to hold at least 1024
1749 /// according to [implimits]. However, as this limit is somewhat easy to
1750 /// hit with template metaprogramming we'd prefer to keep it as large
1751 /// as possible. At the moment it has been left as a non-bitfield since
1752 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1753 /// to introduce the performance impact of a bitfield.
1754 unsigned NumArgs;
1755 };
1756
1757 class DependentTemplateSpecializationTypeBitfields {
1758 friend class DependentTemplateSpecializationType;
1759
1760 unsigned : NumTypeBits;
1761 unsigned : NumTypeWithKeywordBits;
1762
1763 /// The number of template arguments named in this class template
1764 /// specialization, which is expected to be able to hold at least 1024
1765 /// according to [implimits]. However, as this limit is somewhat easy to
1766 /// hit with template metaprogramming we'd prefer to keep it as large
1767 /// as possible. At the moment it has been left as a non-bitfield since
1768 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1769 /// to introduce the performance impact of a bitfield.
1770 unsigned NumArgs;
1771 };
1772
1773 class PackExpansionTypeBitfields {
1774 friend class PackExpansionType;
1775
1776 unsigned : NumTypeBits;
1777
1778 /// The number of expansions that this pack expansion will
1779 /// generate when substituted (+1), which is expected to be able to
1780 /// hold at least 1024 according to [implimits]. However, as this limit
1781 /// is somewhat easy to hit with template metaprogramming we'd prefer to
1782 /// keep it as large as possible. At the moment it has been left as a
1783 /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
1784 /// there is no reason to introduce the performance impact of a bitfield.
1785 ///
1786 /// This field will only have a non-zero value when some of the parameter
1787 /// packs that occur within the pattern have been substituted but others
1788 /// have not.
1789 unsigned NumExpansions;
1790 };
1791
1792 union {
1793 TypeBitfields TypeBits;
1794 ArrayTypeBitfields ArrayTypeBits;
1795 ConstantArrayTypeBitfields ConstantArrayTypeBits;
1796 AttributedTypeBitfields AttributedTypeBits;
1797 AutoTypeBitfields AutoTypeBits;
1798 BuiltinTypeBitfields BuiltinTypeBits;
1799 FunctionTypeBitfields FunctionTypeBits;
1800 ObjCObjectTypeBitfields ObjCObjectTypeBits;
1801 ReferenceTypeBitfields ReferenceTypeBits;
1802 TypeWithKeywordBitfields TypeWithKeywordBits;
1803 ElaboratedTypeBitfields ElaboratedTypeBits;
1804 VectorTypeBitfields VectorTypeBits;
1805 SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
1806 TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
1807 DependentTemplateSpecializationTypeBitfields
1808 DependentTemplateSpecializationTypeBits;
1809 PackExpansionTypeBitfields PackExpansionTypeBits;
1810 };
1811
1812private:
1813 template <class T> friend class TypePropertyCache;
1814
1815 /// Set whether this type comes from an AST file.
1816 void setFromAST(bool V = true) const {
1817 TypeBits.FromAST = V;
1818 }
1819
1820protected:
1821 friend class ASTContext;
1822
1823 Type(TypeClass tc, QualType canon, TypeDependence Dependence)
1824 : ExtQualsTypeCommonBase(this,
1825 canon.isNull() ? QualType(this_(), 0) : canon) {
1826 static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
1827 "changing bitfields changed sizeof(Type)!");
1828 static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
1829 "Insufficient alignment!");
1830 TypeBits.TC = tc;
1831 TypeBits.Dependence = static_cast<unsigned>(Dependence);
1832 TypeBits.CacheValid = false;
1833 TypeBits.CachedLocalOrUnnamed = false;
1834 TypeBits.CachedLinkage = NoLinkage;
1835 TypeBits.FromAST = false;
1836 }
1837
1838 // silence VC++ warning C4355: 'this' : used in base member initializer list
1839 Type *this_() { return this; }
1840
1841 void setDependence(TypeDependence D) {
1842 TypeBits.Dependence = static_cast<unsigned>(D);
1843 }
1844
1845 void addDependence(TypeDependence D) { setDependence(getDependence() | D); }
1846
1847public:
1848 friend class ASTReader;
1849 friend class ASTWriter;
1850 template <class T> friend class serialization::AbstractTypeReader;
1851 template <class T> friend class serialization::AbstractTypeWriter;
1852
1853 Type(const Type &) = delete;
1854 Type(Type &&) = delete;
1855 Type &operator=(const Type &) = delete;
1856 Type &operator=(Type &&) = delete;
1857
1858 TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
1859
1860 /// Whether this type comes from an AST file.
1861 bool isFromAST() const { return TypeBits.FromAST; }
1862
1863 /// Whether this type is or contains an unexpanded parameter
1864 /// pack, used to support C++0x variadic templates.
1865 ///
1866 /// A type that contains a parameter pack shall be expanded by the
1867 /// ellipsis operator at some point. For example, the typedef in the
1868 /// following example contains an unexpanded parameter pack 'T':
1869 ///
1870 /// \code
1871 /// template<typename ...T>
1872 /// struct X {
1873 /// typedef T* pointer_types; // ill-formed; T is a parameter pack.
1874 /// };
1875 /// \endcode
1876 ///
1877 /// Note that this routine does not specify which
1878 bool containsUnexpandedParameterPack() const {
1879 return getDependence() & TypeDependence::UnexpandedPack;
1880 }
1881
1882 /// Determines if this type would be canonical if it had no further
1883 /// qualification.
1884 bool isCanonicalUnqualified() const {
1885 return CanonicalType == QualType(this, 0);
1886 }
1887
1888 /// Pull a single level of sugar off of this locally-unqualified type.
1889 /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
1890 /// or QualType::getSingleStepDesugaredType(const ASTContext&).
1891 QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
1892
1893 /// As an extension, we classify types as one of "sized" or "sizeless";
1894 /// every type is one or the other. Standard types are all sized;
1895 /// sizeless types are purely an extension.
1896 ///
1897 /// Sizeless types contain data with no specified size, alignment,
1898 /// or layout.
1899 bool isSizelessType() const;
1900 bool isSizelessBuiltinType() const;
1901
1902 /// Determines if this is a sizeless type supported by the
1903 /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
1904 /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
1905 bool isVLSTBuiltinType() const;
1906
1907 /// Returns the representative type for the element of an SVE builtin type.
1908 /// This is used to represent fixed-length SVE vectors created with the
1909 /// 'arm_sve_vector_bits' type attribute as VectorType.
1910 QualType getSveEltType(const ASTContext &Ctx) const;
1911
1912 /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
1913 /// object types, function types, and incomplete types.
1914
1915 /// Return true if this is an incomplete type.
1916 /// A type that can describe objects, but which lacks information needed to
1917 /// determine its size (e.g. void, or a fwd declared struct). Clients of this
1918 /// routine will need to determine if the size is actually required.
1919 ///
1920 /// Def If non-null, and the type refers to some kind of declaration
1921 /// that can be completed (such as a C struct, C++ class, or Objective-C
1922 /// class), will be set to the declaration.
1923 bool isIncompleteType(NamedDecl **Def = nullptr) const;
1924
1925 /// Return true if this is an incomplete or object
1926 /// type, in other words, not a function type.
1927 bool isIncompleteOrObjectType() const {
1928 return !isFunctionType();
1929 }
1930
1931 /// Determine whether this type is an object type.
1932 bool isObjectType() const {
1933 // C++ [basic.types]p8:
1934 // An object type is a (possibly cv-qualified) type that is not a
1935 // function type, not a reference type, and not a void type.
1936 return !isReferenceType() && !isFunctionType() && !isVoidType();
1937 }
1938
1939 /// Return true if this is a literal type
1940 /// (C++11 [basic.types]p10)
1941 bool isLiteralType(const ASTContext &Ctx) const;
1942
1943 /// Determine if this type is a structural type, per C++20 [temp.param]p7.
1944 bool isStructuralType() const;
1945
1946 /// Test if this type is a standard-layout type.
1947 /// (C++0x [basic.type]p9)
1948 bool isStandardLayoutType() const;
1949
1950 /// Helper methods to distinguish type categories. All type predicates
1951 /// operate on the canonical type, ignoring typedefs and qualifiers.
1952
1953 /// Returns true if the type is a builtin type.
1954 bool isBuiltinType() const;
1955
1956 /// Test for a particular builtin type.
1957 bool isSpecificBuiltinType(unsigned K) const;
1958
1959 /// Test for a type which does not represent an actual type-system type but
1960 /// is instead used as a placeholder for various convenient purposes within
1961 /// Clang. All such types are BuiltinTypes.
1962 bool isPlaceholderType() const;
1963 const BuiltinType *getAsPlaceholderType() const;
1964
1965 /// Test for a specific placeholder type.
1966 bool isSpecificPlaceholderType(unsigned K) const;
1967
1968 /// Test for a placeholder type other than Overload; see
1969 /// BuiltinType::isNonOverloadPlaceholderType.
1970 bool isNonOverloadPlaceholderType() const;
1971
1972 /// isIntegerType() does *not* include complex integers (a GCC extension).
1973 /// isComplexIntegerType() can be used to test for complex integers.
1974 bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum)
1975 bool isEnumeralType() const;
1976
1977 /// Determine whether this type is a scoped enumeration type.
1978 bool isScopedEnumeralType() const;
1979 bool isBooleanType() const;
1980 bool isCharType() const;
1981 bool isWideCharType() const;
1982 bool isChar8Type() const;
1983 bool isChar16Type() const;
1984 bool isChar32Type() const;
1985 bool isAnyCharacterType() const;
1986 bool isIntegralType(const ASTContext &Ctx) const;
1987
1988 /// Determine whether this type is an integral or enumeration type.
1989 bool isIntegralOrEnumerationType() const;
1990
1991 /// Determine whether this type is an integral or unscoped enumeration type.
1992 bool isIntegralOrUnscopedEnumerationType() const;
1993 bool isUnscopedEnumerationType() const;
1994
1995 /// Floating point categories.
1996 bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
1997 /// isComplexType() does *not* include complex integers (a GCC extension).
1998 /// isComplexIntegerType() can be used to test for complex integers.
1999 bool isComplexType() const; // C99 6.2.5p11 (complex)
2000 bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int.
2001 bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex)
2002 bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
2003 bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661
2004 bool isBFloat16Type() const;
2005 bool isFloat128Type() const;
2006 bool isRealType() const; // C99 6.2.5p17 (real floating + integer)
2007 bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating)
2008 bool isVoidType() const; // C99 6.2.5p19
2009 bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers)
2010 bool isAggregateType() const;
2011 bool isFundamentalType() const;
2012 bool isCompoundType() const;
2013
2014 // Type Predicates: Check to see if this type is structurally the specified
2015 // type, ignoring typedefs and qualifiers.
2016 bool isFunctionType() const;
2017 bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
2018 bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
2019 bool isPointerType() const;
2020 bool isAnyPointerType() const; // Any C pointer or ObjC object pointer
2021 bool isBlockPointerType() const;
2022 bool isVoidPointerType() const;
2023 bool isReferenceType() const;
2024 bool isLValueReferenceType() const;
2025 bool isRValueReferenceType() const;
2026 bool isObjectPointerType() const;
2027 bool isFunctionPointerType() const;
2028 bool isFunctionReferenceType() const;
2029 bool isMemberPointerType() const;
2030 bool isMemberFunctionPointerType() const;
2031 bool isMemberDataPointerType() const;
2032 bool isArrayType() const;
2033 bool isConstantArrayType() const;
2034 bool isIncompleteArrayType() const;
2035 bool isVariableArrayType() const;
2036 bool isDependentSizedArrayType() const;
2037 bool isRecordType() const;
2038 bool isClassType() const;
2039 bool isStructureType() const;
2040 bool isObjCBoxableRecordType() const;
2041 bool isInterfaceType() const;
2042 bool isStructureOrClassType() const;
2043 bool isUnionType() const;
2044 bool isComplexIntegerType() const; // GCC _Complex integer type.
2045 bool isVectorType() const; // GCC vector type.
2046 bool isExtVectorType() const; // Extended vector type.
2047 bool isMatrixType() const; // Matrix type.
2048 bool isConstantMatrixType() const; // Constant matrix type.
2049 bool isDependentAddressSpaceType() const; // value-dependent address space qualifier
2050 bool isObjCObjectPointerType() const; // pointer to ObjC object
2051 bool isObjCRetainableType() const; // ObjC object or block pointer
2052 bool isObjCLifetimeType() const; // (array of)* retainable type
2053 bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type
2054 bool isObjCNSObjectType() const; // __attribute__((NSObject))
2055 bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class))
2056 // FIXME: change this to 'raw' interface type, so we can used 'interface' type
2057 // for the common case.
2058 bool isObjCObjectType() const; // NSString or typeof(*(id)0)
2059 bool isObjCQualifiedInterfaceType() const; // NSString<foo>
2060 bool isObjCQualifiedIdType() const; // id<foo>
2061 bool isObjCQualifiedClassType() const; // Class<foo>
2062 bool isObjCObjectOrInterfaceType() const;
2063 bool isObjCIdType() const; // id
2064 bool isDecltypeType() const;
2065 /// Was this type written with the special inert-in-ARC __unsafe_unretained
2066 /// qualifier?
2067 ///
2068 /// This approximates the answer to the following question: if this
2069 /// translation unit were compiled in ARC, would this type be qualified
2070 /// with __unsafe_unretained?
2071 bool isObjCInertUnsafeUnretainedType() const {
2072 return hasAttr(attr::ObjCInertUnsafeUnretained);
2073 }
2074
2075 /// Whether the type is Objective-C 'id' or a __kindof type of an
2076 /// object type, e.g., __kindof NSView * or __kindof id
2077 /// <NSCopying>.
2078 ///
2079 /// \param bound Will be set to the bound on non-id subtype types,
2080 /// which will be (possibly specialized) Objective-C class type, or
2081 /// null for 'id.
2082 bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
2083 const ObjCObjectType *&bound) const;
2084
2085 bool isObjCClassType() const; // Class
2086
2087 /// Whether the type is Objective-C 'Class' or a __kindof type of an
2088 /// Class type, e.g., __kindof Class <NSCopying>.
2089 ///
2090 /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
2091 /// here because Objective-C's type system cannot express "a class
2092 /// object for a subclass of NSFoo".
2093 bool isObjCClassOrClassKindOfType() const;
2094
2095 bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
2096 bool isObjCSelType() const; // Class
2097 bool isObjCBuiltinType() const; // 'id' or 'Class'
2098 bool isObjCARCBridgableType() const;
2099 bool isCARCBridgableType() const;
2100 bool isTemplateTypeParmType() const; // C++ template type parameter
2101 bool isNullPtrType() const; // C++11 std::nullptr_t
2102 bool isNothrowT() const; // C++ std::nothrow_t
2103 bool isAlignValT() const; // C++17 std::align_val_t
2104 bool isStdByteType() const; // C++17 std::byte
2105 bool isAtomicType() const; // C11 _Atomic()
2106 bool isUndeducedAutoType() const; // C++11 auto or
2107 // C++14 decltype(auto)
2108 bool isTypedefNameType() const; // typedef or alias template
2109
2110#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2111 bool is##Id##Type() const;
2112#include "clang/Basic/OpenCLImageTypes.def"
2113
2114 bool isImageType() const; // Any OpenCL image type
2115
2116 bool isSamplerT() const; // OpenCL sampler_t
2117 bool isEventT() const; // OpenCL event_t
2118 bool isClkEventT() const; // OpenCL clk_event_t
2119 bool isQueueT() const; // OpenCL queue_t
2120 bool isReserveIDT() const; // OpenCL reserve_id_t
2121
2122#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2123 bool is##Id##Type() const;
2124#include "clang/Basic/OpenCLExtensionTypes.def"
2125 // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
2126 bool isOCLIntelSubgroupAVCType() const;
2127 bool isOCLExtOpaqueType() const; // Any OpenCL extension type
2128
2129 bool isPipeType() const; // OpenCL pipe type
2130 bool isExtIntType() const; // Extended Int Type
2131 bool isOpenCLSpecificType() const; // Any OpenCL specific type
2132
2133 /// Determines if this type, which must satisfy
2134 /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
2135 /// than implicitly __strong.
2136 bool isObjCARCImplicitlyUnretainedType() const;
2137
2138 /// Check if the type is the CUDA device builtin surface type.
2139 bool isCUDADeviceBuiltinSurfaceType() const;
2140 /// Check if the type is the CUDA device builtin texture type.
2141 bool isCUDADeviceBuiltinTextureType() const;
2142
2143 /// Return the implicit lifetime for this type, which must not be dependent.
2144 Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
2145
2146 enum ScalarTypeKind {
2147 STK_CPointer,
2148 STK_BlockPointer,
2149 STK_ObjCObjectPointer,
2150 STK_MemberPointer,
2151 STK_Bool,
2152 STK_Integral,
2153 STK_Floating,
2154 STK_IntegralComplex,
2155 STK_FloatingComplex,
2156 STK_FixedPoint
2157 };
2158
2159 /// Given that this is a scalar type, classify it.
2160 ScalarTypeKind getScalarTypeKind() const;
2161
2162 TypeDependence getDependence() const {
2163 return static_cast<TypeDependence>(TypeBits.Dependence);
2164 }
2165
2166 /// Whether this type is an error type.
2167 bool containsErrors() const {
2168 return getDependence() & TypeDependence::Error;
2169 }
2170
2171 /// Whether this type is a dependent type, meaning that its definition
2172 /// somehow depends on a template parameter (C++ [temp.dep.type]).
2173 bool isDependentType() const {
2174 return getDependence() & TypeDependence::Dependent;
2175 }
2176
2177 /// Determine whether this type is an instantiation-dependent type,
2178 /// meaning that the type involves a template parameter (even if the
2179 /// definition does not actually depend on the type substituted for that
2180 /// template parameter).
2181 bool isInstantiationDependentType() const {
2182 return getDependence() & TypeDependence::Instantiation;
2183 }
2184
2185 /// Determine whether this type is an undeduced type, meaning that
2186 /// it somehow involves a C++11 'auto' type or similar which has not yet been
2187 /// deduced.
2188 bool isUndeducedType() const;
2189
2190 /// Whether this type is a variably-modified type (C99 6.7.5).
2191 bool isVariablyModifiedType() const {
2192 return getDependence() & TypeDependence::VariablyModified;
2193 }
2194
2195 /// Whether this type involves a variable-length array type
2196 /// with a definite size.
2197 bool hasSizedVLAType() const;
2198
2199 /// Whether this type is or contains a local or unnamed type.
2200 bool hasUnnamedOrLocalType() const;
2201
2202 bool isOverloadableType() const;
2203
2204 /// Determine wither this type is a C++ elaborated-type-specifier.
2205 bool isElaboratedTypeSpecifier() const;
2206
2207 bool canDecayToPointerType() const;
2208
2209 /// Whether this type is represented natively as a pointer. This includes
2210 /// pointers, references, block pointers, and Objective-C interface,
2211 /// qualified id, and qualified interface types, as well as nullptr_t.
2212 bool hasPointerRepresentation() const;
2213
2214 /// Whether this type can represent an objective pointer type for the
2215 /// purpose of GC'ability
2216 bool hasObjCPointerRepresentation() const;
2217
2218 /// Determine whether this type has an integer representation
2219 /// of some sort, e.g., it is an integer type or a vector.
2220 bool hasIntegerRepresentation() const;
2221
2222 /// Determine whether this type has an signed integer representation
2223 /// of some sort, e.g., it is an signed integer type or a vector.
2224 bool hasSignedIntegerRepresentation() const;
2225
2226 /// Determine whether this type has an unsigned integer representation
2227 /// of some sort, e.g., it is an unsigned integer type or a vector.
2228 bool hasUnsignedIntegerRepresentation() const;
2229
2230 /// Determine whether this type has a floating-point representation
2231 /// of some sort, e.g., it is a floating-point type or a vector thereof.
2232 bool hasFloatingRepresentation() const;
2233
2234 // Type Checking Functions: Check to see if this type is structurally the
2235 // specified type, ignoring typedefs and qualifiers, and return a pointer to
2236 // the best type we can.
2237 const RecordType *getAsStructureType() const;
2238 /// NOTE: getAs*ArrayType are methods on ASTContext.
2239 const RecordType *getAsUnionType() const;
2240 const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
2241 const ObjCObjectType *getAsObjCInterfaceType() const;
2242
2243 // The following is a convenience method that returns an ObjCObjectPointerType
2244 // for object declared using an interface.
2245 const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
2246 const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
2247 const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
2248 const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
2249
2250 /// Retrieves the CXXRecordDecl that this type refers to, either
2251 /// because the type is a RecordType or because it is the injected-class-name
2252 /// type of a class template or class template partial specialization.
2253 CXXRecordDecl *getAsCXXRecordDecl() const;
2254
2255 /// Retrieves the RecordDecl this type refers to.
2256 RecordDecl *getAsRecordDecl() const;
2257
2258 /// Retrieves the TagDecl that this type refers to, either
2259 /// because the type is a TagType or because it is the injected-class-name
2260 /// type of a class template or class template partial specialization.
2261 TagDecl *getAsTagDecl() const;
2262
2263 /// If this is a pointer or reference to a RecordType, return the
2264 /// CXXRecordDecl that the type refers to.
2265 ///
2266 /// If this is not a pointer or reference, or the type being pointed to does
2267 /// not refer to a CXXRecordDecl, returns NULL.
2268 const CXXRecordDecl *getPointeeCXXRecordDecl() const;
2269
2270 /// Get the DeducedType whose type will be deduced for a variable with
2271 /// an initializer of this type. This looks through declarators like pointer
2272 /// types, but not through decltype or typedefs.
2273 DeducedType *getContainedDeducedType() const;
2274
2275 /// Get the AutoType whose type will be deduced for a variable with
2276 /// an initializer of this type. This looks through declarators like pointer
2277 /// types, but not through decltype or typedefs.
2278 AutoType *getContainedAutoType() const {
2279 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2280 }
2281
2282 /// Determine whether this type was written with a leading 'auto'
2283 /// corresponding to a trailing return type (possibly for a nested
2284 /// function type within a pointer to function type or similar).
2285 bool hasAutoForTrailingReturnType() const;
2286
2287 /// Member-template getAs<specific type>'. Look through sugar for
2288 /// an instance of \<specific type>. This scheme will eventually
2289 /// replace the specific getAsXXXX methods above.
2290 ///
2291 /// There are some specializations of this member template listed
2292 /// immediately following this class.
2293 template <typename T> const T *getAs() const;
2294
2295 /// Member-template getAsAdjusted<specific type>. Look through specific kinds
2296 /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
2297 /// This is used when you need to walk over sugar nodes that represent some
2298 /// kind of type adjustment from a type that was written as a \<specific type>
2299 /// to another type that is still canonically a \<specific type>.
2300 template <typename T> const T *getAsAdjusted() const;
2301
2302 /// A variant of getAs<> for array types which silently discards
2303 /// qualifiers from the outermost type.
2304 const ArrayType *getAsArrayTypeUnsafe() const;
2305
2306 /// Member-template castAs<specific type>. Look through sugar for
2307 /// the underlying instance of \<specific type>.
2308 ///
2309 /// This method has the same relationship to getAs<T> as cast<T> has
2310 /// to dyn_cast<T>; which is to say, the underlying type *must*
2311 /// have the intended type, and this method will never return null.
2312 template <typename T> const T *castAs() const;
2313
2314 /// A variant of castAs<> for array type which silently discards
2315 /// qualifiers from the outermost type.
2316 const ArrayType *castAsArrayTypeUnsafe() const;
2317
2318 /// Determine whether this type had the specified attribute applied to it
2319 /// (looking through top-level type sugar).
2320 bool hasAttr(attr::Kind AK) const;
2321
2322 /// Get the base element type of this type, potentially discarding type
2323 /// qualifiers. This should never be used when type qualifiers
2324 /// are meaningful.
2325 const Type *getBaseElementTypeUnsafe() const;
2326
2327 /// If this is an array type, return the element type of the array,
2328 /// potentially with type qualifiers missing.
2329 /// This should never be used when type qualifiers are meaningful.
2330 const Type *getArrayElementTypeNoTypeQual() const;
2331
2332 /// If this is a pointer type, return the pointee type.
2333 /// If this is an array type, return the array element type.
2334 /// This should never be used when type qualifiers are meaningful.
2335 const Type *getPointeeOrArrayElementType() const;
2336
2337 /// If this is a pointer, ObjC object pointer, or block
2338 /// pointer, this returns the respective pointee.
2339 QualType getPointeeType() const;
2340
2341 /// Return the specified type with any "sugar" removed from the type,
2342 /// removing any typedefs, typeofs, etc., as well as any qualifiers.
2343 const Type *getUnqualifiedDesugaredType() const;
2344
2345 /// More type predicates useful for type checking/promotion
2346 bool isPromotableIntegerType() const; // C99 6.3.1.1p2
2347
2348 /// Return true if this is an integer type that is
2349 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
2350 /// or an enum decl which has a signed representation.
2351 bool isSignedIntegerType() const;
2352
2353 /// Return true if this is an integer type that is
2354 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
2355 /// or an enum decl which has an unsigned representation.
2356 bool isUnsignedIntegerType() const;
2357
2358 /// Determines whether this is an integer type that is signed or an
2359 /// enumeration types whose underlying type is a signed integer type.
2360 bool isSignedIntegerOrEnumerationType() const;
2361
2362 /// Determines whether this is an integer type that is unsigned or an
2363 /// enumeration types whose underlying type is a unsigned integer type.
2364 bool isUnsignedIntegerOrEnumerationType() const;
2365
2366 /// Return true if this is a fixed point type according to
2367 /// ISO/IEC JTC1 SC22 WG14 N1169.
2368 bool isFixedPointType() const;
2369
2370 /// Return true if this is a fixed point or integer type.
2371 bool isFixedPointOrIntegerType() const;
2372
2373 /// Return true if this is a saturated fixed point type according to
2374 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2375 bool isSaturatedFixedPointType() const;
2376
2377 /// Return true if this is a saturated fixed point type according to
2378 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2379 bool isUnsaturatedFixedPointType() const;
2380
2381 /// Return true if this is a fixed point type that is signed according
2382 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2383 bool isSignedFixedPointType() const;
2384
2385 /// Return true if this is a fixed point type that is unsigned according
2386 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2387 bool isUnsignedFixedPointType() const;
2388
2389 /// Return true if this is not a variable sized type,
2390 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
2391 /// incomplete types.
2392 bool isConstantSizeType() const;
2393
2394 /// Returns true if this type can be represented by some
2395 /// set of type specifiers.
2396 bool isSpecifierType() const;
2397
2398 /// Determine the linkage of this type.
2399 Linkage getLinkage() const;
2400
2401 /// Determine the visibility of this type.
2402 Visibility getVisibility() const {
2403 return getLinkageAndVisibility().getVisibility();
2404 }
2405
2406 /// Return true if the visibility was explicitly set is the code.
2407 bool isVisibilityExplicit() const {
2408 return getLinkageAndVisibility().isVisibilityExplicit();
2409 }
2410
2411 /// Determine the linkage and visibility of this type.
2412 LinkageInfo getLinkageAndVisibility() const;
2413
2414 /// True if the computed linkage is valid. Used for consistency
2415 /// checking. Should always return true.
2416 bool isLinkageValid() const;
2417
2418 /// Determine the nullability of the given type.
2419 ///
2420 /// Note that nullability is only captured as sugar within the type
2421 /// system, not as part of the canonical type, so nullability will
2422 /// be lost by canonicalization and desugaring.
2423 Optional<NullabilityKind> getNullability(const ASTContext &context) const;
2424
2425 /// Determine whether the given type can have a nullability
2426 /// specifier applied to it, i.e., if it is any kind of pointer type.
2427 ///
2428 /// \param ResultIfUnknown The value to return if we don't yet know whether
2429 /// this type can have nullability because it is dependent.
2430 bool canHaveNullability(bool ResultIfUnknown = true) const;
2431
2432 /// Retrieve the set of substitutions required when accessing a member
2433 /// of the Objective-C receiver type that is declared in the given context.
2434 ///
2435 /// \c *this is the type of the object we're operating on, e.g., the
2436 /// receiver for a message send or the base of a property access, and is
2437 /// expected to be of some object or object pointer type.
2438 ///
2439 /// \param dc The declaration context for which we are building up a
2440 /// substitution mapping, which should be an Objective-C class, extension,
2441 /// category, or method within.
2442 ///
2443 /// \returns an array of type arguments that can be substituted for
2444 /// the type parameters of the given declaration context in any type described
2445 /// within that context, or an empty optional to indicate that no
2446 /// substitution is required.
2447 Optional<ArrayRef<QualType>>
2448 getObjCSubstitutions(const DeclContext *dc) const;
2449
2450 /// Determines if this is an ObjC interface type that may accept type
2451 /// parameters.
2452 bool acceptsObjCTypeParams() const;
2453
2454 const char *getTypeClassName() const;
2455
2456 QualType getCanonicalTypeInternal() const {
2457 return CanonicalType;
2458 }
2459
2460 CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
2461 void dump() const;
2462 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
2463};
2464
2465/// This will check for a TypedefType by removing any existing sugar
2466/// until it reaches a TypedefType or a non-sugared type.
2467template <> const TypedefType *Type::getAs() const;
2468
2469/// This will check for a TemplateSpecializationType by removing any
2470/// existing sugar until it reaches a TemplateSpecializationType or a
2471/// non-sugared type.
2472template <> const TemplateSpecializationType *Type::getAs() const;
2473
2474/// This will check for an AttributedType by removing any existing sugar
2475/// until it reaches an AttributedType or a non-sugared type.
2476template <> const AttributedType *Type::getAs() const;
2477
2478// We can do canonical leaf types faster, because we don't have to
2479// worry about preserving child type decoration.
2480#define TYPE(Class, Base)
2481#define LEAF_TYPE(Class) \
2482template <> inline const Class##Type *Type::getAs() const { \
2483 return dyn_cast<Class##Type>(CanonicalType); \
2484} \
2485template <> inline const Class##Type *Type::castAs() const { \
2486 return cast<Class##Type>(CanonicalType); \
2487}
2488#include "clang/AST/TypeNodes.inc"
2489
2490/// This class is used for builtin types like 'int'. Builtin
2491/// types are always canonical and have a literal name field.
2492class BuiltinType : public Type {
2493public:
2494 enum Kind {
2495// OpenCL image types
2496#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2497#include "clang/Basic/OpenCLImageTypes.def"
2498// OpenCL extension types
2499#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2500#include "clang/Basic/OpenCLExtensionTypes.def"
2501// SVE Types
2502#define SVE_TYPE(Name, Id, SingletonId) Id,
2503#include "clang/Basic/AArch64SVEACLETypes.def"
2504// PPC MMA Types
2505#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2506#include "clang/Basic/PPCTypes.def"
2507// RVV Types
2508#define RVV_TYPE(Name, Id, SingletonId) Id,
2509#include "clang/Basic/RISCVVTypes.def"
2510// All other builtin types
2511#define BUILTIN_TYPE(Id, SingletonId) Id,
2512#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2513#include "clang/AST/BuiltinTypes.def"
2514 };
2515
2516private:
2517 friend class ASTContext; // ASTContext creates these.
2518
2519 BuiltinType(Kind K)
2520 : Type(Builtin, QualType(),
2521 K == Dependent ? TypeDependence::DependentInstantiation
2522 : TypeDependence::None) {
2523 BuiltinTypeBits.Kind = K;
2524 }
2525
2526public:
2527 Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
2528 StringRef getName(const PrintingPolicy &Policy) const;
2529
2530 const char *getNameAsCString(const PrintingPolicy &Policy) const {
2531 // The StringRef is null-terminated.
2532 StringRef str = getName(Policy);
2533 assert(!str.empty() && str.data()[str.size()] == '\0')(static_cast<void> (0));
2534 return str.data();
2535 }
2536
2537 bool isSugared() const { return false; }
2538 QualType desugar() const { return QualType(this, 0); }
2539
2540 bool isInteger() const {
2541 return getKind() >= Bool && getKind() <= Int128;
2542 }
2543
2544 bool isSignedInteger() const {
2545 return getKind() >= Char_S && getKind() <= Int128;
2546 }
2547
2548 bool isUnsignedInteger() const {
2549 return getKind() >= Bool && getKind() <= UInt128;
2550 }
2551
2552 bool isFloatingPoint() const {
2553 return getKind() >= Half && getKind() <= Float128;
2554 }
2555
2556 /// Determines whether the given kind corresponds to a placeholder type.
2557 static bool isPlaceholderTypeKind(Kind K) {
2558 return K >= Overload;
2559 }
2560
2561 /// Determines whether this type is a placeholder type, i.e. a type
2562 /// which cannot appear in arbitrary positions in a fully-formed
2563 /// expression.
2564 bool isPlaceholderType() const {
2565 return isPlaceholderTypeKind(getKind());
2566 }
2567
2568 /// Determines whether this type is a placeholder type other than
2569 /// Overload. Most placeholder types require only syntactic
2570 /// information about their context in order to be resolved (e.g.
2571 /// whether it is a call expression), which means they can (and
2572 /// should) be resolved in an earlier "phase" of analysis.
2573 /// Overload expressions sometimes pick up further information
2574 /// from their context, like whether the context expects a
2575 /// specific function-pointer type, and so frequently need
2576 /// special treatment.
2577 bool isNonOverloadPlaceholderType() const {
2578 return getKind() > Overload;
2579 }
2580
2581 static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2582};
2583
2584/// Complex values, per C99 6.2.5p11. This supports the C99 complex
2585/// types (_Complex float etc) as well as the GCC integer complex extensions.
2586class ComplexType : public Type, public llvm::FoldingSetNode {
2587 friend class ASTContext; // ASTContext creates these.
2588
2589 QualType ElementType;
2590
2591 ComplexType(QualType Element, QualType CanonicalPtr)
2592 : Type(Complex, CanonicalPtr, Element->getDependence()),
2593 ElementType(Element) {}
2594
2595public:
2596 QualType getElementType() const { return ElementType; }
2597
2598 bool isSugared() const { return false; }
2599 QualType desugar() const { return QualType(this, 0); }
2600
2601 void Profile(llvm::FoldingSetNodeID &ID) {
2602 Profile(ID, getElementType());
2603 }
2604
2605 static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
2606 ID.AddPointer(Element.getAsOpaquePtr());
2607 }
2608
2609 static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2610};
2611
2612/// Sugar for parentheses used when specifying types.
2613class ParenType : public Type, public llvm::FoldingSetNode {
2614 friend class ASTContext; // ASTContext creates these.
2615
2616 QualType Inner;
2617
2618 ParenType(QualType InnerType, QualType CanonType)
2619 : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
2620
2621public:
2622 QualType getInnerType() const { return Inner; }
2623
2624 bool isSugared() const { return true; }
2625 QualType desugar() const { return getInnerType(); }
2626
2627 void Profile(llvm::FoldingSetNodeID &ID) {
2628 Profile(ID, getInnerType());
2629 }
2630
2631 static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
2632 Inner.Profile(ID);
2633 }
2634
2635 static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2636};
2637
2638/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2639class PointerType : public Type, public llvm::FoldingSetNode {
2640 friend class ASTContext; // ASTContext creates these.
2641
2642 QualType PointeeType;
2643
2644 PointerType(QualType Pointee, QualType CanonicalPtr)
2645 : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
2646 PointeeType(Pointee) {}
2647
2648public:
2649 QualType getPointeeType() const { return PointeeType; }
2650
2651 bool isSugared() const { return false; }
2652 QualType desugar() const { return QualType(this, 0); }
2653
2654 void Profile(llvm::FoldingSetNodeID &ID) {
2655 Profile(ID, getPointeeType());
2656 }
2657
2658 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2659 ID.AddPointer(Pointee.getAsOpaquePtr());
2660 }
2661
2662 static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2663};
2664
2665/// Represents a type which was implicitly adjusted by the semantic
2666/// engine for arbitrary reasons. For example, array and function types can
2667/// decay, and function types can have their calling conventions adjusted.
2668class AdjustedType : public Type, public llvm::FoldingSetNode {
2669 QualType OriginalTy;
2670 QualType AdjustedTy;
2671
2672protected:
2673 friend class ASTContext; // ASTContext creates these.
2674
2675 AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
2676 QualType CanonicalPtr)
2677 : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
2678 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
2679
2680public:
2681 QualType getOriginalType() const { return OriginalTy; }
2682 QualType getAdjustedType() const { return AdjustedTy; }
2683
2684 bool isSugared() const { return true; }
2685 QualType desugar() const { return AdjustedTy; }
2686
2687 void Profile(llvm::FoldingSetNodeID &ID) {
2688 Profile(ID, OriginalTy, AdjustedTy);
2689 }
2690
2691 static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
2692 ID.AddPointer(Orig.getAsOpaquePtr());
2693 ID.AddPointer(New.getAsOpaquePtr());
2694 }
2695
2696 static bool classof(const Type *T) {
2697 return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
2698 }
2699};
2700
2701/// Represents a pointer type decayed from an array or function type.
2702class DecayedType : public AdjustedType {
2703 friend class ASTContext; // ASTContext creates these.
2704
2705 inline
2706 DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);
2707
2708public:
2709 QualType getDecayedType() const { return getAdjustedType(); }
2710
2711 inline QualType getPointeeType() const;
2712
2713 static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2714};
2715
2716/// Pointer to a block type.
2717/// This type is to represent types syntactically represented as
2718/// "void (^)(int)", etc. Pointee is required to always be a function type.
2719class BlockPointerType : public Type, public llvm::FoldingSetNode {
2720 friend class ASTContext; // ASTContext creates these.
2721
2722 // Block is some kind of pointer type
2723 QualType PointeeType;
2724
2725 BlockPointerType(QualType Pointee, QualType CanonicalCls)
2726 : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
2727 PointeeType(Pointee) {}
2728
2729public:
2730 // Get the pointee type. Pointee is required to always be a function type.
2731 QualType getPointeeType() const { return PointeeType; }
2732
2733 bool isSugared() const { return false; }
2734 QualType desugar() const { return QualType(this, 0); }
2735
2736 void Profile(llvm::FoldingSetNodeID &ID) {
2737 Profile(ID, getPointeeType());
2738 }
2739
2740 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2741 ID.AddPointer(Pointee.getAsOpaquePtr());
2742 }
2743
2744 static bool classof(const Type *T) {
2745 return T->getTypeClass() == BlockPointer;
2746 }
2747};
2748
2749/// Base for LValueReferenceType and RValueReferenceType
2750class ReferenceType : public Type, public llvm::FoldingSetNode {
2751 QualType PointeeType;
2752
2753protected:
2754 ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
2755 bool SpelledAsLValue)
2756 : Type(tc, CanonicalRef, Referencee->getDependence()),
2757 PointeeType(Referencee) {
2758 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
2759 ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
2760 }
2761
2762public:
2763 bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
2764 bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }
2765
2766 QualType getPointeeTypeAsWritten() const { return PointeeType; }
2767
2768 QualType getPointeeType() const {
2769 // FIXME: this might strip inner qualifiers; okay?
2770 const ReferenceType *T = this;
2771 while (T->isInnerRef())
2772 T = T->PointeeType->castAs<ReferenceType>();
2773 return T->PointeeType;
2774 }
2775
2776 void Profile(llvm::FoldingSetNodeID &ID) {
2777 Profile(ID, PointeeType, isSpelledAsLValue());
2778 }
2779
2780 static void Profile(llvm::FoldingSetNodeID &ID,
2781 QualType Referencee,
2782 bool SpelledAsLValue) {
2783 ID.AddPointer(Referencee.getAsOpaquePtr());
2784 ID.AddBoolean(SpelledAsLValue);
2785 }
2786
2787 static bool classof(const Type *T) {
2788 return T->getTypeClass() == LValueReference ||
2789 T->getTypeClass() == RValueReference;
2790 }
2791};
2792
2793/// An lvalue reference type, per C++11 [dcl.ref].
2794class LValueReferenceType : public ReferenceType {
2795 friend class ASTContext; // ASTContext creates these
2796
2797 LValueReferenceType(QualType Referencee, QualType CanonicalRef,
2798 bool SpelledAsLValue)
2799 : ReferenceType(LValueReference, Referencee, CanonicalRef,
2800 SpelledAsLValue) {}
2801
2802public:
2803 bool isSugared() const { return false; }
2804 QualType desugar() const { return QualType(this, 0); }
2805
2806 static bool classof(const Type *T) {
2807 return T->getTypeClass() == LValueReference;
2808 }
2809};
2810
2811/// An rvalue reference type, per C++11 [dcl.ref].
2812class RValueReferenceType : public ReferenceType {
2813 friend class ASTContext; // ASTContext creates these
2814
2815 RValueReferenceType(QualType Referencee, QualType CanonicalRef)
2816 : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}
2817
2818public:
2819 bool isSugared() const { return false; }
2820 QualType desugar() const { return QualType(this, 0); }
2821
2822 static bool classof(const Type *T) {
2823 return T->getTypeClass() == RValueReference;
2824 }
2825};
2826
2827/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2828///
2829/// This includes both pointers to data members and pointer to member functions.
2830class MemberPointerType : public Type, public llvm::FoldingSetNode {
2831 friend class ASTContext; // ASTContext creates these.
2832
2833 QualType PointeeType;
2834
2835 /// The class of which the pointee is a member. Must ultimately be a
2836 /// RecordType, but could be a typedef or a template parameter too.
2837 const Type *Class;
2838
2839 MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
2840 : Type(MemberPointer, CanonicalPtr,
2841 (Cls->getDependence() & ~TypeDependence::VariablyModified) |
2842 Pointee->getDependence()),
2843 PointeeType(Pointee), Class(Cls) {}
2844
2845public:
2846 QualType getPointeeType() const { return PointeeType; }
2847
2848 /// Returns true if the member type (i.e. the pointee type) is a
2849 /// function type rather than a data-member type.
2850 bool isMemberFunctionPointer() const {
2851 return PointeeType->isFunctionProtoType();
2852 }
2853
2854 /// Returns true if the member type (i.e. the pointee type) is a
2855 /// data type rather than a function type.
2856 bool isMemberDataPointer() const {
2857 return !PointeeType->isFunctionProtoType();
2858 }
2859
2860 const Type *getClass() const { return Class; }
2861 CXXRecordDecl *getMostRecentCXXRecordDecl() const;
2862
2863 bool isSugared() const { return false; }
2864 QualType desugar() const { return QualType(this, 0); }
2865
2866 void Profile(llvm::FoldingSetNodeID &ID) {
2867 Profile(ID, getPointeeType(), getClass());
2868 }
2869
2870 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
2871 const Type *Class) {
2872 ID.AddPointer(Pointee.getAsOpaquePtr());
2873 ID.AddPointer(Class);
2874 }
2875
2876 static bool classof(const Type *T) {
2877 return T->getTypeClass() == MemberPointer;
2878 }
2879};
2880
2881/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2882class ArrayType : public Type, public llvm::FoldingSetNode {
2883public:
2884 /// Capture whether this is a normal array (e.g. int X[4])
2885 /// an array with a static size (e.g. int X[static 4]), or an array
2886 /// with a star size (e.g. int X[*]).
2887 /// 'static' is only allowed on function parameters.
2888 enum ArraySizeModifier {
2889 Normal, Static, Star
2890 };
2891
2892private:
2893 /// The element type of the array.
2894 QualType ElementType;
2895
2896protected:
2897 friend class ASTContext; // ASTContext creates these.
2898
2899 ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
2900 unsigned tq, const Expr *sz = nullptr);
2901
2902public:
2903 QualType getElementType() const { return ElementType; }
2904
2905 ArraySizeModifier getSizeModifier() const {
2906 return ArraySizeModifier(ArrayTypeBits.SizeModifier);
2907 }
2908
2909 Qualifiers getIndexTypeQualifiers() const {
2910 return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
2911 }
2912
2913 unsigned getIndexTypeCVRQualifiers() const {
2914 return ArrayTypeBits.IndexTypeQuals;
2915 }
2916
2917 static bool classof(const Type *T) {
2918 return T->getTypeClass() == ConstantArray ||
2919 T->getTypeClass() == VariableArray ||
2920 T->getTypeClass() == IncompleteArray ||
2921 T->getTypeClass() == DependentSizedArray;
2922 }
2923};
2924
2925/// Represents the canonical version of C arrays with a specified constant size.
2926/// For example, the canonical type for 'int A[4 + 4*100]' is a
2927/// ConstantArrayType where the element type is 'int' and the size is 404.
2928class ConstantArrayType final
2929 : public ArrayType,
2930 private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
2931 friend class ASTContext; // ASTContext creates these.
2932 friend TrailingObjects;
2933
2934 llvm::APInt Size; // Allows us to unique the type.
2935
2936 ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
2937 const Expr *sz, ArraySizeModifier sm, unsigned tq)
2938 : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
2939 ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
2940 if (ConstantArrayTypeBits.HasStoredSizeExpr) {
2941 assert(!can.isNull() && "canonical constant array should not have size")(static_cast<void> (0));
2942 *getTrailingObjects<const Expr*>() = sz;
2943 }
2944 }
2945
2946 unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
2947 return ConstantArrayTypeBits.HasStoredSizeExpr;
2948 }
2949
2950public:
2951 const llvm::APInt &getSize() const { return Size; }
2952 const Expr *getSizeExpr() const {
2953 return ConstantArrayTypeBits.HasStoredSizeExpr
2954 ? *getTrailingObjects<const Expr *>()
2955 : nullptr;
2956 }
2957 bool isSugared() const { return false; }
2958 QualType desugar() const { return QualType(this, 0); }
2959
2960 /// Determine the number of bits required to address a member of
2961 // an array with the given element type and number of elements.
2962 static unsigned getNumAddressingBits(const ASTContext &Context,
2963 QualType ElementType,
2964 const llvm::APInt &NumElements);
2965
2966 /// Determine the maximum number of active bits that an array's size
2967 /// can require, which limits the maximum size of the array.
2968 static unsigned getMaxSizeBits(const ASTContext &Context);
2969
2970 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
2971 Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
2972 getSizeModifier(), getIndexTypeCVRQualifiers());
2973 }
2974
2975 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
2976 QualType ET, const llvm::APInt &ArraySize,
2977 const Expr *SizeExpr, ArraySizeModifier SizeMod,
2978 unsigned TypeQuals);
2979
2980 static bool classof(const Type *T) {
2981 return T->getTypeClass() == ConstantArray;
2982 }
2983};
2984
2985/// Represents a C array with an unspecified size. For example 'int A[]' has
2986/// an IncompleteArrayType where the element type is 'int' and the size is
2987/// unspecified.
2988class IncompleteArrayType : public ArrayType {
2989 friend class ASTContext; // ASTContext creates these.
2990
2991 IncompleteArrayType(QualType et, QualType can,
2992 ArraySizeModifier sm, unsigned tq)
2993 : ArrayType(IncompleteArray, et, can, sm, tq) {}
2994
2995public:
2996 friend class StmtIteratorBase;
2997
2998 bool isSugared() const { return false; }
2999 QualType desugar() const { return QualType(this, 0); }
3000
3001 static bool classof(const Type *T) {
3002 return T->getTypeClass() == IncompleteArray;
3003 }
3004
3005 void Profile(llvm::FoldingSetNodeID &ID) {
3006 Profile(ID, getElementType(), getSizeModifier(),
3007 getIndexTypeCVRQualifiers());
3008 }
3009
3010 static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
3011 ArraySizeModifier SizeMod, unsigned TypeQuals) {
3012 ID.AddPointer(ET.getAsOpaquePtr());
3013 ID.AddInteger(SizeMod);
3014 ID.AddInteger(TypeQuals);
3015 }
3016};
3017
3018/// Represents a C array with a specified size that is not an
3019/// integer-constant-expression. For example, 'int s[x+foo()]'.
3020/// Since the size expression is an arbitrary expression, we store it as such.
3021///
3022/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3023/// should not be: two lexically equivalent variable array types could mean
3024/// different things, for example, these variables do not have the same type
3025/// dynamically:
3026///
3027/// void foo(int x) {
3028/// int Y[x];
3029/// ++x;
3030/// int Z[x];
3031/// }
3032class VariableArrayType : public ArrayType {
3033 friend class ASTContext; // ASTContext creates these.
3034
3035 /// An assignment-expression. VLA's are only permitted within
3036 /// a function block.
3037 Stmt *SizeExpr;
3038
3039 /// The range spanned by the left and right array brackets.
3040 SourceRange Brackets;
3041
3042 VariableArrayType(QualType et, QualType can, Expr *e,
3043 ArraySizeModifier sm, unsigned tq,
3044 SourceRange brackets)
3045 : ArrayType(VariableArray, et, can, sm, tq, e),
3046 SizeExpr((Stmt*) e), Brackets(brackets) {}
3047
3048public:
3049 friend class StmtIteratorBase;
3050
3051 Expr *getSizeExpr() const {
3052 // We use C-style casts instead of cast<> here because we do not wish
3053 // to have a dependency of Type.h on Stmt.h/Expr.h.
3054 return (Expr*) SizeExpr;
3055 }
3056
3057 SourceRange getBracketsRange() const { return Brackets; }
3058 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3059 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3060
3061 bool isSugared() const { return false; }
3062 QualType desugar() const { return QualType(this, 0); }
3063
3064 static bool classof(const Type *T) {
3065 return T->getTypeClass() == VariableArray;
3066 }
3067
3068 void Profile(llvm::FoldingSetNodeID &ID) {
3069 llvm_unreachable("Cannot unique VariableArrayTypes.")__builtin_unreachable();
3070 }
3071};
3072
3073/// Represents an array type in C++ whose size is a value-dependent expression.
3074///
3075/// For example:
3076/// \code
3077/// template<typename T, int Size>
3078/// class array {
3079/// T data[Size];
3080/// };
3081/// \endcode
3082///
3083/// For these types, we won't actually know what the array bound is
3084/// until template instantiation occurs, at which point this will
3085/// become either a ConstantArrayType or a VariableArrayType.
3086class DependentSizedArrayType : public ArrayType {
3087 friend class ASTContext; // ASTContext creates these.
3088
3089 const ASTContext &Context;
3090
3091 /// An assignment expression that will instantiate to the
3092 /// size of the array.
3093 ///
3094 /// The expression itself might be null, in which case the array
3095 /// type will have its size deduced from an initializer.
3096 Stmt *SizeExpr;
3097
3098 /// The range spanned by the left and right array brackets.
3099 SourceRange Brackets;
3100
3101 DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
3102 Expr *e, ArraySizeModifier sm, unsigned tq,
3103 SourceRange brackets);
3104
3105public:
3106 friend class StmtIteratorBase;
3107
3108 Expr *getSizeExpr() const {
3109 // We use C-style casts instead of cast<> here because we do not wish
3110 // to have a dependency of Type.h on Stmt.h/Expr.h.
3111 return (Expr*) SizeExpr;
3112 }
3113
3114 SourceRange getBracketsRange() const { return Brackets; }
3115 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3116 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3117
3118 bool isSugared() const { return false; }
3119 QualType desugar() const { return QualType(this, 0); }
3120
3121 static bool classof(const Type *T) {
3122 return T->getTypeClass() == DependentSizedArray;
3123 }
3124
3125 void Profile(llvm::FoldingSetNodeID &ID) {
3126 Profile(ID, Context, getElementType(),
3127 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3128 }
3129
3130 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3131 QualType ET, ArraySizeModifier SizeMod,
3132 unsigned TypeQuals, Expr *E);
3133};
3134
3135/// Represents an extended address space qualifier where the input address space
3136/// value is dependent. Non-dependent address spaces are not represented with a
3137/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3138///
3139/// For example:
3140/// \code
3141/// template<typename T, int AddrSpace>
3142/// class AddressSpace {
3143/// typedef T __attribute__((address_space(AddrSpace))) type;
3144/// }
3145/// \endcode
3146class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
3147 friend class ASTContext;
3148
3149 const ASTContext &Context;
3150 Expr *AddrSpaceExpr;
3151 QualType PointeeType;
3152 SourceLocation loc;
3153
3154 DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
3155 QualType can, Expr *AddrSpaceExpr,
3156 SourceLocation loc);
3157
3158public:
3159 Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
3160 QualType getPointeeType() const { return PointeeType; }
3161 SourceLocation getAttributeLoc() const { return loc; }
3162
3163 bool isSugared() const { return false; }
3164 QualType desugar() const { return QualType(this, 0); }
3165
3166 static bool classof(const Type *T) {
3167 return T->getTypeClass() == DependentAddressSpace;
3168 }
3169
3170 void Profile(llvm::FoldingSetNodeID &ID) {
3171 Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
3172 }
3173
3174 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3175 QualType PointeeType, Expr *AddrSpaceExpr);
3176};
3177
3178/// Represents an extended vector type where either the type or size is
3179/// dependent.
3180///
3181/// For example:
3182/// \code
3183/// template<typename T, int Size>
3184/// class vector {
3185/// typedef T __attribute__((ext_vector_type(Size))) type;
3186/// }
3187/// \endcode
3188class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
3189 friend class ASTContext;
3190
3191 const ASTContext &Context;
3192 Expr *SizeExpr;
3193
3194 /// The element type of the array.
3195 QualType ElementType;
3196
3197 SourceLocation loc;
3198
3199 DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
3200 QualType can, Expr *SizeExpr, SourceLocation loc);
3201
3202public:
3203 Expr *getSizeExpr() const { return SizeExpr; }
3204 QualType getElementType() const { return ElementType; }
3205 SourceLocation getAttributeLoc() const { return loc; }
3206
3207 bool isSugared() const { return false; }
3208 QualType desugar() const { return QualType(this, 0); }
3209
3210 static bool classof(const Type *T) {
3211 return T->getTypeClass() == DependentSizedExtVector;
3212 }
3213
3214 void Profile(llvm::FoldingSetNodeID &ID) {
3215 Profile(ID, Context, getElementType(), getSizeExpr());
3216 }
3217
3218 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3219 QualType ElementType, Expr *SizeExpr);
3220};
3221
3222
3223/// Represents a GCC generic vector type. This type is created using
3224/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3225/// bytes; or from an Altivec __vector or vector declaration.
3226/// Since the constructor takes the number of vector elements, the
3227/// client is responsible for converting the size into the number of elements.
3228class VectorType : public Type, public llvm::FoldingSetNode {
3229public:
3230 enum VectorKind {
3231 /// not a target-specific vector type
3232 GenericVector,
3233
3234 /// is AltiVec vector
3235 AltiVecVector,
3236
3237 /// is AltiVec 'vector Pixel'
3238 AltiVecPixel,
3239
3240 /// is AltiVec 'vector bool ...'
3241 AltiVecBool,
3242
3243 /// is ARM Neon vector
3244 NeonVector,
3245
3246 /// is ARM Neon polynomial vector
3247 NeonPolyVector,
3248
3249 /// is AArch64 SVE fixed-length data vector
3250 SveFixedLengthDataVector,
3251
3252 /// is AArch64 SVE fixed-length predicate vector
3253 SveFixedLengthPredicateVector
3254 };
3255
3256protected:
3257 friend class ASTContext; // ASTContext creates these.
3258
3259 /// The element type of the vector.
3260 QualType ElementType;
3261
3262 VectorType(QualType vecType, unsigned nElements, QualType canonType,
3263 VectorKind vecKind);
3264
3265 VectorType(TypeClass tc, QualType vecType, unsigned nElements,
3266 QualType canonType, VectorKind vecKind);
3267
3268public:
3269 QualType getElementType() const { return ElementType; }
3270 unsigned getNumElements() const { return VectorTypeBits.NumElements; }
3271
3272 bool isSugared() const { return false; }
3273 QualType desugar() const { return QualType(this, 0); }
3274
3275 VectorKind getVectorKind() const {
3276 return VectorKind(VectorTypeBits.VecKind);
3277 }
3278
3279 void Profile(llvm::FoldingSetNodeID &ID) {
3280 Profile(ID, getElementType(), getNumElements(),
3281 getTypeClass(), getVectorKind());
3282 }
3283
3284 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3285 unsigned NumElements, TypeClass TypeClass,
3286 VectorKind VecKind) {
3287 ID.AddPointer(ElementType.getAsOpaquePtr());
3288 ID.AddInteger(NumElements);
3289 ID.AddInteger(TypeClass);
3290 ID.AddInteger(VecKind);
3291 }
3292
3293 static bool classof(const Type *T) {
3294 return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
3295 }
3296};
3297
3298/// Represents a vector type where either the type or size is dependent.
3299////
3300/// For example:
3301/// \code
3302/// template<typename T, int Size>
3303/// class vector {
3304/// typedef T __attribute__((vector_size(Size))) type;
3305/// }
3306/// \endcode
3307class DependentVectorType : public Type, public llvm::FoldingSetNode {
3308 friend class ASTContext;
3309
3310 const ASTContext &Context;
3311 QualType ElementType;
3312 Expr *SizeExpr;
3313 SourceLocation Loc;
3314
3315 DependentVectorType(const ASTContext &Context, QualType ElementType,
3316 QualType CanonType, Expr *SizeExpr,
3317 SourceLocation Loc, VectorType::VectorKind vecKind);
3318
3319public:
3320 Expr *getSizeExpr() const { return SizeExpr; }
3321 QualType getElementType() const { return ElementType; }
3322 SourceLocation getAttributeLoc() const { return Loc; }
3323 VectorType::VectorKind getVectorKind() const {
3324 return VectorType::VectorKind(VectorTypeBits.VecKind);
3325 }
3326
3327 bool isSugared() const { return false; }
3328 QualType desugar() const { return QualType(this, 0); }
3329
3330 static bool classof(const Type *T) {
3331 return T->getTypeClass() == DependentVector;
3332 }
3333
3334 void Profile(llvm::FoldingSetNodeID &ID) {
3335 Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
3336 }
3337
3338 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3339 QualType ElementType, const Expr *SizeExpr,
3340 VectorType::VectorKind VecKind);
3341};
3342
3343/// ExtVectorType - Extended vector type. This type is created using
3344/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3345/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3346/// class enables syntactic extensions, like Vector Components for accessing
3347/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3348/// Shading Language).
3349class ExtVectorType : public VectorType {
3350 friend class ASTContext; // ASTContext creates these.
3351
3352 ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
3353 : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}
3354
3355public:
3356 static int getPointAccessorIdx(char c) {
3357 switch (c) {
3358 default: return -1;
3359 case 'x': case 'r': return 0;
3360 case 'y': case 'g': return 1;
3361 case 'z': case 'b': return 2;
3362 case 'w': case 'a': return 3;
3363 }
3364 }
3365
3366 static int getNumericAccessorIdx(char c) {
3367 switch (c) {
3368 default: return -1;
3369 case '0': return 0;
3370 case '1': return 1;
3371 case '2': return 2;
3372 case '3': return 3;
3373 case '4': return 4;
3374 case '5': return 5;
3375 case '6': return 6;
3376 case '7': return 7;
3377 case '8': return 8;
3378 case '9': return 9;
3379 case 'A':
3380 case 'a': return 10;
3381 case 'B':
3382 case 'b': return 11;
3383 case 'C':
3384 case 'c': return 12;
3385 case 'D':
3386 case 'd': return 13;
3387 case 'E':
3388 case 'e': return 14;
3389 case 'F':
3390 case 'f': return 15;
3391 }
3392 }
3393
3394 static int getAccessorIdx(char c, bool isNumericAccessor) {
3395 if (isNumericAccessor)
3396 return getNumericAccessorIdx(c);
3397 else
3398 return getPointAccessorIdx(c);
3399 }
3400
3401 bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
3402 if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
3403 return unsigned(idx-1) < getNumElements();
3404 return false;
3405 }
3406
3407 bool isSugared() const { return false; }
3408 QualType desugar() const { return QualType(this, 0); }
3409
3410 static bool classof(const Type *T) {
3411 return T->getTypeClass() == ExtVector;
3412 }
3413};
3414
3415/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3416/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3417/// number of rows and "columns" specifies the number of columns.
3418class MatrixType : public Type, public llvm::FoldingSetNode {
3419protected:
3420 friend class ASTContext;
3421
3422 /// The element type of the matrix.
3423 QualType ElementType;
3424
3425 MatrixType(QualType ElementTy, QualType CanonElementTy);
3426
3427 MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
3428 const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);
3429
3430public:
3431 /// Returns type of the elements being stored in the matrix
3432 QualType getElementType() const { return ElementType; }
3433
3434 /// Valid elements types are the following:
3435 /// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
3436 /// and _Bool
3437 /// * the standard floating types float or double
3438 /// * a half-precision floating point type, if one is supported on the target
3439 static bool isValidElementType(QualType T) {
3440 return T->isDependentType() ||
3441 (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
3442 }
3443
3444 bool isSugared() const { return false; }
3445 QualType desugar() const { return QualType(this, 0); }
3446
3447 static bool classof(const Type *T) {
3448 return T->getTypeClass() == ConstantMatrix ||
3449 T->getTypeClass() == DependentSizedMatrix;
3450 }
3451};
3452
3453/// Represents a concrete matrix type with constant number of rows and columns
3454class ConstantMatrixType final : public MatrixType {
3455protected:
3456 friend class ASTContext;
3457
3458 /// Number of rows and columns.
3459 unsigned NumRows;
3460 unsigned NumColumns;
3461
3462 static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
3463
3464 ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
3465 unsigned NColumns, QualType CanonElementType);
3466
3467 ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
3468 unsigned NColumns, QualType CanonElementType);
3469
3470public:
3471 /// Returns the number of rows in the matrix.
3472 unsigned getNumRows() const { return NumRows; }
3473
3474 /// Returns the number of columns in the matrix.
3475 unsigned getNumColumns() const { return NumColumns; }
3476
3477 /// Returns the number of elements required to embed the matrix into a vector.
3478 unsigned getNumElementsFlattened() const {
3479 return getNumRows() * getNumColumns();
3480 }
3481
3482 /// Returns true if \p NumElements is a valid matrix dimension.
3483 static constexpr bool isDimensionValid(size_t NumElements) {
3484 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
3485 }
3486
3487 /// Returns the maximum number of elements per dimension.
3488 static constexpr unsigned getMaxElementsPerDimension() {
3489 return MaxElementsPerDimension;
3490 }
3491
3492 void Profile(llvm::FoldingSetNodeID &ID) {
3493 Profile(ID, getElementType(), getNumRows(), getNumColumns(),
3494 getTypeClass());
3495 }
3496
3497 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3498 unsigned NumRows, unsigned NumColumns,
3499 TypeClass TypeClass) {
3500 ID.AddPointer(ElementType.getAsOpaquePtr());
3501 ID.AddInteger(NumRows);
3502 ID.AddInteger(NumColumns);
3503 ID.AddInteger(TypeClass);
3504 }
3505
3506 static bool classof(const Type *T) {
3507 return T->getTypeClass() == ConstantMatrix;
3508 }
3509};
3510
3511/// Represents a matrix type where the type and the number of rows and columns
3512/// is dependent on a template.
3513class DependentSizedMatrixType final : public MatrixType {
3514 friend class ASTContext;
3515
3516 const ASTContext &Context;
3517 Expr *RowExpr;
3518 Expr *ColumnExpr;
3519
3520 SourceLocation loc;
3521
3522 DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
3523 QualType CanonicalType, Expr *RowExpr,
3524 Expr *ColumnExpr, SourceLocation loc);
3525
3526public:
3527 Expr *getRowExpr() const { return RowExpr; }
3528 Expr *getColumnExpr() const { return ColumnExpr; }
3529 SourceLocation getAttributeLoc() const { return loc; }
3530
3531 static bool classof(const Type *T) {
3532 return T->getTypeClass() == DependentSizedMatrix;
3533 }
3534
3535 void Profile(llvm::FoldingSetNodeID &ID) {
3536 Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
3537 }
3538
3539 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3540 QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3541};
3542
3543/// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base
3544/// class of FunctionNoProtoType and FunctionProtoType.
3545class FunctionType : public Type {
3546 // The type returned by the function.
3547 QualType ResultType;
3548
3549public:
3550 /// Interesting information about a specific parameter that can't simply
3551 /// be reflected in parameter's type. This is only used by FunctionProtoType
3552 /// but is in FunctionType to make this class available during the
3553 /// specification of the bases of FunctionProtoType.
3554 ///
3555 /// It makes sense to model language features this way when there's some
3556 /// sort of parameter-specific override (such as an attribute) that
3557 /// affects how the function is called. For example, the ARC ns_consumed
3558 /// attribute changes whether a parameter is passed at +0 (the default)
3559 /// or +1 (ns_consumed). This must be reflected in the function type,
3560 /// but isn't really a change to the parameter type.
3561 ///
3562 /// One serious disadvantage of modelling language features this way is
3563 /// that they generally do not work with language features that attempt
3564 /// to destructure types. For example, template argument deduction will
3565 /// not be able to match a parameter declared as
3566 /// T (*)(U)
3567 /// against an argument of type
3568 /// void (*)(__attribute__((ns_consumed)) id)
3569 /// because the substitution of T=void, U=id into the former will
3570 /// not produce the latter.
3571 class ExtParameterInfo {
3572 enum {
3573 ABIMask = 0x0F,
3574 IsConsumed = 0x10,
3575 HasPassObjSize = 0x20,
3576 IsNoEscape = 0x40,
3577 };
3578 unsigned char Data = 0;
3579
3580 public:
3581 ExtParameterInfo() = default;
3582
3583 /// Return the ABI treatment of this parameter.
3584 ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
3585 ExtParameterInfo withABI(ParameterABI kind) const {
3586 ExtParameterInfo copy = *this;
3587 copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
3588 return copy;
3589 }
3590
3591 /// Is this parameter considered "consumed" by Objective-C ARC?
3592 /// Consumed parameters must have retainable object type.
3593 bool isConsumed() const { return (Data & IsConsumed); }
3594 ExtParameterInfo withIsConsumed(bool consumed) const {
3595 ExtParameterInfo copy = *this;
3596 if (consumed)
3597 copy.Data |= IsConsumed;
3598 else
3599 copy.Data &= ~IsConsumed;
3600 return copy;
3601 }
3602
3603 bool hasPassObjectSize() const { return Data & HasPassObjSize; }
3604 ExtParameterInfo withHasPassObjectSize() const {
3605 ExtParameterInfo Copy = *this;
3606 Copy.Data |= HasPassObjSize;
3607 return Copy;
3608 }
3609
3610 bool isNoEscape() const { return Data & IsNoEscape; }
3611 ExtParameterInfo withIsNoEscape(bool NoEscape) const {
3612 ExtParameterInfo Copy = *this;
3613 if (NoEscape)
3614 Copy.Data |= IsNoEscape;
3615 else
3616 Copy.Data &= ~IsNoEscape;
3617 return Copy;
3618 }
3619
3620 unsigned char getOpaqueValue() const { return Data; }
3621 static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
3622 ExtParameterInfo result;
3623 result.Data = data;
3624 return result;
3625 }
3626
3627 friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3628 return lhs.Data == rhs.Data;
3629 }
3630
3631 friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3632 return lhs.Data != rhs.Data;
3633 }
3634 };
3635
3636 /// A class which abstracts out some details necessary for
3637 /// making a call.
3638 ///
3639 /// It is not actually used directly for storing this information in
3640 /// a FunctionType, although FunctionType does currently use the
3641 /// same bit-pattern.
3642 ///
3643 // If you add a field (say Foo), other than the obvious places (both,
3644 // constructors, compile failures), what you need to update is
3645 // * Operator==
3646 // * getFoo
3647 // * withFoo
3648 // * functionType. Add Foo, getFoo.
3649 // * ASTContext::getFooType
3650 // * ASTContext::mergeFunctionTypes
3651 // * FunctionNoProtoType::Profile
3652 // * FunctionProtoType::Profile
3653 // * TypePrinter::PrintFunctionProto
3654 // * AST read and write
3655 // * Codegen
3656 class ExtInfo {
3657 friend class FunctionType;
3658
3659 // Feel free to rearrange or add bits, but if you go over 16, you'll need to
3660 // adjust the Bits field below, and if you add bits, you'll need to adjust
3661 // Type::FunctionTypeBitfields::ExtInfo as well.
3662
3663 // | CC |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
3664 // |0 .. 4| 5 | 6 | 7 |8 .. 10| 11 | 12 |
3665 //
3666 // regparm is either 0 (no regparm attribute) or the regparm value+1.
3667 enum { CallConvMask = 0x1F };
3668 enum { NoReturnMask = 0x20 };
3669 enum { ProducesResultMask = 0x40 };
3670 enum { NoCallerSavedRegsMask = 0x80 };
3671 enum {
3672 RegParmMask = 0x700,
3673 RegParmOffset = 8
3674 };
3675 enum { NoCfCheckMask = 0x800 };
3676 enum { CmseNSCallMask = 0x1000 };
3677 uint16_t Bits = CC_C;
3678
3679 ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
3680
3681 public:
3682 // Constructor with no defaults. Use this when you know that you
3683 // have all the elements (when reading an AST file for example).
3684 ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
3685 bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
3686 bool cmseNSCall) {
3687 assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(static_cast<void> (0));
3688 Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
3689 (producesResult ? ProducesResultMask : 0) |
3690 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
3691 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
3692 (NoCfCheck ? NoCfCheckMask : 0) |
3693 (cmseNSCall ? CmseNSCallMask : 0);
3694 }
3695
3696 // Constructor with all defaults. Use when for example creating a
3697 // function known to use defaults.
3698 ExtInfo() = default;
3699
3700 // Constructor with just the calling convention, which is an important part
3701 // of the canonical type.
3702 ExtInfo(CallingConv CC) : Bits(CC) {}
3703
3704 bool getNoReturn() const { return Bits & NoReturnMask; }
3705 bool getProducesResult() const { return Bits & ProducesResultMask; }
3706 bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
3707 bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
3708 bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
3709 bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
3710
3711 unsigned getRegParm() const {
3712 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
3713 if (RegParm > 0)
3714 --RegParm;
3715 return RegParm;
3716 }
3717
3718 CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
3719
3720 bool operator==(ExtInfo Other) const {
3721 return Bits == Other.Bits;
3722 }
3723 bool operator!=(ExtInfo Other) const {
3724 return Bits != Other.Bits;
3725 }
3726
3727 // Note that we don't have setters. That is by design, use
3728 // the following with methods instead of mutating these objects.
3729
3730 ExtInfo withNoReturn(bool noReturn) const {
3731 if (noReturn)
3732 return ExtInfo(Bits | NoReturnMask);
3733 else
3734 return ExtInfo(Bits & ~NoReturnMask);
3735 }
3736
3737 ExtInfo withProducesResult(bool producesResult) const {
3738 if (producesResult)
3739 return ExtInfo(Bits | ProducesResultMask);
3740 else
3741 return ExtInfo(Bits & ~ProducesResultMask);
3742 }
3743
3744 ExtInfo withCmseNSCall(bool cmseNSCall) const {
3745 if (cmseNSCall)
3746 return ExtInfo(Bits | CmseNSCallMask);
3747 else
3748 return ExtInfo(Bits & ~CmseNSCallMask);
3749 }
3750
3751 ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
3752 if (noCallerSavedRegs)
3753 return ExtInfo(Bits | NoCallerSavedRegsMask);
3754 else
3755 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
3756 }
3757
3758 ExtInfo withNoCfCheck(bool noCfCheck) const {
3759 if (noCfCheck)
3760 return ExtInfo(Bits | NoCfCheckMask);
3761 else
3762 return ExtInfo(Bits & ~NoCfCheckMask);
3763 }
3764
3765 ExtInfo withRegParm(unsigned RegParm) const {
3766 assert(RegParm < 7 && "Invalid regparm value")(static_cast<void> (0));
3767 return ExtInfo((Bits & ~RegParmMask) |
3768 ((RegParm + 1) << RegParmOffset));
3769 }
3770
3771 ExtInfo withCallingConv(CallingConv cc) const {
3772 return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
3773 }
3774
3775 void Profile(llvm::FoldingSetNodeID &ID) const {
3776 ID.AddInteger(Bits);
3777 }
3778 };
3779
3780 /// A simple holder for a QualType representing a type in an
3781 /// exception specification. Unfortunately needed by FunctionProtoType
3782 /// because TrailingObjects cannot handle repeated types.
3783 struct ExceptionType { QualType Type; };
3784
3785 /// A simple holder for various uncommon bits which do not fit in
3786 /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
3787 /// alignment of subsequent objects in TrailingObjects. You must update
3788 /// hasExtraBitfields in FunctionProtoType after adding extra data here.
3789 struct alignas(void *) FunctionTypeExtraBitfields {
3790 /// The number of types in the exception specification.
3791 /// A whole unsigned is not needed here and according to
3792 /// [implimits] 8 bits would be enough here.
3793 unsigned NumExceptionType;
3794 };
3795
3796protected:
3797 FunctionType(TypeClass tc, QualType res, QualType Canonical,
3798 TypeDependence Dependence, ExtInfo Info)
3799 : Type(tc, Canonical, Dependence), ResultType(res) {
3800 FunctionTypeBits.ExtInfo = Info.Bits;
3801 }
3802
3803 Qualifiers getFastTypeQuals() const {
3804 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
3805 }
3806
3807public:
3808 QualType getReturnType() const { return ResultType; }
3809
3810 bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
3811 unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
3812
3813 /// Determine whether this function type includes the GNU noreturn
3814 /// attribute. The C++11 [[noreturn]] attribute does not affect the function
3815 /// type.
3816 bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
3817
3818 bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
3819 CallingConv getCallConv() const { return getExtInfo().getCC(); }
3820 ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
3821
3822 static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
3823 "Const, volatile and restrict are assumed to be a subset of "
3824 "the fast qualifiers.");
3825
3826 bool isConst() const { return getFastTypeQuals().hasConst(); }
3827 bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
3828 bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }
3829
3830 /// Determine the type of an expression that calls a function of
3831 /// this type.
3832 QualType getCallResultType(const ASTContext &Context) const {
3833 return getReturnType().getNonLValueExprType(Context);
3834 }
3835
3836 static StringRef getNameForCallConv(CallingConv CC);
3837
3838 static bool classof(const Type *T) {
3839 return T->getTypeClass() == FunctionNoProto ||
3840 T->getTypeClass() == FunctionProto;
3841 }
3842};
3843
3844/// Represents a K&R-style 'int foo()' function, which has
3845/// no information available about its arguments.
3846class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
3847 friend class ASTContext; // ASTContext creates these.
3848
3849 FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
3850 : FunctionType(FunctionNoProto, Result, Canonical,
3851 Result->getDependence() &
3852 ~(TypeDependence::DependentInstantiation |
3853 TypeDependence::UnexpandedPack),
3854 Info) {}
3855
3856public:
3857 // No additional state past what FunctionType provides.
3858
3859 bool isSugared() const { return false; }
3860 QualType desugar() const { return QualType(this, 0); }
3861
3862 void Profile(llvm::FoldingSetNodeID &ID) {
3863 Profile(ID, getReturnType(), getExtInfo());
3864 }
3865
3866 static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
3867 ExtInfo Info) {
3868 Info.Profile(ID);
3869 ID.AddPointer(ResultType.getAsOpaquePtr());
3870 }
3871
3872 static bool classof(const Type *T) {
3873 return T->getTypeClass() == FunctionNoProto;
3874 }
3875};
3876
3877/// Represents a prototype with parameter type info, e.g.
3878/// 'int foo(int)' or 'int foo(void)'. 'void' is represented as having no
3879/// parameters, not as having a single void parameter. Such a type can have
3880/// an exception specification, but this specification is not part of the
3881/// canonical type. FunctionProtoType has several trailing objects, some of
3882/// which optional. For more information about the trailing objects see
3883/// the first comment inside FunctionProtoType.
3884class FunctionProtoType final
3885 : public FunctionType,
3886 public llvm::FoldingSetNode,
3887 private llvm::TrailingObjects<
3888 FunctionProtoType, QualType, SourceLocation,
3889 FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
3890 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
3891 friend class ASTContext; // ASTContext creates these.
3892 friend TrailingObjects;
3893
3894 // FunctionProtoType is followed by several trailing objects, some of
3895 // which optional. They are in order:
3896 //
3897 // * An array of getNumParams() QualType holding the parameter types.
3898 // Always present. Note that for the vast majority of FunctionProtoType,
3899 // these will be the only trailing objects.
3900 //
3901 // * Optionally if the function is variadic, the SourceLocation of the
3902 // ellipsis.
3903 //
3904 // * Optionally if some extra data is stored in FunctionTypeExtraBitfields
3905 // (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
3906 // a single FunctionTypeExtraBitfields. Present if and only if
3907 // hasExtraBitfields() is true.
3908 //
3909 // * Optionally exactly one of:
3910 // * an array of getNumExceptions() ExceptionType,
3911 // * a single Expr *,
3912 // * a pair of FunctionDecl *,
3913 // * a single FunctionDecl *
3914 // used to store information about the various types of exception
3915 // specification. See getExceptionSpecSize for the details.
3916 //
3917 // * Optionally an array of getNumParams() ExtParameterInfo holding
3918 // an ExtParameterInfo for each of the parameters. Present if and
3919 // only if hasExtParameterInfos() is true.
3920 //
3921 // * Optionally a Qualifiers object to represent extra qualifiers that can't
3922 // be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
3923 // if hasExtQualifiers() is true.
3924 //
3925 // The optional FunctionTypeExtraBitfields has to be before the data
3926 // related to the exception specification since it contains the number
3927 // of exception types.
3928 //
3929 // We put the ExtParameterInfos last. If all were equal, it would make
3930 // more sense to put these before the exception specification, because
3931 // it's much easier to skip past them compared to the elaborate switch
3932 // required to skip the exception specification. However, all is not
3933 // equal; ExtParameterInfos are used to model very uncommon features,
3934 // and it's better not to burden the more common paths.
3935
3936public:
3937 /// Holds information about the various types of exception specification.
3938 /// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
3939 /// used to group together the various bits of information about the
3940 /// exception specification.
3941 struct ExceptionSpecInfo {
3942 /// The kind of exception specification this is.
3943 ExceptionSpecificationType Type = EST_None;
3944
3945 /// Explicitly-specified list of exception types.
3946 ArrayRef<QualType> Exceptions;
3947
3948 /// Noexcept expression, if this is a computed noexcept specification.
3949 Expr *NoexceptExpr = nullptr;
3950
3951 /// The function whose exception specification this is, for
3952 /// EST_Unevaluated and EST_Uninstantiated.
3953 FunctionDecl *SourceDecl = nullptr;
3954
3955 /// The function template whose exception specification this is instantiated
3956 /// from, for EST_Uninstantiated.
3957 FunctionDecl *SourceTemplate = nullptr;
3958
3959 ExceptionSpecInfo() = default;
3960
3961 ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
3962 };
3963
3964 /// Extra information about a function prototype. ExtProtoInfo is not
3965 /// stored as such in FunctionProtoType but is used to group together
3966 /// the various bits of extra information about a function prototype.
3967 struct ExtProtoInfo {
3968 FunctionType::ExtInfo ExtInfo;
3969 bool Variadic : 1;
3970 bool HasTrailingReturn : 1;
3971 Qualifiers TypeQuals;
3972 RefQualifierKind RefQualifier = RQ_None;
3973 ExceptionSpecInfo ExceptionSpec;
3974 const ExtParameterInfo *ExtParameterInfos = nullptr;
3975 SourceLocation EllipsisLoc;
3976
3977 ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}
3978
3979 ExtProtoInfo(CallingConv CC)
3980 : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}
3981
3982 ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
3983 ExtProtoInfo Result(*this);
3984 Result.ExceptionSpec = ESI;
3985 return Result;
3986 }
3987 };
3988
3989private:
3990 unsigned numTrailingObjects(OverloadToken<QualType>) const {
3991 return getNumParams();
3992 }
3993
3994 unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
3995 return isVariadic();
3996 }
3997
3998 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
3999 return hasExtraBitfields();
4000 }
4001
4002 unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
4003 return getExceptionSpecSize().NumExceptionType;
4004 }
4005
4006 unsigned numTrailingObjects(OverloadToken<Expr *>) const {
4007 return getExceptionSpecSize().NumExprPtr;
4008 }
4009
4010 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
4011 return getExceptionSpecSize().NumFunctionDeclPtr;
4012 }
4013
4014 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
4015 return hasExtParameterInfos() ? getNumParams() : 0;
4016 }
4017
4018 /// Determine whether there are any argument types that
4019 /// contain an unexpanded parameter pack.
4020 static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
4021 unsigned numArgs) {
4022 for (unsigned Idx = 0; Idx < numArgs; ++Idx)
4023 if (ArgArray[Idx]->containsUnexpandedParameterPack())
4024 return true;
4025
4026 return false;
4027 }
4028
4029 FunctionProtoType(QualType result, ArrayRef<QualType> params,
4030 QualType canonical, const ExtProtoInfo &epi);
4031
4032 /// This struct is returned by getExceptionSpecSize and is used to
4033 /// translate an ExceptionSpecificationType to the number and kind
4034 /// of trailing objects related to the exception specification.
4035 struct ExceptionSpecSizeHolder {
4036 unsigned NumExceptionType;
4037 unsigned NumExprPtr;
4038 unsigned NumFunctionDeclPtr;
4039 };
4040
4041 /// Return the number and kind of trailing objects
4042 /// related to the exception specification.
4043 static ExceptionSpecSizeHolder
4044 getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
4045 switch (EST) {
4046 case EST_None:
4047 case EST_DynamicNone:
4048 case EST_MSAny:
4049 case EST_BasicNoexcept:
4050 case EST_Unparsed:
4051 case EST_NoThrow:
4052 return {0, 0, 0};
4053
4054 case EST_Dynamic:
4055 return {NumExceptions, 0, 0};
4056
4057 case EST_DependentNoexcept:
4058 case EST_NoexceptFalse:
4059 case EST_NoexceptTrue:
4060 return {0, 1, 0};
4061
4062 case EST_Uninstantiated:
4063 return {0, 0, 2};
4064
4065 case EST_Unevaluated:
4066 return {0, 0, 1};
4067 }
4068 llvm_unreachable("bad exception specification kind")__builtin_unreachable();
4069 }
4070
4071 /// Return the number and kind of trailing objects
4072 /// related to the exception specification.
4073 ExceptionSpecSizeHolder getExceptionSpecSize() const {
4074 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
4075 }
4076
4077 /// Whether the trailing FunctionTypeExtraBitfields is present.
4078 static bool hasExtraBitfields(ExceptionSpecificationType EST) {
4079 // If the exception spec type is EST_Dynamic then we have > 0 exception
4080 // types and the exact number is stored in FunctionTypeExtraBitfields.
4081 return EST == EST_Dynamic;
4082 }
4083
4084 /// Whether the trailing FunctionTypeExtraBitfields is present.
4085 bool hasExtraBitfields() const {
4086 return hasExtraBitfields(getExceptionSpecType());
4087 }
4088
4089 bool hasExtQualifiers() const {
4090 return FunctionTypeBits.HasExtQuals;
4091 }
4092
4093public:
4094 unsigned getNumParams() const { return FunctionTypeBits.NumParams; }
4095
4096 QualType getParamType(unsigned i) const {
4097 assert(i < getNumParams() && "invalid parameter index")(static_cast<void> (0));
4098 return param_type_begin()[i];
4099 }
4100
4101 ArrayRef<QualType> getParamTypes() const {
4102 return llvm::makeArrayRef(param_type_begin(), param_type_end());
4103 }
4104
4105 ExtProtoInfo getExtProtoInfo() const {
4106 ExtProtoInfo EPI;
4107 EPI.ExtInfo = getExtInfo();
4108 EPI.Variadic = isVariadic();
4109 EPI.EllipsisLoc = getEllipsisLoc();
4110 EPI.HasTrailingReturn = hasTrailingReturn();
4111 EPI.ExceptionSpec = getExceptionSpecInfo();
4112 EPI.TypeQuals = getMethodQuals();
4113 EPI.RefQualifier = getRefQualifier();
4114 EPI.ExtParameterInfos = getExtParameterInfosOrNull();
4115 return EPI;
4116 }
4117
4118 /// Get the kind of exception specification on this function.
4119 ExceptionSpecificationType getExceptionSpecType() const {
4120 return static_cast<ExceptionSpecificationType>(
4121 FunctionTypeBits.ExceptionSpecType);
4122 }
4123
4124 /// Return whether this function has any kind of exception spec.
4125 bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }
4126
4127 /// Return whether this function has a dynamic (throw) exception spec.
4128 bool hasDynamicExceptionSpec() const {
4129 return isDynamicExceptionSpec(getExceptionSpecType());
4130 }
4131
4132 /// Return whether this function has a noexcept exception spec.
4133 bool hasNoexceptExceptionSpec() const {
4134 return isNoexceptExceptionSpec(getExceptionSpecType());
4135 }
4136
4137 /// Return whether this function has a dependent exception spec.
4138 bool hasDependentExceptionSpec() const;
4139
4140 /// Return whether this function has an instantiation-dependent exception
4141 /// spec.
4142 bool hasInstantiationDependentExceptionSpec() const;
4143
4144 /// Return all the available information about this type's exception spec.
4145 ExceptionSpecInfo getExceptionSpecInfo() const {
4146 ExceptionSpecInfo Result;
4147 Result.Type = getExceptionSpecType();
4148 if (Result.Type == EST_Dynamic) {
4149 Result.Exceptions = exceptions();
4150 } else if (isComputedNoexcept(Result.Type)) {
4151 Result.NoexceptExpr = getNoexceptExpr();
4152 } else if (Result.Type == EST_Uninstantiated) {
4153 Result.SourceDecl = getExceptionSpecDecl();
4154 Result.SourceTemplate = getExceptionSpecTemplate();
4155 } else if (Result.Type == EST_Unevaluated) {
4156 Result.SourceDecl = getExceptionSpecDecl();
4157 }
4158 return Result;
4159 }
4160
4161 /// Return the number of types in the exception specification.
4162 unsigned getNumExceptions() const {
4163 return getExceptionSpecType() == EST_Dynamic
4164 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4165 ->NumExceptionType
4166 : 0;
4167 }
4168
4169 /// Return the ith exception type, where 0 <= i < getNumExceptions().
4170 QualType getExceptionType(unsigned i) const {
4171 assert(i < getNumExceptions() && "Invalid exception number!")(static_cast<void> (0));
4172 return exception_begin()[i];
4173 }
4174
4175 /// Return the expression inside noexcept(expression), or a null pointer
4176 /// if there is none (because the exception spec is not of this form).
4177 Expr *getNoexceptExpr() const {
4178 if (!isComputedNoexcept(getExceptionSpecType()))
4179 return nullptr;
4180 return *getTrailingObjects<Expr *>();
4181 }
4182
4183 /// If this function type has an exception specification which hasn't
4184 /// been determined yet (either because it has not been evaluated or because
4185 /// it has not been instantiated), this is the function whose exception
4186 /// specification is represented by this type.
4187 FunctionDecl *getExceptionSpecDecl() const {
4188 if (getExceptionSpecType() != EST_Uninstantiated &&
4189 getExceptionSpecType() != EST_Unevaluated)
4190 return nullptr;
4191 return getTrailingObjects<FunctionDecl *>()[0];
4192 }
4193
4194 /// If this function type has an uninstantiated exception
4195 /// specification, this is the function whose exception specification
4196 /// should be instantiated to find the exception specification for
4197 /// this type.
4198 FunctionDecl *getExceptionSpecTemplate() const {
4199 if (getExceptionSpecType() != EST_Uninstantiated)
4200 return nullptr;
4201 return getTrailingObjects<FunctionDecl *>()[1];
4202 }
4203
4204 /// Determine whether this function type has a non-throwing exception
4205 /// specification.
4206 CanThrowResult canThrow() const;
4207
4208 /// Determine whether this function type has a non-throwing exception
4209 /// specification. If this depends on template arguments, returns
4210 /// \c ResultIfDependent.
4211 bool isNothrow(bool ResultIfDependent = false) const {
4212 return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
4213 }
4214
4215 /// Whether this function prototype is variadic.
4216 bool isVariadic() const { return FunctionTypeBits.Variadic; }
4217
4218 SourceLocation getEllipsisLoc() const {
4219 return isVariadic() ? *getTrailingObjects<SourceLocation>()
4220 : SourceLocation();
4221 }
4222
4223 /// Determines whether this function prototype contains a
4224 /// parameter pack at the end.
4225 ///
4226 /// A function template whose last parameter is a parameter pack can be
4227 /// called with an arbitrary number of arguments, much like a variadic
4228 /// function.
4229 bool isTemplateVariadic() const;
4230
4231 /// Whether this function prototype has a trailing return type.
4232 bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }
4233
4234 Qualifiers getMethodQuals() const {
4235 if (hasExtQualifiers())
4236 return *getTrailingObjects<Qualifiers>();
4237 else
4238 return getFastTypeQuals();
4239 }
4240
4241 /// Retrieve the ref-qualifier associated with this function type.
4242 RefQualifierKind getRefQualifier() const {
4243 return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
4244 }
4245
4246 using param_type_iterator = const QualType *;
4247 using param_type_range = llvm::iterator_range<param_type_iterator>;
4248
4249 param_type_range param_types() const {
4250 return param_type_range(param_type_begin(), param_type_end());
4251 }
4252
4253 param_type_iterator param_type_begin() const {
4254 return getTrailingObjects<QualType>();
4255 }
4256
4257 param_type_iterator param_type_end() const {
4258 return param_type_begin() + getNumParams();
4259 }
4260
4261 using exception_iterator = const QualType *;
4262
4263 ArrayRef<QualType> exceptions() const {
4264 return llvm::makeArrayRef(exception_begin(), exception_end());
4265 }
4266
4267 exception_iterator exception_begin() const {
4268 return reinterpret_cast<exception_iterator>(
4269 getTrailingObjects<ExceptionType>());
4270 }
4271
4272 exception_iterator exception_end() const {
4273 return exception_begin() + getNumExceptions();
4274 }
4275
4276 /// Is there any interesting extra information for any of the parameters
4277 /// of this function type?
4278 bool hasExtParameterInfos() const {
4279 return FunctionTypeBits.HasExtParameterInfos;
4280 }
4281
4282 ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
4283 assert(hasExtParameterInfos())(static_cast<void> (0));
4284 return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
4285 getNumParams());
4286 }
4287
4288 /// Return a pointer to the beginning of the array of extra parameter
4289 /// information, if present, or else null if none of the parameters
4290 /// carry it. This is equivalent to getExtProtoInfo().ExtParameterInfos.
4291 const ExtParameterInfo *getExtParameterInfosOrNull() const {
4292 if (!hasExtParameterInfos())
4293 return nullptr;
4294 return getTrailingObjects<ExtParameterInfo>();
4295 }
4296
4297 ExtParameterInfo getExtParameterInfo(unsigned I) const {
4298 assert(I < getNumParams() && "parameter index out of range")(static_cast<void> (0));
4299 if (hasExtParameterInfos())
4300 return getTrailingObjects<ExtParameterInfo>()[I];
4301 return ExtParameterInfo();
4302 }
4303
4304 ParameterABI getParameterABI(unsigned I) const {
4305 assert(I < getNumParams() && "parameter index out of range")(static_cast<void> (0));
4306 if (hasExtParameterInfos())
4307 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
4308 return ParameterABI::Ordinary;
4309 }
4310
4311 bool isParamConsumed(unsigned I) const {
4312 assert(I < getNumParams() && "parameter index out of range")(static_cast<void> (0));
4313 if (hasExtParameterInfos())
4314 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
4315 return false;
4316 }
4317
4318 bool isSugared() const { return false; }
4319 QualType desugar() const { return QualType(this, 0); }
4320
4321 void printExceptionSpecification(raw_ostream &OS,
4322 const PrintingPolicy &Policy) const;
4323
4324 static bool classof(const Type *T) {
4325 return T->getTypeClass() == FunctionProto;
4326 }
4327
4328 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
4329 static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
4330 param_type_iterator ArgTys, unsigned NumArgs,
4331 const ExtProtoInfo &EPI, const ASTContext &Context,
4332 bool Canonical);
4333};
4334
4335/// Represents the dependent type named by a dependently-scoped
4336/// typename using declaration, e.g.
4337/// using typename Base<T>::foo;
4338///
4339/// Template instantiation turns these into the underlying type.
4340class UnresolvedUsingType : public Type {
4341 friend class ASTContext; // ASTContext creates these.
4342
4343 UnresolvedUsingTypenameDecl *Decl;
4344
4345 UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
4346 : Type(UnresolvedUsing, QualType(),
4347 TypeDependence::DependentInstantiation),
4348 Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}
4349
4350public:
4351 UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }
4352
4353 bool isSugared() const { return false; }
4354 QualType desugar() const { return QualType(this, 0); }
4355
4356 static bool classof(const Type *T) {
4357 return T->getTypeClass() == UnresolvedUsing;
4358 }
4359
4360 void Profile(llvm::FoldingSetNodeID &ID) {
4361 return Profile(ID, Decl);
4362 }
4363
4364 static void Profile(llvm::FoldingSetNodeID &ID,
4365 UnresolvedUsingTypenameDecl *D) {
4366 ID.AddPointer(D);
4367 }
4368};
4369
4370class TypedefType : public Type {
4371 TypedefNameDecl *Decl;
4372
4373private:
4374 friend class ASTContext; // ASTContext creates these.
4375
4376 TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
4377 QualType can);
4378
4379public:
4380 TypedefNameDecl *getDecl() const { return Decl; }
4381
4382 bool isSugared() const { return true; }
4383 QualType desugar() const;
4384
4385 static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4386};
4387
4388/// Sugar type that represents a type that was qualified by a qualifier written
4389/// as a macro invocation.
4390class MacroQualifiedType : public Type {
4391 friend class ASTContext; // ASTContext creates these.
4392
4393 QualType UnderlyingTy;
4394 const IdentifierInfo *MacroII;
4395
4396 MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
4397 const IdentifierInfo *MacroII)
4398 : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
4399 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
4400 assert(isa<AttributedType>(UnderlyingTy) &&(static_cast<void> (0))
4401 "Expected a macro qualified type to only wrap attributed types.")(static_cast<void> (0));
4402 }
4403
4404public:
4405 const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
4406 QualType getUnderlyingType() const { return UnderlyingTy; }
4407
4408 /// Return this attributed type's modified type with no qualifiers attached to
4409 /// it.
4410 QualType getModifiedType() const;
4411
4412 bool isSugared() const { return true; }
4413 QualType desugar() const;
4414
4415 static bool classof(const Type *T) {
4416 return T->getTypeClass() == MacroQualified;
4417 }
4418};
4419
4420/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4421class TypeOfExprType : public Type {
4422 Expr *TOExpr;
4423
4424protected:
4425 friend class ASTContext; // ASTContext creates these.
4426
4427 TypeOfExprType(Expr *E, QualType can = QualType());
4428
4429public:
4430 Expr *getUnderlyingExpr() const { return TOExpr; }
4431
4432 /// Remove a single level of sugar.
4433 QualType desugar() const;
4434
4435 /// Returns whether this type directly provides sugar.
4436 bool isSugared() const;
4437
4438 static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4439};
4440
4441/// Internal representation of canonical, dependent
4442/// `typeof(expr)` types.
4443///
4444/// This class is used internally by the ASTContext to manage
4445/// canonical, dependent types, only. Clients will only see instances
4446/// of this class via TypeOfExprType nodes.
4447class DependentTypeOfExprType
4448 : public TypeOfExprType, public llvm::FoldingSetNode {
4449 const ASTContext &Context;
4450
4451public:
4452 DependentTypeOfExprType(const ASTContext &Context, Expr *E)
4453 : TypeOfExprType(E), Context(Context) {}
4454
4455 void Profile(llvm::FoldingSetNodeID &ID) {
4456 Profile(ID, Context, getUnderlyingExpr());
4457 }
4458
4459 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4460 Expr *E);
4461};
4462
4463/// Represents `typeof(type)`, a GCC extension.
4464class TypeOfType : public Type {
4465 friend class ASTContext; // ASTContext creates these.
4466
4467 QualType TOType;
4468
4469 TypeOfType(QualType T, QualType can)
4470 : Type(TypeOf, can, T->getDependence()), TOType(T) {
4471 assert(!isa<TypedefType>(can) && "Invalid canonical type")(static_cast<void> (0));
4472 }
4473
4474public:
4475 QualType getUnderlyingType() const { return TOType; }
4476
4477 /// Remove a single level of sugar.
4478 QualType desugar() const { return getUnderlyingType(); }
4479
4480 /// Returns whether this type directly provides sugar.
4481 bool isSugared() const { return true; }
4482
4483 static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4484};
4485
4486/// Represents the type `decltype(expr)` (C++11).
4487class DecltypeType : public Type {
4488 Expr *E;
4489 QualType UnderlyingType;
4490
4491protected:
4492 friend class ASTContext; // ASTContext creates these.
4493
4494 DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
4495
4496public:
4497 Expr *getUnderlyingExpr() const { return E; }
4498 QualType getUnderlyingType() const { return UnderlyingType; }
4499
4500 /// Remove a single level of sugar.
4501 QualType desugar() const;
4502
4503 /// Returns whether this type directly provides sugar.
4504 bool isSugared() const;
4505
4506 static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4507};
4508
4509/// Internal representation of canonical, dependent
4510/// decltype(expr) types.
4511///
4512/// This class is used internally by the ASTContext to manage
4513/// canonical, dependent types, only. Clients will only see instances
4514/// of this class via DecltypeType nodes.
4515class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
4516 const ASTContext &Context;
4517
4518public:
4519 DependentDecltypeType(const ASTContext &Context, Expr *E);
4520
4521 void Profile(llvm::FoldingSetNodeID &ID) {
4522 Profile(ID, Context, getUnderlyingExpr());
4523 }
4524
4525 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4526 Expr *E);
4527};
4528
4529/// A unary type transform, which is a type constructed from another.
4530class UnaryTransformType : public Type {
4531public:
4532 enum UTTKind {
4533 EnumUnderlyingType
4534 };
4535
4536private:
4537 /// The untransformed type.
4538 QualType BaseType;
4539
4540 /// The transformed type if not dependent, otherwise the same as BaseType.
4541 QualType UnderlyingType;
4542
4543 UTTKind UKind;
4544
4545protected:
4546 friend class ASTContext;
4547
4548 UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
4549 QualType CanonicalTy);
4550
4551public:
4552 bool isSugared() const { return !isDependentType(); }
4553 QualType desugar() const { return UnderlyingType; }
4554
4555 QualType getUnderlyingType() const { return UnderlyingType; }
4556 QualType getBaseType() const { return BaseType; }
4557
4558 UTTKind getUTTKind() const { return UKind; }
4559
4560 static bool classof(const Type *T) {
4561 return T->getTypeClass() == UnaryTransform;
4562 }
4563};
4564
4565/// Internal representation of canonical, dependent
4566/// __underlying_type(type) types.
4567///
4568/// This class is used internally by the ASTContext to manage
4569/// canonical, dependent types, only. Clients will only see instances
4570/// of this class via UnaryTransformType nodes.
4571class DependentUnaryTransformType : public UnaryTransformType,
4572 public llvm::FoldingSetNode {
4573public:
4574 DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
4575 UTTKind UKind);
4576
4577 void Profile(llvm::FoldingSetNodeID &ID) {
4578 Profile(ID, getBaseType(), getUTTKind());
4579 }
4580
4581 static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
4582 UTTKind UKind) {
4583 ID.AddPointer(BaseType.getAsOpaquePtr());
4584 ID.AddInteger((unsigned)UKind);
4585 }
4586};
4587
4588class TagType : public Type {
4589 friend class ASTReader;
4590 template <class T> friend class serialization::AbstractTypeReader;
4591
4592 /// Stores the TagDecl associated with this type. The decl may point to any
4593 /// TagDecl that declares the entity.
4594 TagDecl *decl;
4595
4596protected:
4597 TagType(TypeClass TC, const TagDecl *D, QualType can);
4598
4599public:
4600 TagDecl *getDecl() const;
4601
4602 /// Determines whether this type is in the process of being defined.
4603 bool isBeingDefined() const;
4604
4605 static bool classof(const Type *T) {
4606 return T->getTypeClass() == Enum || T->getTypeClass() == Record;
4607 }
4608};
4609
4610/// A helper class that allows the use of isa/cast/dyncast
4611/// to detect TagType objects of structs/unions/classes.
4612class RecordType : public TagType {
4613protected:
4614 friend class ASTContext; // ASTContext creates these.
4615
4616 explicit RecordType(const RecordDecl *D)
4617 : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4618 explicit RecordType(TypeClass TC, RecordDecl *D)
4619 : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4620
4621public:
4622 RecordDecl *getDecl() const {
4623 return reinterpret_cast<RecordDecl*>(TagType::getDecl());
4624 }
4625
4626 /// Recursively check all fields in the record for const-ness. If any field
4627 /// is declared const, return true. Otherwise, return false.
4628 bool hasConstFields() const;
4629
4630 bool isSugared() const { return false; }
4631 QualType desugar() const { return QualType(this, 0); }
4632
4633 static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4634};
4635
4636/// A helper class that allows the use of isa/cast/dyncast
4637/// to detect TagType objects of enums.
4638class EnumType : public TagType {
4639 friend class ASTContext; // ASTContext creates these.
4640
4641 explicit EnumType(const EnumDecl *D)
4642 : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4643
4644public:
4645 EnumDecl *getDecl() const {
4646 return reinterpret_cast<EnumDecl*>(TagType::getDecl());
4647 }
4648
4649 bool isSugared() const { return false; }
4650 QualType desugar() const { return QualType(this, 0); }
4651
4652 static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4653};
4654
4655/// An attributed type is a type to which a type attribute has been applied.
4656///
4657/// The "modified type" is the fully-sugared type to which the attributed
4658/// type was applied; generally it is not canonically equivalent to the
4659/// attributed type. The "equivalent type" is the minimally-desugared type
4660/// which the type is canonically equivalent to.
4661///
4662/// For example, in the following attributed type:
4663/// int32_t __attribute__((vector_size(16)))
4664/// - the modified type is the TypedefType for int32_t
4665/// - the equivalent type is VectorType(16, int32_t)
4666/// - the canonical type is VectorType(16, int)
4667class AttributedType : public Type, public llvm::FoldingSetNode {
4668public:
4669 using Kind = attr::Kind;
4670
4671private:
4672 friend class ASTContext; // ASTContext creates these
4673
4674 QualType ModifiedType;
4675 QualType EquivalentType;
4676
4677 AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
4678 QualType equivalent)
4679 : Type(Attributed, canon, equivalent->getDependence()),
4680 ModifiedType(modified), EquivalentType(equivalent) {
4681 AttributedTypeBits.AttrKind = attrKind;
4682 }
4683
4684public:
4685 Kind getAttrKind() const {
4686 return static_cast<Kind>(AttributedTypeBits.AttrKind);
4687 }
4688
4689 QualType getModifiedType() const { return ModifiedType; }
4690 QualType getEquivalentType() const { return EquivalentType; }
4691
4692 bool isSugared() const { return true; }
4693 QualType desugar() const { return getEquivalentType(); }
4694
4695 /// Does this attribute behave like a type qualifier?
4696 ///
4697 /// A type qualifier adjusts a type to provide specialized rules for
4698 /// a specific object, like the standard const and volatile qualifiers.
4699 /// This includes attributes controlling things like nullability,
4700 /// address spaces, and ARC ownership. The value of the object is still
4701 /// largely described by the modified type.
4702 ///
4703 /// In contrast, many type attributes "rewrite" their modified type to
4704 /// produce a fundamentally different type, not necessarily related in any
4705 /// formalizable way to the original type. For example, calling convention
4706 /// and vector attributes are not simple type qualifiers.
4707 ///
4708 /// Type qualifiers are often, but not always, reflected in the canonical
4709 /// type.
4710 bool isQualifier() const;
4711
4712 bool isMSTypeSpec() const;
4713
4714 bool isCallingConv() const;
4715
4716 llvm::Optional<NullabilityKind> getImmediateNullability() const;
4717
4718 /// Retrieve the attribute kind corresponding to the given
4719 /// nullability kind.
4720 static Kind getNullabilityAttrKind(NullabilityKind kind) {
4721 switch (kind) {
4722 case NullabilityKind::NonNull:
4723 return attr::TypeNonNull;
4724
4725 case NullabilityKind::Nullable:
4726 return attr::TypeNullable;
4727
4728 case NullabilityKind::NullableResult:
4729 return attr::TypeNullableResult;
4730
4731 case NullabilityKind::Unspecified:
4732 return attr::TypeNullUnspecified;
4733 }
4734 llvm_unreachable("Unknown nullability kind.")__builtin_unreachable();
4735 }
4736
4737 /// Strip off the top-level nullability annotation on the given
4738 /// type, if it's there.
4739 ///
4740 /// \param T The type to strip. If the type is exactly an
4741 /// AttributedType specifying nullability (without looking through
4742 /// type sugar), the nullability is returned and this type changed
4743 /// to the underlying modified type.
4744 ///
4745 /// \returns the top-level nullability, if present.
4746 static Optional<NullabilityKind> stripOuterNullability(QualType &T);
4747
4748 void Profile(llvm::FoldingSetNodeID &ID) {
4749 Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
4750 }
4751
4752 static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
4753 QualType modified, QualType equivalent) {
4754 ID.AddInteger(attrKind);
4755 ID.AddPointer(modified.getAsOpaquePtr());
4756 ID.AddPointer(equivalent.getAsOpaquePtr());
4757 }
4758
4759 static bool classof(const Type *T) {
4760 return T->getTypeClass() == Attributed;
4761 }
4762};
4763
4764class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4765 friend class ASTContext; // ASTContext creates these
4766
4767 // Helper data collector for canonical types.
4768 struct CanonicalTTPTInfo {
4769 unsigned Depth : 15;
4770 unsigned ParameterPack : 1;
4771 unsigned Index : 16;
4772 };
4773
4774 union {
4775 // Info for the canonical type.
4776 CanonicalTTPTInfo CanTTPTInfo;
4777
4778 // Info for the non-canonical type.
4779 TemplateTypeParmDecl *TTPDecl;
4780 };
4781
4782 /// Build a non-canonical type.
4783 TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
4784 : Type(TemplateTypeParm, Canon,
4785 TypeDependence::DependentInstantiation |
4786 (Canon->getDependence() & TypeDependence::UnexpandedPack)),
4787 TTPDecl(TTPDecl) {}
4788
4789 /// Build the canonical type.
4790 TemplateTypeParmType(unsigned D, unsigned I, bool PP)
4791 : Type(TemplateTypeParm, QualType(this, 0),
4792 TypeDependence::DependentInstantiation |
4793 (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
4794 CanTTPTInfo.Depth = D;
4795 CanTTPTInfo.Index = I;
4796 CanTTPTInfo.ParameterPack = PP;
4797 }
4798
4799 const CanonicalTTPTInfo& getCanTTPTInfo() const {
4800 QualType Can = getCanonicalTypeInternal();
4801 return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
4802 }
4803
4804public:
4805 unsigned getDepth() const { return getCanTTPTInfo().Depth; }
4806 unsigned getIndex() const { return getCanTTPTInfo().Index; }
4807 bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }
4808
4809 TemplateTypeParmDecl *getDecl() const {
4810 return isCanonicalUnqualified() ? nullptr : TTPDecl;
4811 }
4812
4813 IdentifierInfo *getIdentifier() const;
4814
4815 bool isSugared() const { return false; }
4816 QualType desugar() const { return QualType(this, 0); }
4817
4818 void Profile(llvm::FoldingSetNodeID &ID) {
4819 Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
4820 }
4821
4822 static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
4823 unsigned Index, bool ParameterPack,
4824 TemplateTypeParmDecl *TTPDecl) {
4825 ID.AddInteger(Depth);
4826 ID.AddInteger(Index);
4827 ID.AddBoolean(ParameterPack);
4828 ID.AddPointer(TTPDecl);
4829 }
4830
4831 static bool classof(const Type *T) {
4832 return T->getTypeClass() == TemplateTypeParm;
4833 }
4834};
4835
4836/// Represents the result of substituting a type for a template
4837/// type parameter.
4838///
4839/// Within an instantiated template, all template type parameters have
4840/// been replaced with these. They are used solely to record that a
4841/// type was originally written as a template type parameter;
4842/// therefore they are never canonical.
4843class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4844 friend class ASTContext;
4845
4846 // The original type parameter.
4847 const TemplateTypeParmType *Replaced;
4848
4849 SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
4850 : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
4851 Replaced(Param) {}
4852
4853public:
4854 /// Gets the template parameter that was substituted for.
4855 const TemplateTypeParmType *getReplacedParameter() const {
4856 return Replaced;
4857 }
4858
4859 /// Gets the type that was substituted for the template
4860 /// parameter.
4861 QualType getReplacementType() const {
4862 return getCanonicalTypeInternal();
4863 }
4864
4865 bool isSugared() const { return true; }
4866 QualType desugar() const { return getReplacementType(); }
4867
4868 void Profile(llvm::FoldingSetNodeID &ID) {
4869 Profile(ID, getReplacedParameter(), getReplacementType());
4870 }
4871
4872 static void Profile(llvm::FoldingSetNodeID &ID,
4873 const TemplateTypeParmType *Replaced,
4874 QualType Replacement) {
4875 ID.AddPointer(Replaced);
4876 ID.AddPointer(Replacement.getAsOpaquePtr());
4877 }
4878
4879 static bool classof(const Type *T) {
4880 return T->getTypeClass() == SubstTemplateTypeParm;
4881 }
4882};
4883
4884/// Represents the result of substituting a set of types for a template
4885/// type parameter pack.
4886///
4887/// When a pack expansion in the source code contains multiple parameter packs
4888/// and those parameter packs correspond to different levels of template
4889/// parameter lists, this type node is used to represent a template type
4890/// parameter pack from an outer level, which has already had its argument pack
4891/// substituted but that still lives within a pack expansion that itself
4892/// could not be instantiated. When actually performing a substitution into
4893/// that pack expansion (e.g., when all template parameters have corresponding
4894/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4895/// at the current pack substitution index.
4896class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
4897 friend class ASTContext;
4898
4899 /// The original type parameter.
4900 const TemplateTypeParmType *Replaced;
4901
4902 /// A pointer to the set of template arguments that this
4903 /// parameter pack is instantiated with.
4904 const TemplateArgument *Arguments;
4905
4906 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
4907 QualType Canon,
4908 const TemplateArgument &ArgPack);
4909
4910public:
4911 IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }
4912
4913 /// Gets the template parameter that was substituted for.
4914 const TemplateTypeParmType *getReplacedParameter() const {
4915 return Replaced;
4916 }
4917
4918 unsigned getNumArgs() const {
4919 return SubstTemplateTypeParmPackTypeBits.NumArgs;
4920 }
4921
4922 bool isSugared() const { return false; }
4923 QualType desugar() const { return QualType(this, 0); }
4924
4925 TemplateArgument getArgumentPack() const;
4926
4927 void Profile(llvm::FoldingSetNodeID &ID);
4928 static void Profile(llvm::FoldingSetNodeID &ID,
4929 const TemplateTypeParmType *Replaced,
4930 const TemplateArgument &ArgPack);
4931
4932 static bool classof(const Type *T) {
4933 return T->getTypeClass() == SubstTemplateTypeParmPack;
4934 }
4935};
4936
4937/// Common base class for placeholders for types that get replaced by
4938/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4939/// class template types, and constrained type names.
4940///
4941/// These types are usually a placeholder for a deduced type. However, before
4942/// the initializer is attached, or (usually) if the initializer is
4943/// type-dependent, there is no deduced type and the type is canonical. In
4944/// the latter case, it is also a dependent type.
4945class DeducedType : public Type {
4946protected:
4947 DeducedType(TypeClass TC, QualType DeducedAsType,
4948 TypeDependence ExtraDependence)
4949 : Type(TC,
4950 // FIXME: Retain the sugared deduced type?
4951 DeducedAsType.isNull() ? QualType(this, 0)
4952 : DeducedAsType.getCanonicalType(),
4953 ExtraDependence | (DeducedAsType.isNull()
4954 ? TypeDependence::None
4955 : DeducedAsType->getDependence() &
4956 ~TypeDependence::VariablyModified)) {}
4957
4958public:
4959 bool isSugared() const { return !isCanonicalUnqualified(); }
4960 QualType desugar() const { return getCanonicalTypeInternal(); }
4961
4962 /// Get the type deduced for this placeholder type, or null if it's
4963 /// either not been deduced or was deduced to a dependent type.
4964 QualType getDeducedType() const {
4965 return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
4966 }
4967 bool isDeduced() const {
4968 return !isCanonicalUnqualified() || isDependentType();
4969 }
4970
4971 static bool classof(const Type *T) {
4972 return T->getTypeClass() == Auto ||
4973 T->getTypeClass() == DeducedTemplateSpecialization;
4974 }
4975};
4976
4977/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4978/// by a type-constraint.
4979class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
4980 friend class ASTContext; // ASTContext creates these
4981
4982 ConceptDecl *TypeConstraintConcept;
4983
4984 AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
4985 TypeDependence ExtraDependence, ConceptDecl *CD,
4986 ArrayRef<TemplateArgument> TypeConstraintArgs);
4987
4988 const TemplateArgument *getArgBuffer() const {
4989 return reinterpret_cast<const TemplateArgument*>(this+1);
4990 }
4991
4992 TemplateArgument *getArgBuffer() {
4993 return reinterpret_cast<TemplateArgument*>(this+1);
4994 }
4995
4996public:
4997 /// Retrieve the template arguments.
4998 const TemplateArgument *getArgs() const {
4999 return getArgBuffer();
5000 }
5001
5002 /// Retrieve the number of template arguments.
5003 unsigned getNumArgs() const {
5004 return AutoTypeBits.NumArgs;
5005 }
5006
5007 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5008
5009 ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
5010 return {getArgs(), getNumArgs()};
5011 }
5012
5013 ConceptDecl *getTypeConstraintConcept() const {
5014 return TypeConstraintConcept;
5015 }
5016
5017 bool isConstrained() const {
5018 return TypeConstraintConcept != nullptr;
5019 }
5020
5021 bool isDecltypeAuto() const {
5022 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
5023 }
5024
5025 AutoTypeKeyword getKeyword() const {
5026 return (AutoTypeKeyword)AutoTypeBits.Keyword;
5027 }
5028
5029 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5030 Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
5031 getTypeConstraintConcept(), getTypeConstraintArguments());
5032 }
5033
5034 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
5035 QualType Deduced, AutoTypeKeyword Keyword,
5036 bool IsDependent, ConceptDecl *CD,
5037 ArrayRef<TemplateArgument> Arguments);
5038
5039 static bool classof(const Type *T) {
5040 return T->getTypeClass() == Auto;
5041 }
5042};
5043
5044/// Represents a C++17 deduced template specialization type.
5045class DeducedTemplateSpecializationType : public DeducedType,
5046 public llvm::FoldingSetNode {
5047 friend class ASTContext; // ASTContext creates these
5048
5049 /// The name of the template whose arguments will be deduced.
5050 TemplateName Template;
5051
5052 DeducedTemplateSpecializationType(TemplateName Template,
5053 QualType DeducedAsType,
5054 bool IsDeducedAsDependent)
5055 : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
5056 toTypeDependence(Template.getDependence()) |
5057 (IsDeducedAsDependent
5058 ? TypeDependence::DependentInstantiation
5059 : TypeDependence::None)),
5060 Template(Template) {}
5061
5062public:
5063 /// Retrieve the name of the template that we are deducing.
5064 TemplateName getTemplateName() const { return Template;}
5065
5066 void Profile(llvm::FoldingSetNodeID &ID) {
5067 Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
5068 }
5069
5070 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
5071 QualType Deduced, bool IsDependent) {
5072 Template.Profile(ID);
5073 ID.AddPointer(Deduced.getAsOpaquePtr());
5074 ID.AddBoolean(IsDependent);
5075 }
5076
5077 static bool classof(const Type *T) {
5078 return T->getTypeClass() == DeducedTemplateSpecialization;
5079 }
5080};
5081
5082/// Represents a type template specialization; the template
5083/// must be a class template, a type alias template, or a template
5084/// template parameter. A template which cannot be resolved to one of
5085/// these, e.g. because it is written with a dependent scope
5086/// specifier, is instead represented as a
5087/// @c DependentTemplateSpecializationType.
5088///
5089/// A non-dependent template specialization type is always "sugar",
5090/// typically for a \c RecordType. For example, a class template
5091/// specialization type of \c vector<int> will refer to a tag type for
5092/// the instantiation \c std::vector<int, std::allocator<int>>
5093///
5094/// Template specializations are dependent if either the template or
5095/// any of the template arguments are dependent, in which case the
5096/// type may also be canonical.
5097///
5098/// Instances of this type are allocated with a trailing array of
5099/// TemplateArguments, followed by a QualType representing the
5100/// non-canonical aliased type when the template is a type alias
5101/// template.
5102class alignas(8) TemplateSpecializationType
5103 : public Type,
5104 public llvm::FoldingSetNode {
5105 friend class ASTContext; // ASTContext creates these
5106
5107 /// The name of the template being specialized. This is
5108 /// either a TemplateName::Template (in which case it is a
5109 /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
5110 /// TypeAliasTemplateDecl*), a
5111 /// TemplateName::SubstTemplateTemplateParmPack, or a
5112 /// TemplateName::SubstTemplateTemplateParm (in which case the
5113 /// replacement must, recursively, be one of these).
5114 TemplateName Template;
5115
5116 TemplateSpecializationType(TemplateName T,
5117 ArrayRef<TemplateArgument> Args,
5118 QualType Canon,
5119 QualType Aliased);
5120
5121public:
5122 /// Determine whether any of the given template arguments are dependent.
5123 ///
5124 /// The converted arguments should be supplied when known; whether an
5125 /// argument is dependent can depend on the conversions performed on it
5126 /// (for example, a 'const int' passed as a template argument might be
5127 /// dependent if the parameter is a reference but non-dependent if the
5128 /// parameter is an int).
5129 ///
5130 /// Note that the \p Args parameter is unused: this is intentional, to remind
5131 /// the caller that they need to pass in the converted arguments, not the
5132 /// specified arguments.
5133 static bool
5134 anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
5135 ArrayRef<TemplateArgument> Converted);
5136 static bool
5137 anyDependentTemplateArguments(const TemplateArgumentListInfo &,
5138 ArrayRef<TemplateArgument> Converted);
5139 static bool anyInstantiationDependentTemplateArguments(
5140 ArrayRef<TemplateArgumentLoc> Args);
5141
5142 /// True if this template specialization type matches a current
5143 /// instantiation in the context in which it is found.
5144 bool isCurrentInstantiation() const {
5145 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
5146 }
5147
5148 /// Determine if this template specialization type is for a type alias
5149 /// template that has been substituted.
5150 ///
5151 /// Nearly every template specialization type whose template is an alias
5152 /// template will be substituted. However, this is not the case when
5153 /// the specialization contains a pack expansion but the template alias
5154 /// does not have a corresponding parameter pack, e.g.,
5155 ///
5156 /// \code
5157 /// template<typename T, typename U, typename V> struct S;
5158 /// template<typename T, typename U> using A = S<T, int, U>;
5159 /// template<typename... Ts> struct X {
5160 /// typedef A<Ts...> type; // not a type alias
5161 /// };
5162 /// \endcode
5163 bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
5164
5165 /// Get the aliased type, if this is a specialization of a type alias
5166 /// template.
5167 QualType getAliasedType() const {
5168 assert(isTypeAlias() && "not a type alias template specialization")(static_cast<void> (0));
5169 return *reinterpret_cast<const QualType*>(end());
5170 }
5171
5172 using iterator = const TemplateArgument *;
5173
5174 iterator begin() const { return getArgs(); }
5175 iterator end() const; // defined inline in TemplateBase.h
5176
5177 /// Retrieve the name of the template that we are specializing.
5178 TemplateName getTemplateName() const { return Template; }
5179
5180 /// Retrieve the template arguments.
5181 const TemplateArgument *getArgs() const {
5182 return reinterpret_cast<const TemplateArgument *>(this + 1);
5183 }
5184
5185 /// Retrieve the number of template arguments.
5186 unsigned getNumArgs() const {
5187 return TemplateSpecializationTypeBits.NumArgs;
5188 }
5189
5190 /// Retrieve a specific template argument as a type.
5191 /// \pre \c isArgType(Arg)
5192 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5193
5194 ArrayRef<TemplateArgument> template_arguments() const {
5195 return {getArgs(), getNumArgs()};
5196 }
5197
5198 bool isSugared() const {
5199 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
5200 }
5201
5202 QualType desugar() const {
5203 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
5204 }
5205
5206 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
5207 Profile(ID, Template, template_arguments(), Ctx);
5208 if (isTypeAlias())
5209 getAliasedType().Profile(ID);
5210 }
5211
5212 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
5213 ArrayRef<TemplateArgument> Args,
5214 const ASTContext &Context);
5215
5216 static bool classof(const Type *T) {
5217 return T->getTypeClass() == TemplateSpecialization;
5218 }
5219};
5220
5221/// Print a template argument list, including the '<' and '>'
5222/// enclosing the template arguments.
5223void printTemplateArgumentList(raw_ostream &OS,
5224 ArrayRef<TemplateArgument> Args,
5225 const PrintingPolicy &Policy,
5226 const TemplateParameterList *TPL = nullptr);
5227
5228void printTemplateArgumentList(raw_ostream &OS,
5229 ArrayRef<TemplateArgumentLoc> Args,
5230 const PrintingPolicy &Policy,
5231 const TemplateParameterList *TPL = nullptr);
5232
5233void printTemplateArgumentList(raw_ostream &OS,
5234 const TemplateArgumentListInfo &Args,
5235 const PrintingPolicy &Policy,
5236 const TemplateParameterList *TPL = nullptr);
5237
5238/// The injected class name of a C++ class template or class
5239/// template partial specialization. Used to record that a type was
5240/// spelled with a bare identifier rather than as a template-id; the
5241/// equivalent for non-templated classes is just RecordType.
5242///
5243/// Injected class name types are always dependent. Template
5244/// instantiation turns these into RecordTypes.
5245///
5246/// Injected class name types are always canonical. This works
5247/// because it is impossible to compare an injected class name type
5248/// with the corresponding non-injected template type, for the same
5249/// reason that it is impossible to directly compare template
5250/// parameters from different dependent contexts: injected class name
5251/// types can only occur within the scope of a particular templated
5252/// declaration, and within that scope every template specialization
5253/// will canonicalize to the injected class name (when appropriate
5254/// according to the rules of the language).
5255class InjectedClassNameType : public Type {
5256 friend class ASTContext; // ASTContext creates these.
5257 friend class ASTNodeImporter;
5258 friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
5259 // currently suitable for AST reading, too much
5260 // interdependencies.
5261 template <class T> friend class serialization::AbstractTypeReader;
5262
5263 CXXRecordDecl *Decl;
5264
5265 /// The template specialization which this type represents.
5266 /// For example, in
5267 /// template <class T> class A { ... };
5268 /// this is A<T>, whereas in
5269 /// template <class X, class Y> class A<B<X,Y> > { ... };
5270 /// this is A<B<X,Y> >.
5271 ///
5272 /// It is always unqualified, always a template specialization type,
5273 /// and always dependent.
5274 QualType InjectedType;
5275
5276 InjectedClassNameType(CXXRecordDecl *D, QualType TST)
5277 : Type(InjectedClassName, QualType(),
5278 TypeDependence::DependentInstantiation),
5279 Decl(D), InjectedType(TST) {
5280 assert(isa<TemplateSpecializationType>(TST))(static_cast<void> (0));
5281 assert(!TST.hasQualifiers())(static_cast<void> (0));
5282 assert(TST->isDependentType())(static_cast<void> (0));
5283 }
5284
5285public:
5286 QualType getInjectedSpecializationType() const { return InjectedType; }
5287
5288 const TemplateSpecializationType *getInjectedTST() const {
5289 return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
5290 }
5291
5292 TemplateName getTemplateName() const {
5293 return getInjectedTST()->getTemplateName();
5294 }
5295
5296 CXXRecordDecl *getDecl() const;
5297
5298 bool isSugared() const { return false; }
5299 QualType desugar() const { return QualType(this, 0); }
5300
5301 static bool classof(const Type *T) {
5302 return T->getTypeClass() == InjectedClassName;
5303 }
5304};
5305
5306/// The kind of a tag type.
5307enum TagTypeKind {
5308 /// The "struct" keyword.
5309 TTK_Struct,
5310
5311 /// The "__interface" keyword.
5312 TTK_Interface,
5313
5314 /// The "union" keyword.
5315 TTK_Union,
5316
5317 /// The "class" keyword.
5318 TTK_Class,
5319
5320 /// The "enum" keyword.
5321 TTK_Enum
5322};
5323
5324/// The elaboration keyword that precedes a qualified type name or
5325/// introduces an elaborated-type-specifier.
5326enum ElaboratedTypeKeyword {
5327 /// The "struct" keyword introduces the elaborated-type-specifier.
5328 ETK_Struct,
5329
5330 /// The "__interface" keyword introduces the elaborated-type-specifier.
5331 ETK_Interface,
5332
5333 /// The "union" keyword introduces the elaborated-type-specifier.
5334 ETK_Union,
5335
5336 /// The "class" keyword introduces the elaborated-type-specifier.
5337 ETK_Class,
5338
5339 /// The "enum" keyword introduces the elaborated-type-specifier.
5340 ETK_Enum,
5341
5342 /// The "typename" keyword precedes the qualified type name, e.g.,
5343 /// \c typename T::type.
5344 ETK_Typename,
5345
5346 /// No keyword precedes the qualified type name.
5347 ETK_None
5348};
5349
5350/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5351/// The keyword in stored in the free bits of the base class.
5352/// Also provides a few static helpers for converting and printing
5353/// elaborated type keyword and tag type kind enumerations.
5354class TypeWithKeyword : public Type {
5355protected:
5356 TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
5357 QualType Canonical, TypeDependence Dependence)
5358 : Type(tc, Canonical, Dependence) {
5359 TypeWithKeywordBits.Keyword = Keyword;
5360 }
5361
5362public:
5363 ElaboratedTypeKeyword getKeyword() const {
5364 return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
5365 }
5366
5367 /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
5368 static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);
5369
5370 /// Converts a type specifier (DeclSpec::TST) into a tag type kind.
5371 /// It is an error to provide a type specifier which *isn't* a tag kind here.
5372 static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);
5373
5374 /// Converts a TagTypeKind into an elaborated type keyword.
5375 static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);
5376
5377 /// Converts an elaborated type keyword into a TagTypeKind.
5378 /// It is an error to provide an elaborated type keyword
5379 /// which *isn't* a tag kind here.
5380 static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);
5381
5382 static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);
5383
5384 static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);
5385
5386 static StringRef getTagTypeKindName(TagTypeKind Kind) {
5387 return getKeywordName(getKeywordForTagTypeKind(Kind));
5388 }
5389
5390 class CannotCastToThisType {};
5391 static CannotCastToThisType classof(const Type *);
5392};
5393
5394/// Represents a type that was referred to using an elaborated type
5395/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5396/// or both.
5397///
5398/// This type is used to keep track of a type name as written in the
5399/// source code, including tag keywords and any nested-name-specifiers.
5400/// The type itself is always "sugar", used to express what was written
5401/// in the source code but containing no additional semantic information.
5402class ElaboratedType final
5403 : public TypeWithKeyword,
5404 public llvm::FoldingSetNode,
5405 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
5406 friend class ASTContext; // ASTContext creates these
5407 friend TrailingObjects;
5408
5409 /// The nested name specifier containing the qualifier.
5410 NestedNameSpecifier *NNS;
5411
5412 /// The type that this qualified name refers to.
5413 QualType NamedType;
5414
5415 /// The (re)declaration of this tag type owned by this occurrence is stored
5416 /// as a trailing object if there is one. Use getOwnedTagDecl to obtain
5417 /// it, or obtain a null pointer if there is none.
5418
5419 ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5420 QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
5421 : TypeWithKeyword(Keyword, Elaborated, CanonType,
5422 // Any semantic dependence on the qualifier will have
5423 // been incorporated into NamedType. We still need to
5424 // track syntactic (instantiation / error / pack)
5425 // dependence on the qualifier.
5426 NamedType->getDependence() |
5427 (NNS ? toSyntacticDependence(
5428 toTypeDependence(NNS->getDependence()))
5429 : TypeDependence::None)),
5430 NNS(NNS), NamedType(NamedType) {
5431 ElaboratedTypeBits.HasOwnedTagDecl = false;
5432 if (OwnedTagDecl) {
5433 ElaboratedTypeBits.HasOwnedTagDecl = true;
5434 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
5435 }
5436 assert(!(Keyword == ETK_None && NNS == nullptr) &&(static_cast<void> (0))
5437 "ElaboratedType cannot have elaborated type keyword "(static_cast<void> (0))
5438 "and name qualifier both null.")(static_cast<void> (0));
5439 }
5440
5441public:
5442 /// Retrieve the qualification on this type.
5443 NestedNameSpecifier *getQualifier() const { return NNS; }
5444
5445 /// Retrieve the type named by the qualified-id.
5446 QualType getNamedType() const { return NamedType; }
5447
5448 /// Remove a single level of sugar.
5449 QualType desugar() const { return getNamedType(); }
5450
5451 /// Returns whether this type directly provides sugar.
5452 bool isSugared() const { return true; }
5453
5454 /// Return the (re)declaration of this type owned by this occurrence of this
5455 /// type, or nullptr if there is none.
5456 TagDecl *getOwnedTagDecl() const {
5457 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
5458 : nullptr;
5459 }
5460
5461 void Profile(llvm::FoldingSetNodeID &ID) {
5462 Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
5463 }
5464
5465 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5466 NestedNameSpecifier *NNS, QualType NamedType,
5467 TagDecl *OwnedTagDecl) {
5468 ID.AddInteger(Keyword);
5469 ID.AddPointer(NNS);
5470 NamedType.Profile(ID);
5471 ID.AddPointer(OwnedTagDecl);
5472 }
5473
5474 static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5475};
5476
5477/// Represents a qualified type name for which the type name is
5478/// dependent.
5479///
5480/// DependentNameType represents a class of dependent types that involve a
5481/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5482/// name of a type. The DependentNameType may start with a "typename" (for a
5483/// typename-specifier), "class", "struct", "union", or "enum" (for a
5484/// dependent elaborated-type-specifier), or nothing (in contexts where we
5485/// know that we must be referring to a type, e.g., in a base class specifier).
5486/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5487/// mode, this type is used with non-dependent names to delay name lookup until
5488/// instantiation.
5489class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
5490 friend class ASTContext; // ASTContext creates these
5491
5492 /// The nested name specifier containing the qualifier.
5493 NestedNameSpecifier *NNS;
5494
5495 /// The type that this typename specifier refers to.
5496 const IdentifierInfo *Name;
5497
5498 DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5499 const IdentifierInfo *Name, QualType CanonType)
5500 : TypeWithKeyword(Keyword, DependentName, CanonType,
5501 TypeDependence::DependentInstantiation |
5502 toTypeDependence(NNS->getDependence())),
5503 NNS(NNS), Name(Name) {}
5504
5505public:
5506 /// Retrieve the qualification on this type.
5507 NestedNameSpecifier *getQualifier() const { return NNS; }
5508
5509 /// Retrieve the type named by the typename specifier as an identifier.
5510 ///
5511 /// This routine will return a non-NULL identifier pointer when the
5512 /// form of the original typename was terminated by an identifier,
5513 /// e.g., "typename T::type".
5514 const IdentifierInfo *getIdentifier() const {
5515 return Name;
5516 }
5517
5518 bool isSugared() const { return false; }
5519 QualType desugar() const { return QualType(this, 0); }
5520
5521 void Profile(llvm::FoldingSetNodeID &ID) {
5522 Profile(ID, getKeyword(), NNS, Name);
5523 }
5524
5525 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5526 NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
5527 ID.AddInteger(Keyword);
5528 ID.AddPointer(NNS);
5529 ID.AddPointer(Name);
5530 }
5531
5532 static bool classof(const Type *T) {
5533 return T->getTypeClass() == DependentName;
5534 }
5535};
5536
5537/// Represents a template specialization type whose template cannot be
5538/// resolved, e.g.
5539/// A<T>::template B<T>
5540class alignas(8) DependentTemplateSpecializationType
5541 : public TypeWithKeyword,
5542 public llvm::FoldingSetNode {
5543 friend class ASTContext; // ASTContext creates these
5544
5545 /// The nested name specifier containing the qualifier.
5546 NestedNameSpecifier *NNS;
5547
5548 /// The identifier of the template.
5549 const IdentifierInfo *Name;
5550
5551 DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
5552 NestedNameSpecifier *NNS,
5553 const IdentifierInfo *Name,
5554 ArrayRef<TemplateArgument> Args,
5555 QualType Canon);
5556
5557 const TemplateArgument *getArgBuffer() const {
5558 return reinterpret_cast<const TemplateArgument*>(this+1);
5559 }
5560
5561 TemplateArgument *getArgBuffer() {
5562 return reinterpret_cast<TemplateArgument*>(this+1);
5563 }
5564
5565public:
5566 NestedNameSpecifier *getQualifier() const { return NNS; }
5567 const IdentifierInfo *getIdentifier() const { return Name; }
5568
5569 /// Retrieve the template arguments.
5570 const TemplateArgument *getArgs() const {
5571 return getArgBuffer();
5572 }
5573
5574 /// Retrieve the number of template arguments.
5575 unsigned getNumArgs() const {
5576 return DependentTemplateSpecializationTypeBits.NumArgs;
5577 }
5578
5579 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5580
5581 ArrayRef<TemplateArgument> template_arguments() const {
5582 return {getArgs(), getNumArgs()};
5583 }
5584
5585 using iterator = const TemplateArgument *;
5586
5587 iterator begin() const { return getArgs(); }
5588 iterator end() const; // inline in TemplateBase.h
5589
5590 bool isSugared() const { return false; }
5591 QualType desugar() const { return QualType(this, 0); }
5592
5593 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5594 Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
5595 }
5596
5597 static void Profile(llvm::FoldingSetNodeID &ID,
5598 const ASTContext &Context,
5599 ElaboratedTypeKeyword Keyword,
5600 NestedNameSpecifier *Qualifier,
5601 const IdentifierInfo *Name,
5602 ArrayRef<TemplateArgument> Args);
5603
5604 static bool classof(const Type *T) {
5605 return T->getTypeClass() == DependentTemplateSpecialization;
5606 }
5607};
5608
5609/// Represents a pack expansion of types.
5610///
5611/// Pack expansions are part of C++11 variadic templates. A pack
5612/// expansion contains a pattern, which itself contains one or more
5613/// "unexpanded" parameter packs. When instantiated, a pack expansion
5614/// produces a series of types, each instantiated from the pattern of
5615/// the expansion, where the Ith instantiation of the pattern uses the
5616/// Ith arguments bound to each of the unexpanded parameter packs. The
5617/// pack expansion is considered to "expand" these unexpanded
5618/// parameter packs.
5619///
5620/// \code
5621/// template<typename ...Types> struct tuple;
5622///
5623/// template<typename ...Types>
5624/// struct tuple_of_references {
5625/// typedef tuple<Types&...> type;
5626/// };
5627/// \endcode
5628///
5629/// Here, the pack expansion \c Types&... is represented via a
5630/// PackExpansionType whose pattern is Types&.
5631class PackExpansionType : public Type, public llvm::FoldingSetNode {
5632 friend class ASTContext; // ASTContext creates these
5633
5634 /// The pattern of the pack expansion.
5635 QualType Pattern;
5636
5637 PackExpansionType(QualType Pattern, QualType Canon,
5638 Optional<unsigned> NumExpansions)
5639 : Type(PackExpansion, Canon,
5640 (Pattern->getDependence() | TypeDependence::Dependent |
5641 TypeDependence::Instantiation) &
5642 ~TypeDependence::UnexpandedPack),
5643 Pattern(Pattern) {
5644 PackExpansionTypeBits.NumExpansions =
5645 NumExpansions ? *NumExpansions + 1 : 0;
5646 }
5647
5648public:
5649 /// Retrieve the pattern of this pack expansion, which is the
5650 /// type that will be repeatedly instantiated when instantiating the
5651 /// pack expansion itself.
5652 QualType getPattern() const { return Pattern; }
5653
5654 /// Retrieve the number of expansions that this pack expansion will
5655 /// generate, if known.
5656 Optional<unsigned> getNumExpansions() const {
5657 if (PackExpansionTypeBits.NumExpansions)
5658 return PackExpansionTypeBits.NumExpansions - 1;
5659 return None;
5660 }
5661
5662 bool isSugared() const { return false; }
5663 QualType desugar() const { return QualType(this, 0); }
5664
5665 void Profile(llvm::FoldingSetNodeID &ID) {
5666 Profile(ID, getPattern(), getNumExpansions());
5667 }
5668
5669 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
5670 Optional<unsigned> NumExpansions) {
5671 ID.AddPointer(Pattern.getAsOpaquePtr());
5672 ID.AddBoolean(NumExpansions.hasValue());
5673 if (NumExpansions)
5674 ID.AddInteger(*NumExpansions);
5675 }
5676
5677 static bool classof(const Type *T) {
5678 return T->getTypeClass() == PackExpansion;
5679 }
5680};
5681
5682/// This class wraps the list of protocol qualifiers. For types that can
5683/// take ObjC protocol qualifers, they can subclass this class.
5684template <class T>
5685class ObjCProtocolQualifiers {
5686protected:
5687 ObjCProtocolQualifiers() = default;
5688
5689 ObjCProtocolDecl * const *getProtocolStorage() const {
5690 return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
5691 }
5692
5693 ObjCProtocolDecl **getProtocolStorage() {
5694 return static_cast<T*>(this)->getProtocolStorageImpl();
5695 }
5696
5697 void setNumProtocols(unsigned N) {
5698 static_cast<T*>(this)->setNumProtocolsImpl(N);
5699 }
5700
5701 void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
5702 setNumProtocols(protocols.size());
5703 assert(getNumProtocols() == protocols.size() &&(static_cast<void> (0))
5704 "bitfield overflow in protocol count")(static_cast<void> (0));
5705 if (!protocols.empty())
5706 memcpy(getProtocolStorage(), protocols.data(),
5707 protocols.size() * sizeof(ObjCProtocolDecl*));
5708 }
5709
5710public:
5711 using qual_iterator = ObjCProtocolDecl * const *;
5712 using qual_range = llvm::iterator_range<qual_iterator>;
5713
5714 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
5715 qual_iterator qual_begin() const { return getProtocolStorage(); }
5716 qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }
5717
5718 bool qual_empty() const { return getNumProtocols() == 0; }
5719
5720 /// Return the number of qualifying protocols in this type, or 0 if
5721 /// there are none.
5722 unsigned getNumProtocols() const {
5723 return static_cast<const T*>(this)->getNumProtocolsImpl();
5724 }
5725
5726 /// Fetch a protocol by index.
5727 ObjCProtocolDecl *getProtocol(unsigned I) const {
5728 assert(I < getNumProtocols() && "Out-of-range protocol access")(static_cast<void> (0));
5729 return qual_begin()[I];
5730 }
5731
5732 /// Retrieve all of the protocol qualifiers.
5733 ArrayRef<ObjCProtocolDecl *> getProtocols() const {
5734 return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
5735 }
5736};
5737
5738/// Represents a type parameter type in Objective C. It can take
5739/// a list of protocols.
5740class ObjCTypeParamType : public Type,
5741 public ObjCProtocolQualifiers<ObjCTypeParamType>,
5742 public llvm::FoldingSetNode {
5743 friend class ASTContext;
5744 friend class ObjCProtocolQualifiers<ObjCTypeParamType>;
5745
5746 /// The number of protocols stored on this type.
5747 unsigned NumProtocols : 6;
5748
5749 ObjCTypeParamDecl *OTPDecl;
5750
5751 /// The protocols are stored after the ObjCTypeParamType node. In the
5752 /// canonical type, the list of protocols are sorted alphabetically
5753 /// and uniqued.
5754 ObjCProtocolDecl **getProtocolStorageImpl();
5755
5756 /// Return the number of qualifying protocols in this interface type,
5757 /// or 0 if there are none.
5758 unsigned getNumProtocolsImpl() const {
5759 return NumProtocols;
5760 }
5761
5762 void setNumProtocolsImpl(unsigned N) {
5763 NumProtocols = N;
5764 }
5765
5766 ObjCTypeParamType(const ObjCTypeParamDecl *D,
5767 QualType can,
5768 ArrayRef<ObjCProtocolDecl *> protocols);
5769
5770public:
5771 bool isSugared() const { return true; }
5772 QualType desugar() const { return getCanonicalTypeInternal(); }
5773
5774 static bool classof(const Type *T) {
5775 return T->getTypeClass() == ObjCTypeParam;
5776 }
5777
5778 void Profile(llvm::FoldingSetNodeID &ID);
5779 static void Profile(llvm::FoldingSetNodeID &ID,
5780 const ObjCTypeParamDecl *OTPDecl,
5781 QualType CanonicalType,
5782 ArrayRef<ObjCProtocolDecl *> protocols);
5783
5784 ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5785};
5786
5787/// Represents a class type in Objective C.
5788///
5789/// Every Objective C type is a combination of a base type, a set of
5790/// type arguments (optional, for parameterized classes) and a list of
5791/// protocols.
5792///
5793/// Given the following declarations:
5794/// \code
5795/// \@class C<T>;
5796/// \@protocol P;
5797/// \endcode
5798///
5799/// 'C' is an ObjCInterfaceType C. It is sugar for an ObjCObjectType
5800/// with base C and no protocols.
5801///
5802/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5803/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5804/// protocol list.
5805/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5806/// and protocol list [P].
5807///
5808/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5809/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5810/// and no protocols.
5811///
5812/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5813/// with base BuiltinType::ObjCIdType and protocol list [P]. Eventually
5814/// this should get its own sugar class to better represent the source.
5815class ObjCObjectType : public Type,
5816 public ObjCProtocolQualifiers<ObjCObjectType> {
5817 friend class ObjCProtocolQualifiers<ObjCObjectType>;
5818
5819 // ObjCObjectType.NumTypeArgs - the number of type arguments stored
5820 // after the ObjCObjectPointerType node.
5821 // ObjCObjectType.NumProtocols - the number of protocols stored
5822 // after the type arguments of ObjCObjectPointerType node.
5823 //
5824 // These protocols are those written directly on the type. If
5825 // protocol qualifiers ever become additive, the iterators will need
5826 // to get kindof complicated.
5827 //
5828 // In the canonical object type, these are sorted alphabetically
5829 // and uniqued.
5830
5831 /// Either a BuiltinType or an InterfaceType or sugar for either.
5832 QualType BaseType;
5833
5834 /// Cached superclass type.
5835 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
5836 CachedSuperClassType;
5837
5838 QualType *getTypeArgStorage();
5839 const QualType *getTypeArgStorage() const {
5840 return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
5841 }
5842
5843 ObjCProtocolDecl **getProtocolStorageImpl();
5844 /// Return the number of qualifying protocols in this interface type,
5845 /// or 0 if there are none.
5846 unsigned getNumProtocolsImpl() const {
5847 return ObjCObjectTypeBits.NumProtocols;
5848 }
5849 void setNumProtocolsImpl(unsigned N) {
5850 ObjCObjectTypeBits.NumProtocols = N;
5851 }
5852
5853protected:
5854 enum Nonce_ObjCInterface { Nonce_ObjCInterface };
5855
5856 ObjCObjectType(QualType Canonical, QualType Base,
5857 ArrayRef<QualType> typeArgs,
5858 ArrayRef<ObjCProtocolDecl *> protocols,
5859 bool isKindOf);
5860
5861 ObjCObjectType(enum Nonce_ObjCInterface)
5862 : Type(ObjCInterface, QualType(), TypeDependence::None),
5863 BaseType(QualType(this_(), 0)) {
5864 ObjCObjectTypeBits.NumProtocols = 0;
5865 ObjCObjectTypeBits.NumTypeArgs = 0;
5866 ObjCObjectTypeBits.IsKindOf = 0;
5867 }
5868
5869 void computeSuperClassTypeSlow() const;
5870
5871public:
5872 /// Gets the base type of this object type. This is always (possibly
5873 /// sugar for) one of:
5874 /// - the 'id' builtin type (as opposed to the 'id' type visible to the
5875 /// user, which is a typedef for an ObjCObjectPointerType)
5876 /// - the 'Class' builtin type (same caveat)
5877 /// - an ObjCObjectType (currently always an ObjCInterfaceType)
5878 QualType getBaseType() const { return BaseType; }
5879
5880 bool isObjCId() const {
5881 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
5882 }
5883
5884 bool isObjCClass() const {
5885 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
5886 }
5887
5888 bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
5889 bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
5890 bool isObjCUnqualifiedIdOrClass() const {
5891 if (!qual_empty()) return false;
5892 if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
5893 return T->getKind() == BuiltinType::ObjCId ||
5894 T->getKind() == BuiltinType::ObjCClass;
5895 return false;
5896 }
5897 bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
5898 bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }
5899
5900 /// Gets the interface declaration for this object type, if the base type
5901 /// really is an interface.
5902 ObjCInterfaceDecl *getInterface() const;
5903
5904 /// Determine whether this object type is "specialized", meaning
5905 /// that it has type arguments.
5906 bool isSpecialized() const;
5907
5908 /// Determine whether this object type was written with type arguments.
5909 bool isSpecializedAsWritten() const {
5910 return ObjCObjectTypeBits.NumTypeArgs > 0;
5911 }
5912
5913 /// Determine whether this object type is "unspecialized", meaning
5914 /// that it has no type arguments.
5915 bool isUnspecialized() const { return !isSpecialized(); }
5916
5917 /// Determine whether this object type is "unspecialized" as
5918 /// written, meaning that it has no type arguments.
5919 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
5920
5921 /// Retrieve the type arguments of this object type (semantically).
5922 ArrayRef<QualType> getTypeArgs() const;
5923
5924 /// Retrieve the type arguments of this object type as they were
5925 /// written.
5926 ArrayRef<QualType> getTypeArgsAsWritten() const {
5927 return llvm::makeArrayRef(getTypeArgStorage(),
5928 ObjCObjectTypeBits.NumTypeArgs);
5929 }
5930
5931 /// Whether this is a "__kindof" type as written.
5932 bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }
5933
5934 /// Whether this ia a "__kindof" type (semantically).
5935 bool isKindOfType() const;
5936
5937 /// Retrieve the type of the superclass of this object type.
5938 ///
5939 /// This operation substitutes any type arguments into the
5940 /// superclass of the current class type, potentially producing a
5941 /// specialization of the superclass type. Produces a null type if
5942 /// there is no superclass.
5943 QualType getSuperClassType() const {
5944 if (!CachedSuperClassType.getInt())
5945 computeSuperClassTypeSlow();
5946
5947 assert(CachedSuperClassType.getInt() && "Superclass not set?")(static_cast<void> (0));
5948 return QualType(CachedSuperClassType.getPointer(), 0);
5949 }
5950
5951 /// Strip off the Objective-C "kindof" type and (with it) any
5952 /// protocol qualifiers.
5953 QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;
5954
5955 bool isSugared() const { return false; }
5956 QualType desugar() const { return QualType(this, 0); }
5957
5958 static bool classof(const Type *T) {
5959 return T->getTypeClass() == ObjCObject ||
5960 T->getTypeClass() == ObjCInterface;
5961 }
5962};
5963
5964/// A class providing a concrete implementation
5965/// of ObjCObjectType, so as to not increase the footprint of
5966/// ObjCInterfaceType. Code outside of ASTContext and the core type
5967/// system should not reference this type.
5968class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
5969 friend class ASTContext;
5970
5971 // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
5972 // will need to be modified.
5973
5974 ObjCObjectTypeImpl(QualType Canonical, QualType Base,
5975 ArrayRef<QualType> typeArgs,
5976 ArrayRef<ObjCProtocolDecl *> protocols,
5977 bool isKindOf)
5978 : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}
5979
5980public:
5981 void Profile(llvm::FoldingSetNodeID &ID);
5982 static void Profile(llvm::FoldingSetNodeID &ID,
5983 QualType Base,
5984 ArrayRef<QualType> typeArgs,
5985 ArrayRef<ObjCProtocolDecl *> protocols,
5986 bool isKindOf);
5987};
5988
5989inline QualType *ObjCObjectType::getTypeArgStorage() {
5990 return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5991}
5992
5993inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
5994 return reinterpret_cast<ObjCProtocolDecl**>(
5995 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5996}
5997
5998inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
5999 return reinterpret_cast<ObjCProtocolDecl**>(
6000 static_cast<ObjCTypeParamType*>(this)+1);
6001}
6002
6003/// Interfaces are the core concept in Objective-C for object oriented design.
6004/// They basically correspond to C++ classes. There are two kinds of interface
6005/// types: normal interfaces like `NSString`, and qualified interfaces, which
6006/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6007///
6008/// ObjCInterfaceType guarantees the following properties when considered
6009/// as a subtype of its superclass, ObjCObjectType:
6010/// - There are no protocol qualifiers. To reinforce this, code which
6011/// tries to invoke the protocol methods via an ObjCInterfaceType will
6012/// fail to compile.
6013/// - It is its own base type. That is, if T is an ObjCInterfaceType*,
6014/// T->getBaseType() == QualType(T, 0).
6015class ObjCInterfaceType : public ObjCObjectType {
6016 friend class ASTContext; // ASTContext creates these.
6017 friend class ASTReader;
6018 friend class ObjCInterfaceDecl;
6019 template <class T> friend class serialization::AbstractTypeReader;
6020
6021 mutable ObjCInterfaceDecl *Decl;
6022
6023 ObjCInterfaceType(const ObjCInterfaceDecl *D)
6024 : ObjCObjectType(Nonce_ObjCInterface),
6025 Decl(const_cast<ObjCInterfaceDecl*>(D)) {}
6026
6027public:
6028 /// Get the declaration of this interface.
6029 ObjCInterfaceDecl *getDecl() const { return Decl; }
6030
6031 bool isSugared() const { return false; }
6032 QualType desugar() const { return QualType(this, 0); }
6033
6034 static bool classof(const Type *T) {
6035 return T->getTypeClass() == ObjCInterface;
6036 }
6037
6038 // Nonsense to "hide" certain members of ObjCObjectType within this
6039 // class. People asking for protocols on an ObjCInterfaceType are
6040 // not going to get what they want: ObjCInterfaceTypes are
6041 // guaranteed to have no protocols.
6042 enum {
6043 qual_iterator,
6044 qual_begin,
6045 qual_end,
6046 getNumProtocols,
6047 getProtocol
6048 };
6049};
6050
6051inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
6052 QualType baseType = getBaseType();
6053 while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
6054 if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
6055 return T->getDecl();
6056
6057 baseType = ObjT->getBaseType();
6058 }
6059
6060 return nullptr;
6061}
6062
6063/// Represents a pointer to an Objective C object.
6064///
6065/// These are constructed from pointer declarators when the pointee type is
6066/// an ObjCObjectType (or sugar for one). In addition, the 'id' and 'Class'
6067/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6068/// and 'Class<P>' are translated into these.
6069///
6070/// Pointers to pointers to Objective C objects are still PointerTypes;
6071/// only the first level of pointer gets it own type implementation.
6072class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
6073 friend class ASTContext; // ASTContext creates these.
6074
6075 QualType PointeeType;
6076
6077 ObjCObjectPointerType(QualType Canonical, QualType Pointee)
6078 : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
6079 PointeeType(Pointee) {}
6080
6081public:
6082 /// Gets the type pointed to by this ObjC pointer.
6083 /// The result will always be an ObjCObjectType or sugar thereof.
6084 QualType getPointeeType() const { return PointeeType; }
6085
6086 /// Gets the type pointed to by this ObjC pointer. Always returns non-null.
6087 ///
6088 /// This method is equivalent to getPointeeType() except that
6089 /// it discards any typedefs (or other sugar) between this
6090 /// type and the "outermost" object type. So for:
6091 /// \code
6092 /// \@class A; \@protocol P; \@protocol Q;
6093 /// typedef A<P> AP;
6094 /// typedef A A1;
6095 /// typedef A1<P> A1P;
6096 /// typedef A1P<Q> A1PQ;
6097 /// \endcode
6098 /// For 'A*', getObjectType() will return 'A'.
6099 /// For 'A<P>*', getObjectType() will return 'A<P>'.
6100 /// For 'AP*', getObjectType() will return 'A<P>'.
6101 /// For 'A1*', getObjectType() will return 'A'.
6102 /// For 'A1<P>*', getObjectType() will return 'A1<P>'.
6103 /// For 'A1P*', getObjectType() will return 'A1<P>'.
6104 /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
6105 /// adding protocols to a protocol-qualified base discards the
6106 /// old qualifiers (for now). But if it didn't, getObjectType()
6107 /// would return 'A1P<Q>' (and we'd have to make iterating over
6108 /// qualifiers more complicated).
6109 const ObjCObjectType *getObjectType() const {
6110 return PointeeType->castAs<ObjCObjectType>();
6111 }
6112
6113 /// If this pointer points to an Objective C
6114 /// \@interface type, gets the type for that interface. Any protocol
6115 /// qualifiers on the interface are ignored.
6116 ///
6117 /// \return null if the base type for this pointer is 'id' or 'Class'
6118 const ObjCInterfaceType *getInterfaceType() const;
6119
6120 /// If this pointer points to an Objective \@interface
6121 /// type, gets the declaration for that interface.
6122 ///
6123 /// \return null if the base type for this pointer is 'id' or 'Class'
6124 ObjCInterfaceDecl *getInterfaceDecl() const {
6125 return getObjectType()->getInterface();
6126 }
6127
6128 /// True if this is equivalent to the 'id' type, i.e. if
6129 /// its object type is the primitive 'id' type with no protocols.
6130 bool isObjCIdType() const {
6131 return getObjectType()->isObjCUnqualifiedId();
6132 }
6133
6134 /// True if this is equivalent to the 'Class' type,
6135 /// i.e. if its object tive is the primitive 'Class' type with no protocols.
6136 bool isObjCClassType() const {
6137 return getObjectType()->isObjCUnqualifiedClass();
6138 }
6139
6140 /// True if this is equivalent to the 'id' or 'Class' type,
6141 bool isObjCIdOrClassType() const {
6142 return getObjectType()->isObjCUnqualifiedIdOrClass();
6143 }
6144
6145 /// True if this is equivalent to 'id<P>' for some non-empty set of
6146 /// protocols.
6147 bool isObjCQualifiedIdType() const {
6148 return getObjectType()->isObjCQualifiedId();
6149 }
6150
6151 /// True if this is equivalent to 'Class<P>' for some non-empty set of
6152 /// protocols.
6153 bool isObjCQualifiedClassType() const {
6154 return getObjectType()->isObjCQualifiedClass();
6155 }
6156
6157 /// Whether this is a "__kindof" type.
6158 bool isKindOfType() const { return getObjectType()->isKindOfType(); }
6159
6160 /// Whether this type is specialized, meaning that it has type arguments.
6161 bool isSpecialized() const { return getObjectType()->isSpecialized(); }
6162
6163 /// Whether this type is specialized, meaning that it has type arguments.
6164 bool isSpecializedAsWritten() const {
6165 return getObjectType()->isSpecializedAsWritten();
6166 }
6167
6168 /// Whether this type is unspecialized, meaning that is has no type arguments.
6169 bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }
6170
6171 /// Determine whether this object type is "unspecialized" as
6172 /// written, meaning that it has no type arguments.
6173 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
6174
6175 /// Retrieve the type arguments for this type.
6176 ArrayRef<QualType> getTypeArgs() const {
6177 return getObjectType()->getTypeArgs();
6178 }
6179
6180 /// Retrieve the type arguments for this type.
6181 ArrayRef<QualType> getTypeArgsAsWritten() const {
6182 return getObjectType()->getTypeArgsAsWritten();
6183 }
6184
6185 /// An iterator over the qualifiers on the object type. Provided
6186 /// for convenience. This will always iterate over the full set of
6187 /// protocols on a type, not just those provided directly.
6188 using qual_iterator = ObjCObjectType::qual_iterator;
6189 using qual_range = llvm::iterator_range<qual_iterator>;
6190
6191 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
6192
6193 qual_iterator qual_begin() const {
6194 return getObjectType()->qual_begin();
6195 }
6196
6197 qual_iterator qual_end() const {
6198 return getObjectType()->qual_end();
6199 }
6200
6201 bool qual_empty() const { return getObjectType()->qual_empty(); }
6202
6203 /// Return the number of qualifying protocols on the object type.
6204 unsigned getNumProtocols() const {
6205 return getObjectType()->getNumProtocols();
6206 }
6207
6208 /// Retrieve a qualifying protocol by index on the object type.
6209 ObjCProtocolDecl *getProtocol(unsigned I) const {
6210 return getObjectType()->getProtocol(I);
6211 }
6212
6213 bool isSugared() const { return false; }
6214 QualType desugar() const { return QualType(this, 0); }
6215
6216 /// Retrieve the type of the superclass of this object pointer type.
6217 ///
6218 /// This operation substitutes any type arguments into the
6219 /// superclass of the current class type, potentially producing a
6220 /// pointer to a specialization of the superclass type. Produces a
6221 /// null type if there is no superclass.
6222 QualType getSuperClassType() const;
6223
6224 /// Strip off the Objective-C "kindof" type and (with it) any
6225 /// protocol qualifiers.
6226 const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
6227 const ASTContext &ctx) const;
6228
6229 void Profile(llvm::FoldingSetNodeID &ID) {
6230 Profile(ID, getPointeeType());
6231 }
6232
6233 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6234 ID.AddPointer(T.getAsOpaquePtr());
6235 }
6236
6237 static bool classof(const Type *T) {
6238 return T->getTypeClass() == ObjCObjectPointer;
6239 }
6240};
6241
6242class AtomicType : public Type, public llvm::FoldingSetNode {
6243 friend class ASTContext; // ASTContext creates these.
6244
6245 QualType ValueType;
6246
6247 AtomicType(QualType ValTy, QualType Canonical)
6248 : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
6249
6250public:
6251 /// Gets the type contained by this atomic type, i.e.
6252 /// the type returned by performing an atomic load of this atomic type.
6253 QualType getValueType() const { return ValueType; }
6254
6255 bool isSugared() const { return false; }
6256 QualType desugar() const { return QualType(this, 0); }
6257
6258 void Profile(llvm::FoldingSetNodeID &ID) {
6259 Profile(ID, getValueType());
6260 }
6261
6262 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6263 ID.AddPointer(T.getAsOpaquePtr());
6264 }
6265
6266 static bool classof(const Type *T) {
6267 return T->getTypeClass() == Atomic;
6268 }
6269};
6270
6271/// PipeType - OpenCL20.
6272class PipeType : public Type, public llvm::FoldingSetNode {
6273 friend class ASTContext; // ASTContext creates these.
6274
6275 QualType ElementType;
6276 bool isRead;
6277
6278 PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
6279 : Type(Pipe, CanonicalPtr, elemType->getDependence()),
6280 ElementType(elemType), isRead(isRead) {}
6281
6282public:
6283 QualType getElementType() const { return ElementType; }
6284
6285 bool isSugared() const { return false; }
6286
6287 QualType desugar() const { return QualType(this, 0); }
6288
6289 void Profile(llvm::FoldingSetNodeID &ID) {
6290 Profile(ID, getElementType(), isReadOnly());
6291 }
6292
6293 static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
6294 ID.AddPointer(T.getAsOpaquePtr());
6295 ID.AddBoolean(isRead);
6296 }
6297
6298 static bool classof(const Type *T) {
6299 return T->getTypeClass() == Pipe;
6300 }
6301
6302 bool isReadOnly() const { return isRead; }
6303};
6304
6305/// A fixed int type of a specified bitwidth.
6306class ExtIntType final : public Type, public llvm::FoldingSetNode {
6307 friend class ASTContext;
6308 unsigned IsUnsigned : 1;
6309 unsigned NumBits : 24;
6310
6311protected:
6312 ExtIntType(bool isUnsigned, unsigned NumBits);
6313
6314public:
6315 bool isUnsigned() const { return IsUnsigned; }
6316 bool isSigned() const { return !IsUnsigned; }
6317 unsigned getNumBits() const { return NumBits; }
6318
6319 bool isSugared() const { return false; }
6320 QualType desugar() const { return QualType(this, 0); }
6321
6322 void Profile(llvm::FoldingSetNodeID &ID) {
6323 Profile(ID, isUnsigned(), getNumBits());
6324 }
6325
6326 static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
6327 unsigned NumBits) {
6328 ID.AddBoolean(IsUnsigned);
6329 ID.AddInteger(NumBits);
6330 }
6331
6332 static bool classof(const Type *T) { return T->getTypeClass() == ExtInt; }
6333};
6334
6335class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
6336 friend class ASTContext;
6337 const ASTContext &Context;
6338 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
6339
6340protected:
6341 DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
6342 Expr *NumBits);
6343
6344public:
6345 bool isUnsigned() const;
6346 bool isSigned() const { return !isUnsigned(); }
6347 Expr *getNumBitsExpr() const;
6348
6349 bool isSugared() const { return false; }
6350 QualType desugar() const { return QualType(this, 0); }
6351
6352 void Profile(llvm::FoldingSetNodeID &ID) {
6353 Profile(ID, Context, isUnsigned(), getNumBitsExpr());
6354 }
6355 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
6356 bool IsUnsigned, Expr *NumBitsExpr);
6357
6358 static bool classof(const Type *T) {
6359 return T->getTypeClass() == DependentExtInt;
6360 }
6361};
6362
6363/// A qualifier set is used to build a set of qualifiers.
6364class QualifierCollector : public Qualifiers {
6365public:
6366 QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}
6367
6368 /// Collect any qualifiers on the given type and return an
6369 /// unqualified type. The qualifiers are assumed to be consistent
6370 /// with those already in the type.
6371 const Type *strip(QualType type) {
6372 addFastQualifiers(type.getLocalFastQualifiers());
6373 if (!type.hasLocalNonFastQualifiers())
6374 return type.getTypePtrUnsafe();
6375
6376 const ExtQuals *extQuals = type.getExtQualsUnsafe();
6377 addConsistentQualifiers(extQuals->getQualifiers());
6378 return extQuals->getBaseType();
6379 }
6380
6381 /// Apply the collected qualifiers to the given type.
6382 QualType apply(const ASTContext &Context, QualType QT) const;
6383
6384 /// Apply the collected qualifiers to the given type.
6385 QualType apply(const ASTContext &Context, const Type* T) const;
6386};
6387
6388/// A container of type source information.
6389///
6390/// A client can read the relevant info using TypeLoc wrappers, e.g:
6391/// @code
6392/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6393/// TL.getBeginLoc().print(OS, SrcMgr);
6394/// @endcode
6395class alignas(8) TypeSourceInfo {
6396 // Contains a memory block after the class, used for type source information,
6397 // allocated by ASTContext.
6398 friend class ASTContext;
6399
6400 QualType Ty;
6401
6402 TypeSourceInfo(QualType ty) : Ty(ty) {}
6403
6404public:
6405 /// Return the type wrapped by this type source info.
6406 QualType getType() const { return Ty; }
6407
6408 /// Return the TypeLoc wrapper for the type source info.
6409 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
6410
6411 /// Override the type stored in this TypeSourceInfo. Use with caution!
6412 void overrideType(QualType T) { Ty = T; }
6413};
6414
6415// Inline function definitions.
6416
6417inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
6418 SplitQualType desugar =
6419 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
6420 desugar.Quals.addConsistentQualifiers(Quals);
6421 return desugar;
6422}
6423
6424inline const Type *QualType::getTypePtr() const {
6425 return getCommonPtr()->BaseType;
6426}
6427
6428inline const Type *QualType::getTypePtrOrNull() const {
6429 return (isNull() ? nullptr : getCommonPtr()->BaseType);
6430}
6431
6432inline SplitQualType QualType::split() const {
6433 if (!hasLocalNonFastQualifiers())
6434 return SplitQualType(getTypePtrUnsafe(),
6435 Qualifiers::fromFastMask(getLocalFastQualifiers()));
6436
6437 const ExtQuals *eq = getExtQualsUnsafe();
6438 Qualifiers qs = eq->getQualifiers();
6439 qs.addFastQualifiers(getLocalFastQualifiers());
6440 return SplitQualType(eq->getBaseType(), qs);
6441}
6442
6443inline Qualifiers QualType::getLocalQualifiers() const {
6444 Qualifiers Quals;
6445 if (hasLocalNonFastQualifiers())
6446 Quals = getExtQualsUnsafe()->getQualifiers();
6447 Quals.addFastQualifiers(getLocalFastQualifiers());
6448 return Quals;
6449}
6450
6451inline Qualifiers QualType::getQualifiers() const {
6452 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
6453 quals.addFastQualifiers(getLocalFastQualifiers());
6454 return quals;
6455}
6456
6457inline unsigned QualType::getCVRQualifiers() const {
6458 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
6459 cvr |= getLocalCVRQualifiers();
6460 return cvr;
6461}
6462
6463inline QualType QualType::getCanonicalType() const {
6464 QualType canon = getCommonPtr()->CanonicalType;
6465 return canon.withFastQualifiers(getLocalFastQualifiers());
6466}
6467
6468inline bool QualType::isCanonical() const {
6469 return getTypePtr()->isCanonicalUnqualified();
6470}
6471
6472inline bool QualType::isCanonicalAsParam() const {
6473 if (!isCanonical()) return false;
6474 if (hasLocalQualifiers()) return false;
6475
6476 const Type *T = getTypePtr();
6477 if (T->isVariablyModifiedType() && T->hasSizedVLAType())
6478 return false;
6479
6480 return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6481}
6482
6483inline bool QualType::isConstQualified() const {
6484 return isLocalConstQualified() ||
6485 getCommonPtr()->CanonicalType.isLocalConstQualified();
6486}
6487
6488inline bool QualType::isRestrictQualified() const {
6489 return isLocalRestrictQualified() ||
6490 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6491}
6492
6493
6494inline bool QualType::isVolatileQualified() const {
6495 return isLocalVolatileQualified() ||
6496 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6497}
6498
6499inline bool QualType::hasQualifiers() const {
6500 return hasLocalQualifiers() ||
6501 getCommonPtr()->CanonicalType.hasLocalQualifiers();
6502}
6503
6504inline QualType QualType::getUnqualifiedType() const {
6505 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6506 return QualType(getTypePtr(), 0);
6507
6508 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6509}
6510
6511inline SplitQualType QualType::getSplitUnqualifiedType() const {
6512 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6513 return split();
6514
6515 return getSplitUnqualifiedTypeImpl(*this);
6516}
6517
6518inline void QualType::removeLocalConst() {
6519 removeLocalFastQualifiers(Qualifiers::Const);
6520}
6521
6522inline void QualType::removeLocalRestrict() {
6523 removeLocalFastQualifiers(Qualifiers::Restrict);
6524}
6525
6526inline void QualType::removeLocalVolatile() {
6527 removeLocalFastQualifiers(Qualifiers::Volatile);
6528}
6529
6530inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
6531 assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")(static_cast<void> (0));
6532 static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
6533 "Fast bits differ from CVR bits!");
6534
6535 // Fast path: we don't need to touch the slow qualifiers.
6536 removeLocalFastQualifiers(Mask);
6537}
6538
6539/// Check if this type has any address space qualifier.
6540inline bool QualType::hasAddressSpace() const {
6541 return getQualifiers().hasAddressSpace();
6542}
6543
6544/// Return the address space of this type.
6545inline LangAS QualType::getAddressSpace() const {
6546 return getQualifiers().getAddressSpace();
6547}
6548
6549/// Return the gc attribute of this type.
6550inline Qualifiers::GC QualType::getObjCGCAttr() const {
6551 return getQualifiers().getObjCGCAttr();
6552}
6553
6554inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
6555 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6556 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
6557 return false;
6558}
6559
6560inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
6561 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6562 return hasNonTrivialToPrimitiveDestructCUnion(RD);
6563 return false;
6564}
6565
6566inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
6567 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6568 return hasNonTrivialToPrimitiveCopyCUnion(RD);
6569 return false;
6570}
6571
6572inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
6573 if (const auto *PT = t.getAs<PointerType>()) {
6574 if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
6575 return FT->getExtInfo();
6576 } else if (const auto *FT = t.getAs<FunctionType>())
6577 return FT->getExtInfo();
6578
6579 return FunctionType::ExtInfo();
6580}
6581
6582inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
6583 return getFunctionExtInfo(*t);
6584}
6585
6586/// Determine whether this type is more
6587/// qualified than the Other type. For example, "const volatile int"
6588/// is more qualified than "const int", "volatile int", and
6589/// "int". However, it is not more qualified than "const volatile
6590/// int".
6591inline bool QualType::isMoreQualifiedThan(QualType other) const {
6592 Qualifiers MyQuals = getQualifiers();
6593 Qualifiers OtherQuals = other.getQualifiers();
6594 return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6595}
6596
6597/// Determine whether this type is at last
6598/// as qualified as the Other type. For example, "const volatile
6599/// int" is at least as qualified as "const int", "volatile int",
6600/// "int", and "const volatile int".
6601inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
6602 Qualifiers OtherQuals = other.getQualifiers();
6603
6604 // Ignore __unaligned qualifier if this type is a void.
6605 if (getUnqualifiedType()->isVoidType())
6606 OtherQuals.removeUnaligned();
6607
6608 return getQualifiers().compatiblyIncludes(OtherQuals);
6609}
6610
6611/// If Type is a reference type (e.g., const
6612/// int&), returns the type that the reference refers to ("const
6613/// int"). Otherwise, returns the type itself. This routine is used
6614/// throughout Sema to implement C++ 5p6:
6615///
6616/// If an expression initially has the type "reference to T" (8.3.2,
6617/// 8.5.3), the type is adjusted to "T" prior to any further
6618/// analysis, the expression designates the object or function
6619/// denoted by the reference, and the expression is an lvalue.
6620inline QualType QualType::getNonReferenceType() const {
6621 if (const auto *RefType = (*this)->getAs<ReferenceType>())
6622 return RefType->getPointeeType();
6623 else
6624 return *this;
6625}
6626
6627inline bool QualType::isCForbiddenLValueType() const {
6628 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
6629 getTypePtr()->isFunctionType());
6630}
6631
6632/// Tests whether the type is categorized as a fundamental type.
6633///
6634/// \returns True for types specified in C++0x [basic.fundamental].
6635inline bool Type::isFundamentalType() const {
6636 return isVoidType() ||
6637 isNullPtrType() ||
6638 // FIXME: It's really annoying that we don't have an
6639 // 'isArithmeticType()' which agrees with the standard definition.
6640 (isArithmeticType() && !isEnumeralType());
6641}
6642
6643/// Tests whether the type is categorized as a compound type.
6644///
6645/// \returns True for types specified in C++0x [basic.compound].
6646inline bool Type::isCompoundType() const {
6647 // C++0x [basic.compound]p1:
6648 // Compound types can be constructed in the following ways:
6649 // -- arrays of objects of a given type [...];
6650 return isArrayType() ||
6651 // -- functions, which have parameters of given types [...];
6652 isFunctionType() ||
6653 // -- pointers to void or objects or functions [...];
6654 isPointerType() ||
6655 // -- references to objects or functions of a given type. [...]
6656 isReferenceType() ||
6657 // -- classes containing a sequence of objects of various types, [...];
6658 isRecordType() ||
6659 // -- unions, which are classes capable of containing objects of different
6660 // types at different times;
6661 isUnionType() ||
6662 // -- enumerations, which comprise a set of named constant values. [...];
6663 isEnumeralType() ||
6664 // -- pointers to non-static class members, [...].
6665 isMemberPointerType();
6666}
6667
6668inline bool Type::isFunctionType() const {
6669 return isa<FunctionType>(CanonicalType);
6670}
6671
6672inline bool Type::isPointerType() const {
6673 return isa<PointerType>(CanonicalType);
6674}
6675
6676inline bool Type::isAnyPointerType() const {
6677 return isPointerType() || isObjCObjectPointerType();
6678}
6679
6680inline bool Type::isBlockPointerType() const {
6681 return isa<BlockPointerType>(CanonicalType);
6682}
6683
6684inline bool Type::isReferenceType() const {
6685 return isa<ReferenceType>(CanonicalType);
6686}
6687
6688inline bool Type::isLValueReferenceType() const {
6689 return isa<LValueReferenceType>(CanonicalType);
6690}
6691
6692inline bool Type::isRValueReferenceType() const {
6693 return isa<RValueReferenceType>(CanonicalType);
6694}
6695
6696inline bool Type::isObjectPointerType() const {
6697 // Note: an "object pointer type" is not the same thing as a pointer to an
6698 // object type; rather, it is a pointer to an object type or a pointer to cv
6699 // void.
6700 if (const auto *T = getAs<PointerType>())
6701 return !T->getPointeeType()->isFunctionType();
6702 else
6703 return false;
6704}
6705
6706inline bool Type::isFunctionPointerType() const {
6707 if (const auto *T = getAs<PointerType>())
6708 return T->getPointeeType()->isFunctionType();
6709 else
6710 return false;
6711}
6712
6713inline bool Type::isFunctionReferenceType() const {
6714 if (const auto *T = getAs<ReferenceType>())
6715 return T->getPointeeType()->isFunctionType();
6716 else
6717 return false;
6718}
6719
6720inline bool Type::isMemberPointerType() const {
6721 return isa<MemberPointerType>(CanonicalType);
6722}
6723
6724inline bool Type::isMemberFunctionPointerType() const {
6725 if (const auto *T = getAs<MemberPointerType>())
6726 return T->isMemberFunctionPointer();
6727 else
6728 return false;
6729}
6730
6731inline bool Type::isMemberDataPointerType() const {
6732 if (const auto *T = getAs<MemberPointerType>())
6733 return T->isMemberDataPointer();
6734 else
6735 return false;
6736}
6737
6738inline bool Type::isArrayType() const {
6739 return isa<ArrayType>(CanonicalType);
6740}
6741
6742inline bool Type::isConstantArrayType() const {
6743 return isa<ConstantArrayType>(CanonicalType);
6744}
6745
6746inline bool Type::isIncompleteArrayType() const {
6747 return isa<IncompleteArrayType>(CanonicalType);
6748}
6749
6750inline bool Type::isVariableArrayType() const {
6751 return isa<VariableArrayType>(CanonicalType);
6752}
6753
6754inline bool Type::isDependentSizedArrayType() const {
6755 return isa<DependentSizedArrayType>(CanonicalType);
6756}
6757
6758inline bool Type::isBuiltinType() const {
6759 return isa<BuiltinType>(CanonicalType);
6760}
6761
6762inline bool Type::isRecordType() const {
6763 return isa<RecordType>(CanonicalType);
6764}
6765
6766inline bool Type::isEnumeralType() const {
6767 return isa<EnumType>(CanonicalType);
6768}
6769
6770inline bool Type::isAnyComplexType() const {
6771 return isa<ComplexType>(CanonicalType);
6772}
6773
6774inline bool Type::isVectorType() const {
6775 return isa<VectorType>(CanonicalType);
6776}
6777
6778inline bool Type::isExtVectorType() const {
6779 return isa<ExtVectorType>(CanonicalType);
6780}
6781
6782inline bool Type::isMatrixType() const {
6783 return isa<MatrixType>(CanonicalType);
6784}
6785
6786inline bool Type::isConstantMatrixType() const {
6787 return isa<ConstantMatrixType>(CanonicalType);
6788}
6789
6790inline bool Type::isDependentAddressSpaceType() const {
6791 return isa<DependentAddressSpaceType>(CanonicalType);
6792}
6793
6794inline bool Type::isObjCObjectPointerType() const {
6795 return isa<ObjCObjectPointerType>(CanonicalType);
6796}
6797
6798inline bool Type::isObjCObjectType() const {
6799 return isa<ObjCObjectType>(CanonicalType);
6800}
6801
6802inline bool Type::isObjCObjectOrInterfaceType() const {
6803 return isa<ObjCInterfaceType>(CanonicalType) ||
6804 isa<ObjCObjectType>(CanonicalType);
6805}
6806
6807inline bool Type::isAtomicType() const {
6808 return isa<AtomicType>(CanonicalType);
6809}
6810
6811inline bool Type::isUndeducedAutoType() const {
6812 return isa<AutoType>(CanonicalType);
6813}
6814
6815inline bool Type::isObjCQualifiedIdType() const {
6816 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6817 return OPT->isObjCQualifiedIdType();
6818 return false;
6819}
6820
6821inline bool Type::isObjCQualifiedClassType() const {
6822 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6823 return OPT->isObjCQualifiedClassType();
6824 return false;
6825}
6826
6827inline bool Type::isObjCIdType() const {
6828 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6829 return OPT->isObjCIdType();
6830 return false;
6831}
6832
6833inline bool Type::isObjCClassType() const {
6834 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6835 return OPT->isObjCClassType();
6836 return false;
6837}
6838
6839inline bool Type::isObjCSelType() const {
6840 if (const auto *OPT = getAs<PointerType>())
6841 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
6842 return false;
6843}
6844
6845inline bool Type::isObjCBuiltinType() const {
6846 return isObjCIdType() || isObjCClassType() || isObjCSelType();
6847}
6848
6849inline bool Type::isDecltypeType() const {
6850 return isa<DecltypeType>(this);
6851}
6852
6853#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6854 inline bool Type::is##Id##Type() const { \
6855 return isSpecificBuiltinType(BuiltinType::Id); \
6856 }
6857#include "clang/Basic/OpenCLImageTypes.def"
6858
6859inline bool Type::isSamplerT() const {
6860 return isSpecificBuiltinType(BuiltinType::OCLSampler);
6861}
6862
6863inline bool Type::isEventT() const {
6864 return isSpecificBuiltinType(BuiltinType::OCLEvent);
6865}
6866
6867inline bool Type::isClkEventT() const {
6868 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6869}
6870
6871inline bool Type::isQueueT() const {
6872 return isSpecificBuiltinType(BuiltinType::OCLQueue);
6873}
6874
6875inline bool Type::isReserveIDT() const {
6876 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6877}
6878
6879inline bool Type::isImageType() const {
6880#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
6881 return
6882#include "clang/Basic/OpenCLImageTypes.def"
6883 false; // end boolean or operation
6884}
6885
6886inline bool Type::isPipeType() const {
6887 return isa<PipeType>(CanonicalType);
6888}
6889
6890inline bool Type::isExtIntType() const {
6891 return isa<ExtIntType>(CanonicalType);
6892}
6893
6894#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6895 inline bool Type::is##Id##Type() const { \
6896 return isSpecificBuiltinType(BuiltinType::Id); \
6897 }
6898#include "clang/Basic/OpenCLExtensionTypes.def"
6899
6900inline bool Type::isOCLIntelSubgroupAVCType() const {
6901#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
6902 isOCLIntelSubgroupAVC##Id##Type() ||
6903 return
6904#include "clang/Basic/OpenCLExtensionTypes.def"
6905 false; // end of boolean or operation
6906}
6907
6908inline bool Type::isOCLExtOpaqueType() const {
6909#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
6910 return
6911#include "clang/Basic/OpenCLExtensionTypes.def"
6912 false; // end of boolean or operation
6913}
6914
6915inline bool Type::isOpenCLSpecificType() const {
6916 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
6917 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6918}
6919
6920inline bool Type::isTemplateTypeParmType() const {
6921 return isa<TemplateTypeParmType>(CanonicalType);
6922}
6923
6924inline bool Type::isSpecificBuiltinType(unsigned K) const {
6925 if (const BuiltinType *BT = getAs<BuiltinType>()) {
6926 return BT->getKind() == static_cast<BuiltinType::Kind>(K);
6927 }
6928 return false;
6929}
6930
6931inline bool Type::isPlaceholderType() const {
6932 if (const auto *BT = dyn_cast<BuiltinType>(this))
6933 return BT->isPlaceholderType();
6934 return false;
6935}
6936
6937inline const BuiltinType *Type::getAsPlaceholderType() const {
6938 if (const auto *BT = dyn_cast<BuiltinType>(this))
6939 if (BT->isPlaceholderType())
6940 return BT;
6941 return nullptr;
6942}
6943
6944inline bool Type::isSpecificPlaceholderType(unsigned K) const {
6945 assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))(static_cast<void> (0));
6946 return isSpecificBuiltinType(K);
6947}
6948
6949inline bool Type::isNonOverloadPlaceholderType() const {
6950 if (const auto *BT = dyn_cast<BuiltinType>(this))
6951 return BT->isNonOverloadPlaceholderType();
6952 return false;
6953}
6954
6955inline bool Type::isVoidType() const {
6956 return isSpecificBuiltinType(BuiltinType::Void);
6957}
6958
6959inline bool Type::isHalfType() const {
6960 // FIXME: Should we allow complex __fp16? Probably not.
6961 return isSpecificBuiltinType(BuiltinType::Half);
6962}
6963
6964inline bool Type::isFloat16Type() const {
6965 return isSpecificBuiltinType(BuiltinType::Float16);
6966}
6967
6968inline bool Type::isBFloat16Type() const {
6969 return isSpecificBuiltinType(BuiltinType::BFloat16);
6970}
6971
6972inline bool Type::isFloat128Type() const {
6973 return isSpecificBuiltinType(BuiltinType::Float128);
6974}
6975
6976inline bool Type::isNullPtrType() const {
6977 return isSpecificBuiltinType(BuiltinType::NullPtr);
6978}
6979
6980bool IsEnumDeclComplete(EnumDecl *);
6981bool IsEnumDeclScoped(EnumDecl *);
6982
6983inline bool Type::isIntegerType() const {
6984 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6985 return BT->getKind() >= BuiltinType::Bool &&
6986 BT->getKind() <= BuiltinType::Int128;
6987 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
6988 // Incomplete enum types are not treated as integer types.
6989 // FIXME: In C++, enum types are never integer types.
6990 return IsEnumDeclComplete(ET->getDecl()) &&
6991 !IsEnumDeclScoped(ET->getDecl());
6992 }
6993 return isExtIntType();
6994}
6995
6996inline bool Type::isFixedPointType() const {
6997 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
6998 return BT->getKind() >= BuiltinType::ShortAccum &&
6999 BT->getKind() <= BuiltinType::SatULongFract;
7000 }
7001 return false;
7002}
7003
7004inline bool Type::isFixedPointOrIntegerType() const {
7005 return isFixedPointType() || isIntegerType();
7006}
7007
7008inline bool Type::isSaturatedFixedPointType() const {
7009 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7010 return BT->getKind() >= BuiltinType::SatShortAccum &&
7011 BT->getKind() <= BuiltinType::SatULongFract;
7012 }
7013 return false;
7014}
7015
7016inline bool Type::isUnsaturatedFixedPointType() const {
7017 return isFixedPointType() && !isSaturatedFixedPointType();
7018}
7019
7020inline bool Type::isSignedFixedPointType() const {
7021 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7022 return ((BT->getKind() >= BuiltinType::ShortAccum &&
7023 BT->getKind() <= BuiltinType::LongAccum) ||
7024 (BT->getKind() >= BuiltinType::ShortFract &&
7025 BT->getKind() <= BuiltinType::LongFract) ||
7026 (BT->getKind() >= BuiltinType::SatShortAccum &&
7027 BT->getKind() <= BuiltinType::SatLongAccum) ||
7028 (BT->getKind() >= BuiltinType::SatShortFract &&
7029 BT->getKind() <= BuiltinType::SatLongFract));
7030 }
7031 return false;
7032}
7033
7034inline bool Type::isUnsignedFixedPointType() const {
7035 return isFixedPointType() && !isSignedFixedPointType();
7036}
7037
7038inline bool Type::isScalarType() const {
7039 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7040 return BT->getKind() > BuiltinType::Void &&
7041 BT->getKind() <= BuiltinType::NullPtr;
7042 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
7043 // Enums are scalar types, but only if they are defined. Incomplete enums
7044 // are not treated as scalar types.
7045 return IsEnumDeclComplete(ET->getDecl());
7046 return isa<PointerType>(CanonicalType) ||
7047 isa<BlockPointerType>(CanonicalType) ||
7048 isa<MemberPointerType>(CanonicalType) ||
7049 isa<ComplexType>(CanonicalType) ||
7050 isa<ObjCObjectPointerType>(CanonicalType) ||
7051 isExtIntType();
7052}
7053
7054inline bool Type::isIntegralOrEnumerationType() const {
7055 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7056 return BT->getKind() >= BuiltinType::Bool &&
7057 BT->getKind() <= BuiltinType::Int128;
7058
7059 // Check for a complete enum type; incomplete enum types are not properly an
7060 // enumeration type in the sense required here.
7061 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
7062 return IsEnumDeclComplete(ET->getDecl());
7063
7064 return isExtIntType();
7065}
7066
7067inline bool Type::isBooleanType() const {
7068 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7069 return BT->getKind() == BuiltinType::Bool;
7070 return false;
7071}
7072
7073inline bool Type::isUndeducedType() const {
7074 auto *DT = getContainedDeducedType();
7075 return DT && !DT->isDeduced();
7076}
7077
7078/// Determines whether this is a type for which one can define
7079/// an overloaded operator.
7080inline bool Type::isOverloadableType() const {
7081 return isDependentType() || isRecordType() || isEnumeralType();
7082}
7083
7084/// Determines whether this type is written as a typedef-name.
7085inline bool Type::isTypedefNameType() const {
7086 if (getAs<TypedefType>())
7087 return true;
7088 if (auto *TST = getAs<TemplateSpecializationType>())
7089 return TST->isTypeAlias();
7090 return false;
7091}
7092
7093/// Determines whether this type can decay to a pointer type.
7094inline bool Type::canDecayToPointerType() const {
7095 return isFunctionType() || isArrayType();
7096}
7097
7098inline bool Type::hasPointerRepresentation() const {
7099 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
7100 isObjCObjectPointerType() || isNullPtrType());
7101}
7102
7103inline bool Type::hasObjCPointerRepresentation() const {
7104 return isObjCObjectPointerType();
7105}
7106
7107inline const Type *Type::getBaseElementTypeUnsafe() const {
7108 const Type *type = this;
7109 while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
7110 type = arrayType->getElementType().getTypePtr();
7111 return type;
7112}
7113
7114inline const Type *Type::getPointeeOrArrayElementType() const {
7115 const Type *type = this;
7116 if (type->isAnyPointerType())
7117 return type->getPointeeType().getTypePtr();
7118 else if (type->isArrayType())
7119 return type->getBaseElementTypeUnsafe();
7120 return type;
7121}
7122/// Insertion operator for partial diagnostics. This allows sending adress
7123/// spaces into a diagnostic with <<.
7124inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7125 LangAS AS) {
7126 PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
7127 DiagnosticsEngine::ArgumentKind::ak_addrspace);
7128 return PD;
7129}
7130
7131/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7132/// into a diagnostic with <<.
7133inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7134 Qualifiers Q) {
7135 PD.AddTaggedVal(Q.getAsOpaqueValue(),
7136 DiagnosticsEngine::ArgumentKind::ak_qual);
7137 return PD;
7138}
7139
7140/// Insertion operator for partial diagnostics. This allows sending QualType's
7141/// into a diagnostic with <<.
7142inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7143 QualType T) {
7144 PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
7145 DiagnosticsEngine::ak_qualtype);
7146 return PD;
7147}
7148
7149// Helper class template that is used by Type::getAs to ensure that one does
7150// not try to look through a qualified type to get to an array type.
7151template <typename T>
7152using TypeIsArrayType =
7153 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
7154 std::is_base_of<ArrayType, T>::value>;
7155
7156// Member-template getAs<specific type>'.
7157template <typename T> const T *Type::getAs() const {
7158 static_assert(!TypeIsArrayType<T>::value,
7159 "ArrayType cannot be used with getAs!");
7160
7161 // If this is directly a T type, return it.
7162 if (const auto *Ty = dyn_cast<T>(this))
7163 return Ty;
7164
7165 // If the canonical form of this type isn't the right kind, reject it.
7166 if (!isa<T>(CanonicalType))
7167 return nullptr;
7168
7169 // If this is a typedef for the type, strip the typedef off without
7170 // losing all typedef information.
7171 return cast<T>(getUnqualifiedDesugaredType());
7172}
7173
7174template <typename T> const T *Type::getAsAdjusted() const {
7175 static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");
7176
7177 // If this is directly a T type, return it.
7178 if (const auto *Ty = dyn_cast<T>(this))
7179 return Ty;
7180
7181 // If the canonical form of this type isn't the right kind, reject it.
7182 if (!isa<T>(CanonicalType))
7183 return nullptr;
7184
7185 // Strip off type adjustments that do not modify the underlying nature of the
7186 // type.
7187 const Type *Ty = this;
7188 while (Ty) {
7189 if (const auto *A = dyn_cast<AttributedType>(Ty))
7190 Ty = A->getModifiedType().getTypePtr();
7191 else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
7192 Ty = E->desugar().getTypePtr();
7193 else if (const auto *P = dyn_cast<ParenType>(Ty))
7194 Ty = P->desugar().getTypePtr();
7195 else if (const auto *A = dyn_cast<AdjustedType>(Ty))
7196 Ty = A->desugar().getTypePtr();
7197 else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
7198 Ty = M->desugar().getTypePtr();
7199 else
7200 break;
7201 }
7202
7203 // Just because the canonical type is correct does not mean we can use cast<>,
7204 // since we may not have stripped off all the sugar down to the base type.
7205 return dyn_cast<T>(Ty);
7206}
7207
7208inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
7209 // If this is directly an array type, return it.
7210 if (const auto *arr = dyn_cast<ArrayType>(this))
7211 return arr;
7212
7213 // If the canonical form of this type isn't the right kind, reject it.
7214 if (!isa<ArrayType>(CanonicalType))
7215 return nullptr;
7216
7217 // If this is a typedef for the type, strip the typedef off without
7218 // losing all typedef information.
7219 return cast<ArrayType>(getUnqualifiedDesugaredType());
7220}
7221
7222template <typename T> const T *Type::castAs() const {
7223 static_assert(!TypeIsArrayType<T>::value,
7224 "ArrayType cannot be used with castAs!");
7225
7226 if (const auto *ty = dyn_cast<T>(this)) return ty;
7227 assert(isa<T>(CanonicalType))(static_cast<void> (0));
7228 return cast<T>(getUnqualifiedDesugaredType());
7229}
7230
7231inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
7232 assert(isa<ArrayType>(CanonicalType))(static_cast<void> (0));
7233 if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
7234 return cast<ArrayType>(getUnqualifiedDesugaredType());
7235}
7236
7237DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
7238 QualType CanonicalPtr)
7239 : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7240#ifndef NDEBUG1
7241 QualType Adjusted = getAdjustedType();
7242 (void)AttributedType::stripOuterNullability(Adjusted);
7243 assert(isa<PointerType>(Adjusted))(static_cast<void> (0));
7244#endif
7245}
7246
7247QualType DecayedType::getPointeeType() const {
7248 QualType Decayed = getDecayedType();
7249 (void)AttributedType::stripOuterNullability(Decayed);
7250 return cast<PointerType>(Decayed)->getPointeeType();
7251}
7252
7253// Get the decimal string representation of a fixed point type, represented
7254// as a scaled integer.
7255// TODO: At some point, we should change the arguments to instead just accept an
7256// APFixedPoint instead of APSInt and scale.
7257void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
7258 unsigned Scale);
7259
7260} // namespace clang
7261
7262#endif // LLVM_CLANG_AST_TYPE_H

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/PointerUnion.h

1//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- 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// This file defines the PointerUnion class, which is a discriminated union of
10// pointer types.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ADT_POINTERUNION_H
15#define LLVM_ADT_POINTERUNION_H
16
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23
24namespace llvm {
25
26namespace pointer_union_detail {
27 /// Determine the number of bits required to store integers with values < n.
28 /// This is ceil(log2(n)).
29 constexpr int bitsRequired(unsigned n) {
30 return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
31 }
32
33 template <typename... Ts> constexpr int lowBitsAvailable() {
34 return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
35 }
36
37 /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
38 /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
39 /// list.
40 template <typename T, typename ...Us> struct TypeIndex;
41 template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
42 static constexpr int Index = 0;
43 };
44 template <typename T, typename U, typename... Us>
45 struct TypeIndex<T, U, Us...> {
46 static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
47 };
48 template <typename T> struct TypeIndex<T> {
49 static constexpr int Index = 0;
50 };
51
52 /// Find the first type in a list of types.
53 template <typename T, typename...> struct GetFirstType {
54 using type = T;
55 };
56
57 /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
58 /// for the template arguments.
59 template <typename ...PTs> class PointerUnionUIntTraits {
60 public:
61 static inline void *getAsVoidPointer(void *P) { return P; }
62 static inline void *getFromVoidPointer(void *P) { return P; }
63 static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
64 };
65
66 template <typename Derived, typename ValTy, int I, typename ...Types>
67 class PointerUnionMembers;
68
69 template <typename Derived, typename ValTy, int I>
70 class PointerUnionMembers<Derived, ValTy, I> {
71 protected:
72 ValTy Val;
73 PointerUnionMembers() = default;
74 PointerUnionMembers(ValTy Val) : Val(Val) {}
75
76 friend struct PointerLikeTypeTraits<Derived>;
77 };
78
79 template <typename Derived, typename ValTy, int I, typename Type,
80 typename ...Types>
81 class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
82 : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
83 using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
84 public:
85 using Base::Base;
86 PointerUnionMembers() = default;
87 PointerUnionMembers(Type V)
88 : Base(ValTy(const_cast<void *>(
89 PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
90 I)) {}
91
92 using Base::operator=;
93 Derived &operator=(Type V) {
94 this->Val = ValTy(
95 const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
96 I);
97 return static_cast<Derived &>(*this);
98 };
99 };
100}
101
102/// A discriminated union of two or more pointer types, with the discriminator
103/// in the low bit of the pointer.
104///
105/// This implementation is extremely efficient in space due to leveraging the
106/// low bits of the pointer, while exposing a natural and type-safe API.
107///
108/// Common use patterns would be something like this:
109/// PointerUnion<int*, float*> P;
110/// P = (int*)0;
111/// printf("%d %d", P.is<int*>(), P.is<float*>()); // prints "1 0"
112/// X = P.get<int*>(); // ok.
113/// Y = P.get<float*>(); // runtime assertion failure.
114/// Z = P.get<double*>(); // compile time failure.
115/// P = (float*)0;
116/// Y = P.get<float*>(); // ok.
117/// X = P.get<int*>(); // runtime assertion failure.
118template <typename... PTs>
119class PointerUnion
120 : public pointer_union_detail::PointerUnionMembers<
121 PointerUnion<PTs...>,
122 PointerIntPair<
123 void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
124 pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
125 0, PTs...> {
126 // The first type is special because we want to directly cast a pointer to a
127 // default-initialized union to a pointer to the first type. But we don't
128 // want PointerUnion to be a 'template <typename First, typename ...Rest>'
129 // because it's much more convenient to have a name for the whole pack. So
130 // split off the first type here.
131 using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
132 using Base = typename PointerUnion::PointerUnionMembers;
133
134public:
135 PointerUnion() = default;
136
137 PointerUnion(std::nullptr_t) : PointerUnion() {}
138 using Base::Base;
139
140 /// Test if the pointer held in the union is null, regardless of
141 /// which type it is.
142 bool isNull() const { return !this->Val.getPointer(); }
35
Assuming the condition is false
36
Returning zero, which participates in a condition later
143
144 explicit operator bool() const { return !isNull(); }
145
146 /// Test if the Union currently holds the type matching T.
147 template <typename T> bool is() const {
148 constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
149 static_assert(Index < sizeof...(PTs),
150 "PointerUnion::is<T> given type not in the union");
151 return this->Val.getInt() == Index;
152 }
153
154 /// Returns the value of the specified pointer type.
155 ///
156 /// If the specified pointer type is incorrect, assert.
157 template <typename T> T get() const {
158 assert(is<T>() && "Invalid accessor called")(static_cast<void> (0));
159 return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
160 }
161
162 /// Returns the current pointer if it is of the specified pointer type,
163 /// otherwise returns null.
164 template <typename T> T dyn_cast() const {
165 if (is<T>())
166 return get<T>();
167 return T();
168 }
169
170 /// If the union is set to the first pointer type get an address pointing to
171 /// it.
172 First const *getAddrOfPtr1() const {
173 return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
174 }
175
176 /// If the union is set to the first pointer type get an address pointing to
177 /// it.
178 First *getAddrOfPtr1() {
179 assert(is<First>() && "Val is not the first pointer")(static_cast<void> (0));
180 assert((static_cast<void> (0))
181 PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==(static_cast<void> (0))
182 this->Val.getPointer() &&(static_cast<void> (0))
183 "Can't get the address because PointerLikeTypeTraits changes the ptr")(static_cast<void> (0));
184 return const_cast<First *>(
185 reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
186 }
187
188 /// Assignment from nullptr which just clears the union.
189 const PointerUnion &operator=(std::nullptr_t) {
190 this->Val.initWithPointer(nullptr);
191 return *this;
192 }
193
194 /// Assignment from elements of the union.
195 using Base::operator=;
196
197 void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
198 static inline PointerUnion getFromOpaqueValue(void *VP) {
199 PointerUnion V;
200 V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
201 return V;
202 }
203};
204
205template <typename ...PTs>
206bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
207 return lhs.getOpaqueValue() == rhs.getOpaqueValue();
208}
209
210template <typename ...PTs>
211bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
212 return lhs.getOpaqueValue() != rhs.getOpaqueValue();
213}
214
215template <typename ...PTs>
216bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
217 return lhs.getOpaqueValue() < rhs.getOpaqueValue();
218}
219
220// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
221// # low bits available = min(PT1bits,PT2bits)-1.
222template <typename ...PTs>
223struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
224 static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
225 return P.getOpaqueValue();
226 }
227
228 static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
229 return PointerUnion<PTs...>::getFromOpaqueValue(P);
230 }
231
232 // The number of bits available are the min of the pointer types minus the
233 // bits needed for the discriminator.
234 static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
235 PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
236};
237
238// Teach DenseMap how to use PointerUnions as keys.
239template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
240 using Union = PointerUnion<PTs...>;
241 using FirstInfo =
242 DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
243
244 static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
245
246 static inline Union getTombstoneKey() {
247 return Union(FirstInfo::getTombstoneKey());
248 }
249
250 static unsigned getHashValue(const Union &UnionVal) {
251 intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
252 return DenseMapInfo<intptr_t>::getHashValue(key);
253 }
254
255 static bool isEqual(const Union &LHS, const Union &RHS) {
256 return LHS == RHS;
257 }
258};
259
260} // end namespace llvm
261
262#endif // LLVM_ADT_POINTERUNION_H