Bug Summary

File:src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCXXScopeSpec.cpp
Warning:line 154, column 12
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaCXXScopeSpec.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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCXXScopeSpec.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCXXScopeSpec.cpp

1//===--- SemaCXXScopeSpec.cpp - Semantic Analysis for C++ scope specifiers-===//
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 C++ semantic analysis for scope specifiers.
10//
11//===----------------------------------------------------------------------===//
12
13#include "TypeLocBuilder.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/DeclTemplate.h"
16#include "clang/AST/ExprCXX.h"
17#include "clang/AST/NestedNameSpecifier.h"
18#include "clang/Basic/PartialDiagnostic.h"
19#include "clang/Sema/DeclSpec.h"
20#include "clang/Sema/Lookup.h"
21#include "clang/Sema/SemaInternal.h"
22#include "clang/Sema/Template.h"
23#include "llvm/ADT/STLExtras.h"
24using namespace clang;
25
26/// Find the current instantiation that associated with the given type.
27static CXXRecordDecl *getCurrentInstantiationOf(QualType T,
28 DeclContext *CurContext) {
29 if (T.isNull())
30 return nullptr;
31
32 const Type *Ty = T->getCanonicalTypeInternal().getTypePtr();
33 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
34 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
35 if (!Record->isDependentContext() ||
36 Record->isCurrentInstantiation(CurContext))
37 return Record;
38
39 return nullptr;
40 } else if (isa<InjectedClassNameType>(Ty))
41 return cast<InjectedClassNameType>(Ty)->getDecl();
42 else
43 return nullptr;
44}
45
46/// Compute the DeclContext that is associated with the given type.
47///
48/// \param T the type for which we are attempting to find a DeclContext.
49///
50/// \returns the declaration context represented by the type T,
51/// or NULL if the declaration context cannot be computed (e.g., because it is
52/// dependent and not the current instantiation).
53DeclContext *Sema::computeDeclContext(QualType T) {
54 if (!T->isDependentType())
55 if (const TagType *Tag = T->getAs<TagType>())
56 return Tag->getDecl();
57
58 return ::getCurrentInstantiationOf(T, CurContext);
59}
60
61/// Compute the DeclContext that is associated with the given
62/// scope specifier.
63///
64/// \param SS the C++ scope specifier as it appears in the source
65///
66/// \param EnteringContext when true, we will be entering the context of
67/// this scope specifier, so we can retrieve the declaration context of a
68/// class template or class template partial specialization even if it is
69/// not the current instantiation.
70///
71/// \returns the declaration context represented by the scope specifier @p SS,
72/// or NULL if the declaration context cannot be computed (e.g., because it is
73/// dependent and not the current instantiation).
74DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS,
75 bool EnteringContext) {
76 if (!SS.isSet() || SS.isInvalid())
3
Calling 'CXXScopeSpec::isSet'
6
Returning from 'CXXScopeSpec::isSet'
7
Calling 'CXXScopeSpec::isInvalid'
9
Returning from 'CXXScopeSpec::isInvalid'
10
Taking false branch
77 return nullptr;
78
79 NestedNameSpecifier *NNS = SS.getScopeRep();
80 if (NNS->isDependent()) {
11
Assuming the condition is false
12
Taking false branch
81 // If this nested-name-specifier refers to the current
82 // instantiation, return its DeclContext.
83 if (CXXRecordDecl *Record = getCurrentInstantiationOf(NNS))
84 return Record;
85
86 if (EnteringContext) {
87 const Type *NNSType = NNS->getAsType();
88 if (!NNSType) {
89 return nullptr;
90 }
91
92 // Look through type alias templates, per C++0x [temp.dep.type]p1.
93 NNSType = Context.getCanonicalType(NNSType);
94 if (const TemplateSpecializationType *SpecType
95 = NNSType->getAs<TemplateSpecializationType>()) {
96 // We are entering the context of the nested name specifier, so try to
97 // match the nested name specifier to either a primary class template
98 // or a class template partial specialization.
99 if (ClassTemplateDecl *ClassTemplate
100 = dyn_cast_or_null<ClassTemplateDecl>(
101 SpecType->getTemplateName().getAsTemplateDecl())) {
102 QualType ContextType
103 = Context.getCanonicalType(QualType(SpecType, 0));
104
105 // If the type of the nested name specifier is the same as the
106 // injected class name of the named class template, we're entering
107 // into that class template definition.
108 QualType Injected
109 = ClassTemplate->getInjectedClassNameSpecialization();
110 if (Context.hasSameType(Injected, ContextType))
111 return ClassTemplate->getTemplatedDecl();
112
113 // If the type of the nested name specifier is the same as the
114 // type of one of the class template's class template partial
115 // specializations, we're entering into the definition of that
116 // class template partial specialization.
117 if (ClassTemplatePartialSpecializationDecl *PartialSpec
118 = ClassTemplate->findPartialSpecialization(ContextType)) {
119 // A declaration of the partial specialization must be visible.
120 // We can always recover here, because this only happens when we're
121 // entering the context, and that can't happen in a SFINAE context.
122 assert(!isSFINAEContext() &&((void)0)
123 "partial specialization scope specifier in SFINAE context?")((void)0);
124 if (!hasVisibleDeclaration(PartialSpec))
125 diagnoseMissingImport(SS.getLastQualifierNameLoc(), PartialSpec,
126 MissingImportKind::PartialSpecialization,
127 /*Recover*/true);
128 return PartialSpec;
129 }
130 }
131 } else if (const RecordType *RecordT = NNSType->getAs<RecordType>()) {
132 // The nested name specifier refers to a member of a class template.
133 return RecordT->getDecl();
134 }
135 }
136
137 return nullptr;
138 }
139
140 switch (NNS->getKind()) {
13
Control jumps to 'case TypeSpecWithTemplate:' at line 151
141 case NestedNameSpecifier::Identifier:
142 llvm_unreachable("Dependent nested-name-specifier has no DeclContext")__builtin_unreachable();
143
144 case NestedNameSpecifier::Namespace:
145 return NNS->getAsNamespace();
146
147 case NestedNameSpecifier::NamespaceAlias:
148 return NNS->getAsNamespaceAlias()->getNamespace();
149
150 case NestedNameSpecifier::TypeSpec:
151 case NestedNameSpecifier::TypeSpecWithTemplate: {
152 const TagType *Tag = NNS->getAsType()->getAs<TagType>();
14
Assuming the object is not a 'TagType'
15
'Tag' initialized to a null pointer value
153 assert(Tag && "Non-tag type in nested-name-specifier")((void)0);
154 return Tag->getDecl();
16
Called C++ object pointer is null
155 }
156
157 case NestedNameSpecifier::Global:
158 return Context.getTranslationUnitDecl();
159
160 case NestedNameSpecifier::Super:
161 return NNS->getAsRecordDecl();
162 }
163
164 llvm_unreachable("Invalid NestedNameSpecifier::Kind!")__builtin_unreachable();
165}
166
167bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) {
168 if (!SS.isSet() || SS.isInvalid())
169 return false;
170
171 return SS.getScopeRep()->isDependent();
172}
173
174/// If the given nested name specifier refers to the current
175/// instantiation, return the declaration that corresponds to that
176/// current instantiation (C++0x [temp.dep.type]p1).
177///
178/// \param NNS a dependent nested name specifier.
179CXXRecordDecl *Sema::getCurrentInstantiationOf(NestedNameSpecifier *NNS) {
180 assert(getLangOpts().CPlusPlus && "Only callable in C++")((void)0);
181 assert(NNS->isDependent() && "Only dependent nested-name-specifier allowed")((void)0);
182
183 if (!NNS->getAsType())
184 return nullptr;
185
186 QualType T = QualType(NNS->getAsType(), 0);
187 return ::getCurrentInstantiationOf(T, CurContext);
188}
189
190/// Require that the context specified by SS be complete.
191///
192/// If SS refers to a type, this routine checks whether the type is
193/// complete enough (or can be made complete enough) for name lookup
194/// into the DeclContext. A type that is not yet completed can be
195/// considered "complete enough" if it is a class/struct/union/enum
196/// that is currently being defined. Or, if we have a type that names
197/// a class template specialization that is not a complete type, we
198/// will attempt to instantiate that class template.
199bool Sema::RequireCompleteDeclContext(CXXScopeSpec &SS,
200 DeclContext *DC) {
201 assert(DC && "given null context")((void)0);
202
203 TagDecl *tag = dyn_cast<TagDecl>(DC);
204
205 // If this is a dependent type, then we consider it complete.
206 // FIXME: This is wrong; we should require a (visible) definition to
207 // exist in this case too.
208 if (!tag || tag->isDependentContext())
209 return false;
210
211 // Grab the tag definition, if there is one.
212 QualType type = Context.getTypeDeclType(tag);
213 tag = type->getAsTagDecl();
214
215 // If we're currently defining this type, then lookup into the
216 // type is okay: don't complain that it isn't complete yet.
217 if (tag->isBeingDefined())
218 return false;
219
220 SourceLocation loc = SS.getLastQualifierNameLoc();
221 if (loc.isInvalid()) loc = SS.getRange().getBegin();
222
223 // The type must be complete.
224 if (RequireCompleteType(loc, type, diag::err_incomplete_nested_name_spec,
225 SS.getRange())) {
226 SS.SetInvalid(SS.getRange());
227 return true;
228 }
229
230 if (auto *EnumD = dyn_cast<EnumDecl>(tag))
231 // Fixed enum types and scoped enum instantiations are complete, but they
232 // aren't valid as scopes until we see or instantiate their definition.
233 return RequireCompleteEnumDecl(EnumD, loc, &SS);
234
235 return false;
236}
237
238/// Require that the EnumDecl is completed with its enumerators defined or
239/// instantiated. SS, if provided, is the ScopeRef parsed.
240///
241bool Sema::RequireCompleteEnumDecl(EnumDecl *EnumD, SourceLocation L,
242 CXXScopeSpec *SS) {
243 if (EnumD->isCompleteDefinition()) {
244 // If we know about the definition but it is not visible, complain.
245 NamedDecl *SuggestedDef = nullptr;
246 if (!hasVisibleDefinition(EnumD, &SuggestedDef,
247 /*OnlyNeedComplete*/false)) {
248 // If the user is going to see an error here, recover by making the
249 // definition visible.
250 bool TreatAsComplete = !isSFINAEContext();
251 diagnoseMissingImport(L, SuggestedDef, MissingImportKind::Definition,
252 /*Recover*/ TreatAsComplete);
253 return !TreatAsComplete;
254 }
255 return false;
256 }
257
258 // Try to instantiate the definition, if this is a specialization of an
259 // enumeration temploid.
260 if (EnumDecl *Pattern = EnumD->getInstantiatedFromMemberEnum()) {
261 MemberSpecializationInfo *MSI = EnumD->getMemberSpecializationInfo();
262 if (MSI->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) {
263 if (InstantiateEnum(L, EnumD, Pattern,
264 getTemplateInstantiationArgs(EnumD),
265 TSK_ImplicitInstantiation)) {
266 if (SS)
267 SS->SetInvalid(SS->getRange());
268 return true;
269 }
270 return false;
271 }
272 }
273
274 if (SS) {
275 Diag(L, diag::err_incomplete_nested_name_spec)
276 << QualType(EnumD->getTypeForDecl(), 0) << SS->getRange();
277 SS->SetInvalid(SS->getRange());
278 } else {
279 Diag(L, diag::err_incomplete_enum) << QualType(EnumD->getTypeForDecl(), 0);
280 Diag(EnumD->getLocation(), diag::note_declared_at);
281 }
282
283 return true;
284}
285
286bool Sema::ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc,
287 CXXScopeSpec &SS) {
288 SS.MakeGlobal(Context, CCLoc);
289 return false;
290}
291
292bool Sema::ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
293 SourceLocation ColonColonLoc,
294 CXXScopeSpec &SS) {
295 CXXRecordDecl *RD = nullptr;
296 for (Scope *S = getCurScope(); S; S = S->getParent()) {
297 if (S->isFunctionScope()) {
298 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(S->getEntity()))
299 RD = MD->getParent();
300 break;
301 }
302 if (S->isClassScope()) {
303 RD = cast<CXXRecordDecl>(S->getEntity());
304 break;
305 }
306 }
307
308 if (!RD) {
309 Diag(SuperLoc, diag::err_invalid_super_scope);
310 return true;
311 } else if (RD->isLambda()) {
312 Diag(SuperLoc, diag::err_super_in_lambda_unsupported);
313 return true;
314 } else if (RD->getNumBases() == 0) {
315 Diag(SuperLoc, diag::err_no_base_classes) << RD->getName();
316 return true;
317 }
318
319 SS.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
320 return false;
321}
322
323/// Determines whether the given declaration is an valid acceptable
324/// result for name lookup of a nested-name-specifier.
325/// \param SD Declaration checked for nested-name-specifier.
326/// \param IsExtension If not null and the declaration is accepted as an
327/// extension, the pointed variable is assigned true.
328bool Sema::isAcceptableNestedNameSpecifier(const NamedDecl *SD,
329 bool *IsExtension) {
330 if (!SD)
331 return false;
332
333 SD = SD->getUnderlyingDecl();
334
335 // Namespace and namespace aliases are fine.
336 if (isa<NamespaceDecl>(SD))
337 return true;
338
339 if (!isa<TypeDecl>(SD))
340 return false;
341
342 // Determine whether we have a class (or, in C++11, an enum) or
343 // a typedef thereof. If so, build the nested-name-specifier.
344 QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
345 if (T->isDependentType())
346 return true;
347 if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) {
348 if (TD->getUnderlyingType()->isRecordType())
349 return true;
350 if (TD->getUnderlyingType()->isEnumeralType()) {
351 if (Context.getLangOpts().CPlusPlus11)
352 return true;
353 if (IsExtension)
354 *IsExtension = true;
355 }
356 } else if (isa<RecordDecl>(SD)) {
357 return true;
358 } else if (isa<EnumDecl>(SD)) {
359 if (Context.getLangOpts().CPlusPlus11)
360 return true;
361 if (IsExtension)
362 *IsExtension = true;
363 }
364
365 return false;
366}
367
368/// If the given nested-name-specifier begins with a bare identifier
369/// (e.g., Base::), perform name lookup for that identifier as a
370/// nested-name-specifier within the given scope, and return the result of that
371/// name lookup.
372NamedDecl *Sema::FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS) {
373 if (!S || !NNS)
374 return nullptr;
375
376 while (NNS->getPrefix())
377 NNS = NNS->getPrefix();
378
379 if (NNS->getKind() != NestedNameSpecifier::Identifier)
380 return nullptr;
381
382 LookupResult Found(*this, NNS->getAsIdentifier(), SourceLocation(),
383 LookupNestedNameSpecifierName);
384 LookupName(Found, S);
385 assert(!Found.isAmbiguous() && "Cannot handle ambiguities here yet")((void)0);
386
387 if (!Found.isSingleResult())
388 return nullptr;
389
390 NamedDecl *Result = Found.getFoundDecl();
391 if (isAcceptableNestedNameSpecifier(Result))
392 return Result;
393
394 return nullptr;
395}
396
397bool Sema::isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
398 NestedNameSpecInfo &IdInfo) {
399 QualType ObjectType = GetTypeFromParser(IdInfo.ObjectType);
400 LookupResult Found(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
401 LookupNestedNameSpecifierName);
402
403 // Determine where to perform name lookup
404 DeclContext *LookupCtx = nullptr;
405 bool isDependent = false;
406 if (!ObjectType.isNull()) {
407 // This nested-name-specifier occurs in a member access expression, e.g.,
408 // x->B::f, and we are looking into the type of the object.
409 assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist")((void)0);
410 LookupCtx = computeDeclContext(ObjectType);
411 isDependent = ObjectType->isDependentType();
412 } else if (SS.isSet()) {
413 // This nested-name-specifier occurs after another nested-name-specifier,
414 // so long into the context associated with the prior nested-name-specifier.
415 LookupCtx = computeDeclContext(SS, false);
416 isDependent = isDependentScopeSpecifier(SS);
417 Found.setContextRange(SS.getRange());
418 }
419
420 if (LookupCtx) {
421 // Perform "qualified" name lookup into the declaration context we
422 // computed, which is either the type of the base of a member access
423 // expression or the declaration context associated with a prior
424 // nested-name-specifier.
425
426 // The declaration context must be complete.
427 if (!LookupCtx->isDependentContext() &&
428 RequireCompleteDeclContext(SS, LookupCtx))
429 return false;
430
431 LookupQualifiedName(Found, LookupCtx);
432 } else if (isDependent) {
433 return false;
434 } else {
435 LookupName(Found, S);
436 }
437 Found.suppressDiagnostics();
438
439 return Found.getAsSingle<NamespaceDecl>();
440}
441
442namespace {
443
444// Callback to only accept typo corrections that can be a valid C++ member
445// intializer: either a non-static field member or a base class.
446class NestedNameSpecifierValidatorCCC final
447 : public CorrectionCandidateCallback {
448public:
449 explicit NestedNameSpecifierValidatorCCC(Sema &SRef)
450 : SRef(SRef) {}
451
452 bool ValidateCandidate(const TypoCorrection &candidate) override {
453 return SRef.isAcceptableNestedNameSpecifier(candidate.getCorrectionDecl());
454 }
455
456 std::unique_ptr<CorrectionCandidateCallback> clone() override {
457 return std::make_unique<NestedNameSpecifierValidatorCCC>(*this);
458 }
459
460 private:
461 Sema &SRef;
462};
463
464}
465
466/// Build a new nested-name-specifier for "identifier::", as described
467/// by ActOnCXXNestedNameSpecifier.
468///
469/// \param S Scope in which the nested-name-specifier occurs.
470/// \param IdInfo Parser information about an identifier in the
471/// nested-name-spec.
472/// \param EnteringContext If true, enter the context specified by the
473/// nested-name-specifier.
474/// \param SS Optional nested name specifier preceding the identifier.
475/// \param ScopeLookupResult Provides the result of name lookup within the
476/// scope of the nested-name-specifier that was computed at template
477/// definition time.
478/// \param ErrorRecoveryLookup Specifies if the method is called to improve
479/// error recovery and what kind of recovery is performed.
480/// \param IsCorrectedToColon If not null, suggestion of replace '::' -> ':'
481/// are allowed. The bool value pointed by this parameter is set to
482/// 'true' if the identifier is treated as if it was followed by ':',
483/// not '::'.
484/// \param OnlyNamespace If true, only considers namespaces in lookup.
485///
486/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
487/// that it contains an extra parameter \p ScopeLookupResult, which provides
488/// the result of name lookup within the scope of the nested-name-specifier
489/// that was computed at template definition time.
490///
491/// If ErrorRecoveryLookup is true, then this call is used to improve error
492/// recovery. This means that it should not emit diagnostics, it should
493/// just return true on failure. It also means it should only return a valid
494/// scope if it *knows* that the result is correct. It should not return in a
495/// dependent context, for example. Nor will it extend \p SS with the scope
496/// specifier.
497bool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
498 bool EnteringContext, CXXScopeSpec &SS,
499 NamedDecl *ScopeLookupResult,
500 bool ErrorRecoveryLookup,
501 bool *IsCorrectedToColon,
502 bool OnlyNamespace) {
503 if (IdInfo.Identifier->isEditorPlaceholder())
504 return true;
505 LookupResult Found(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
506 OnlyNamespace ? LookupNamespaceName
507 : LookupNestedNameSpecifierName);
508 QualType ObjectType = GetTypeFromParser(IdInfo.ObjectType);
509
510 // Determine where to perform name lookup
511 DeclContext *LookupCtx = nullptr;
512 bool isDependent = false;
513 if (IsCorrectedToColon)
514 *IsCorrectedToColon = false;
515 if (!ObjectType.isNull()) {
516 // This nested-name-specifier occurs in a member access expression, e.g.,
517 // x->B::f, and we are looking into the type of the object.
518 assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist")((void)0);
519 LookupCtx = computeDeclContext(ObjectType);
520 isDependent = ObjectType->isDependentType();
521 } else if (SS.isSet()) {
522 // This nested-name-specifier occurs after another nested-name-specifier,
523 // so look into the context associated with the prior nested-name-specifier.
524 LookupCtx = computeDeclContext(SS, EnteringContext);
525 isDependent = isDependentScopeSpecifier(SS);
526 Found.setContextRange(SS.getRange());
527 }
528
529 bool ObjectTypeSearchedInScope = false;
530 if (LookupCtx) {
531 // Perform "qualified" name lookup into the declaration context we
532 // computed, which is either the type of the base of a member access
533 // expression or the declaration context associated with a prior
534 // nested-name-specifier.
535
536 // The declaration context must be complete.
537 if (!LookupCtx->isDependentContext() &&
538 RequireCompleteDeclContext(SS, LookupCtx))
539 return true;
540
541 LookupQualifiedName(Found, LookupCtx);
542
543 if (!ObjectType.isNull() && Found.empty()) {
544 // C++ [basic.lookup.classref]p4:
545 // If the id-expression in a class member access is a qualified-id of
546 // the form
547 //
548 // class-name-or-namespace-name::...
549 //
550 // the class-name-or-namespace-name following the . or -> operator is
551 // looked up both in the context of the entire postfix-expression and in
552 // the scope of the class of the object expression. If the name is found
553 // only in the scope of the class of the object expression, the name
554 // shall refer to a class-name. If the name is found only in the
555 // context of the entire postfix-expression, the name shall refer to a
556 // class-name or namespace-name. [...]
557 //
558 // Qualified name lookup into a class will not find a namespace-name,
559 // so we do not need to diagnose that case specifically. However,
560 // this qualified name lookup may find nothing. In that case, perform
561 // unqualified name lookup in the given scope (if available) or
562 // reconstruct the result from when name lookup was performed at template
563 // definition time.
564 if (S)
565 LookupName(Found, S);
566 else if (ScopeLookupResult)
567 Found.addDecl(ScopeLookupResult);
568
569 ObjectTypeSearchedInScope = true;
570 }
571 } else if (!isDependent) {
572 // Perform unqualified name lookup in the current scope.
573 LookupName(Found, S);
574 }
575
576 if (Found.isAmbiguous())
577 return true;
578
579 // If we performed lookup into a dependent context and did not find anything,
580 // that's fine: just build a dependent nested-name-specifier.
581 if (Found.empty() && isDependent &&
582 !(LookupCtx && LookupCtx->isRecord() &&
583 (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
584 !cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases()))) {
585 // Don't speculate if we're just trying to improve error recovery.
586 if (ErrorRecoveryLookup)
587 return true;
588
589 // We were not able to compute the declaration context for a dependent
590 // base object type or prior nested-name-specifier, so this
591 // nested-name-specifier refers to an unknown specialization. Just build
592 // a dependent nested-name-specifier.
593 SS.Extend(Context, IdInfo.Identifier, IdInfo.IdentifierLoc, IdInfo.CCLoc);
594 return false;
595 }
596
597 if (Found.empty() && !ErrorRecoveryLookup) {
598 // If identifier is not found as class-name-or-namespace-name, but is found
599 // as other entity, don't look for typos.
600 LookupResult R(*this, Found.getLookupNameInfo(), LookupOrdinaryName);
601 if (LookupCtx)
602 LookupQualifiedName(R, LookupCtx);
603 else if (S && !isDependent)
604 LookupName(R, S);
605 if (!R.empty()) {
606 // Don't diagnose problems with this speculative lookup.
607 R.suppressDiagnostics();
608 // The identifier is found in ordinary lookup. If correction to colon is
609 // allowed, suggest replacement to ':'.
610 if (IsCorrectedToColon) {
611 *IsCorrectedToColon = true;
612 Diag(IdInfo.CCLoc, diag::err_nested_name_spec_is_not_class)
613 << IdInfo.Identifier << getLangOpts().CPlusPlus
614 << FixItHint::CreateReplacement(IdInfo.CCLoc, ":");
615 if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
616 Diag(ND->getLocation(), diag::note_declared_at);
617 return true;
618 }
619 // Replacement '::' -> ':' is not allowed, just issue respective error.
620 Diag(R.getNameLoc(), OnlyNamespace
621 ? unsigned(diag::err_expected_namespace_name)
622 : unsigned(diag::err_expected_class_or_namespace))
623 << IdInfo.Identifier << getLangOpts().CPlusPlus;
624 if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
625 Diag(ND->getLocation(), diag::note_entity_declared_at)
626 << IdInfo.Identifier;
627 return true;
628 }
629 }
630
631 if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {
632 // We haven't found anything, and we're not recovering from a
633 // different kind of error, so look for typos.
634 DeclarationName Name = Found.getLookupName();
635 Found.clear();
636 NestedNameSpecifierValidatorCCC CCC(*this);
637 if (TypoCorrection Corrected = CorrectTypo(
638 Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS, CCC,
639 CTK_ErrorRecovery, LookupCtx, EnteringContext)) {
640 if (LookupCtx) {
641 bool DroppedSpecifier =
642 Corrected.WillReplaceSpecifier() &&
643 Name.getAsString() == Corrected.getAsString(getLangOpts());
644 if (DroppedSpecifier)
645 SS.clear();
646 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
647 << Name << LookupCtx << DroppedSpecifier
648 << SS.getRange());
649 } else
650 diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
651 << Name);
652
653 if (Corrected.getCorrectionSpecifier())
654 SS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
655 SourceRange(Found.getNameLoc()));
656
657 if (NamedDecl *ND = Corrected.getFoundDecl())
658 Found.addDecl(ND);
659 Found.setLookupName(Corrected.getCorrection());
660 } else {
661 Found.setLookupName(IdInfo.Identifier);
662 }
663 }
664
665 NamedDecl *SD =
666 Found.isSingleResult() ? Found.getRepresentativeDecl() : nullptr;
667 bool IsExtension = false;
668 bool AcceptSpec = isAcceptableNestedNameSpecifier(SD, &IsExtension);
669 if (!AcceptSpec && IsExtension) {
670 AcceptSpec = true;
671 Diag(IdInfo.IdentifierLoc, diag::ext_nested_name_spec_is_enum);
672 }
673 if (AcceptSpec) {
674 if (!ObjectType.isNull() && !ObjectTypeSearchedInScope &&
675 !getLangOpts().CPlusPlus11) {
676 // C++03 [basic.lookup.classref]p4:
677 // [...] If the name is found in both contexts, the
678 // class-name-or-namespace-name shall refer to the same entity.
679 //
680 // We already found the name in the scope of the object. Now, look
681 // into the current scope (the scope of the postfix-expression) to
682 // see if we can find the same name there. As above, if there is no
683 // scope, reconstruct the result from the template instantiation itself.
684 //
685 // Note that C++11 does *not* perform this redundant lookup.
686 NamedDecl *OuterDecl;
687 if (S) {
688 LookupResult FoundOuter(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
689 LookupNestedNameSpecifierName);
690 LookupName(FoundOuter, S);
691 OuterDecl = FoundOuter.getAsSingle<NamedDecl>();
692 } else
693 OuterDecl = ScopeLookupResult;
694
695 if (isAcceptableNestedNameSpecifier(OuterDecl) &&
696 OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() &&
697 (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) ||
698 !Context.hasSameType(
699 Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
700 Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
701 if (ErrorRecoveryLookup)
702 return true;
703
704 Diag(IdInfo.IdentifierLoc,
705 diag::err_nested_name_member_ref_lookup_ambiguous)
706 << IdInfo.Identifier;
707 Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type)
708 << ObjectType;
709 Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);
710
711 // Fall through so that we'll pick the name we found in the object
712 // type, since that's probably what the user wanted anyway.
713 }
714 }
715
716 if (auto *TD = dyn_cast_or_null<TypedefNameDecl>(SD))
717 MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
718
719 // If we're just performing this lookup for error-recovery purposes,
720 // don't extend the nested-name-specifier. Just return now.
721 if (ErrorRecoveryLookup)
722 return false;
723
724 // The use of a nested name specifier may trigger deprecation warnings.
725 DiagnoseUseOfDecl(SD, IdInfo.CCLoc);
726
727 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) {
728 SS.Extend(Context, Namespace, IdInfo.IdentifierLoc, IdInfo.CCLoc);
729 return false;
730 }
731
732 if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) {
733 SS.Extend(Context, Alias, IdInfo.IdentifierLoc, IdInfo.CCLoc);
734 return false;
735 }
736
737 QualType T =
738 Context.getTypeDeclType(cast<TypeDecl>(SD->getUnderlyingDecl()));
739 TypeLocBuilder TLB;
740 if (isa<InjectedClassNameType>(T)) {
741 InjectedClassNameTypeLoc InjectedTL
742 = TLB.push<InjectedClassNameTypeLoc>(T);
743 InjectedTL.setNameLoc(IdInfo.IdentifierLoc);
744 } else if (isa<RecordType>(T)) {
745 RecordTypeLoc RecordTL = TLB.push<RecordTypeLoc>(T);
746 RecordTL.setNameLoc(IdInfo.IdentifierLoc);
747 } else if (isa<TypedefType>(T)) {
748 TypedefTypeLoc TypedefTL = TLB.push<TypedefTypeLoc>(T);
749 TypedefTL.setNameLoc(IdInfo.IdentifierLoc);
750 } else if (isa<EnumType>(T)) {
751 EnumTypeLoc EnumTL = TLB.push<EnumTypeLoc>(T);
752 EnumTL.setNameLoc(IdInfo.IdentifierLoc);
753 } else if (isa<TemplateTypeParmType>(T)) {
754 TemplateTypeParmTypeLoc TemplateTypeTL
755 = TLB.push<TemplateTypeParmTypeLoc>(T);
756 TemplateTypeTL.setNameLoc(IdInfo.IdentifierLoc);
757 } else if (isa<UnresolvedUsingType>(T)) {
758 UnresolvedUsingTypeLoc UnresolvedTL
759 = TLB.push<UnresolvedUsingTypeLoc>(T);
760 UnresolvedTL.setNameLoc(IdInfo.IdentifierLoc);
761 } else if (isa<SubstTemplateTypeParmType>(T)) {
762 SubstTemplateTypeParmTypeLoc TL
763 = TLB.push<SubstTemplateTypeParmTypeLoc>(T);
764 TL.setNameLoc(IdInfo.IdentifierLoc);
765 } else if (isa<SubstTemplateTypeParmPackType>(T)) {
766 SubstTemplateTypeParmPackTypeLoc TL
767 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(T);
768 TL.setNameLoc(IdInfo.IdentifierLoc);
769 } else {
770 llvm_unreachable("Unhandled TypeDecl node in nested-name-specifier")__builtin_unreachable();
771 }
772
773 if (T->isEnumeralType())
774 Diag(IdInfo.IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec);
775
776 SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
777 IdInfo.CCLoc);
778 return false;
779 }
780
781 // Otherwise, we have an error case. If we don't want diagnostics, just
782 // return an error now.
783 if (ErrorRecoveryLookup)
784 return true;
785
786 // If we didn't find anything during our lookup, try again with
787 // ordinary name lookup, which can help us produce better error
788 // messages.
789 if (Found.empty()) {
790 Found.clear(LookupOrdinaryName);
791 LookupName(Found, S);
792 }
793
794 // In Microsoft mode, if we are within a templated function and we can't
795 // resolve Identifier, then extend the SS with Identifier. This will have
796 // the effect of resolving Identifier during template instantiation.
797 // The goal is to be able to resolve a function call whose
798 // nested-name-specifier is located inside a dependent base class.
799 // Example:
800 //
801 // class C {
802 // public:
803 // static void foo2() { }
804 // };
805 // template <class T> class A { public: typedef C D; };
806 //
807 // template <class T> class B : public A<T> {
808 // public:
809 // void foo() { D::foo2(); }
810 // };
811 if (getLangOpts().MSVCCompat) {
812 DeclContext *DC = LookupCtx ? LookupCtx : CurContext;
813 if (DC->isDependentContext() && DC->isFunctionOrMethod()) {
814 CXXRecordDecl *ContainingClass = dyn_cast<CXXRecordDecl>(DC->getParent());
815 if (ContainingClass && ContainingClass->hasAnyDependentBases()) {
816 Diag(IdInfo.IdentifierLoc,
817 diag::ext_undeclared_unqual_id_with_dependent_base)
818 << IdInfo.Identifier << ContainingClass;
819 SS.Extend(Context, IdInfo.Identifier, IdInfo.IdentifierLoc,
820 IdInfo.CCLoc);
821 return false;
822 }
823 }
824 }
825
826 if (!Found.empty()) {
827 if (TypeDecl *TD = Found.getAsSingle<TypeDecl>())
828 Diag(IdInfo.IdentifierLoc, diag::err_expected_class_or_namespace)
829 << Context.getTypeDeclType(TD) << getLangOpts().CPlusPlus;
830 else {
831 Diag(IdInfo.IdentifierLoc, diag::err_expected_class_or_namespace)
832 << IdInfo.Identifier << getLangOpts().CPlusPlus;
833 if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
834 Diag(ND->getLocation(), diag::note_entity_declared_at)
835 << IdInfo.Identifier;
836 }
837 } else if (SS.isSet())
838 Diag(IdInfo.IdentifierLoc, diag::err_no_member) << IdInfo.Identifier
839 << LookupCtx << SS.getRange();
840 else
841 Diag(IdInfo.IdentifierLoc, diag::err_undeclared_var_use)
842 << IdInfo.Identifier;
843
844 return true;
845}
846
847bool Sema::ActOnCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
848 bool EnteringContext, CXXScopeSpec &SS,
849 bool ErrorRecoveryLookup,
850 bool *IsCorrectedToColon,
851 bool OnlyNamespace) {
852 if (SS.isInvalid())
853 return true;
854
855 return BuildCXXNestedNameSpecifier(S, IdInfo, EnteringContext, SS,
856 /*ScopeLookupResult=*/nullptr, false,
857 IsCorrectedToColon, OnlyNamespace);
858}
859
860bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
861 const DeclSpec &DS,
862 SourceLocation ColonColonLoc) {
863 if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
864 return true;
865
866 assert(DS.getTypeSpecType() == DeclSpec::TST_decltype)((void)0);
867
868 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
869 if (T.isNull())
870 return true;
871
872 if (!T->isDependentType() && !T->getAs<TagType>()) {
873 Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class_or_namespace)
874 << T << getLangOpts().CPlusPlus;
875 return true;
876 }
877
878 TypeLocBuilder TLB;
879 DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
880 DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
881 SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
882 ColonColonLoc);
883 return false;
884}
885
886/// IsInvalidUnlessNestedName - This method is used for error recovery
887/// purposes to determine whether the specified identifier is only valid as
888/// a nested name specifier, for example a namespace name. It is
889/// conservatively correct to always return false from this method.
890///
891/// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
892bool Sema::IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
893 NestedNameSpecInfo &IdInfo,
894 bool EnteringContext) {
895 if (SS.isInvalid())
896 return false;
897
898 return !BuildCXXNestedNameSpecifier(S, IdInfo, EnteringContext, SS,
899 /*ScopeLookupResult=*/nullptr, true);
900}
901
902bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
903 CXXScopeSpec &SS,
904 SourceLocation TemplateKWLoc,
905 TemplateTy OpaqueTemplate,
906 SourceLocation TemplateNameLoc,
907 SourceLocation LAngleLoc,
908 ASTTemplateArgsPtr TemplateArgsIn,
909 SourceLocation RAngleLoc,
910 SourceLocation CCLoc,
911 bool EnteringContext) {
912 if (SS.isInvalid())
913 return true;
914
915 TemplateName Template = OpaqueTemplate.get();
916
917 // Translate the parser's template argument list in our AST format.
918 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
919 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
920
921 DependentTemplateName *DTN = Template.getAsDependentTemplateName();
922 if (DTN && DTN->isIdentifier()) {
923 // Handle a dependent template specialization for which we cannot resolve
924 // the template name.
925 assert(DTN->getQualifier() == SS.getScopeRep())((void)0);
926 QualType T = Context.getDependentTemplateSpecializationType(ETK_None,
927 DTN->getQualifier(),
928 DTN->getIdentifier(),
929 TemplateArgs);
930
931 // Create source-location information for this type.
932 TypeLocBuilder Builder;
933 DependentTemplateSpecializationTypeLoc SpecTL
934 = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
935 SpecTL.setElaboratedKeywordLoc(SourceLocation());
936 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
937 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
938 SpecTL.setTemplateNameLoc(TemplateNameLoc);
939 SpecTL.setLAngleLoc(LAngleLoc);
940 SpecTL.setRAngleLoc(RAngleLoc);
941 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
942 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
943
944 SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
945 CCLoc);
946 return false;
947 }
948
949 // If we assumed an undeclared identifier was a template name, try to
950 // typo-correct it now.
951 if (Template.getAsAssumedTemplateName() &&
952 resolveAssumedTemplateNameAsType(S, Template, TemplateNameLoc))
953 return true;
954
955 TemplateDecl *TD = Template.getAsTemplateDecl();
956 if (Template.getAsOverloadedTemplate() || DTN ||
957 isa<FunctionTemplateDecl>(TD) || isa<VarTemplateDecl>(TD)) {
958 SourceRange R(TemplateNameLoc, RAngleLoc);
959 if (SS.getRange().isValid())
960 R.setBegin(SS.getRange().getBegin());
961
962 Diag(CCLoc, diag::err_non_type_template_in_nested_name_specifier)
963 << (TD && isa<VarTemplateDecl>(TD)) << Template << R;
964 NoteAllFoundTemplates(Template);
965 return true;
966 }
967
968 // We were able to resolve the template name to an actual template.
969 // Build an appropriate nested-name-specifier.
970 QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
971 if (T.isNull())
972 return true;
973
974 // Alias template specializations can produce types which are not valid
975 // nested name specifiers.
976 if (!T->isDependentType() && !T->getAs<TagType>()) {
977 Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T;
978 NoteAllFoundTemplates(Template);
979 return true;
980 }
981
982 // Provide source-location information for the template specialization type.
983 TypeLocBuilder Builder;
984 TemplateSpecializationTypeLoc SpecTL
985 = Builder.push<TemplateSpecializationTypeLoc>(T);
986 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
987 SpecTL.setTemplateNameLoc(TemplateNameLoc);
988 SpecTL.setLAngleLoc(LAngleLoc);
989 SpecTL.setRAngleLoc(RAngleLoc);
990 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
991 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
992
993
994 SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
995 CCLoc);
996 return false;
997}
998
999namespace {
1000 /// A structure that stores a nested-name-specifier annotation,
1001 /// including both the nested-name-specifier
1002 struct NestedNameSpecifierAnnotation {
1003 NestedNameSpecifier *NNS;
1004 };
1005}
1006
1007void *Sema::SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS) {
1008 if (SS.isEmpty() || SS.isInvalid())
1009 return nullptr;
1010
1011 void *Mem = Context.Allocate(
1012 (sizeof(NestedNameSpecifierAnnotation) + SS.location_size()),
1013 alignof(NestedNameSpecifierAnnotation));
1014 NestedNameSpecifierAnnotation *Annotation
1015 = new (Mem) NestedNameSpecifierAnnotation;
1016 Annotation->NNS = SS.getScopeRep();
1017 memcpy(Annotation + 1, SS.location_data(), SS.location_size());
1018 return Annotation;
1019}
1020
1021void Sema::RestoreNestedNameSpecifierAnnotation(void *AnnotationPtr,
1022 SourceRange AnnotationRange,
1023 CXXScopeSpec &SS) {
1024 if (!AnnotationPtr) {
1025 SS.SetInvalid(AnnotationRange);
1026 return;
1027 }
1028
1029 NestedNameSpecifierAnnotation *Annotation
1030 = static_cast<NestedNameSpecifierAnnotation *>(AnnotationPtr);
1031 SS.Adopt(NestedNameSpecifierLoc(Annotation->NNS, Annotation + 1));
1032}
1033
1034bool Sema::ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
1035 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.")((void)0);
1036
1037 // Don't enter a declarator context when the current context is an Objective-C
1038 // declaration.
1039 if (isa<ObjCContainerDecl>(CurContext) || isa<ObjCMethodDecl>(CurContext))
1040 return false;
1041
1042 NestedNameSpecifier *Qualifier = SS.getScopeRep();
1043
1044 // There are only two places a well-formed program may qualify a
1045 // declarator: first, when defining a namespace or class member
1046 // out-of-line, and second, when naming an explicitly-qualified
1047 // friend function. The latter case is governed by
1048 // C++03 [basic.lookup.unqual]p10:
1049 // In a friend declaration naming a member function, a name used
1050 // in the function declarator and not part of a template-argument
1051 // in a template-id is first looked up in the scope of the member
1052 // function's class. If it is not found, or if the name is part of
1053 // a template-argument in a template-id, the look up is as
1054 // described for unqualified names in the definition of the class
1055 // granting friendship.
1056 // i.e. we don't push a scope unless it's a class member.
1057
1058 switch (Qualifier->getKind()) {
1059 case NestedNameSpecifier::Global:
1060 case NestedNameSpecifier::Namespace:
1061 case NestedNameSpecifier::NamespaceAlias:
1062 // These are always namespace scopes. We never want to enter a
1063 // namespace scope from anything but a file context.
1064 return CurContext->getRedeclContext()->isFileContext();
1065
1066 case NestedNameSpecifier::Identifier:
1067 case NestedNameSpecifier::TypeSpec:
1068 case NestedNameSpecifier::TypeSpecWithTemplate:
1069 case NestedNameSpecifier::Super:
1070 // These are never namespace scopes.
1071 return true;
1072 }
1073
1074 llvm_unreachable("Invalid NestedNameSpecifier::Kind!")__builtin_unreachable();
1075}
1076
1077/// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1078/// scope or nested-name-specifier) is parsed, part of a declarator-id.
1079/// After this method is called, according to [C++ 3.4.3p3], names should be
1080/// looked up in the declarator-id's scope, until the declarator is parsed and
1081/// ActOnCXXExitDeclaratorScope is called.
1082/// The 'SS' should be a non-empty valid CXXScopeSpec.
1083bool Sema::ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS) {
1084 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.")((void)0);
1085
1086 if (SS.isInvalid()) return true;
1
Taking false branch
1087
1088 DeclContext *DC = computeDeclContext(SS, true);
2
Calling 'Sema::computeDeclContext'
1089 if (!DC) return true;
1090
1091 // Before we enter a declarator's context, we need to make sure that
1092 // it is a complete declaration context.
1093 if (!DC->isDependentContext() && RequireCompleteDeclContext(SS, DC))
1094 return true;
1095
1096 EnterDeclaratorContext(S, DC);
1097
1098 // Rebuild the nested name specifier for the new scope.
1099 if (DC->isDependentContext())
1100 RebuildNestedNameSpecifierInCurrentInstantiation(SS);
1101
1102 return false;
1103}
1104
1105/// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1106/// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1107/// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1108/// Used to indicate that names should revert to being looked up in the
1109/// defining scope.
1110void Sema::ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
1111 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.")((void)0);
1112 if (SS.isInvalid())
1113 return;
1114 assert(!SS.isInvalid() && computeDeclContext(SS, true) &&((void)0)
1115 "exiting declarator scope we never really entered")((void)0);
1116 ExitDeclaratorContext(S);
1117}

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/Sema/DeclSpec.h

1//===--- DeclSpec.h - Parsed declaration specifiers -------------*- 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/// This file defines the classes used to store parsed information about
11/// declaration-specifiers and declarators.
12///
13/// \verbatim
14/// static const int volatile x, *y, *(*(*z)[10])(const void *x);
15/// ------------------------- - -- ---------------------------
16/// declaration-specifiers \ | /
17/// declarators
18/// \endverbatim
19///
20//===----------------------------------------------------------------------===//
21
22#ifndef LLVM_CLANG_SEMA_DECLSPEC_H
23#define LLVM_CLANG_SEMA_DECLSPEC_H
24
25#include "clang/AST/DeclCXX.h"
26#include "clang/AST/DeclObjCCommon.h"
27#include "clang/AST/NestedNameSpecifier.h"
28#include "clang/Basic/ExceptionSpecificationType.h"
29#include "clang/Basic/Lambda.h"
30#include "clang/Basic/OperatorKinds.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Lex/Token.h"
33#include "clang/Sema/Ownership.h"
34#include "clang/Sema/ParsedAttr.h"
35#include "llvm/ADT/SmallVector.h"
36#include "llvm/Support/Compiler.h"
37#include "llvm/Support/ErrorHandling.h"
38
39namespace clang {
40 class ASTContext;
41 class CXXRecordDecl;
42 class TypeLoc;
43 class LangOptions;
44 class IdentifierInfo;
45 class NamespaceAliasDecl;
46 class NamespaceDecl;
47 class ObjCDeclSpec;
48 class Sema;
49 class Declarator;
50 struct TemplateIdAnnotation;
51
52/// Represents a C++ nested-name-specifier or a global scope specifier.
53///
54/// These can be in 3 states:
55/// 1) Not present, identified by isEmpty()
56/// 2) Present, identified by isNotEmpty()
57/// 2.a) Valid, identified by isValid()
58/// 2.b) Invalid, identified by isInvalid().
59///
60/// isSet() is deprecated because it mostly corresponded to "valid" but was
61/// often used as if it meant "present".
62///
63/// The actual scope is described by getScopeRep().
64class CXXScopeSpec {
65 SourceRange Range;
66 NestedNameSpecifierLocBuilder Builder;
67
68public:
69 SourceRange getRange() const { return Range; }
70 void setRange(SourceRange R) { Range = R; }
71 void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); }
72 void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); }
73 SourceLocation getBeginLoc() const { return Range.getBegin(); }
74 SourceLocation getEndLoc() const { return Range.getEnd(); }
75
76 /// Retrieve the representation of the nested-name-specifier.
77 NestedNameSpecifier *getScopeRep() const {
78 return Builder.getRepresentation();
79 }
80
81 /// Extend the current nested-name-specifier by another
82 /// nested-name-specifier component of the form 'type::'.
83 ///
84 /// \param Context The AST context in which this nested-name-specifier
85 /// resides.
86 ///
87 /// \param TemplateKWLoc The location of the 'template' keyword, if present.
88 ///
89 /// \param TL The TypeLoc that describes the type preceding the '::'.
90 ///
91 /// \param ColonColonLoc The location of the trailing '::'.
92 void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,
93 SourceLocation ColonColonLoc);
94
95 /// Extend the current nested-name-specifier by another
96 /// nested-name-specifier component of the form 'identifier::'.
97 ///
98 /// \param Context The AST context in which this nested-name-specifier
99 /// resides.
100 ///
101 /// \param Identifier The identifier.
102 ///
103 /// \param IdentifierLoc The location of the identifier.
104 ///
105 /// \param ColonColonLoc The location of the trailing '::'.
106 void Extend(ASTContext &Context, IdentifierInfo *Identifier,
107 SourceLocation IdentifierLoc, SourceLocation ColonColonLoc);
108
109 /// Extend the current nested-name-specifier by another
110 /// nested-name-specifier component of the form 'namespace::'.
111 ///
112 /// \param Context The AST context in which this nested-name-specifier
113 /// resides.
114 ///
115 /// \param Namespace The namespace.
116 ///
117 /// \param NamespaceLoc The location of the namespace name.
118 ///
119 /// \param ColonColonLoc The location of the trailing '::'.
120 void Extend(ASTContext &Context, NamespaceDecl *Namespace,
121 SourceLocation NamespaceLoc, SourceLocation ColonColonLoc);
122
123 /// Extend the current nested-name-specifier by another
124 /// nested-name-specifier component of the form 'namespace-alias::'.
125 ///
126 /// \param Context The AST context in which this nested-name-specifier
127 /// resides.
128 ///
129 /// \param Alias The namespace alias.
130 ///
131 /// \param AliasLoc The location of the namespace alias
132 /// name.
133 ///
134 /// \param ColonColonLoc The location of the trailing '::'.
135 void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
136 SourceLocation AliasLoc, SourceLocation ColonColonLoc);
137
138 /// Turn this (empty) nested-name-specifier into the global
139 /// nested-name-specifier '::'.
140 void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);
141
142 /// Turns this (empty) nested-name-specifier into '__super'
143 /// nested-name-specifier.
144 ///
145 /// \param Context The AST context in which this nested-name-specifier
146 /// resides.
147 ///
148 /// \param RD The declaration of the class in which nested-name-specifier
149 /// appeared.
150 ///
151 /// \param SuperLoc The location of the '__super' keyword.
152 /// name.
153 ///
154 /// \param ColonColonLoc The location of the trailing '::'.
155 void MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
156 SourceLocation SuperLoc, SourceLocation ColonColonLoc);
157
158 /// Make a new nested-name-specifier from incomplete source-location
159 /// information.
160 ///
161 /// FIXME: This routine should be used very, very rarely, in cases where we
162 /// need to synthesize a nested-name-specifier. Most code should instead use
163 /// \c Adopt() with a proper \c NestedNameSpecifierLoc.
164 void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier,
165 SourceRange R);
166
167 /// Adopt an existing nested-name-specifier (with source-range
168 /// information).
169 void Adopt(NestedNameSpecifierLoc Other);
170
171 /// Retrieve a nested-name-specifier with location information, copied
172 /// into the given AST context.
173 ///
174 /// \param Context The context into which this nested-name-specifier will be
175 /// copied.
176 NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const;
177
178 /// Retrieve the location of the name in the last qualifier
179 /// in this nested name specifier.
180 ///
181 /// For example, the location of \c bar
182 /// in
183 /// \verbatim
184 /// \::foo::bar<0>::
185 /// ^~~
186 /// \endverbatim
187 SourceLocation getLastQualifierNameLoc() const;
188
189 /// No scope specifier.
190 bool isEmpty() const { return Range.isInvalid() && getScopeRep() == nullptr; }
191 /// A scope specifier is present, but may be valid or invalid.
192 bool isNotEmpty() const { return !isEmpty(); }
193
194 /// An error occurred during parsing of the scope specifier.
195 bool isInvalid() const { return Range.isValid() && getScopeRep() == nullptr; }
8
Returning zero, which participates in a condition later
196 /// A scope specifier is present, and it refers to a real scope.
197 bool isValid() const { return getScopeRep() != nullptr; }
198
199 /// Indicate that this nested-name-specifier is invalid.
200 void SetInvalid(SourceRange R) {
201 assert(R.isValid() && "Must have a valid source range")((void)0);
202 if (Range.getBegin().isInvalid())
203 Range.setBegin(R.getBegin());
204 Range.setEnd(R.getEnd());
205 Builder.Clear();
206 }
207
208 /// Deprecated. Some call sites intend isNotEmpty() while others intend
209 /// isValid().
210 bool isSet() const { return getScopeRep() != nullptr; }
4
Assuming the condition is true
5
Returning the value 1, which participates in a condition later
211
212 void clear() {
213 Range = SourceRange();
214 Builder.Clear();
215 }
216
217 /// Retrieve the data associated with the source-location information.
218 char *location_data() const { return Builder.getBuffer().first; }
219
220 /// Retrieve the size of the data associated with source-location
221 /// information.
222 unsigned location_size() const { return Builder.getBuffer().second; }
223};
224
225/// Captures information about "declaration specifiers".
226///
227/// "Declaration specifiers" encompasses storage-class-specifiers,
228/// type-specifiers, type-qualifiers, and function-specifiers.
229class DeclSpec {
230public:
231 /// storage-class-specifier
232 /// \note The order of these enumerators is important for diagnostics.
233 enum SCS {
234 SCS_unspecified = 0,
235 SCS_typedef,
236 SCS_extern,
237 SCS_static,
238 SCS_auto,
239 SCS_register,
240 SCS_private_extern,
241 SCS_mutable
242 };
243
244 // Import thread storage class specifier enumeration and constants.
245 // These can be combined with SCS_extern and SCS_static.
246 typedef ThreadStorageClassSpecifier TSCS;
247 static const TSCS TSCS_unspecified = clang::TSCS_unspecified;
248 static const TSCS TSCS___thread = clang::TSCS___thread;
249 static const TSCS TSCS_thread_local = clang::TSCS_thread_local;
250 static const TSCS TSCS__Thread_local = clang::TSCS__Thread_local;
251
252 enum TSC {
253 TSC_unspecified,
254 TSC_imaginary,
255 TSC_complex
256 };
257
258 // Import type specifier type enumeration and constants.
259 typedef TypeSpecifierType TST;
260 static const TST TST_unspecified = clang::TST_unspecified;
261 static const TST TST_void = clang::TST_void;
262 static const TST TST_char = clang::TST_char;
263 static const TST TST_wchar = clang::TST_wchar;
264 static const TST TST_char8 = clang::TST_char8;
265 static const TST TST_char16 = clang::TST_char16;
266 static const TST TST_char32 = clang::TST_char32;
267 static const TST TST_int = clang::TST_int;
268 static const TST TST_int128 = clang::TST_int128;
269 static const TST TST_extint = clang::TST_extint;
270 static const TST TST_half = clang::TST_half;
271 static const TST TST_BFloat16 = clang::TST_BFloat16;
272 static const TST TST_float = clang::TST_float;
273 static const TST TST_double = clang::TST_double;
274 static const TST TST_float16 = clang::TST_Float16;
275 static const TST TST_accum = clang::TST_Accum;
276 static const TST TST_fract = clang::TST_Fract;
277 static const TST TST_float128 = clang::TST_float128;
278 static const TST TST_bool = clang::TST_bool;
279 static const TST TST_decimal32 = clang::TST_decimal32;
280 static const TST TST_decimal64 = clang::TST_decimal64;
281 static const TST TST_decimal128 = clang::TST_decimal128;
282 static const TST TST_enum = clang::TST_enum;
283 static const TST TST_union = clang::TST_union;
284 static const TST TST_struct = clang::TST_struct;
285 static const TST TST_interface = clang::TST_interface;
286 static const TST TST_class = clang::TST_class;
287 static const TST TST_typename = clang::TST_typename;
288 static const TST TST_typeofType = clang::TST_typeofType;
289 static const TST TST_typeofExpr = clang::TST_typeofExpr;
290 static const TST TST_decltype = clang::TST_decltype;
291 static const TST TST_decltype_auto = clang::TST_decltype_auto;
292 static const TST TST_underlyingType = clang::TST_underlyingType;
293 static const TST TST_auto = clang::TST_auto;
294 static const TST TST_auto_type = clang::TST_auto_type;
295 static const TST TST_unknown_anytype = clang::TST_unknown_anytype;
296 static const TST TST_atomic = clang::TST_atomic;
297#define GENERIC_IMAGE_TYPE(ImgType, Id) \
298 static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
299#include "clang/Basic/OpenCLImageTypes.def"
300 static const TST TST_error = clang::TST_error;
301
302 // type-qualifiers
303 enum TQ { // NOTE: These flags must be kept in sync with Qualifiers::TQ.
304 TQ_unspecified = 0,
305 TQ_const = 1,
306 TQ_restrict = 2,
307 TQ_volatile = 4,
308 TQ_unaligned = 8,
309 // This has no corresponding Qualifiers::TQ value, because it's not treated
310 // as a qualifier in our type system.
311 TQ_atomic = 16
312 };
313
314 /// ParsedSpecifiers - Flags to query which specifiers were applied. This is
315 /// returned by getParsedSpecifiers.
316 enum ParsedSpecifiers {
317 PQ_None = 0,
318 PQ_StorageClassSpecifier = 1,
319 PQ_TypeSpecifier = 2,
320 PQ_TypeQualifier = 4,
321 PQ_FunctionSpecifier = 8
322 // FIXME: Attributes should be included here.
323 };
324
325private:
326 // storage-class-specifier
327 /*SCS*/unsigned StorageClassSpec : 3;
328 /*TSCS*/unsigned ThreadStorageClassSpec : 2;
329 unsigned SCS_extern_in_linkage_spec : 1;
330
331 // type-specifier
332 /*TypeSpecifierWidth*/ unsigned TypeSpecWidth : 2;
333 /*TSC*/unsigned TypeSpecComplex : 2;
334 /*TSS*/unsigned TypeSpecSign : 2;
335 /*TST*/unsigned TypeSpecType : 6;
336 unsigned TypeAltiVecVector : 1;
337 unsigned TypeAltiVecPixel : 1;
338 unsigned TypeAltiVecBool : 1;
339 unsigned TypeSpecOwned : 1;
340 unsigned TypeSpecPipe : 1;
341 unsigned TypeSpecSat : 1;
342 unsigned ConstrainedAuto : 1;
343
344 // type-qualifiers
345 unsigned TypeQualifiers : 5; // Bitwise OR of TQ.
346
347 // function-specifier
348 unsigned FS_inline_specified : 1;
349 unsigned FS_forceinline_specified: 1;
350 unsigned FS_virtual_specified : 1;
351 unsigned FS_noreturn_specified : 1;
352
353 // friend-specifier
354 unsigned Friend_specified : 1;
355
356 // constexpr-specifier
357 unsigned ConstexprSpecifier : 2;
358
359 union {
360 UnionParsedType TypeRep;
361 Decl *DeclRep;
362 Expr *ExprRep;
363 TemplateIdAnnotation *TemplateIdRep;
364 };
365
366 /// ExplicitSpecifier - Store information about explicit spicifer.
367 ExplicitSpecifier FS_explicit_specifier;
368
369 // attributes.
370 ParsedAttributes Attrs;
371
372 // Scope specifier for the type spec, if applicable.
373 CXXScopeSpec TypeScope;
374
375 // SourceLocation info. These are null if the item wasn't specified or if
376 // the setting was synthesized.
377 SourceRange Range;
378
379 SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
380 SourceRange TSWRange;
381 SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc;
382 /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
383 /// typename, then this is the location of the named type (if present);
384 /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
385 /// TSTNameLoc provides source range info for tag types.
386 SourceLocation TSTNameLoc;
387 SourceRange TypeofParensRange;
388 SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
389 TQ_unalignedLoc;
390 SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
391 SourceLocation FS_explicitCloseParenLoc;
392 SourceLocation FS_forceinlineLoc;
393 SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
394 SourceLocation TQ_pipeLoc;
395
396 WrittenBuiltinSpecs writtenBS;
397 void SaveWrittenBuiltinSpecs();
398
399 ObjCDeclSpec *ObjCQualifiers;
400
401 static bool isTypeRep(TST T) {
402 return (T == TST_typename || T == TST_typeofType ||
403 T == TST_underlyingType || T == TST_atomic);
404 }
405 static bool isExprRep(TST T) {
406 return (T == TST_typeofExpr || T == TST_decltype || T == TST_extint);
407 }
408 static bool isTemplateIdRep(TST T) {
409 return (T == TST_auto || T == TST_decltype_auto);
410 }
411
412 DeclSpec(const DeclSpec &) = delete;
413 void operator=(const DeclSpec &) = delete;
414public:
415 static bool isDeclRep(TST T) {
416 return (T == TST_enum || T == TST_struct ||
417 T == TST_interface || T == TST_union ||
418 T == TST_class);
419 }
420
421 DeclSpec(AttributeFactory &attrFactory)
422 : StorageClassSpec(SCS_unspecified),
423 ThreadStorageClassSpec(TSCS_unspecified),
424 SCS_extern_in_linkage_spec(false),
425 TypeSpecWidth(static_cast<unsigned>(TypeSpecifierWidth::Unspecified)),
426 TypeSpecComplex(TSC_unspecified),
427 TypeSpecSign(static_cast<unsigned>(TypeSpecifierSign::Unspecified)),
428 TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
429 TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
430 TypeSpecPipe(false), TypeSpecSat(false), ConstrainedAuto(false),
431 TypeQualifiers(TQ_unspecified), FS_inline_specified(false),
432 FS_forceinline_specified(false), FS_virtual_specified(false),
433 FS_noreturn_specified(false), Friend_specified(false),
434 ConstexprSpecifier(
435 static_cast<unsigned>(ConstexprSpecKind::Unspecified)),
436 FS_explicit_specifier(), Attrs(attrFactory), writtenBS(),
437 ObjCQualifiers(nullptr) {}
438
439 // storage-class-specifier
440 SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
441 TSCS getThreadStorageClassSpec() const {
442 return (TSCS)ThreadStorageClassSpec;
443 }
444 bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
445 void setExternInLinkageSpec(bool Value) {
446 SCS_extern_in_linkage_spec = Value;
447 }
448
449 SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; }
450 SourceLocation getThreadStorageClassSpecLoc() const {
451 return ThreadStorageClassSpecLoc;
452 }
453
454 void ClearStorageClassSpecs() {
455 StorageClassSpec = DeclSpec::SCS_unspecified;
456 ThreadStorageClassSpec = DeclSpec::TSCS_unspecified;
457 SCS_extern_in_linkage_spec = false;
458 StorageClassSpecLoc = SourceLocation();
459 ThreadStorageClassSpecLoc = SourceLocation();
460 }
461
462 void ClearTypeSpecType() {
463 TypeSpecType = DeclSpec::TST_unspecified;
464 TypeSpecOwned = false;
465 TSTLoc = SourceLocation();
466 }
467
468 // type-specifier
469 TypeSpecifierWidth getTypeSpecWidth() const {
470 return static_cast<TypeSpecifierWidth>(TypeSpecWidth);
471 }
472 TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; }
473 TypeSpecifierSign getTypeSpecSign() const {
474 return static_cast<TypeSpecifierSign>(TypeSpecSign);
475 }
476 TST getTypeSpecType() const { return (TST)TypeSpecType; }
477 bool isTypeAltiVecVector() const { return TypeAltiVecVector; }
478 bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; }
479 bool isTypeAltiVecBool() const { return TypeAltiVecBool; }
480 bool isTypeSpecOwned() const { return TypeSpecOwned; }
481 bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); }
482 bool isTypeSpecPipe() const { return TypeSpecPipe; }
483 bool isTypeSpecSat() const { return TypeSpecSat; }
484 bool isConstrainedAuto() const { return ConstrainedAuto; }
485
486 ParsedType getRepAsType() const {
487 assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type")((void)0);
488 return TypeRep;
489 }
490 Decl *getRepAsDecl() const {
491 assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl")((void)0);
492 return DeclRep;
493 }
494 Expr *getRepAsExpr() const {
495 assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr")((void)0);
496 return ExprRep;
497 }
498 TemplateIdAnnotation *getRepAsTemplateId() const {
499 assert(isTemplateIdRep((TST) TypeSpecType) &&((void)0)
500 "DeclSpec does not store a template id")((void)0);
501 return TemplateIdRep;
502 }
503 CXXScopeSpec &getTypeSpecScope() { return TypeScope; }
504 const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }
505
506 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
507 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
508 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
509
510 SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); }
511 SourceRange getTypeSpecWidthRange() const { return TSWRange; }
512 SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }
513 SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }
514 SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }
515 SourceLocation getAltiVecLoc() const { return AltiVecLoc; }
516 SourceLocation getTypeSpecSatLoc() const { return TSSatLoc; }
517
518 SourceLocation getTypeSpecTypeNameLoc() const {
519 assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename)((void)0);
520 return TSTNameLoc;
521 }
522
523 SourceRange getTypeofParensRange() const { return TypeofParensRange; }
524 void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; }
525
526 bool hasAutoTypeSpec() const {
527 return (TypeSpecType == TST_auto || TypeSpecType == TST_auto_type ||
528 TypeSpecType == TST_decltype_auto);
529 }
530
531 bool hasTagDefinition() const;
532
533 /// Turn a type-specifier-type into a string like "_Bool" or "union".
534 static const char *getSpecifierName(DeclSpec::TST T,
535 const PrintingPolicy &Policy);
536 static const char *getSpecifierName(DeclSpec::TQ Q);
537 static const char *getSpecifierName(TypeSpecifierSign S);
538 static const char *getSpecifierName(DeclSpec::TSC C);
539 static const char *getSpecifierName(TypeSpecifierWidth W);
540 static const char *getSpecifierName(DeclSpec::SCS S);
541 static const char *getSpecifierName(DeclSpec::TSCS S);
542 static const char *getSpecifierName(ConstexprSpecKind C);
543
544 // type-qualifiers
545
546 /// getTypeQualifiers - Return a set of TQs.
547 unsigned getTypeQualifiers() const { return TypeQualifiers; }
548 SourceLocation getConstSpecLoc() const { return TQ_constLoc; }
549 SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }
550 SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }
551 SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }
552 SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; }
553 SourceLocation getPipeLoc() const { return TQ_pipeLoc; }
554
555 /// Clear out all of the type qualifiers.
556 void ClearTypeQualifiers() {
557 TypeQualifiers = 0;
558 TQ_constLoc = SourceLocation();
559 TQ_restrictLoc = SourceLocation();
560 TQ_volatileLoc = SourceLocation();
561 TQ_atomicLoc = SourceLocation();
562 TQ_unalignedLoc = SourceLocation();
563 TQ_pipeLoc = SourceLocation();
564 }
565
566 // function-specifier
567 bool isInlineSpecified() const {
568 return FS_inline_specified | FS_forceinline_specified;
569 }
570 SourceLocation getInlineSpecLoc() const {
571 return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc;
572 }
573
574 ExplicitSpecifier getExplicitSpecifier() const {
575 return FS_explicit_specifier;
576 }
577
578 bool isVirtualSpecified() const { return FS_virtual_specified; }
579 SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }
580
581 bool hasExplicitSpecifier() const {
582 return FS_explicit_specifier.isSpecified();
583 }
584 SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }
585 SourceRange getExplicitSpecRange() const {
586 return FS_explicit_specifier.getExpr()
587 ? SourceRange(FS_explicitLoc, FS_explicitCloseParenLoc)
588 : SourceRange(FS_explicitLoc);
589 }
590
591 bool isNoreturnSpecified() const { return FS_noreturn_specified; }
592 SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }
593
594 void ClearFunctionSpecs() {
595 FS_inline_specified = false;
596 FS_inlineLoc = SourceLocation();
597 FS_forceinline_specified = false;
598 FS_forceinlineLoc = SourceLocation();
599 FS_virtual_specified = false;
600 FS_virtualLoc = SourceLocation();
601 FS_explicit_specifier = ExplicitSpecifier();
602 FS_explicitLoc = SourceLocation();
603 FS_explicitCloseParenLoc = SourceLocation();
604 FS_noreturn_specified = false;
605 FS_noreturnLoc = SourceLocation();
606 }
607
608 /// This method calls the passed in handler on each CVRU qual being
609 /// set.
610 /// Handle - a handler to be invoked.
611 void forEachCVRUQualifier(
612 llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);
613
614 /// This method calls the passed in handler on each qual being
615 /// set.
616 /// Handle - a handler to be invoked.
617 void forEachQualifier(
618 llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);
619
620 /// Return true if any type-specifier has been found.
621 bool hasTypeSpecifier() const {
622 return getTypeSpecType() != DeclSpec::TST_unspecified ||
623 getTypeSpecWidth() != TypeSpecifierWidth::Unspecified ||
624 getTypeSpecComplex() != DeclSpec::TSC_unspecified ||
625 getTypeSpecSign() != TypeSpecifierSign::Unspecified;
626 }
627
628 /// Return a bitmask of which flavors of specifiers this
629 /// DeclSpec includes.
630 unsigned getParsedSpecifiers() const;
631
632 /// isEmpty - Return true if this declaration specifier is completely empty:
633 /// no tokens were parsed in the production of it.
634 bool isEmpty() const {
635 return getParsedSpecifiers() == DeclSpec::PQ_None;
636 }
637
638 void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); }
639 void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); }
640
641 /// These methods set the specified attribute of the DeclSpec and
642 /// return false if there was no error. If an error occurs (for
643 /// example, if we tried to set "auto" on a spec with "extern"
644 /// already set), they return true and set PrevSpec and DiagID
645 /// such that
646 /// Diag(Loc, DiagID) << PrevSpec;
647 /// will yield a useful result.
648 ///
649 /// TODO: use a more general approach that still allows these
650 /// diagnostics to be ignored when desired.
651 bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
652 const char *&PrevSpec, unsigned &DiagID,
653 const PrintingPolicy &Policy);
654 bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
655 const char *&PrevSpec, unsigned &DiagID);
656 bool SetTypeSpecWidth(TypeSpecifierWidth W, SourceLocation Loc,
657 const char *&PrevSpec, unsigned &DiagID,
658 const PrintingPolicy &Policy);
659 bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,
660 unsigned &DiagID);
661 bool SetTypeSpecSign(TypeSpecifierSign S, SourceLocation Loc,
662 const char *&PrevSpec, unsigned &DiagID);
663 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
664 unsigned &DiagID, const PrintingPolicy &Policy);
665 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
666 unsigned &DiagID, ParsedType Rep,
667 const PrintingPolicy &Policy);
668 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
669 unsigned &DiagID, TypeResult Rep,
670 const PrintingPolicy &Policy) {
671 if (Rep.isInvalid())
672 return SetTypeSpecError();
673 return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Rep.get(), Policy);
674 }
675 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
676 unsigned &DiagID, Decl *Rep, bool Owned,
677 const PrintingPolicy &Policy);
678 bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
679 SourceLocation TagNameLoc, const char *&PrevSpec,
680 unsigned &DiagID, ParsedType Rep,
681 const PrintingPolicy &Policy);
682 bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
683 SourceLocation TagNameLoc, const char *&PrevSpec,
684 unsigned &DiagID, Decl *Rep, bool Owned,
685 const PrintingPolicy &Policy);
686 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
687 unsigned &DiagID, TemplateIdAnnotation *Rep,
688 const PrintingPolicy &Policy);
689
690 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
691 unsigned &DiagID, Expr *Rep,
692 const PrintingPolicy &policy);
693 bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
694 const char *&PrevSpec, unsigned &DiagID,
695 const PrintingPolicy &Policy);
696 bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
697 const char *&PrevSpec, unsigned &DiagID,
698 const PrintingPolicy &Policy);
699 bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
700 const char *&PrevSpec, unsigned &DiagID,
701 const PrintingPolicy &Policy);
702 bool SetTypePipe(bool isPipe, SourceLocation Loc,
703 const char *&PrevSpec, unsigned &DiagID,
704 const PrintingPolicy &Policy);
705 bool SetExtIntType(SourceLocation KWLoc, Expr *BitWidth,
706 const char *&PrevSpec, unsigned &DiagID,
707 const PrintingPolicy &Policy);
708 bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
709 unsigned &DiagID);
710 bool SetTypeSpecError();
711 void UpdateDeclRep(Decl *Rep) {
712 assert(isDeclRep((TST) TypeSpecType))((void)0);
713 DeclRep = Rep;
714 }
715 void UpdateTypeRep(ParsedType Rep) {
716 assert(isTypeRep((TST) TypeSpecType))((void)0);
717 TypeRep = Rep;
718 }
719 void UpdateExprRep(Expr *Rep) {
720 assert(isExprRep((TST) TypeSpecType))((void)0);
721 ExprRep = Rep;
722 }
723
724 bool SetTypeQual(TQ T, SourceLocation Loc);
725
726 bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
727 unsigned &DiagID, const LangOptions &Lang);
728
729 bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
730 unsigned &DiagID);
731 bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
732 unsigned &DiagID);
733 bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
734 unsigned &DiagID);
735 bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
736 unsigned &DiagID, ExplicitSpecifier ExplicitSpec,
737 SourceLocation CloseParenLoc);
738 bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
739 unsigned &DiagID);
740
741 bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
742 unsigned &DiagID);
743 bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
744 unsigned &DiagID);
745 bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc,
746 const char *&PrevSpec, unsigned &DiagID);
747
748 bool isFriendSpecified() const { return Friend_specified; }
749 SourceLocation getFriendSpecLoc() const { return FriendLoc; }
750
751 bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
752 SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }
753
754 ConstexprSpecKind getConstexprSpecifier() const {
755 return ConstexprSpecKind(ConstexprSpecifier);
756 }
757
758 SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
759 bool hasConstexprSpecifier() const {
760 return getConstexprSpecifier() != ConstexprSpecKind::Unspecified;
761 }
762
763 void ClearConstexprSpec() {
764 ConstexprSpecifier = static_cast<unsigned>(ConstexprSpecKind::Unspecified);
765 ConstexprLoc = SourceLocation();
766 }
767
768 AttributePool &getAttributePool() const {
769 return Attrs.getPool();
770 }
771
772 /// Concatenates two attribute lists.
773 ///
774 /// The GCC attribute syntax allows for the following:
775 ///
776 /// \code
777 /// short __attribute__(( unused, deprecated ))
778 /// int __attribute__(( may_alias, aligned(16) )) var;
779 /// \endcode
780 ///
781 /// This declares 4 attributes using 2 lists. The following syntax is
782 /// also allowed and equivalent to the previous declaration.
783 ///
784 /// \code
785 /// short __attribute__((unused)) __attribute__((deprecated))
786 /// int __attribute__((may_alias)) __attribute__((aligned(16))) var;
787 /// \endcode
788 ///
789 void addAttributes(ParsedAttributesView &AL) {
790 Attrs.addAll(AL.begin(), AL.end());
791 }
792
793 bool hasAttributes() const { return !Attrs.empty(); }
794
795 ParsedAttributes &getAttributes() { return Attrs; }
796 const ParsedAttributes &getAttributes() const { return Attrs; }
797
798 void takeAttributesFrom(ParsedAttributes &attrs) {
799 Attrs.takeAllFrom(attrs);
800 }
801
802 /// Finish - This does final analysis of the declspec, issuing diagnostics for
803 /// things like "_Imaginary" (lacking an FP type). After calling this method,
804 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
805 void Finish(Sema &S, const PrintingPolicy &Policy);
806
807 const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
808 return writtenBS;
809 }
810
811 ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; }
812 void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; }
813
814 /// Checks if this DeclSpec can stand alone, without a Declarator.
815 ///
816 /// Only tag declspecs can stand alone.
817 bool isMissingDeclaratorOk();
818};
819
820/// Captures information about "declaration specifiers" specific to
821/// Objective-C.
822class ObjCDeclSpec {
823public:
824 /// ObjCDeclQualifier - Qualifier used on types in method
825 /// declarations. Not all combinations are sensible. Parameters
826 /// can be one of { in, out, inout } with one of { bycopy, byref }.
827 /// Returns can either be { oneway } or not.
828 ///
829 /// This should be kept in sync with Decl::ObjCDeclQualifier.
830 enum ObjCDeclQualifier {
831 DQ_None = 0x0,
832 DQ_In = 0x1,
833 DQ_Inout = 0x2,
834 DQ_Out = 0x4,
835 DQ_Bycopy = 0x8,
836 DQ_Byref = 0x10,
837 DQ_Oneway = 0x20,
838 DQ_CSNullability = 0x40
839 };
840
841 ObjCDeclSpec()
842 : objcDeclQualifier(DQ_None),
843 PropertyAttributes(ObjCPropertyAttribute::kind_noattr), Nullability(0),
844 GetterName(nullptr), SetterName(nullptr) {}
845
846 ObjCDeclQualifier getObjCDeclQualifier() const {
847 return (ObjCDeclQualifier)objcDeclQualifier;
848 }
849 void setObjCDeclQualifier(ObjCDeclQualifier DQVal) {
850 objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal);
851 }
852 void clearObjCDeclQualifier(ObjCDeclQualifier DQVal) {
853 objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal);
854 }
855
856 ObjCPropertyAttribute::Kind getPropertyAttributes() const {
857 return ObjCPropertyAttribute::Kind(PropertyAttributes);
858 }
859 void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {
860 PropertyAttributes =
861 (ObjCPropertyAttribute::Kind)(PropertyAttributes | PRVal);
862 }
863
864 NullabilityKind getNullability() const {
865 assert(((void)0)
866 ((getObjCDeclQualifier() & DQ_CSNullability) ||((void)0)
867 (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&((void)0)
868 "Objective-C declspec doesn't have nullability")((void)0);
869 return static_cast<NullabilityKind>(Nullability);
870 }
871
872 SourceLocation getNullabilityLoc() const {
873 assert(((void)0)
874 ((getObjCDeclQualifier() & DQ_CSNullability) ||((void)0)
875 (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&((void)0)
876 "Objective-C declspec doesn't have nullability")((void)0);
877 return NullabilityLoc;
878 }
879
880 void setNullability(SourceLocation loc, NullabilityKind kind) {
881 assert(((void)0)
882 ((getObjCDeclQualifier() & DQ_CSNullability) ||((void)0)
883 (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&((void)0)
884 "Set the nullability declspec or property attribute first")((void)0);
885 Nullability = static_cast<unsigned>(kind);
886 NullabilityLoc = loc;
887 }
888
889 const IdentifierInfo *getGetterName() const { return GetterName; }
890 IdentifierInfo *getGetterName() { return GetterName; }
891 SourceLocation getGetterNameLoc() const { return GetterNameLoc; }
892 void setGetterName(IdentifierInfo *name, SourceLocation loc) {
893 GetterName = name;
894 GetterNameLoc = loc;
895 }
896
897 const IdentifierInfo *getSetterName() const { return SetterName; }
898 IdentifierInfo *getSetterName() { return SetterName; }
899 SourceLocation getSetterNameLoc() const { return SetterNameLoc; }
900 void setSetterName(IdentifierInfo *name, SourceLocation loc) {
901 SetterName = name;
902 SetterNameLoc = loc;
903 }
904
905private:
906 // FIXME: These two are unrelated and mutually exclusive. So perhaps
907 // we can put them in a union to reflect their mutual exclusivity
908 // (space saving is negligible).
909 unsigned objcDeclQualifier : 7;
910
911 // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttribute::Kind
912 unsigned PropertyAttributes : NumObjCPropertyAttrsBits;
913
914 unsigned Nullability : 2;
915
916 SourceLocation NullabilityLoc;
917
918 IdentifierInfo *GetterName; // getter name or NULL if no getter
919 IdentifierInfo *SetterName; // setter name or NULL if no setter
920 SourceLocation GetterNameLoc; // location of the getter attribute's value
921 SourceLocation SetterNameLoc; // location of the setter attribute's value
922
923};
924
925/// Describes the kind of unqualified-id parsed.
926enum class UnqualifiedIdKind {
927 /// An identifier.
928 IK_Identifier,
929 /// An overloaded operator name, e.g., operator+.
930 IK_OperatorFunctionId,
931 /// A conversion function name, e.g., operator int.
932 IK_ConversionFunctionId,
933 /// A user-defined literal name, e.g., operator "" _i.
934 IK_LiteralOperatorId,
935 /// A constructor name.
936 IK_ConstructorName,
937 /// A constructor named via a template-id.
938 IK_ConstructorTemplateId,
939 /// A destructor name.
940 IK_DestructorName,
941 /// A template-id, e.g., f<int>.
942 IK_TemplateId,
943 /// An implicit 'self' parameter
944 IK_ImplicitSelfParam,
945 /// A deduction-guide name (a template-name)
946 IK_DeductionGuideName
947};
948
949/// Represents a C++ unqualified-id that has been parsed.
950class UnqualifiedId {
951private:
952 UnqualifiedId(const UnqualifiedId &Other) = delete;
953 const UnqualifiedId &operator=(const UnqualifiedId &) = delete;
954
955public:
956 /// Describes the kind of unqualified-id parsed.
957 UnqualifiedIdKind Kind;
958
959 struct OFI {
960 /// The kind of overloaded operator.
961 OverloadedOperatorKind Operator;
962
963 /// The source locations of the individual tokens that name
964 /// the operator, e.g., the "new", "[", and "]" tokens in
965 /// operator new [].
966 ///
967 /// Different operators have different numbers of tokens in their name,
968 /// up to three. Any remaining source locations in this array will be
969 /// set to an invalid value for operators with fewer than three tokens.
970 SourceLocation SymbolLocations[3];
971 };
972
973 /// Anonymous union that holds extra data associated with the
974 /// parsed unqualified-id.
975 union {
976 /// When Kind == IK_Identifier, the parsed identifier, or when
977 /// Kind == IK_UserLiteralId, the identifier suffix.
978 IdentifierInfo *Identifier;
979
980 /// When Kind == IK_OperatorFunctionId, the overloaded operator
981 /// that we parsed.
982 struct OFI OperatorFunctionId;
983
984 /// When Kind == IK_ConversionFunctionId, the type that the
985 /// conversion function names.
986 UnionParsedType ConversionFunctionId;
987
988 /// When Kind == IK_ConstructorName, the class-name of the type
989 /// whose constructor is being referenced.
990 UnionParsedType ConstructorName;
991
992 /// When Kind == IK_DestructorName, the type referred to by the
993 /// class-name.
994 UnionParsedType DestructorName;
995
996 /// When Kind == IK_DeductionGuideName, the parsed template-name.
997 UnionParsedTemplateTy TemplateName;
998
999 /// When Kind == IK_TemplateId or IK_ConstructorTemplateId,
1000 /// the template-id annotation that contains the template name and
1001 /// template arguments.
1002 TemplateIdAnnotation *TemplateId;
1003 };
1004
1005 /// The location of the first token that describes this unqualified-id,
1006 /// which will be the location of the identifier, "operator" keyword,
1007 /// tilde (for a destructor), or the template name of a template-id.
1008 SourceLocation StartLocation;
1009
1010 /// The location of the last token that describes this unqualified-id.
1011 SourceLocation EndLocation;
1012
1013 UnqualifiedId()
1014 : Kind(UnqualifiedIdKind::IK_Identifier), Identifier(nullptr) {}
1015
1016 /// Clear out this unqualified-id, setting it to default (invalid)
1017 /// state.
1018 void clear() {
1019 Kind = UnqualifiedIdKind::IK_Identifier;
1020 Identifier = nullptr;
1021 StartLocation = SourceLocation();
1022 EndLocation = SourceLocation();
1023 }
1024
1025 /// Determine whether this unqualified-id refers to a valid name.
1026 bool isValid() const { return StartLocation.isValid(); }
1027
1028 /// Determine whether this unqualified-id refers to an invalid name.
1029 bool isInvalid() const { return !isValid(); }
1030
1031 /// Determine what kind of name we have.
1032 UnqualifiedIdKind getKind() const { return Kind; }
1033
1034 /// Specify that this unqualified-id was parsed as an identifier.
1035 ///
1036 /// \param Id the parsed identifier.
1037 /// \param IdLoc the location of the parsed identifier.
1038 void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) {
1039 Kind = UnqualifiedIdKind::IK_Identifier;
1040 Identifier = const_cast<IdentifierInfo *>(Id);
1041 StartLocation = EndLocation = IdLoc;
1042 }
1043
1044 /// Specify that this unqualified-id was parsed as an
1045 /// operator-function-id.
1046 ///
1047 /// \param OperatorLoc the location of the 'operator' keyword.
1048 ///
1049 /// \param Op the overloaded operator.
1050 ///
1051 /// \param SymbolLocations the locations of the individual operator symbols
1052 /// in the operator.
1053 void setOperatorFunctionId(SourceLocation OperatorLoc,
1054 OverloadedOperatorKind Op,
1055 SourceLocation SymbolLocations[3]);
1056
1057 /// Specify that this unqualified-id was parsed as a
1058 /// conversion-function-id.
1059 ///
1060 /// \param OperatorLoc the location of the 'operator' keyword.
1061 ///
1062 /// \param Ty the type to which this conversion function is converting.
1063 ///
1064 /// \param EndLoc the location of the last token that makes up the type name.
1065 void setConversionFunctionId(SourceLocation OperatorLoc,
1066 ParsedType Ty,
1067 SourceLocation EndLoc) {
1068 Kind = UnqualifiedIdKind::IK_ConversionFunctionId;
1069 StartLocation = OperatorLoc;
1070 EndLocation = EndLoc;
1071 ConversionFunctionId = Ty;
1072 }
1073
1074 /// Specific that this unqualified-id was parsed as a
1075 /// literal-operator-id.
1076 ///
1077 /// \param Id the parsed identifier.
1078 ///
1079 /// \param OpLoc the location of the 'operator' keyword.
1080 ///
1081 /// \param IdLoc the location of the identifier.
1082 void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc,
1083 SourceLocation IdLoc) {
1084 Kind = UnqualifiedIdKind::IK_LiteralOperatorId;
1085 Identifier = const_cast<IdentifierInfo *>(Id);
1086 StartLocation = OpLoc;
1087 EndLocation = IdLoc;
1088 }
1089
1090 /// Specify that this unqualified-id was parsed as a constructor name.
1091 ///
1092 /// \param ClassType the class type referred to by the constructor name.
1093 ///
1094 /// \param ClassNameLoc the location of the class name.
1095 ///
1096 /// \param EndLoc the location of the last token that makes up the type name.
1097 void setConstructorName(ParsedType ClassType,
1098 SourceLocation ClassNameLoc,
1099 SourceLocation EndLoc) {
1100 Kind = UnqualifiedIdKind::IK_ConstructorName;
1101 StartLocation = ClassNameLoc;
1102 EndLocation = EndLoc;
1103 ConstructorName = ClassType;
1104 }
1105
1106 /// Specify that this unqualified-id was parsed as a
1107 /// template-id that names a constructor.
1108 ///
1109 /// \param TemplateId the template-id annotation that describes the parsed
1110 /// template-id. This UnqualifiedId instance will take ownership of the
1111 /// \p TemplateId and will free it on destruction.
1112 void setConstructorTemplateId(TemplateIdAnnotation *TemplateId);
1113
1114 /// Specify that this unqualified-id was parsed as a destructor name.
1115 ///
1116 /// \param TildeLoc the location of the '~' that introduces the destructor
1117 /// name.
1118 ///
1119 /// \param ClassType the name of the class referred to by the destructor name.
1120 void setDestructorName(SourceLocation TildeLoc,
1121 ParsedType ClassType,
1122 SourceLocation EndLoc) {
1123 Kind = UnqualifiedIdKind::IK_DestructorName;
1124 StartLocation = TildeLoc;
1125 EndLocation = EndLoc;
1126 DestructorName = ClassType;
1127 }
1128
1129 /// Specify that this unqualified-id was parsed as a template-id.
1130 ///
1131 /// \param TemplateId the template-id annotation that describes the parsed
1132 /// template-id. This UnqualifiedId instance will take ownership of the
1133 /// \p TemplateId and will free it on destruction.
1134 void setTemplateId(TemplateIdAnnotation *TemplateId);
1135
1136 /// Specify that this unqualified-id was parsed as a template-name for
1137 /// a deduction-guide.
1138 ///
1139 /// \param Template The parsed template-name.
1140 /// \param TemplateLoc The location of the parsed template-name.
1141 void setDeductionGuideName(ParsedTemplateTy Template,
1142 SourceLocation TemplateLoc) {
1143 Kind = UnqualifiedIdKind::IK_DeductionGuideName;
1144 TemplateName = Template;
1145 StartLocation = EndLocation = TemplateLoc;
1146 }
1147
1148 /// Specify that this unqualified-id is an implicit 'self'
1149 /// parameter.
1150 ///
1151 /// \param Id the identifier.
1152 void setImplicitSelfParam(const IdentifierInfo *Id) {
1153 Kind = UnqualifiedIdKind::IK_ImplicitSelfParam;
1154 Identifier = const_cast<IdentifierInfo *>(Id);
1155 StartLocation = EndLocation = SourceLocation();
1156 }
1157
1158 /// Return the source range that covers this unqualified-id.
1159 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
1160 return SourceRange(StartLocation, EndLocation);
1161 }
1162 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return StartLocation; }
1163 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return EndLocation; }
1164};
1165
1166/// A set of tokens that has been cached for later parsing.
1167typedef SmallVector<Token, 4> CachedTokens;
1168
1169/// One instance of this struct is used for each type in a
1170/// declarator that is parsed.
1171///
1172/// This is intended to be a small value object.
1173struct DeclaratorChunk {
1174 DeclaratorChunk() {};
1175
1176 enum {
1177 Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren, Pipe
1178 } Kind;
1179
1180 /// Loc - The place where this type was defined.
1181 SourceLocation Loc;
1182 /// EndLoc - If valid, the place where this chunck ends.
1183 SourceLocation EndLoc;
1184
1185 SourceRange getSourceRange() const {
1186 if (EndLoc.isInvalid())
1187 return SourceRange(Loc, Loc);
1188 return SourceRange(Loc, EndLoc);
1189 }
1190
1191 ParsedAttributesView AttrList;
1192
1193 struct PointerTypeInfo {
1194 /// The type qualifiers: const/volatile/restrict/unaligned/atomic.
1195 unsigned TypeQuals : 5;
1196
1197 /// The location of the const-qualifier, if any.
1198 SourceLocation ConstQualLoc;
1199
1200 /// The location of the volatile-qualifier, if any.
1201 SourceLocation VolatileQualLoc;
1202
1203 /// The location of the restrict-qualifier, if any.
1204 SourceLocation RestrictQualLoc;
1205
1206 /// The location of the _Atomic-qualifier, if any.
1207 SourceLocation AtomicQualLoc;
1208
1209 /// The location of the __unaligned-qualifier, if any.
1210 SourceLocation UnalignedQualLoc;
1211
1212 void destroy() {
1213 }
1214 };
1215
1216 struct ReferenceTypeInfo {
1217 /// The type qualifier: restrict. [GNU] C++ extension
1218 bool HasRestrict : 1;
1219 /// True if this is an lvalue reference, false if it's an rvalue reference.
1220 bool LValueRef : 1;
1221 void destroy() {
1222 }
1223 };
1224
1225 struct ArrayTypeInfo {
1226 /// The type qualifiers for the array:
1227 /// const/volatile/restrict/__unaligned/_Atomic.
1228 unsigned TypeQuals : 5;
1229
1230 /// True if this dimension included the 'static' keyword.
1231 unsigned hasStatic : 1;
1232
1233 /// True if this dimension was [*]. In this case, NumElts is null.
1234 unsigned isStar : 1;
1235
1236 /// This is the size of the array, or null if [] or [*] was specified.
1237 /// Since the parser is multi-purpose, and we don't want to impose a root
1238 /// expression class on all clients, NumElts is untyped.
1239 Expr *NumElts;
1240
1241 void destroy() {}
1242 };
1243
1244 /// ParamInfo - An array of paraminfo objects is allocated whenever a function
1245 /// declarator is parsed. There are two interesting styles of parameters
1246 /// here:
1247 /// K&R-style identifier lists and parameter type lists. K&R-style identifier
1248 /// lists will have information about the identifier, but no type information.
1249 /// Parameter type lists will have type info (if the actions module provides
1250 /// it), but may have null identifier info: e.g. for 'void foo(int X, int)'.
1251 struct ParamInfo {
1252 IdentifierInfo *Ident;
1253 SourceLocation IdentLoc;
1254 Decl *Param;
1255
1256 /// DefaultArgTokens - When the parameter's default argument
1257 /// cannot be parsed immediately (because it occurs within the
1258 /// declaration of a member function), it will be stored here as a
1259 /// sequence of tokens to be parsed once the class definition is
1260 /// complete. Non-NULL indicates that there is a default argument.
1261 std::unique_ptr<CachedTokens> DefaultArgTokens;
1262
1263 ParamInfo() = default;
1264 ParamInfo(IdentifierInfo *ident, SourceLocation iloc,
1265 Decl *param,
1266 std::unique_ptr<CachedTokens> DefArgTokens = nullptr)
1267 : Ident(ident), IdentLoc(iloc), Param(param),
1268 DefaultArgTokens(std::move(DefArgTokens)) {}
1269 };
1270
1271 struct TypeAndRange {
1272 ParsedType Ty;
1273 SourceRange Range;
1274 };
1275
1276 struct FunctionTypeInfo {
1277 /// hasPrototype - This is true if the function had at least one typed
1278 /// parameter. If the function is () or (a,b,c), then it has no prototype,
1279 /// and is treated as a K&R-style function.
1280 unsigned hasPrototype : 1;
1281
1282 /// isVariadic - If this function has a prototype, and if that
1283 /// proto ends with ',...)', this is true. When true, EllipsisLoc
1284 /// contains the location of the ellipsis.
1285 unsigned isVariadic : 1;
1286
1287 /// Can this declaration be a constructor-style initializer?
1288 unsigned isAmbiguous : 1;
1289
1290 /// Whether the ref-qualifier (if any) is an lvalue reference.
1291 /// Otherwise, it's an rvalue reference.
1292 unsigned RefQualifierIsLValueRef : 1;
1293
1294 /// ExceptionSpecType - An ExceptionSpecificationType value.
1295 unsigned ExceptionSpecType : 4;
1296
1297 /// DeleteParams - If this is true, we need to delete[] Params.
1298 unsigned DeleteParams : 1;
1299
1300 /// HasTrailingReturnType - If this is true, a trailing return type was
1301 /// specified.
1302 unsigned HasTrailingReturnType : 1;
1303
1304 /// The location of the left parenthesis in the source.
1305 SourceLocation LParenLoc;
1306
1307 /// When isVariadic is true, the location of the ellipsis in the source.
1308 SourceLocation EllipsisLoc;
1309
1310 /// The location of the right parenthesis in the source.
1311 SourceLocation RParenLoc;
1312
1313 /// NumParams - This is the number of formal parameters specified by the
1314 /// declarator.
1315 unsigned NumParams;
1316
1317 /// NumExceptionsOrDecls - This is the number of types in the
1318 /// dynamic-exception-decl, if the function has one. In C, this is the
1319 /// number of declarations in the function prototype.
1320 unsigned NumExceptionsOrDecls;
1321
1322 /// The location of the ref-qualifier, if any.
1323 ///
1324 /// If this is an invalid location, there is no ref-qualifier.
1325 SourceLocation RefQualifierLoc;
1326
1327 /// The location of the 'mutable' qualifer in a lambda-declarator, if
1328 /// any.
1329 SourceLocation MutableLoc;
1330
1331 /// The beginning location of the exception specification, if any.
1332 SourceLocation ExceptionSpecLocBeg;
1333
1334 /// The end location of the exception specification, if any.
1335 SourceLocation ExceptionSpecLocEnd;
1336
1337 /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
1338 /// describe the parameters specified by this function declarator. null if
1339 /// there are no parameters specified.
1340 ParamInfo *Params;
1341
1342 /// DeclSpec for the function with the qualifier related info.
1343 DeclSpec *MethodQualifiers;
1344
1345 /// AtttibuteFactory for the MethodQualifiers.
1346 AttributeFactory *QualAttrFactory;
1347
1348 union {
1349 /// Pointer to a new[]'d array of TypeAndRange objects that
1350 /// contain the types in the function's dynamic exception specification
1351 /// and their locations, if there is one.
1352 TypeAndRange *Exceptions;
1353
1354 /// Pointer to the expression in the noexcept-specifier of this
1355 /// function, if it has one.
1356 Expr *NoexceptExpr;
1357
1358 /// Pointer to the cached tokens for an exception-specification
1359 /// that has not yet been parsed.
1360 CachedTokens *ExceptionSpecTokens;
1361
1362 /// Pointer to a new[]'d array of declarations that need to be available
1363 /// for lookup inside the function body, if one exists. Does not exist in
1364 /// C++.
1365 NamedDecl **DeclsInPrototype;
1366 };
1367
1368 /// If HasTrailingReturnType is true, this is the trailing return
1369 /// type specified.
1370 UnionParsedType TrailingReturnType;
1371
1372 /// If HasTrailingReturnType is true, this is the location of the trailing
1373 /// return type.
1374 SourceLocation TrailingReturnTypeLoc;
1375
1376 /// Reset the parameter list to having zero parameters.
1377 ///
1378 /// This is used in various places for error recovery.
1379 void freeParams() {
1380 for (unsigned I = 0; I < NumParams; ++I)
1381 Params[I].DefaultArgTokens.reset();
1382 if (DeleteParams) {
1383 delete[] Params;
1384 DeleteParams = false;
1385 }
1386 NumParams = 0;
1387 }
1388
1389 void destroy() {
1390 freeParams();
1391 delete QualAttrFactory;
1392 delete MethodQualifiers;
1393 switch (getExceptionSpecType()) {
1394 default:
1395 break;
1396 case EST_Dynamic:
1397 delete[] Exceptions;
1398 break;
1399 case EST_Unparsed:
1400 delete ExceptionSpecTokens;
1401 break;
1402 case EST_None:
1403 if (NumExceptionsOrDecls != 0)
1404 delete[] DeclsInPrototype;
1405 break;
1406 }
1407 }
1408
1409 DeclSpec &getOrCreateMethodQualifiers() {
1410 if (!MethodQualifiers) {
1411 QualAttrFactory = new AttributeFactory();
1412 MethodQualifiers = new DeclSpec(*QualAttrFactory);
1413 }
1414 return *MethodQualifiers;
1415 }
1416
1417 /// isKNRPrototype - Return true if this is a K&R style identifier list,
1418 /// like "void foo(a,b,c)". In a function definition, this will be followed
1419 /// by the parameter type definitions.
1420 bool isKNRPrototype() const { return !hasPrototype && NumParams != 0; }
1421
1422 SourceLocation getLParenLoc() const { return LParenLoc; }
1423
1424 SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
1425
1426 SourceLocation getRParenLoc() const { return RParenLoc; }
1427
1428 SourceLocation getExceptionSpecLocBeg() const {
1429 return ExceptionSpecLocBeg;
1430 }
1431
1432 SourceLocation getExceptionSpecLocEnd() const {
1433 return ExceptionSpecLocEnd;
1434 }
1435
1436 SourceRange getExceptionSpecRange() const {
1437 return SourceRange(getExceptionSpecLocBeg(), getExceptionSpecLocEnd());
1438 }
1439
1440 /// Retrieve the location of the ref-qualifier, if any.
1441 SourceLocation getRefQualifierLoc() const { return RefQualifierLoc; }
1442
1443 /// Retrieve the location of the 'const' qualifier.
1444 SourceLocation getConstQualifierLoc() const {
1445 assert(MethodQualifiers)((void)0);
1446 return MethodQualifiers->getConstSpecLoc();
1447 }
1448
1449 /// Retrieve the location of the 'volatile' qualifier.
1450 SourceLocation getVolatileQualifierLoc() const {
1451 assert(MethodQualifiers)((void)0);
1452 return MethodQualifiers->getVolatileSpecLoc();
1453 }
1454
1455 /// Retrieve the location of the 'restrict' qualifier.
1456 SourceLocation getRestrictQualifierLoc() const {
1457 assert(MethodQualifiers)((void)0);
1458 return MethodQualifiers->getRestrictSpecLoc();
1459 }
1460
1461 /// Retrieve the location of the 'mutable' qualifier, if any.
1462 SourceLocation getMutableLoc() const { return MutableLoc; }
1463
1464 /// Determine whether this function declaration contains a
1465 /// ref-qualifier.
1466 bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }
1467
1468 /// Determine whether this lambda-declarator contains a 'mutable'
1469 /// qualifier.
1470 bool hasMutableQualifier() const { return getMutableLoc().isValid(); }
1471
1472 /// Determine whether this method has qualifiers.
1473 bool hasMethodTypeQualifiers() const {
1474 return MethodQualifiers && (MethodQualifiers->getTypeQualifiers() ||
1475 MethodQualifiers->getAttributes().size());
1476 }
1477
1478 /// Get the type of exception specification this function has.
1479 ExceptionSpecificationType getExceptionSpecType() const {
1480 return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
1481 }
1482
1483 /// Get the number of dynamic exception specifications.
1484 unsigned getNumExceptions() const {
1485 assert(ExceptionSpecType != EST_None)((void)0);
1486 return NumExceptionsOrDecls;
1487 }
1488
1489 /// Get the non-parameter decls defined within this function
1490 /// prototype. Typically these are tag declarations.
1491 ArrayRef<NamedDecl *> getDeclsInPrototype() const {
1492 assert(ExceptionSpecType == EST_None)((void)0);
1493 return llvm::makeArrayRef(DeclsInPrototype, NumExceptionsOrDecls);
1494 }
1495
1496 /// Determine whether this function declarator had a
1497 /// trailing-return-type.
1498 bool hasTrailingReturnType() const { return HasTrailingReturnType; }
1499
1500 /// Get the trailing-return-type for this function declarator.
1501 ParsedType getTrailingReturnType() const {
1502 assert(HasTrailingReturnType)((void)0);
1503 return TrailingReturnType;
1504 }
1505
1506 /// Get the trailing-return-type location for this function declarator.
1507 SourceLocation getTrailingReturnTypeLoc() const {
1508 assert(HasTrailingReturnType)((void)0);
1509 return TrailingReturnTypeLoc;
1510 }
1511 };
1512
1513 struct BlockPointerTypeInfo {
1514 /// For now, sema will catch these as invalid.
1515 /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
1516 unsigned TypeQuals : 5;
1517
1518 void destroy() {
1519 }
1520 };
1521
1522 struct MemberPointerTypeInfo {
1523 /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
1524 unsigned TypeQuals : 5;
1525 /// Location of the '*' token.
1526 SourceLocation StarLoc;
1527 // CXXScopeSpec has a constructor, so it can't be a direct member.
1528 // So we need some pointer-aligned storage and a bit of trickery.
1529 alignas(CXXScopeSpec) char ScopeMem[sizeof(CXXScopeSpec)];
1530 CXXScopeSpec &Scope() {
1531 return *reinterpret_cast<CXXScopeSpec *>(ScopeMem);
1532 }
1533 const CXXScopeSpec &Scope() const {
1534 return *reinterpret_cast<const CXXScopeSpec *>(ScopeMem);
1535 }
1536 void destroy() {
1537 Scope().~CXXScopeSpec();
1538 }
1539 };
1540
1541 struct PipeTypeInfo {
1542 /// The access writes.
1543 unsigned AccessWrites : 3;
1544
1545 void destroy() {}
1546 };
1547
1548 union {
1549 PointerTypeInfo Ptr;
1550 ReferenceTypeInfo Ref;
1551 ArrayTypeInfo Arr;
1552 FunctionTypeInfo Fun;
1553 BlockPointerTypeInfo Cls;
1554 MemberPointerTypeInfo Mem;
1555 PipeTypeInfo PipeInfo;
1556 };
1557
1558 void destroy() {
1559 switch (Kind) {
1560 case DeclaratorChunk::Function: return Fun.destroy();
1561 case DeclaratorChunk::Pointer: return Ptr.destroy();
1562 case DeclaratorChunk::BlockPointer: return Cls.destroy();
1563 case DeclaratorChunk::Reference: return Ref.destroy();
1564 case DeclaratorChunk::Array: return Arr.destroy();
1565 case DeclaratorChunk::MemberPointer: return Mem.destroy();
1566 case DeclaratorChunk::Paren: return;
1567 case DeclaratorChunk::Pipe: return PipeInfo.destroy();
1568 }
1569 }
1570
1571 /// If there are attributes applied to this declaratorchunk, return
1572 /// them.
1573 const ParsedAttributesView &getAttrs() const { return AttrList; }
1574 ParsedAttributesView &getAttrs() { return AttrList; }
1575
1576 /// Return a DeclaratorChunk for a pointer.
1577 static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
1578 SourceLocation ConstQualLoc,
1579 SourceLocation VolatileQualLoc,
1580 SourceLocation RestrictQualLoc,
1581 SourceLocation AtomicQualLoc,
1582 SourceLocation UnalignedQualLoc) {
1583 DeclaratorChunk I;
1584 I.Kind = Pointer;
1585 I.Loc = Loc;
1586 new (&I.Ptr) PointerTypeInfo;
1587 I.Ptr.TypeQuals = TypeQuals;
1588 I.Ptr.ConstQualLoc = ConstQualLoc;
1589 I.Ptr.VolatileQualLoc = VolatileQualLoc;
1590 I.Ptr.RestrictQualLoc = RestrictQualLoc;
1591 I.Ptr.AtomicQualLoc = AtomicQualLoc;
1592 I.Ptr.UnalignedQualLoc = UnalignedQualLoc;
1593 return I;
1594 }
1595
1596 /// Return a DeclaratorChunk for a reference.
1597 static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,
1598 bool lvalue) {
1599 DeclaratorChunk I;
1600 I.Kind = Reference;
1601 I.Loc = Loc;
1602 I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0;
1603 I.Ref.LValueRef = lvalue;
1604 return I;
1605 }
1606
1607 /// Return a DeclaratorChunk for an array.
1608 static DeclaratorChunk getArray(unsigned TypeQuals,
1609 bool isStatic, bool isStar, Expr *NumElts,
1610 SourceLocation LBLoc, SourceLocation RBLoc) {
1611 DeclaratorChunk I;
1612 I.Kind = Array;
1613 I.Loc = LBLoc;
1614 I.EndLoc = RBLoc;
1615 I.Arr.TypeQuals = TypeQuals;
1616 I.Arr.hasStatic = isStatic;
1617 I.Arr.isStar = isStar;
1618 I.Arr.NumElts = NumElts;
1619 return I;
1620 }
1621
1622 /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
1623 /// "TheDeclarator" is the declarator that this will be added to.
1624 static DeclaratorChunk getFunction(bool HasProto,
1625 bool IsAmbiguous,
1626 SourceLocation LParenLoc,
1627 ParamInfo *Params, unsigned NumParams,
1628 SourceLocation EllipsisLoc,
1629 SourceLocation RParenLoc,
1630 bool RefQualifierIsLvalueRef,
1631 SourceLocation RefQualifierLoc,
1632 SourceLocation MutableLoc,
1633 ExceptionSpecificationType ESpecType,
1634 SourceRange ESpecRange,
1635 ParsedType *Exceptions,
1636 SourceRange *ExceptionRanges,
1637 unsigned NumExceptions,
1638 Expr *NoexceptExpr,
1639 CachedTokens *ExceptionSpecTokens,
1640 ArrayRef<NamedDecl *> DeclsInPrototype,
1641 SourceLocation LocalRangeBegin,
1642 SourceLocation LocalRangeEnd,
1643 Declarator &TheDeclarator,
1644 TypeResult TrailingReturnType =
1645 TypeResult(),
1646 SourceLocation TrailingReturnTypeLoc =
1647 SourceLocation(),
1648 DeclSpec *MethodQualifiers = nullptr);
1649
1650 /// Return a DeclaratorChunk for a block.
1651 static DeclaratorChunk getBlockPointer(unsigned TypeQuals,
1652 SourceLocation Loc) {
1653 DeclaratorChunk I;
1654 I.Kind = BlockPointer;
1655 I.Loc = Loc;
1656 I.Cls.TypeQuals = TypeQuals;
1657 return I;
1658 }
1659
1660 /// Return a DeclaratorChunk for a block.
1661 static DeclaratorChunk getPipe(unsigned TypeQuals,
1662 SourceLocation Loc) {
1663 DeclaratorChunk I;
1664 I.Kind = Pipe;
1665 I.Loc = Loc;
1666 I.Cls.TypeQuals = TypeQuals;
1667 return I;
1668 }
1669
1670 static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS,
1671 unsigned TypeQuals,
1672 SourceLocation StarLoc,
1673 SourceLocation EndLoc) {
1674 DeclaratorChunk I;
1675 I.Kind = MemberPointer;
1676 I.Loc = SS.getBeginLoc();
1677 I.EndLoc = EndLoc;
1678 new (&I.Mem) MemberPointerTypeInfo;
1679 I.Mem.StarLoc = StarLoc;
1680 I.Mem.TypeQuals = TypeQuals;
1681 new (I.Mem.ScopeMem) CXXScopeSpec(SS);
1682 return I;
1683 }
1684
1685 /// Return a DeclaratorChunk for a paren.
1686 static DeclaratorChunk getParen(SourceLocation LParenLoc,
1687 SourceLocation RParenLoc) {
1688 DeclaratorChunk I;
1689 I.Kind = Paren;
1690 I.Loc = LParenLoc;
1691 I.EndLoc = RParenLoc;
1692 return I;
1693 }
1694
1695 bool isParen() const {
1696 return Kind == Paren;
1697 }
1698};
1699
1700/// A parsed C++17 decomposition declarator of the form
1701/// '[' identifier-list ']'
1702class DecompositionDeclarator {
1703public:
1704 struct Binding {
1705 IdentifierInfo *Name;
1706 SourceLocation NameLoc;
1707 };
1708
1709private:
1710 /// The locations of the '[' and ']' tokens.
1711 SourceLocation LSquareLoc, RSquareLoc;
1712
1713 /// The bindings.
1714 Binding *Bindings;
1715 unsigned NumBindings : 31;
1716 unsigned DeleteBindings : 1;
1717
1718 friend class Declarator;
1719
1720public:
1721 DecompositionDeclarator()
1722 : Bindings(nullptr), NumBindings(0), DeleteBindings(false) {}
1723 DecompositionDeclarator(const DecompositionDeclarator &G) = delete;
1724 DecompositionDeclarator &operator=(const DecompositionDeclarator &G) = delete;
1725 ~DecompositionDeclarator() {
1726 if (DeleteBindings)
1727 delete[] Bindings;
1728 }
1729
1730 void clear() {
1731 LSquareLoc = RSquareLoc = SourceLocation();
1732 if (DeleteBindings)
1733 delete[] Bindings;
1734 Bindings = nullptr;
1735 NumBindings = 0;
1736 DeleteBindings = false;
1737 }
1738
1739 ArrayRef<Binding> bindings() const {
1740 return llvm::makeArrayRef(Bindings, NumBindings);
1741 }
1742
1743 bool isSet() const { return LSquareLoc.isValid(); }
1744
1745 SourceLocation getLSquareLoc() const { return LSquareLoc; }
1746 SourceLocation getRSquareLoc() const { return RSquareLoc; }
1747 SourceRange getSourceRange() const {
1748 return SourceRange(LSquareLoc, RSquareLoc);
1749 }
1750};
1751
1752/// Described the kind of function definition (if any) provided for
1753/// a function.
1754enum class FunctionDefinitionKind {
1755 Declaration,
1756 Definition,
1757 Defaulted,
1758 Deleted
1759};
1760
1761enum class DeclaratorContext {
1762 File, // File scope declaration.
1763 Prototype, // Within a function prototype.
1764 ObjCResult, // An ObjC method result type.
1765 ObjCParameter, // An ObjC method parameter type.
1766 KNRTypeList, // K&R type definition list for formals.
1767 TypeName, // Abstract declarator for types.
1768 FunctionalCast, // Type in a C++ functional cast expression.
1769 Member, // Struct/Union field.
1770 Block, // Declaration within a block in a function.
1771 ForInit, // Declaration within first part of a for loop.
1772 SelectionInit, // Declaration within optional init stmt of if/switch.
1773 Condition, // Condition declaration in a C++ if/switch/while/for.
1774 TemplateParam, // Within a template parameter list.
1775 CXXNew, // C++ new-expression.
1776 CXXCatch, // C++ catch exception-declaration
1777 ObjCCatch, // Objective-C catch exception-declaration
1778 BlockLiteral, // Block literal declarator.
1779 LambdaExpr, // Lambda-expression declarator.
1780 LambdaExprParameter, // Lambda-expression parameter declarator.
1781 ConversionId, // C++ conversion-type-id.
1782 TrailingReturn, // C++11 trailing-type-specifier.
1783 TrailingReturnVar, // C++11 trailing-type-specifier for variable.
1784 TemplateArg, // Any template argument (in template argument list).
1785 TemplateTypeArg, // Template type argument (in default argument).
1786 AliasDecl, // C++11 alias-declaration.
1787 AliasTemplate, // C++11 alias-declaration template.
1788 RequiresExpr // C++2a requires-expression.
1789};
1790
1791/// Information about one declarator, including the parsed type
1792/// information and the identifier.
1793///
1794/// When the declarator is fully formed, this is turned into the appropriate
1795/// Decl object.
1796///
1797/// Declarators come in two types: normal declarators and abstract declarators.
1798/// Abstract declarators are used when parsing types, and don't have an
1799/// identifier. Normal declarators do have ID's.
1800///
1801/// Instances of this class should be a transient object that lives on the
1802/// stack, not objects that are allocated in large quantities on the heap.
1803class Declarator {
1804
1805private:
1806 const DeclSpec &DS;
1807 CXXScopeSpec SS;
1808 UnqualifiedId Name;
1809 SourceRange Range;
1810
1811 /// Where we are parsing this declarator.
1812 DeclaratorContext Context;
1813
1814 /// The C++17 structured binding, if any. This is an alternative to a Name.
1815 DecompositionDeclarator BindingGroup;
1816
1817 /// DeclTypeInfo - This holds each type that the declarator includes as it is
1818 /// parsed. This is pushed from the identifier out, which means that element
1819 /// #0 will be the most closely bound to the identifier, and
1820 /// DeclTypeInfo.back() will be the least closely bound.
1821 SmallVector<DeclaratorChunk, 8> DeclTypeInfo;
1822
1823 /// InvalidType - Set by Sema::GetTypeForDeclarator().
1824 unsigned InvalidType : 1;
1825
1826 /// GroupingParens - Set by Parser::ParseParenDeclarator().
1827 unsigned GroupingParens : 1;
1828
1829 /// FunctionDefinition - Is this Declarator for a function or member
1830 /// definition and, if so, what kind?
1831 ///
1832 /// Actually a FunctionDefinitionKind.
1833 unsigned FunctionDefinition : 2;
1834
1835 /// Is this Declarator a redeclaration?
1836 unsigned Redeclaration : 1;
1837
1838 /// true if the declaration is preceded by \c __extension__.
1839 unsigned Extension : 1;
1840
1841 /// Indicates whether this is an Objective-C instance variable.
1842 unsigned ObjCIvar : 1;
1843
1844 /// Indicates whether this is an Objective-C 'weak' property.
1845 unsigned ObjCWeakProperty : 1;
1846
1847 /// Indicates whether the InlineParams / InlineBindings storage has been used.
1848 unsigned InlineStorageUsed : 1;
1849
1850 /// Indicates whether this declarator has an initializer.
1851 unsigned HasInitializer : 1;
1852
1853 /// Attrs - Attributes.
1854 ParsedAttributes Attrs;
1855
1856 /// The asm label, if specified.
1857 Expr *AsmLabel;
1858
1859 /// \brief The constraint-expression specified by the trailing
1860 /// requires-clause, or null if no such clause was specified.
1861 Expr *TrailingRequiresClause;
1862
1863 /// If this declarator declares a template, its template parameter lists.
1864 ArrayRef<TemplateParameterList *> TemplateParameterLists;
1865
1866 /// If the declarator declares an abbreviated function template, the innermost
1867 /// template parameter list containing the invented and explicit template
1868 /// parameters (if any).
1869 TemplateParameterList *InventedTemplateParameterList;
1870
1871#ifndef _MSC_VER
1872 union {
1873#endif
1874 /// InlineParams - This is a local array used for the first function decl
1875 /// chunk to avoid going to the heap for the common case when we have one
1876 /// function chunk in the declarator.
1877 DeclaratorChunk::ParamInfo InlineParams[16];
1878 DecompositionDeclarator::Binding InlineBindings[16];
1879#ifndef _MSC_VER
1880 };
1881#endif
1882
1883 /// If this is the second or subsequent declarator in this declaration,
1884 /// the location of the comma before this declarator.
1885 SourceLocation CommaLoc;
1886
1887 /// If provided, the source location of the ellipsis used to describe
1888 /// this declarator as a parameter pack.
1889 SourceLocation EllipsisLoc;
1890
1891 friend struct DeclaratorChunk;
1892
1893public:
1894 Declarator(const DeclSpec &ds, DeclaratorContext C)
1895 : DS(ds), Range(ds.getSourceRange()), Context(C),
1896 InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
1897 GroupingParens(false), FunctionDefinition(static_cast<unsigned>(
1898 FunctionDefinitionKind::Declaration)),
1899 Redeclaration(false), Extension(false), ObjCIvar(false),
1900 ObjCWeakProperty(false), InlineStorageUsed(false),
1901 HasInitializer(false), Attrs(ds.getAttributePool().getFactory()),
1902 AsmLabel(nullptr), TrailingRequiresClause(nullptr),
1903 InventedTemplateParameterList(nullptr) {}
1904
1905 ~Declarator() {
1906 clear();
1907 }
1908 /// getDeclSpec - Return the declaration-specifier that this declarator was
1909 /// declared with.
1910 const DeclSpec &getDeclSpec() const { return DS; }
1911
1912 /// getMutableDeclSpec - Return a non-const version of the DeclSpec. This
1913 /// should be used with extreme care: declspecs can often be shared between
1914 /// multiple declarators, so mutating the DeclSpec affects all of the
1915 /// Declarators. This should only be done when the declspec is known to not
1916 /// be shared or when in error recovery etc.
1917 DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); }
1918
1919 AttributePool &getAttributePool() const {
1920 return Attrs.getPool();
1921 }
1922
1923 /// getCXXScopeSpec - Return the C++ scope specifier (global scope or
1924 /// nested-name-specifier) that is part of the declarator-id.
1925 const CXXScopeSpec &getCXXScopeSpec() const { return SS; }
1926 CXXScopeSpec &getCXXScopeSpec() { return SS; }
1927
1928 /// Retrieve the name specified by this declarator.
1929 UnqualifiedId &getName() { return Name; }
1930
1931 const DecompositionDeclarator &getDecompositionDeclarator() const {
1932 return BindingGroup;
1933 }
1934
1935 DeclaratorContext getContext() const { return Context; }
1936
1937 bool isPrototypeContext() const {
1938 return (Context == DeclaratorContext::Prototype ||
1939 Context == DeclaratorContext::ObjCParameter ||
1940 Context == DeclaratorContext::ObjCResult ||
1941 Context == DeclaratorContext::LambdaExprParameter);
1942 }
1943
1944 /// Get the source range that spans this declarator.
1945 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
1946 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
1947 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
1948
1949 void SetSourceRange(SourceRange R) { Range = R; }
1950 /// SetRangeBegin - Set the start of the source range to Loc, unless it's
1951 /// invalid.
1952 void SetRangeBegin(SourceLocation Loc) {
1953 if (!Loc.isInvalid())
1954 Range.setBegin(Loc);
1955 }
1956 /// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
1957 void SetRangeEnd(SourceLocation Loc) {
1958 if (!Loc.isInvalid())
1959 Range.setEnd(Loc);
1960 }
1961 /// ExtendWithDeclSpec - Extend the declarator source range to include the
1962 /// given declspec, unless its location is invalid. Adopts the range start if
1963 /// the current range start is invalid.
1964 void ExtendWithDeclSpec(const DeclSpec &DS) {
1965 SourceRange SR = DS.getSourceRange();
1966 if (Range.getBegin().isInvalid())
1967 Range.setBegin(SR.getBegin());
1968 if (!SR.getEnd().isInvalid())
1969 Range.setEnd(SR.getEnd());
1970 }
1971
1972 /// Reset the contents of this Declarator.
1973 void clear() {
1974 SS.clear();
1975 Name.clear();
1976 Range = DS.getSourceRange();
1977 BindingGroup.clear();
1978
1979 for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i)
1980 DeclTypeInfo[i].destroy();
1981 DeclTypeInfo.clear();
1982 Attrs.clear();
1983 AsmLabel = nullptr;
1984 InlineStorageUsed = false;
1985 HasInitializer = false;
1986 ObjCIvar = false;
1987 ObjCWeakProperty = false;
1988 CommaLoc = SourceLocation();
1989 EllipsisLoc = SourceLocation();
1990 }
1991
1992 /// mayOmitIdentifier - Return true if the identifier is either optional or
1993 /// not allowed. This is true for typenames, prototypes, and template
1994 /// parameter lists.
1995 bool mayOmitIdentifier() const {
1996 switch (Context) {
1997 case DeclaratorContext::File:
1998 case DeclaratorContext::KNRTypeList:
1999 case DeclaratorContext::Member:
2000 case DeclaratorContext::Block:
2001 case DeclaratorContext::ForInit:
2002 case DeclaratorContext::SelectionInit:
2003 case DeclaratorContext::Condition:
2004 return false;
2005
2006 case DeclaratorContext::TypeName:
2007 case DeclaratorContext::FunctionalCast:
2008 case DeclaratorContext::AliasDecl:
2009 case DeclaratorContext::AliasTemplate:
2010 case DeclaratorContext::Prototype:
2011 case DeclaratorContext::LambdaExprParameter:
2012 case DeclaratorContext::ObjCParameter:
2013 case DeclaratorContext::ObjCResult:
2014 case DeclaratorContext::TemplateParam:
2015 case DeclaratorContext::CXXNew:
2016 case DeclaratorContext::CXXCatch:
2017 case DeclaratorContext::ObjCCatch:
2018 case DeclaratorContext::BlockLiteral:
2019 case DeclaratorContext::LambdaExpr:
2020 case DeclaratorContext::ConversionId:
2021 case DeclaratorContext::TemplateArg:
2022 case DeclaratorContext::TemplateTypeArg:
2023 case DeclaratorContext::TrailingReturn:
2024 case DeclaratorContext::TrailingReturnVar:
2025 case DeclaratorContext::RequiresExpr:
2026 return true;
2027 }
2028 llvm_unreachable("unknown context kind!")__builtin_unreachable();
2029 }
2030
2031 /// mayHaveIdentifier - Return true if the identifier is either optional or
2032 /// required. This is true for normal declarators and prototypes, but not
2033 /// typenames.
2034 bool mayHaveIdentifier() const {
2035 switch (Context) {
2036 case DeclaratorContext::File:
2037 case DeclaratorContext::KNRTypeList:
2038 case DeclaratorContext::Member:
2039 case DeclaratorContext::Block:
2040 case DeclaratorContext::ForInit:
2041 case DeclaratorContext::SelectionInit:
2042 case DeclaratorContext::Condition:
2043 case DeclaratorContext::Prototype:
2044 case DeclaratorContext::LambdaExprParameter:
2045 case DeclaratorContext::TemplateParam:
2046 case DeclaratorContext::CXXCatch:
2047 case DeclaratorContext::ObjCCatch:
2048 case DeclaratorContext::RequiresExpr:
2049 return true;
2050
2051 case DeclaratorContext::TypeName:
2052 case DeclaratorContext::FunctionalCast:
2053 case DeclaratorContext::CXXNew:
2054 case DeclaratorContext::AliasDecl:
2055 case DeclaratorContext::AliasTemplate:
2056 case DeclaratorContext::ObjCParameter:
2057 case DeclaratorContext::ObjCResult:
2058 case DeclaratorContext::BlockLiteral:
2059 case DeclaratorContext::LambdaExpr:
2060 case DeclaratorContext::ConversionId:
2061 case DeclaratorContext::TemplateArg:
2062 case DeclaratorContext::TemplateTypeArg:
2063 case DeclaratorContext::TrailingReturn:
2064 case DeclaratorContext::TrailingReturnVar:
2065 return false;
2066 }
2067 llvm_unreachable("unknown context kind!")__builtin_unreachable();
2068 }
2069
2070 /// Return true if the context permits a C++17 decomposition declarator.
2071 bool mayHaveDecompositionDeclarator() const {
2072 switch (Context) {
2073 case DeclaratorContext::File:
2074 // FIXME: It's not clear that the proposal meant to allow file-scope
2075 // structured bindings, but it does.
2076 case DeclaratorContext::Block:
2077 case DeclaratorContext::ForInit:
2078 case DeclaratorContext::SelectionInit:
2079 case DeclaratorContext::Condition:
2080 return true;
2081
2082 case DeclaratorContext::Member:
2083 case DeclaratorContext::Prototype:
2084 case DeclaratorContext::TemplateParam:
2085 case DeclaratorContext::RequiresExpr:
2086 // Maybe one day...
2087 return false;
2088
2089 // These contexts don't allow any kind of non-abstract declarator.
2090 case DeclaratorContext::KNRTypeList:
2091 case DeclaratorContext::TypeName:
2092 case DeclaratorContext::FunctionalCast:
2093 case DeclaratorContext::AliasDecl:
2094 case DeclaratorContext::AliasTemplate:
2095 case DeclaratorContext::LambdaExprParameter:
2096 case DeclaratorContext::ObjCParameter:
2097 case DeclaratorContext::ObjCResult:
2098 case DeclaratorContext::CXXNew:
2099 case DeclaratorContext::CXXCatch:
2100 case DeclaratorContext::ObjCCatch:
2101 case DeclaratorContext::BlockLiteral:
2102 case DeclaratorContext::LambdaExpr:
2103 case DeclaratorContext::ConversionId:
2104 case DeclaratorContext::TemplateArg:
2105 case DeclaratorContext::TemplateTypeArg:
2106 case DeclaratorContext::TrailingReturn:
2107 case DeclaratorContext::TrailingReturnVar:
2108 return false;
2109 }
2110 llvm_unreachable("unknown context kind!")__builtin_unreachable();
2111 }
2112
2113 /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be
2114 /// followed by a C++ direct initializer, e.g. "int x(1);".
2115 bool mayBeFollowedByCXXDirectInit() const {
2116 if (hasGroupingParens()) return false;
2117
2118 if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
2119 return false;
2120
2121 if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern &&
2122 Context != DeclaratorContext::File)
2123 return false;
2124
2125 // Special names can't have direct initializers.
2126 if (Name.getKind() != UnqualifiedIdKind::IK_Identifier)
2127 return false;
2128
2129 switch (Context) {
2130 case DeclaratorContext::File:
2131 case DeclaratorContext::Block:
2132 case DeclaratorContext::ForInit:
2133 case DeclaratorContext::SelectionInit:
2134 case DeclaratorContext::TrailingReturnVar:
2135 return true;
2136
2137 case DeclaratorContext::Condition:
2138 // This may not be followed by a direct initializer, but it can't be a
2139 // function declaration either, and we'd prefer to perform a tentative
2140 // parse in order to produce the right diagnostic.
2141 return true;
2142
2143 case DeclaratorContext::KNRTypeList:
2144 case DeclaratorContext::Member:
2145 case DeclaratorContext::Prototype:
2146 case DeclaratorContext::LambdaExprParameter:
2147 case DeclaratorContext::ObjCParameter:
2148 case DeclaratorContext::ObjCResult:
2149 case DeclaratorContext::TemplateParam:
2150 case DeclaratorContext::CXXCatch:
2151 case DeclaratorContext::ObjCCatch:
2152 case DeclaratorContext::TypeName:
2153 case DeclaratorContext::FunctionalCast: // FIXME
2154 case DeclaratorContext::CXXNew:
2155 case DeclaratorContext::AliasDecl:
2156 case DeclaratorContext::AliasTemplate:
2157 case DeclaratorContext::BlockLiteral:
2158 case DeclaratorContext::LambdaExpr:
2159 case DeclaratorContext::ConversionId:
2160 case DeclaratorContext::TemplateArg:
2161 case DeclaratorContext::TemplateTypeArg:
2162 case DeclaratorContext::TrailingReturn:
2163 case DeclaratorContext::RequiresExpr:
2164 return false;
2165 }
2166 llvm_unreachable("unknown context kind!")__builtin_unreachable();
2167 }
2168
2169 /// isPastIdentifier - Return true if we have parsed beyond the point where
2170 /// the name would appear. (This may happen even if we haven't actually parsed
2171 /// a name, perhaps because this context doesn't require one.)
2172 bool isPastIdentifier() const { return Name.isValid(); }
2173
2174 /// hasName - Whether this declarator has a name, which might be an
2175 /// identifier (accessible via getIdentifier()) or some kind of
2176 /// special C++ name (constructor, destructor, etc.), or a structured
2177 /// binding (which is not exactly a name, but occupies the same position).
2178 bool hasName() const {
2179 return Name.getKind() != UnqualifiedIdKind::IK_Identifier ||
2180 Name.Identifier || isDecompositionDeclarator();
2181 }
2182
2183 /// Return whether this declarator is a decomposition declarator.
2184 bool isDecompositionDeclarator() const {
2185 return BindingGroup.isSet();
2186 }
2187
2188 IdentifierInfo *getIdentifier() const {
2189 if (Name.getKind() == UnqualifiedIdKind::IK_Identifier)
2190 return Name.Identifier;
2191
2192 return nullptr;
2193 }
2194 SourceLocation getIdentifierLoc() const { return Name.StartLocation; }
2195
2196 /// Set the name of this declarator to be the given identifier.
2197 void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc) {
2198 Name.setIdentifier(Id, IdLoc);
2199 }
2200
2201 /// Set the decomposition bindings for this declarator.
2202 void
2203 setDecompositionBindings(SourceLocation LSquareLoc,
2204 ArrayRef<DecompositionDeclarator::Binding> Bindings,
2205 SourceLocation RSquareLoc);
2206
2207 /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
2208 /// EndLoc, which should be the last token of the chunk.
2209 /// This function takes attrs by R-Value reference because it takes ownership
2210 /// of those attributes from the parameter.
2211 void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs,
2212 SourceLocation EndLoc) {
2213 DeclTypeInfo.push_back(TI);
2214 DeclTypeInfo.back().getAttrs().addAll(attrs.begin(), attrs.end());
2215 getAttributePool().takeAllFrom(attrs.getPool());
2216
2217 if (!EndLoc.isInvalid())
2218 SetRangeEnd(EndLoc);
2219 }
2220
2221 /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
2222 /// EndLoc, which should be the last token of the chunk.
2223 void AddTypeInfo(const DeclaratorChunk &TI, SourceLocation EndLoc) {
2224 DeclTypeInfo.push_back(TI);
2225
2226 if (!EndLoc.isInvalid())
2227 SetRangeEnd(EndLoc);
2228 }
2229
2230 /// Add a new innermost chunk to this declarator.
2231 void AddInnermostTypeInfo(const DeclaratorChunk &TI) {
2232 DeclTypeInfo.insert(DeclTypeInfo.begin(), TI);
2233 }
2234
2235 /// Return the number of types applied to this declarator.
2236 unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); }
2237
2238 /// Return the specified TypeInfo from this declarator. TypeInfo #0 is
2239 /// closest to the identifier.
2240 const DeclaratorChunk &getTypeObject(unsigned i) const {
2241 assert(i < DeclTypeInfo.size() && "Invalid type chunk")((void)0);
2242 return DeclTypeInfo[i];
2243 }
2244 DeclaratorChunk &getTypeObject(unsigned i) {
2245 assert(i < DeclTypeInfo.size() && "Invalid type chunk")((void)0);
2246 return DeclTypeInfo[i];
2247 }
2248
2249 typedef SmallVectorImpl<DeclaratorChunk>::const_iterator type_object_iterator;
2250 typedef llvm::iterator_range<type_object_iterator> type_object_range;
2251
2252 /// Returns the range of type objects, from the identifier outwards.
2253 type_object_range type_objects() const {
2254 return type_object_range(DeclTypeInfo.begin(), DeclTypeInfo.end());
2255 }
2256
2257 void DropFirstTypeObject() {
2258 assert(!DeclTypeInfo.empty() && "No type chunks to drop.")((void)0);
2259 DeclTypeInfo.front().destroy();
2260 DeclTypeInfo.erase(DeclTypeInfo.begin());
2261 }
2262
2263 /// Return the innermost (closest to the declarator) chunk of this
2264 /// declarator that is not a parens chunk, or null if there are no
2265 /// non-parens chunks.
2266 const DeclaratorChunk *getInnermostNonParenChunk() const {
2267 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
2268 if (!DeclTypeInfo[i].isParen())
2269 return &DeclTypeInfo[i];
2270 }
2271 return nullptr;
2272 }
2273
2274 /// Return the outermost (furthest from the declarator) chunk of
2275 /// this declarator that is not a parens chunk, or null if there are
2276 /// no non-parens chunks.
2277 const DeclaratorChunk *getOutermostNonParenChunk() const {
2278 for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) {
2279 if (!DeclTypeInfo[i-1].isParen())
2280 return &DeclTypeInfo[i-1];
2281 }
2282 return nullptr;
2283 }
2284
2285 /// isArrayOfUnknownBound - This method returns true if the declarator
2286 /// is a declarator for an array of unknown bound (looking through
2287 /// parentheses).
2288 bool isArrayOfUnknownBound() const {
2289 const DeclaratorChunk *chunk = getInnermostNonParenChunk();
2290 return (chunk && chunk->Kind == DeclaratorChunk::Array &&
2291 !chunk->Arr.NumElts);
2292 }
2293
2294 /// isFunctionDeclarator - This method returns true if the declarator
2295 /// is a function declarator (looking through parentheses).
2296 /// If true is returned, then the reference type parameter idx is
2297 /// assigned with the index of the declaration chunk.
2298 bool isFunctionDeclarator(unsigned& idx) const {
2299 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
2300 switch (DeclTypeInfo[i].Kind) {
2301 case DeclaratorChunk::Function:
2302 idx = i;
2303 return true;
2304 case DeclaratorChunk::Paren:
2305 continue;
2306 case DeclaratorChunk::Pointer:
2307 case DeclaratorChunk::Reference:
2308 case DeclaratorChunk::Array:
2309 case DeclaratorChunk::BlockPointer:
2310 case DeclaratorChunk::MemberPointer:
2311 case DeclaratorChunk::Pipe:
2312 return false;
2313 }
2314 llvm_unreachable("Invalid type chunk")__builtin_unreachable();
2315 }
2316 return false;
2317 }
2318
2319 /// isFunctionDeclarator - Once this declarator is fully parsed and formed,
2320 /// this method returns true if the identifier is a function declarator
2321 /// (looking through parentheses).
2322 bool isFunctionDeclarator() const {
2323 unsigned index;
2324 return isFunctionDeclarator(index);
2325 }
2326
2327 /// getFunctionTypeInfo - Retrieves the function type info object
2328 /// (looking through parentheses).
2329 DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() {
2330 assert(isFunctionDeclarator() && "Not a function declarator!")((void)0);
2331 unsigned index = 0;
2332 isFunctionDeclarator(index);
2333 return DeclTypeInfo[index].Fun;
2334 }
2335
2336 /// getFunctionTypeInfo - Retrieves the function type info object
2337 /// (looking through parentheses).
2338 const DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() const {
2339 return const_cast<Declarator*>(this)->getFunctionTypeInfo();
2340 }
2341
2342 /// Determine whether the declaration that will be produced from
2343 /// this declaration will be a function.
2344 ///
2345 /// A declaration can declare a function even if the declarator itself
2346 /// isn't a function declarator, if the type specifier refers to a function
2347 /// type. This routine checks for both cases.
2348 bool isDeclarationOfFunction() const;
2349
2350 /// Return true if this declaration appears in a context where a
2351 /// function declarator would be a function declaration.
2352 bool isFunctionDeclarationContext() const {
2353 if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
2354 return false;
2355
2356 switch (Context) {
2357 case DeclaratorContext::File:
2358 case DeclaratorContext::Member:
2359 case DeclaratorContext::Block:
2360 case DeclaratorContext::ForInit:
2361 case DeclaratorContext::SelectionInit:
2362 return true;
2363
2364 case DeclaratorContext::Condition:
2365 case DeclaratorContext::KNRTypeList:
2366 case DeclaratorContext::TypeName:
2367 case DeclaratorContext::FunctionalCast:
2368 case DeclaratorContext::AliasDecl:
2369 case DeclaratorContext::AliasTemplate:
2370 case DeclaratorContext::Prototype:
2371 case DeclaratorContext::LambdaExprParameter:
2372 case DeclaratorContext::ObjCParameter:
2373 case DeclaratorContext::ObjCResult:
2374 case DeclaratorContext::TemplateParam:
2375 case DeclaratorContext::CXXNew:
2376 case DeclaratorContext::CXXCatch:
2377 case DeclaratorContext::ObjCCatch:
2378 case DeclaratorContext::BlockLiteral:
2379 case DeclaratorContext::LambdaExpr:
2380 case DeclaratorContext::ConversionId:
2381 case DeclaratorContext::TemplateArg:
2382 case DeclaratorContext::TemplateTypeArg:
2383 case DeclaratorContext::TrailingReturn:
2384 case DeclaratorContext::TrailingReturnVar:
2385 case DeclaratorContext::RequiresExpr:
2386 return false;
2387 }
2388 llvm_unreachable("unknown context kind!")__builtin_unreachable();
2389 }
2390
2391 /// Determine whether this declaration appears in a context where an
2392 /// expression could appear.
2393 bool isExpressionContext() const {
2394 switch (Context) {
2395 case DeclaratorContext::File:
2396 case DeclaratorContext::KNRTypeList:
2397 case DeclaratorContext::Member:
2398
2399 // FIXME: sizeof(...) permits an expression.
2400 case DeclaratorContext::TypeName:
2401
2402 case DeclaratorContext::FunctionalCast:
2403 case DeclaratorContext::AliasDecl:
2404 case DeclaratorContext::AliasTemplate:
2405 case DeclaratorContext::Prototype:
2406 case DeclaratorContext::LambdaExprParameter:
2407 case DeclaratorContext::ObjCParameter:
2408 case DeclaratorContext::ObjCResult:
2409 case DeclaratorContext::TemplateParam:
2410 case DeclaratorContext::CXXNew:
2411 case DeclaratorContext::CXXCatch:
2412 case DeclaratorContext::ObjCCatch:
2413 case DeclaratorContext::BlockLiteral:
2414 case DeclaratorContext::LambdaExpr:
2415 case DeclaratorContext::ConversionId:
2416 case DeclaratorContext::TrailingReturn:
2417 case DeclaratorContext::TrailingReturnVar:
2418 case DeclaratorContext::TemplateTypeArg:
2419 case DeclaratorContext::RequiresExpr:
2420 return false;
2421
2422 case DeclaratorContext::Block:
2423 case DeclaratorContext::ForInit:
2424 case DeclaratorContext::SelectionInit:
2425 case DeclaratorContext::Condition:
2426 case DeclaratorContext::TemplateArg:
2427 return true;
2428 }
2429
2430 llvm_unreachable("unknown context kind!")__builtin_unreachable();
2431 }
2432
2433 /// Return true if a function declarator at this position would be a
2434 /// function declaration.
2435 bool isFunctionDeclaratorAFunctionDeclaration() const {
2436 if (!isFunctionDeclarationContext())
2437 return false;
2438
2439 for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I)
2440 if (getTypeObject(I).Kind != DeclaratorChunk::Paren)
2441 return false;
2442
2443 return true;
2444 }
2445
2446 /// Determine whether a trailing return type was written (at any
2447 /// level) within this declarator.
2448 bool hasTrailingReturnType() const {
2449 for (const auto &Chunk : type_objects())
2450 if (Chunk.Kind == DeclaratorChunk::Function &&
2451 Chunk.Fun.hasTrailingReturnType())
2452 return true;
2453 return false;
2454 }
2455 /// Get the trailing return type appearing (at any level) within this
2456 /// declarator.
2457 ParsedType getTrailingReturnType() const {
2458 for (const auto &Chunk : type_objects())
2459 if (Chunk.Kind == DeclaratorChunk::Function &&
2460 Chunk.Fun.hasTrailingReturnType())
2461 return Chunk.Fun.getTrailingReturnType();
2462 return ParsedType();
2463 }
2464
2465 /// \brief Sets a trailing requires clause for this declarator.
2466 void setTrailingRequiresClause(Expr *TRC) {
2467 TrailingRequiresClause = TRC;
2468
2469 SetRangeEnd(TRC->getEndLoc());
2470 }
2471
2472 /// \brief Sets a trailing requires clause for this declarator.
2473 Expr *getTrailingRequiresClause() {
2474 return TrailingRequiresClause;
2475 }
2476
2477 /// \brief Determine whether a trailing requires clause was written in this
2478 /// declarator.
2479 bool hasTrailingRequiresClause() const {
2480 return TrailingRequiresClause != nullptr;
2481 }
2482
2483 /// Sets the template parameter lists that preceded the declarator.
2484 void setTemplateParameterLists(ArrayRef<TemplateParameterList *> TPLs) {
2485 TemplateParameterLists = TPLs;
2486 }
2487
2488 /// The template parameter lists that preceded the declarator.
2489 ArrayRef<TemplateParameterList *> getTemplateParameterLists() const {
2490 return TemplateParameterLists;
2491 }
2492
2493 /// Sets the template parameter list generated from the explicit template
2494 /// parameters along with any invented template parameters from
2495 /// placeholder-typed parameters.
2496 void setInventedTemplateParameterList(TemplateParameterList *Invented) {
2497 InventedTemplateParameterList = Invented;
2498 }
2499
2500 /// The template parameter list generated from the explicit template
2501 /// parameters along with any invented template parameters from
2502 /// placeholder-typed parameters, if there were any such parameters.
2503 TemplateParameterList * getInventedTemplateParameterList() const {
2504 return InventedTemplateParameterList;
2505 }
2506
2507 /// takeAttributes - Takes attributes from the given parsed-attributes
2508 /// set and add them to this declarator.
2509 ///
2510 /// These examples both add 3 attributes to "var":
2511 /// short int var __attribute__((aligned(16),common,deprecated));
2512 /// short int x, __attribute__((aligned(16)) var
2513 /// __attribute__((common,deprecated));
2514 ///
2515 /// Also extends the range of the declarator.
2516 void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc) {
2517 Attrs.takeAllFrom(attrs);
2518
2519 if (!lastLoc.isInvalid())
2520 SetRangeEnd(lastLoc);
2521 }
2522
2523 const ParsedAttributes &getAttributes() const { return Attrs; }
2524 ParsedAttributes &getAttributes() { return Attrs; }
2525
2526 /// hasAttributes - do we contain any attributes?
2527 bool hasAttributes() const {
2528 if (!getAttributes().empty() || getDeclSpec().hasAttributes())
2529 return true;
2530 for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
2531 if (!getTypeObject(i).getAttrs().empty())
2532 return true;
2533 return false;
2534 }
2535
2536 /// Return a source range list of C++11 attributes associated
2537 /// with the declarator.
2538 void getCXX11AttributeRanges(SmallVectorImpl<SourceRange> &Ranges) {
2539 for (const ParsedAttr &AL : Attrs)
2540 if (AL.isCXX11Attribute())
2541 Ranges.push_back(AL.getRange());
2542 }
2543
2544 void setAsmLabel(Expr *E) { AsmLabel = E; }
2545 Expr *getAsmLabel() const { return AsmLabel; }
2546
2547 void setExtension(bool Val = true) { Extension = Val; }
2548 bool getExtension() const { return Extension; }
2549
2550 void setObjCIvar(bool Val = true) { ObjCIvar = Val; }
2551 bool isObjCIvar() const { return ObjCIvar; }
2552
2553 void setObjCWeakProperty(bool Val = true) { ObjCWeakProperty = Val; }
2554 bool isObjCWeakProperty() const { return ObjCWeakProperty; }
2555
2556 void setInvalidType(bool Val = true) { InvalidType = Val; }
2557 bool isInvalidType() const {
2558 return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error;
2559 }
2560
2561 void setGroupingParens(bool flag) { GroupingParens = flag; }
2562 bool hasGroupingParens() const { return GroupingParens; }
2563
2564 bool isFirstDeclarator() const { return !CommaLoc.isValid(); }
2565 SourceLocation getCommaLoc() const { return CommaLoc; }
2566 void setCommaLoc(SourceLocation CL) { CommaLoc = CL; }
2567
2568 bool hasEllipsis() const { return EllipsisLoc.isValid(); }
2569 SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
2570 void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; }
2571
2572 void setFunctionDefinitionKind(FunctionDefinitionKind Val) {
2573 FunctionDefinition = static_cast<unsigned>(Val);
2574 }
2575
2576 bool isFunctionDefinition() const {
2577 return getFunctionDefinitionKind() != FunctionDefinitionKind::Declaration;
2578 }
2579
2580 FunctionDefinitionKind getFunctionDefinitionKind() const {
2581 return (FunctionDefinitionKind)FunctionDefinition;
2582 }
2583
2584 void setHasInitializer(bool Val = true) { HasInitializer = Val; }
2585 bool hasInitializer() const { return HasInitializer; }
2586
2587 /// Returns true if this declares a real member and not a friend.
2588 bool isFirstDeclarationOfMember() {
2589 return getContext() == DeclaratorContext::Member &&
2590 !getDeclSpec().isFriendSpecified();
2591 }
2592
2593 /// Returns true if this declares a static member. This cannot be called on a
2594 /// declarator outside of a MemberContext because we won't know until
2595 /// redeclaration time if the decl is static.
2596 bool isStaticMember();
2597
2598 /// Returns true if this declares a constructor or a destructor.
2599 bool isCtorOrDtor();
2600
2601 void setRedeclaration(bool Val) { Redeclaration = Val; }
2602 bool isRedeclaration() const { return Redeclaration; }
2603};
2604
2605/// This little struct is used to capture information about
2606/// structure field declarators, which is basically just a bitfield size.
2607struct FieldDeclarator {
2608 Declarator D;
2609 Expr *BitfieldSize;
2610 explicit FieldDeclarator(const DeclSpec &DS)
2611 : D(DS, DeclaratorContext::Member), BitfieldSize(nullptr) {}
2612};
2613
2614/// Represents a C++11 virt-specifier-seq.
2615class VirtSpecifiers {
2616public:
2617 enum Specifier {
2618 VS_None = 0,
2619 VS_Override = 1,
2620 VS_Final = 2,
2621 VS_Sealed = 4,
2622 // Represents the __final keyword, which is legal for gcc in pre-C++11 mode.
2623 VS_GNU_Final = 8,
2624 VS_Abstract = 16
2625 };
2626
2627 VirtSpecifiers() : Specifiers(0), LastSpecifier(VS_None) { }
2628
2629 bool SetSpecifier(Specifier VS, SourceLocation Loc,
2630 const char *&PrevSpec);
2631
2632 bool isUnset() const { return Specifiers == 0; }
2633
2634 bool isOverrideSpecified() const { return Specifiers & VS_Override; }
2635 SourceLocation getOverrideLoc() const { return VS_overrideLoc; }
2636
2637 bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed | VS_GNU_Final); }
2638 bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; }
2639 SourceLocation getFinalLoc() const { return VS_finalLoc; }
2640 SourceLocation getAbstractLoc() const { return VS_abstractLoc; }
2641
2642 void clear() { Specifiers = 0; }
2643
2644 static const char *getSpecifierName(Specifier VS);
2645
2646 SourceLocation getFirstLocation() const { return FirstLocation; }
2647 SourceLocation getLastLocation() const { return LastLocation; }
2648 Specifier getLastSpecifier() const { return LastSpecifier; }
2649
2650private:
2651 unsigned Specifiers;
2652 Specifier LastSpecifier;
2653
2654 SourceLocation VS_overrideLoc, VS_finalLoc, VS_abstractLoc;
2655 SourceLocation FirstLocation;
2656 SourceLocation LastLocation;
2657};
2658
2659enum class LambdaCaptureInitKind {
2660 NoInit, //!< [a]
2661 CopyInit, //!< [a = b], [a = {b}]
2662 DirectInit, //!< [a(b)]
2663 ListInit //!< [a{b}]
2664};
2665
2666/// Represents a complete lambda introducer.
2667struct LambdaIntroducer {
2668 /// An individual capture in a lambda introducer.
2669 struct LambdaCapture {
2670 LambdaCaptureKind Kind;
2671 SourceLocation Loc;
2672 IdentifierInfo *Id;
2673 SourceLocation EllipsisLoc;
2674 LambdaCaptureInitKind InitKind;
2675 ExprResult Init;
2676 ParsedType InitCaptureType;
2677 SourceRange ExplicitRange;
2678
2679 LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc,
2680 IdentifierInfo *Id, SourceLocation EllipsisLoc,
2681 LambdaCaptureInitKind InitKind, ExprResult Init,
2682 ParsedType InitCaptureType,
2683 SourceRange ExplicitRange)
2684 : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc),
2685 InitKind(InitKind), Init(Init), InitCaptureType(InitCaptureType),
2686 ExplicitRange(ExplicitRange) {}
2687 };
2688
2689 SourceRange Range;
2690 SourceLocation DefaultLoc;
2691 LambdaCaptureDefault Default;
2692 SmallVector<LambdaCapture, 4> Captures;
2693
2694 LambdaIntroducer()
2695 : Default(LCD_None) {}
2696
2697 /// Append a capture in a lambda introducer.
2698 void addCapture(LambdaCaptureKind Kind,
2699 SourceLocation Loc,
2700 IdentifierInfo* Id,
2701 SourceLocation EllipsisLoc,
2702 LambdaCaptureInitKind InitKind,
2703 ExprResult Init,
2704 ParsedType InitCaptureType,
2705 SourceRange ExplicitRange) {
2706 Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
2707 InitCaptureType, ExplicitRange));
2708 }
2709};
2710
2711struct InventedTemplateParameterInfo {
2712 /// The number of parameters in the template parameter list that were
2713 /// explicitly specified by the user, as opposed to being invented by use
2714 /// of an auto parameter.
2715 unsigned NumExplicitTemplateParams = 0;
2716
2717 /// If this is a generic lambda or abbreviated function template, use this
2718 /// as the depth of each 'auto' parameter, during initial AST construction.
2719 unsigned AutoTemplateParameterDepth = 0;
2720
2721 /// Store the list of the template parameters for a generic lambda or an
2722 /// abbreviated function template.
2723 /// If this is a generic lambda or abbreviated function template, this holds
2724 /// the explicit template parameters followed by the auto parameters
2725 /// converted into TemplateTypeParmDecls.
2726 /// It can be used to construct the generic lambda or abbreviated template's
2727 /// template parameter list during initial AST construction.
2728 SmallVector<NamedDecl*, 4> TemplateParams;
2729};
2730
2731} // end namespace clang
2732
2733#endif // LLVM_CLANG_SEMA_DECLSPEC_H