Bug Summary

File:clang/lib/Parse/ParseExprCXX.cpp
Warning:line 2053, column 5
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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

/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/clang/lib/Parse/ParseExprCXX.cpp

1//===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Expression parsing implementation for C++.
10//
11//===----------------------------------------------------------------------===//
12#include "clang/AST/ASTContext.h"
13#include "clang/AST/Decl.h"
14#include "clang/AST/DeclTemplate.h"
15#include "clang/AST/ExprCXX.h"
16#include "clang/Basic/PrettyStackTrace.h"
17#include "clang/Lex/LiteralSupport.h"
18#include "clang/Parse/ParseDiagnostic.h"
19#include "clang/Parse/Parser.h"
20#include "clang/Parse/RAIIObjectsForParser.h"
21#include "clang/Sema/DeclSpec.h"
22#include "clang/Sema/ParsedTemplate.h"
23#include "clang/Sema/Scope.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <numeric>
26
27using namespace clang;
28
29static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
30 switch (Kind) {
31 // template name
32 case tok::unknown: return 0;
33 // casts
34 case tok::kw_addrspace_cast: return 1;
35 case tok::kw_const_cast: return 2;
36 case tok::kw_dynamic_cast: return 3;
37 case tok::kw_reinterpret_cast: return 4;
38 case tok::kw_static_cast: return 5;
39 default:
40 llvm_unreachable("Unknown type for digraph error message.")::llvm::llvm_unreachable_internal("Unknown type for digraph error message."
, "clang/lib/Parse/ParseExprCXX.cpp", 40)
;
41 }
42}
43
44// Are the two tokens adjacent in the same source file?
45bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
46 SourceManager &SM = PP.getSourceManager();
47 SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
48 SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
49 return FirstEnd == SM.getSpellingLoc(Second.getLocation());
50}
51
52// Suggest fixit for "<::" after a cast.
53static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
54 Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
55 // Pull '<:' and ':' off token stream.
56 if (!AtDigraph)
57 PP.Lex(DigraphToken);
58 PP.Lex(ColonToken);
59
60 SourceRange Range;
61 Range.setBegin(DigraphToken.getLocation());
62 Range.setEnd(ColonToken.getLocation());
63 P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
64 << SelectDigraphErrorMessage(Kind)
65 << FixItHint::CreateReplacement(Range, "< ::");
66
67 // Update token information to reflect their change in token type.
68 ColonToken.setKind(tok::coloncolon);
69 ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
70 ColonToken.setLength(2);
71 DigraphToken.setKind(tok::less);
72 DigraphToken.setLength(1);
73
74 // Push new tokens back to token stream.
75 PP.EnterToken(ColonToken, /*IsReinject*/ true);
76 if (!AtDigraph)
77 PP.EnterToken(DigraphToken, /*IsReinject*/ true);
78}
79
80// Check for '<::' which should be '< ::' instead of '[:' when following
81// a template name.
82void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
83 bool EnteringContext,
84 IdentifierInfo &II, CXXScopeSpec &SS) {
85 if (!Next.is(tok::l_square) || Next.getLength() != 2)
86 return;
87
88 Token SecondToken = GetLookAheadToken(2);
89 if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
90 return;
91
92 TemplateTy Template;
93 UnqualifiedId TemplateName;
94 TemplateName.setIdentifier(&II, Tok.getLocation());
95 bool MemberOfUnknownSpecialization;
96 if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
97 TemplateName, ObjectType, EnteringContext,
98 Template, MemberOfUnknownSpecialization))
99 return;
100
101 FixDigraph(*this, PP, Next, SecondToken, tok::unknown,
102 /*AtDigraph*/false);
103}
104
105/// Parse global scope or nested-name-specifier if present.
106///
107/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
108/// may be preceded by '::'). Note that this routine will not parse ::new or
109/// ::delete; it will just leave them in the token stream.
110///
111/// '::'[opt] nested-name-specifier
112/// '::'
113///
114/// nested-name-specifier:
115/// type-name '::'
116/// namespace-name '::'
117/// nested-name-specifier identifier '::'
118/// nested-name-specifier 'template'[opt] simple-template-id '::'
119///
120///
121/// \param SS the scope specifier that will be set to the parsed
122/// nested-name-specifier (or empty)
123///
124/// \param ObjectType if this nested-name-specifier is being parsed following
125/// the "." or "->" of a member access expression, this parameter provides the
126/// type of the object whose members are being accessed.
127///
128/// \param ObjectHadErrors if this unqualified-id occurs within a member access
129/// expression, indicates whether the original subexpressions had any errors.
130/// When true, diagnostics for missing 'template' keyword will be supressed.
131///
132/// \param EnteringContext whether we will be entering into the context of
133/// the nested-name-specifier after parsing it.
134///
135/// \param MayBePseudoDestructor When non-NULL, points to a flag that
136/// indicates whether this nested-name-specifier may be part of a
137/// pseudo-destructor name. In this case, the flag will be set false
138/// if we don't actually end up parsing a destructor name. Moreover,
139/// if we do end up determining that we are parsing a destructor name,
140/// the last component of the nested-name-specifier is not parsed as
141/// part of the scope specifier.
142///
143/// \param IsTypename If \c true, this nested-name-specifier is known to be
144/// part of a type name. This is used to improve error recovery.
145///
146/// \param LastII When non-NULL, points to an IdentifierInfo* that will be
147/// filled in with the leading identifier in the last component of the
148/// nested-name-specifier, if any.
149///
150/// \param OnlyNamespace If true, only considers namespaces in lookup.
151///
152///
153/// \returns true if there was an error parsing a scope specifier
154bool Parser::ParseOptionalCXXScopeSpecifier(
155 CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
156 bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename,
157 IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) {
158 assert(getLangOpts().CPlusPlus &&(static_cast <bool> (getLangOpts().CPlusPlus &&
"Call sites of this function should be guarded by checking for C++"
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Call sites of this function should be guarded by checking for C++\""
, "clang/lib/Parse/ParseExprCXX.cpp", 159, __extension__ __PRETTY_FUNCTION__
))
159 "Call sites of this function should be guarded by checking for C++")(static_cast <bool> (getLangOpts().CPlusPlus &&
"Call sites of this function should be guarded by checking for C++"
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Call sites of this function should be guarded by checking for C++\""
, "clang/lib/Parse/ParseExprCXX.cpp", 159, __extension__ __PRETTY_FUNCTION__
))
;
160
161 if (Tok.is(tok::annot_cxxscope)) {
162 assert(!LastII && "want last identifier but have already annotated scope")(static_cast <bool> (!LastII && "want last identifier but have already annotated scope"
) ? void (0) : __assert_fail ("!LastII && \"want last identifier but have already annotated scope\""
, "clang/lib/Parse/ParseExprCXX.cpp", 162, __extension__ __PRETTY_FUNCTION__
))
;
163 assert(!MayBePseudoDestructor && "unexpected annot_cxxscope")(static_cast <bool> (!MayBePseudoDestructor && "unexpected annot_cxxscope"
) ? void (0) : __assert_fail ("!MayBePseudoDestructor && \"unexpected annot_cxxscope\""
, "clang/lib/Parse/ParseExprCXX.cpp", 163, __extension__ __PRETTY_FUNCTION__
))
;
164 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
165 Tok.getAnnotationRange(),
166 SS);
167 ConsumeAnnotationToken();
168 return false;
169 }
170
171 // Has to happen before any "return false"s in this function.
172 bool CheckForDestructor = false;
173 if (MayBePseudoDestructor && *MayBePseudoDestructor) {
174 CheckForDestructor = true;
175 *MayBePseudoDestructor = false;
176 }
177
178 if (LastII)
179 *LastII = nullptr;
180
181 bool HasScopeSpecifier = false;
182
183 if (Tok.is(tok::coloncolon)) {
184 // ::new and ::delete aren't nested-name-specifiers.
185 tok::TokenKind NextKind = NextToken().getKind();
186 if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
187 return false;
188
189 if (NextKind == tok::l_brace) {
190 // It is invalid to have :: {, consume the scope qualifier and pretend
191 // like we never saw it.
192 Diag(ConsumeToken(), diag::err_expected) << tok::identifier;
193 } else {
194 // '::' - Global scope qualifier.
195 if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS))
196 return true;
197
198 HasScopeSpecifier = true;
199 }
200 }
201
202 if (Tok.is(tok::kw___super)) {
203 SourceLocation SuperLoc = ConsumeToken();
204 if (!Tok.is(tok::coloncolon)) {
205 Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super);
206 return true;
207 }
208
209 return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS);
210 }
211
212 if (!HasScopeSpecifier &&
213 Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {
214 DeclSpec DS(AttrFactory);
215 SourceLocation DeclLoc = Tok.getLocation();
216 SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
217
218 SourceLocation CCLoc;
219 // Work around a standard defect: 'decltype(auto)::' is not a
220 // nested-name-specifier.
221 if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto ||
222 !TryConsumeToken(tok::coloncolon, CCLoc)) {
223 AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
224 return false;
225 }
226
227 if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
228 SS.SetInvalid(SourceRange(DeclLoc, CCLoc));
229
230 HasScopeSpecifier = true;
231 }
232
233 // Preferred type might change when parsing qualifiers, we need the original.
234 auto SavedType = PreferredType;
235 while (true) {
236 if (HasScopeSpecifier) {
237 if (Tok.is(tok::code_completion)) {
238 cutOffParsing();
239 // Code completion for a nested-name-specifier, where the code
240 // completion token follows the '::'.
241 Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext,
242 InUsingDeclaration, ObjectType.get(),
243 SavedType.get(SS.getBeginLoc()));
244 // Include code completion token into the range of the scope otherwise
245 // when we try to annotate the scope tokens the dangling code completion
246 // token will cause assertion in
247 // Preprocessor::AnnotatePreviousCachedTokens.
248 SS.setEndLoc(Tok.getLocation());
249 return true;
250 }
251
252 // C++ [basic.lookup.classref]p5:
253 // If the qualified-id has the form
254 //
255 // ::class-name-or-namespace-name::...
256 //
257 // the class-name-or-namespace-name is looked up in global scope as a
258 // class-name or namespace-name.
259 //
260 // To implement this, we clear out the object type as soon as we've
261 // seen a leading '::' or part of a nested-name-specifier.
262 ObjectType = nullptr;
263 }
264
265 // nested-name-specifier:
266 // nested-name-specifier 'template'[opt] simple-template-id '::'
267
268 // Parse the optional 'template' keyword, then make sure we have
269 // 'identifier <' after it.
270 if (Tok.is(tok::kw_template)) {
271 // If we don't have a scope specifier or an object type, this isn't a
272 // nested-name-specifier, since they aren't allowed to start with
273 // 'template'.
274 if (!HasScopeSpecifier && !ObjectType)
275 break;
276
277 TentativeParsingAction TPA(*this);
278 SourceLocation TemplateKWLoc = ConsumeToken();
279
280 UnqualifiedId TemplateName;
281 if (Tok.is(tok::identifier)) {
282 // Consume the identifier.
283 TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
284 ConsumeToken();
285 } else if (Tok.is(tok::kw_operator)) {
286 // We don't need to actually parse the unqualified-id in this case,
287 // because a simple-template-id cannot start with 'operator', but
288 // go ahead and parse it anyway for consistency with the case where
289 // we already annotated the template-id.
290 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
291 TemplateName)) {
292 TPA.Commit();
293 break;
294 }
295
296 if (TemplateName.getKind() != UnqualifiedIdKind::IK_OperatorFunctionId &&
297 TemplateName.getKind() != UnqualifiedIdKind::IK_LiteralOperatorId) {
298 Diag(TemplateName.getSourceRange().getBegin(),
299 diag::err_id_after_template_in_nested_name_spec)
300 << TemplateName.getSourceRange();
301 TPA.Commit();
302 break;
303 }
304 } else {
305 TPA.Revert();
306 break;
307 }
308
309 // If the next token is not '<', we have a qualified-id that refers
310 // to a template name, such as T::template apply, but is not a
311 // template-id.
312 if (Tok.isNot(tok::less)) {
313 TPA.Revert();
314 break;
315 }
316
317 // Commit to parsing the template-id.
318 TPA.Commit();
319 TemplateTy Template;
320 TemplateNameKind TNK = Actions.ActOnTemplateName(
321 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
322 EnteringContext, Template, /*AllowInjectedClassName*/ true);
323 if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
324 TemplateName, false))
325 return true;
326
327 continue;
328 }
329
330 if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
331 // We have
332 //
333 // template-id '::'
334 //
335 // So we need to check whether the template-id is a simple-template-id of
336 // the right kind (it should name a type or be dependent), and then
337 // convert it into a type within the nested-name-specifier.
338 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
339 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
340 *MayBePseudoDestructor = true;
341 return false;
342 }
343
344 if (LastII)
345 *LastII = TemplateId->Name;
346
347 // Consume the template-id token.
348 ConsumeAnnotationToken();
349
350 assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!")(static_cast <bool> (Tok.is(tok::coloncolon) &&
"NextToken() not working properly!") ? void (0) : __assert_fail
("Tok.is(tok::coloncolon) && \"NextToken() not working properly!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 350, __extension__ __PRETTY_FUNCTION__
))
;
351 SourceLocation CCLoc = ConsumeToken();
352
353 HasScopeSpecifier = true;
354
355 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
356 TemplateId->NumArgs);
357
358 if (TemplateId->isInvalid() ||
359 Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
360 SS,
361 TemplateId->TemplateKWLoc,
362 TemplateId->Template,
363 TemplateId->TemplateNameLoc,
364 TemplateId->LAngleLoc,
365 TemplateArgsPtr,
366 TemplateId->RAngleLoc,
367 CCLoc,
368 EnteringContext)) {
369 SourceLocation StartLoc
370 = SS.getBeginLoc().isValid()? SS.getBeginLoc()
371 : TemplateId->TemplateNameLoc;
372 SS.SetInvalid(SourceRange(StartLoc, CCLoc));
373 }
374
375 continue;
376 }
377
378 // The rest of the nested-name-specifier possibilities start with
379 // tok::identifier.
380 if (Tok.isNot(tok::identifier))
381 break;
382
383 IdentifierInfo &II = *Tok.getIdentifierInfo();
384
385 // nested-name-specifier:
386 // type-name '::'
387 // namespace-name '::'
388 // nested-name-specifier identifier '::'
389 Token Next = NextToken();
390 Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(),
391 ObjectType);
392
393 // If we get foo:bar, this is almost certainly a typo for foo::bar. Recover
394 // and emit a fixit hint for it.
395 if (Next.is(tok::colon) && !ColonIsSacred) {
396 if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo,
397 EnteringContext) &&
398 // If the token after the colon isn't an identifier, it's still an
399 // error, but they probably meant something else strange so don't
400 // recover like this.
401 PP.LookAhead(1).is(tok::identifier)) {
402 Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
403 << FixItHint::CreateReplacement(Next.getLocation(), "::");
404 // Recover as if the user wrote '::'.
405 Next.setKind(tok::coloncolon);
406 }
407 }
408
409 if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) {
410 // It is invalid to have :: {, consume the scope qualifier and pretend
411 // like we never saw it.
412 Token Identifier = Tok; // Stash away the identifier.
413 ConsumeToken(); // Eat the identifier, current token is now '::'.
414 Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected)
415 << tok::identifier;
416 UnconsumeToken(Identifier); // Stick the identifier back.
417 Next = NextToken(); // Point Next at the '{' token.
418 }
419
420 if (Next.is(tok::coloncolon)) {
421 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
422 *MayBePseudoDestructor = true;
423 return false;
424 }
425
426 if (ColonIsSacred) {
427 const Token &Next2 = GetLookAheadToken(2);
428 if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
429 Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {
430 Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
431 << Next2.getName()
432 << FixItHint::CreateReplacement(Next.getLocation(), ":");
433 Token ColonColon;
434 PP.Lex(ColonColon);
435 ColonColon.setKind(tok::colon);
436 PP.EnterToken(ColonColon, /*IsReinject*/ true);
437 break;
438 }
439 }
440
441 if (LastII)
442 *LastII = &II;
443
444 // We have an identifier followed by a '::'. Lookup this name
445 // as the name in a nested-name-specifier.
446 Token Identifier = Tok;
447 SourceLocation IdLoc = ConsumeToken();
448 assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&(static_cast <bool> (Tok.isOneOf(tok::coloncolon, tok::
colon) && "NextToken() not working properly!") ? void
(0) : __assert_fail ("Tok.isOneOf(tok::coloncolon, tok::colon) && \"NextToken() not working properly!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 449, __extension__ __PRETTY_FUNCTION__
))
449 "NextToken() not working properly!")(static_cast <bool> (Tok.isOneOf(tok::coloncolon, tok::
colon) && "NextToken() not working properly!") ? void
(0) : __assert_fail ("Tok.isOneOf(tok::coloncolon, tok::colon) && \"NextToken() not working properly!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 449, __extension__ __PRETTY_FUNCTION__
))
;
450 Token ColonColon = Tok;
451 SourceLocation CCLoc = ConsumeToken();
452
453 bool IsCorrectedToColon = false;
454 bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
455 if (Actions.ActOnCXXNestedNameSpecifier(
456 getCurScope(), IdInfo, EnteringContext, SS, false,
457 CorrectionFlagPtr, OnlyNamespace)) {
458 // Identifier is not recognized as a nested name, but we can have
459 // mistyped '::' instead of ':'.
460 if (CorrectionFlagPtr && IsCorrectedToColon) {
461 ColonColon.setKind(tok::colon);
462 PP.EnterToken(Tok, /*IsReinject*/ true);
463 PP.EnterToken(ColonColon, /*IsReinject*/ true);
464 Tok = Identifier;
465 break;
466 }
467 SS.SetInvalid(SourceRange(IdLoc, CCLoc));
468 }
469 HasScopeSpecifier = true;
470 continue;
471 }
472
473 CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
474
475 // nested-name-specifier:
476 // type-name '<'
477 if (Next.is(tok::less)) {
478
479 TemplateTy Template;
480 UnqualifiedId TemplateName;
481 TemplateName.setIdentifier(&II, Tok.getLocation());
482 bool MemberOfUnknownSpecialization;
483 if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
484 /*hasTemplateKeyword=*/false,
485 TemplateName,
486 ObjectType,
487 EnteringContext,
488 Template,
489 MemberOfUnknownSpecialization)) {
490 // If lookup didn't find anything, we treat the name as a template-name
491 // anyway. C++20 requires this, and in prior language modes it improves
492 // error recovery. But before we commit to this, check that we actually
493 // have something that looks like a template-argument-list next.
494 if (!IsTypename && TNK == TNK_Undeclared_template &&
495 isTemplateArgumentList(1) == TPResult::False)
496 break;
497
498 // We have found a template name, so annotate this token
499 // with a template-id annotation. We do not permit the
500 // template-id to be translated into a type annotation,
501 // because some clients (e.g., the parsing of class template
502 // specializations) still want to see the original template-id
503 // token, and it might not be a type at all (e.g. a concept name in a
504 // type-constraint).
505 ConsumeToken();
506 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
507 TemplateName, false))
508 return true;
509 continue;
510 }
511
512 if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
513 (IsTypename || isTemplateArgumentList(1) == TPResult::True)) {
514 // If we had errors before, ObjectType can be dependent even without any
515 // templates. Do not report missing template keyword in that case.
516 if (!ObjectHadErrors) {
517 // We have something like t::getAs<T>, where getAs is a
518 // member of an unknown specialization. However, this will only
519 // parse correctly as a template, so suggest the keyword 'template'
520 // before 'getAs' and treat this as a dependent template name.
521 unsigned DiagID = diag::err_missing_dependent_template_keyword;
522 if (getLangOpts().MicrosoftExt)
523 DiagID = diag::warn_missing_dependent_template_keyword;
524
525 Diag(Tok.getLocation(), DiagID)
526 << II.getName()
527 << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
528 }
529
530 SourceLocation TemplateNameLoc = ConsumeToken();
531
532 TemplateNameKind TNK = Actions.ActOnTemplateName(
533 getCurScope(), SS, TemplateNameLoc, TemplateName, ObjectType,
534 EnteringContext, Template, /*AllowInjectedClassName*/ true);
535 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
536 TemplateName, false))
537 return true;
538
539 continue;
540 }
541 }
542
543 // We don't have any tokens that form the beginning of a
544 // nested-name-specifier, so we're done.
545 break;
546 }
547
548 // Even if we didn't see any pieces of a nested-name-specifier, we
549 // still check whether there is a tilde in this position, which
550 // indicates a potential pseudo-destructor.
551 if (CheckForDestructor && !HasScopeSpecifier && Tok.is(tok::tilde))
552 *MayBePseudoDestructor = true;
553
554 return false;
555}
556
557ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS,
558 bool isAddressOfOperand,
559 Token &Replacement) {
560 ExprResult E;
561
562 // We may have already annotated this id-expression.
563 switch (Tok.getKind()) {
564 case tok::annot_non_type: {
565 NamedDecl *ND = getNonTypeAnnotation(Tok);
566 SourceLocation Loc = ConsumeAnnotationToken();
567 E = Actions.ActOnNameClassifiedAsNonType(getCurScope(), SS, ND, Loc, Tok);
568 break;
569 }
570
571 case tok::annot_non_type_dependent: {
572 IdentifierInfo *II = getIdentifierAnnotation(Tok);
573 SourceLocation Loc = ConsumeAnnotationToken();
574
575 // This is only the direct operand of an & operator if it is not
576 // followed by a postfix-expression suffix.
577 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
578 isAddressOfOperand = false;
579
580 E = Actions.ActOnNameClassifiedAsDependentNonType(SS, II, Loc,
581 isAddressOfOperand);
582 break;
583 }
584
585 case tok::annot_non_type_undeclared: {
586 assert(SS.isEmpty() &&(static_cast <bool> (SS.isEmpty() && "undeclared non-type annotation should be unqualified"
) ? void (0) : __assert_fail ("SS.isEmpty() && \"undeclared non-type annotation should be unqualified\""
, "clang/lib/Parse/ParseExprCXX.cpp", 587, __extension__ __PRETTY_FUNCTION__
))
587 "undeclared non-type annotation should be unqualified")(static_cast <bool> (SS.isEmpty() && "undeclared non-type annotation should be unqualified"
) ? void (0) : __assert_fail ("SS.isEmpty() && \"undeclared non-type annotation should be unqualified\""
, "clang/lib/Parse/ParseExprCXX.cpp", 587, __extension__ __PRETTY_FUNCTION__
))
;
588 IdentifierInfo *II = getIdentifierAnnotation(Tok);
589 SourceLocation Loc = ConsumeAnnotationToken();
590 E = Actions.ActOnNameClassifiedAsUndeclaredNonType(II, Loc);
591 break;
592 }
593
594 default:
595 SourceLocation TemplateKWLoc;
596 UnqualifiedId Name;
597 if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
598 /*ObjectHadErrors=*/false,
599 /*EnteringContext=*/false,
600 /*AllowDestructorName=*/false,
601 /*AllowConstructorName=*/false,
602 /*AllowDeductionGuide=*/false, &TemplateKWLoc, Name))
603 return ExprError();
604
605 // This is only the direct operand of an & operator if it is not
606 // followed by a postfix-expression suffix.
607 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
608 isAddressOfOperand = false;
609
610 E = Actions.ActOnIdExpression(
611 getCurScope(), SS, TemplateKWLoc, Name, Tok.is(tok::l_paren),
612 isAddressOfOperand, /*CCC=*/nullptr, /*IsInlineAsmIdentifier=*/false,
613 &Replacement);
614 break;
615 }
616
617 if (!E.isInvalid() && !E.isUnset() && Tok.is(tok::less))
618 checkPotentialAngleBracket(E);
619 return E;
620}
621
622/// ParseCXXIdExpression - Handle id-expression.
623///
624/// id-expression:
625/// unqualified-id
626/// qualified-id
627///
628/// qualified-id:
629/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
630/// '::' identifier
631/// '::' operator-function-id
632/// '::' template-id
633///
634/// NOTE: The standard specifies that, for qualified-id, the parser does not
635/// expect:
636///
637/// '::' conversion-function-id
638/// '::' '~' class-name
639///
640/// This may cause a slight inconsistency on diagnostics:
641///
642/// class C {};
643/// namespace A {}
644/// void f() {
645/// :: A :: ~ C(); // Some Sema error about using destructor with a
646/// // namespace.
647/// :: ~ C(); // Some Parser error like 'unexpected ~'.
648/// }
649///
650/// We simplify the parser a bit and make it work like:
651///
652/// qualified-id:
653/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
654/// '::' unqualified-id
655///
656/// That way Sema can handle and report similar errors for namespaces and the
657/// global scope.
658///
659/// The isAddressOfOperand parameter indicates that this id-expression is a
660/// direct operand of the address-of operator. This is, besides member contexts,
661/// the only place where a qualified-id naming a non-static class member may
662/// appear.
663///
664ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
665 // qualified-id:
666 // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
667 // '::' unqualified-id
668 //
669 CXXScopeSpec SS;
670 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
671 /*ObjectHasErrors=*/false,
672 /*EnteringContext=*/false);
673
674 Token Replacement;
675 ExprResult Result =
676 tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
677 if (Result.isUnset()) {
678 // If the ExprResult is valid but null, then typo correction suggested a
679 // keyword replacement that needs to be reparsed.
680 UnconsumeToken(Replacement);
681 Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
682 }
683 assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "(static_cast <bool> (!Result.isUnset() && "Typo correction suggested a keyword replacement "
"for a previous keyword suggestion") ? void (0) : __assert_fail
("!Result.isUnset() && \"Typo correction suggested a keyword replacement \" \"for a previous keyword suggestion\""
, "clang/lib/Parse/ParseExprCXX.cpp", 684, __extension__ __PRETTY_FUNCTION__
))
684 "for a previous keyword suggestion")(static_cast <bool> (!Result.isUnset() && "Typo correction suggested a keyword replacement "
"for a previous keyword suggestion") ? void (0) : __assert_fail
("!Result.isUnset() && \"Typo correction suggested a keyword replacement \" \"for a previous keyword suggestion\""
, "clang/lib/Parse/ParseExprCXX.cpp", 684, __extension__ __PRETTY_FUNCTION__
))
;
685 return Result;
686}
687
688/// ParseLambdaExpression - Parse a C++11 lambda expression.
689///
690/// lambda-expression:
691/// lambda-introducer lambda-declarator compound-statement
692/// lambda-introducer '<' template-parameter-list '>'
693/// requires-clause[opt] lambda-declarator compound-statement
694///
695/// lambda-introducer:
696/// '[' lambda-capture[opt] ']'
697///
698/// lambda-capture:
699/// capture-default
700/// capture-list
701/// capture-default ',' capture-list
702///
703/// capture-default:
704/// '&'
705/// '='
706///
707/// capture-list:
708/// capture
709/// capture-list ',' capture
710///
711/// capture:
712/// simple-capture
713/// init-capture [C++1y]
714///
715/// simple-capture:
716/// identifier
717/// '&' identifier
718/// 'this'
719///
720/// init-capture: [C++1y]
721/// identifier initializer
722/// '&' identifier initializer
723///
724/// lambda-declarator:
725/// lambda-specifiers [C++2b]
726/// '(' parameter-declaration-clause ')' lambda-specifiers
727/// requires-clause[opt]
728///
729/// lambda-specifiers:
730/// decl-specifier-seq[opt] noexcept-specifier[opt]
731/// attribute-specifier-seq[opt] trailing-return-type[opt]
732///
733ExprResult Parser::ParseLambdaExpression() {
734 // Parse lambda-introducer.
735 LambdaIntroducer Intro;
736 if (ParseLambdaIntroducer(Intro)) {
737 SkipUntil(tok::r_square, StopAtSemi);
738 SkipUntil(tok::l_brace, StopAtSemi);
739 SkipUntil(tok::r_brace, StopAtSemi);
740 return ExprError();
741 }
742
743 return ParseLambdaExpressionAfterIntroducer(Intro);
744}
745
746/// Use lookahead and potentially tentative parsing to determine if we are
747/// looking at a C++11 lambda expression, and parse it if we are.
748///
749/// If we are not looking at a lambda expression, returns ExprError().
750ExprResult Parser::TryParseLambdaExpression() {
751 assert(getLangOpts().CPlusPlus11(static_cast <bool> (getLangOpts().CPlusPlus11 &&
Tok.is(tok::l_square) && "Not at the start of a possible lambda expression."
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "clang/lib/Parse/ParseExprCXX.cpp", 753, __extension__ __PRETTY_FUNCTION__
))
752 && Tok.is(tok::l_square)(static_cast <bool> (getLangOpts().CPlusPlus11 &&
Tok.is(tok::l_square) && "Not at the start of a possible lambda expression."
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "clang/lib/Parse/ParseExprCXX.cpp", 753, __extension__ __PRETTY_FUNCTION__
))
753 && "Not at the start of a possible lambda expression.")(static_cast <bool> (getLangOpts().CPlusPlus11 &&
Tok.is(tok::l_square) && "Not at the start of a possible lambda expression."
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "clang/lib/Parse/ParseExprCXX.cpp", 753, __extension__ __PRETTY_FUNCTION__
))
;
754
755 const Token Next = NextToken();
756 if (Next.is(tok::eof)) // Nothing else to lookup here...
757 return ExprEmpty();
758
759 const Token After = GetLookAheadToken(2);
760 // If lookahead indicates this is a lambda...
761 if (Next.is(tok::r_square) || // []
762 Next.is(tok::equal) || // [=
763 (Next.is(tok::amp) && // [&] or [&,
764 After.isOneOf(tok::r_square, tok::comma)) ||
765 (Next.is(tok::identifier) && // [identifier]
766 After.is(tok::r_square)) ||
767 Next.is(tok::ellipsis)) { // [...
768 return ParseLambdaExpression();
769 }
770
771 // If lookahead indicates an ObjC message send...
772 // [identifier identifier
773 if (Next.is(tok::identifier) && After.is(tok::identifier))
774 return ExprEmpty();
775
776 // Here, we're stuck: lambda introducers and Objective-C message sends are
777 // unambiguous, but it requires arbitrary lookhead. [a,b,c,d,e,f,g] is a
778 // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send. Instead of
779 // writing two routines to parse a lambda introducer, just try to parse
780 // a lambda introducer first, and fall back if that fails.
781 LambdaIntroducer Intro;
782 {
783 TentativeParsingAction TPA(*this);
784 LambdaIntroducerTentativeParse Tentative;
785 if (ParseLambdaIntroducer(Intro, &Tentative)) {
786 TPA.Commit();
787 return ExprError();
788 }
789
790 switch (Tentative) {
791 case LambdaIntroducerTentativeParse::Success:
792 TPA.Commit();
793 break;
794
795 case LambdaIntroducerTentativeParse::Incomplete:
796 // Didn't fully parse the lambda-introducer, try again with a
797 // non-tentative parse.
798 TPA.Revert();
799 Intro = LambdaIntroducer();
800 if (ParseLambdaIntroducer(Intro))
801 return ExprError();
802 break;
803
804 case LambdaIntroducerTentativeParse::MessageSend:
805 case LambdaIntroducerTentativeParse::Invalid:
806 // Not a lambda-introducer, might be a message send.
807 TPA.Revert();
808 return ExprEmpty();
809 }
810 }
811
812 return ParseLambdaExpressionAfterIntroducer(Intro);
813}
814
815/// Parse a lambda introducer.
816/// \param Intro A LambdaIntroducer filled in with information about the
817/// contents of the lambda-introducer.
818/// \param Tentative If non-null, we are disambiguating between a
819/// lambda-introducer and some other construct. In this mode, we do not
820/// produce any diagnostics or take any other irreversible action unless
821/// we're sure that this is a lambda-expression.
822/// \return \c true if parsing (or disambiguation) failed with a diagnostic and
823/// the caller should bail out / recover.
824bool Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
825 LambdaIntroducerTentativeParse *Tentative) {
826 if (Tentative)
827 *Tentative = LambdaIntroducerTentativeParse::Success;
828
829 assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.")(static_cast <bool> (Tok.is(tok::l_square) && "Lambda expressions begin with '['."
) ? void (0) : __assert_fail ("Tok.is(tok::l_square) && \"Lambda expressions begin with '['.\""
, "clang/lib/Parse/ParseExprCXX.cpp", 829, __extension__ __PRETTY_FUNCTION__
))
;
830 BalancedDelimiterTracker T(*this, tok::l_square);
831 T.consumeOpen();
832
833 Intro.Range.setBegin(T.getOpenLocation());
834
835 bool First = true;
836
837 // Produce a diagnostic if we're not tentatively parsing; otherwise track
838 // that our parse has failed.
839 auto Invalid = [&](llvm::function_ref<void()> Action) {
840 if (Tentative) {
841 *Tentative = LambdaIntroducerTentativeParse::Invalid;
842 return false;
843 }
844 Action();
845 return true;
846 };
847
848 // Perform some irreversible action if this is a non-tentative parse;
849 // otherwise note that our actions were incomplete.
850 auto NonTentativeAction = [&](llvm::function_ref<void()> Action) {
851 if (Tentative)
852 *Tentative = LambdaIntroducerTentativeParse::Incomplete;
853 else
854 Action();
855 };
856
857 // Parse capture-default.
858 if (Tok.is(tok::amp) &&
859 (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
860 Intro.Default = LCD_ByRef;
861 Intro.DefaultLoc = ConsumeToken();
862 First = false;
863 if (!Tok.getIdentifierInfo()) {
864 // This can only be a lambda; no need for tentative parsing any more.
865 // '[[and]]' can still be an attribute, though.
866 Tentative = nullptr;
867 }
868 } else if (Tok.is(tok::equal)) {
869 Intro.Default = LCD_ByCopy;
870 Intro.DefaultLoc = ConsumeToken();
871 First = false;
872 Tentative = nullptr;
873 }
874
875 while (Tok.isNot(tok::r_square)) {
876 if (!First) {
877 if (Tok.isNot(tok::comma)) {
878 // Provide a completion for a lambda introducer here. Except
879 // in Objective-C, where this is Almost Surely meant to be a message
880 // send. In that case, fail here and let the ObjC message
881 // expression parser perform the completion.
882 if (Tok.is(tok::code_completion) &&
883 !(getLangOpts().ObjC && Tentative)) {
884 cutOffParsing();
885 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
886 /*AfterAmpersand=*/false);
887 break;
888 }
889
890 return Invalid([&] {
891 Diag(Tok.getLocation(), diag::err_expected_comma_or_rsquare);
892 });
893 }
894 ConsumeToken();
895 }
896
897 if (Tok.is(tok::code_completion)) {
898 cutOffParsing();
899 // If we're in Objective-C++ and we have a bare '[', then this is more
900 // likely to be a message receiver.
901 if (getLangOpts().ObjC && Tentative && First)
902 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
903 else
904 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
905 /*AfterAmpersand=*/false);
906 break;
907 }
908
909 First = false;
910
911 // Parse capture.
912 LambdaCaptureKind Kind = LCK_ByCopy;
913 LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
914 SourceLocation Loc;
915 IdentifierInfo *Id = nullptr;
916 SourceLocation EllipsisLocs[4];
917 ExprResult Init;
918 SourceLocation LocStart = Tok.getLocation();
919
920 if (Tok.is(tok::star)) {
921 Loc = ConsumeToken();
922 if (Tok.is(tok::kw_this)) {
923 ConsumeToken();
924 Kind = LCK_StarThis;
925 } else {
926 return Invalid([&] {
927 Diag(Tok.getLocation(), diag::err_expected_star_this_capture);
928 });
929 }
930 } else if (Tok.is(tok::kw_this)) {
931 Kind = LCK_This;
932 Loc = ConsumeToken();
933 } else if (Tok.isOneOf(tok::amp, tok::equal) &&
934 NextToken().isOneOf(tok::comma, tok::r_square) &&
935 Intro.Default == LCD_None) {
936 // We have a lone "&" or "=" which is either a misplaced capture-default
937 // or the start of a capture (in the "&" case) with the rest of the
938 // capture missing. Both are an error but a misplaced capture-default
939 // is more likely if we don't already have a capture default.
940 return Invalid(
941 [&] { Diag(Tok.getLocation(), diag::err_capture_default_first); });
942 } else {
943 TryConsumeToken(tok::ellipsis, EllipsisLocs[0]);
944
945 if (Tok.is(tok::amp)) {
946 Kind = LCK_ByRef;
947 ConsumeToken();
948
949 if (Tok.is(tok::code_completion)) {
950 cutOffParsing();
951 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
952 /*AfterAmpersand=*/true);
953 break;
954 }
955 }
956
957 TryConsumeToken(tok::ellipsis, EllipsisLocs[1]);
958
959 if (Tok.is(tok::identifier)) {
960 Id = Tok.getIdentifierInfo();
961 Loc = ConsumeToken();
962 } else if (Tok.is(tok::kw_this)) {
963 return Invalid([&] {
964 // FIXME: Suggest a fixit here.
965 Diag(Tok.getLocation(), diag::err_this_captured_by_reference);
966 });
967 } else {
968 return Invalid([&] {
969 Diag(Tok.getLocation(), diag::err_expected_capture);
970 });
971 }
972
973 TryConsumeToken(tok::ellipsis, EllipsisLocs[2]);
974
975 if (Tok.is(tok::l_paren)) {
976 BalancedDelimiterTracker Parens(*this, tok::l_paren);
977 Parens.consumeOpen();
978
979 InitKind = LambdaCaptureInitKind::DirectInit;
980
981 ExprVector Exprs;
982 CommaLocsTy Commas;
983 if (Tentative) {
984 Parens.skipToEnd();
985 *Tentative = LambdaIntroducerTentativeParse::Incomplete;
986 } else if (ParseExpressionList(Exprs, Commas)) {
987 Parens.skipToEnd();
988 Init = ExprError();
989 } else {
990 Parens.consumeClose();
991 Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
992 Parens.getCloseLocation(),
993 Exprs);
994 }
995 } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
996 // Each lambda init-capture forms its own full expression, which clears
997 // Actions.MaybeODRUseExprs. So create an expression evaluation context
998 // to save the necessary state, and restore it later.
999 EnterExpressionEvaluationContext EC(
1000 Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1001
1002 if (TryConsumeToken(tok::equal))
1003 InitKind = LambdaCaptureInitKind::CopyInit;
1004 else
1005 InitKind = LambdaCaptureInitKind::ListInit;
1006
1007 if (!Tentative) {
1008 Init = ParseInitializer();
1009 } else if (Tok.is(tok::l_brace)) {
1010 BalancedDelimiterTracker Braces(*this, tok::l_brace);
1011 Braces.consumeOpen();
1012 Braces.skipToEnd();
1013 *Tentative = LambdaIntroducerTentativeParse::Incomplete;
1014 } else {
1015 // We're disambiguating this:
1016 //
1017 // [..., x = expr
1018 //
1019 // We need to find the end of the following expression in order to
1020 // determine whether this is an Obj-C message send's receiver, a
1021 // C99 designator, or a lambda init-capture.
1022 //
1023 // Parse the expression to find where it ends, and annotate it back
1024 // onto the tokens. We would have parsed this expression the same way
1025 // in either case: both the RHS of an init-capture and the RHS of an
1026 // assignment expression are parsed as an initializer-clause, and in
1027 // neither case can anything be added to the scope between the '[' and
1028 // here.
1029 //
1030 // FIXME: This is horrible. Adding a mechanism to skip an expression
1031 // would be much cleaner.
1032 // FIXME: If there is a ',' before the next ']' or ':', we can skip to
1033 // that instead. (And if we see a ':' with no matching '?', we can
1034 // classify this as an Obj-C message send.)
1035 SourceLocation StartLoc = Tok.getLocation();
1036 InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
1037 Init = ParseInitializer();
1038 if (!Init.isInvalid())
1039 Init = Actions.CorrectDelayedTyposInExpr(Init.get());
1040
1041 if (Tok.getLocation() != StartLoc) {
1042 // Back out the lexing of the token after the initializer.
1043 PP.RevertCachedTokens(1);
1044
1045 // Replace the consumed tokens with an appropriate annotation.
1046 Tok.setLocation(StartLoc);
1047 Tok.setKind(tok::annot_primary_expr);
1048 setExprAnnotation(Tok, Init);
1049 Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation());
1050 PP.AnnotateCachedTokens(Tok);
1051
1052 // Consume the annotated initializer.
1053 ConsumeAnnotationToken();
1054 }
1055 }
1056 }
1057
1058 TryConsumeToken(tok::ellipsis, EllipsisLocs[3]);
1059 }
1060
1061 // Check if this is a message send before we act on a possible init-capture.
1062 if (Tentative && Tok.is(tok::identifier) &&
1063 NextToken().isOneOf(tok::colon, tok::r_square)) {
1064 // This can only be a message send. We're done with disambiguation.
1065 *Tentative = LambdaIntroducerTentativeParse::MessageSend;
1066 return false;
1067 }
1068
1069 // Ensure that any ellipsis was in the right place.
1070 SourceLocation EllipsisLoc;
1071 if (llvm::any_of(EllipsisLocs,
1072 [](SourceLocation Loc) { return Loc.isValid(); })) {
1073 // The '...' should appear before the identifier in an init-capture, and
1074 // after the identifier otherwise.
1075 bool InitCapture = InitKind != LambdaCaptureInitKind::NoInit;
1076 SourceLocation *ExpectedEllipsisLoc =
1077 !InitCapture ? &EllipsisLocs[2] :
1078 Kind == LCK_ByRef ? &EllipsisLocs[1] :
1079 &EllipsisLocs[0];
1080 EllipsisLoc = *ExpectedEllipsisLoc;
1081
1082 unsigned DiagID = 0;
1083 if (EllipsisLoc.isInvalid()) {
1084 DiagID = diag::err_lambda_capture_misplaced_ellipsis;
1085 for (SourceLocation Loc : EllipsisLocs) {
1086 if (Loc.isValid())
1087 EllipsisLoc = Loc;
1088 }
1089 } else {
1090 unsigned NumEllipses = std::accumulate(
1091 std::begin(EllipsisLocs), std::end(EllipsisLocs), 0,
1092 [](int N, SourceLocation Loc) { return N + Loc.isValid(); });
1093 if (NumEllipses > 1)
1094 DiagID = diag::err_lambda_capture_multiple_ellipses;
1095 }
1096 if (DiagID) {
1097 NonTentativeAction([&] {
1098 // Point the diagnostic at the first misplaced ellipsis.
1099 SourceLocation DiagLoc;
1100 for (SourceLocation &Loc : EllipsisLocs) {
1101 if (&Loc != ExpectedEllipsisLoc && Loc.isValid()) {
1102 DiagLoc = Loc;
1103 break;
1104 }
1105 }
1106 assert(DiagLoc.isValid() && "no location for diagnostic")(static_cast <bool> (DiagLoc.isValid() && "no location for diagnostic"
) ? void (0) : __assert_fail ("DiagLoc.isValid() && \"no location for diagnostic\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1106, __extension__ __PRETTY_FUNCTION__
))
;
1107
1108 // Issue the diagnostic and produce fixits showing where the ellipsis
1109 // should have been written.
1110 auto &&D = Diag(DiagLoc, DiagID);
1111 if (DiagID == diag::err_lambda_capture_misplaced_ellipsis) {
1112 SourceLocation ExpectedLoc =
1113 InitCapture ? Loc
1114 : Lexer::getLocForEndOfToken(
1115 Loc, 0, PP.getSourceManager(), getLangOpts());
1116 D << InitCapture << FixItHint::CreateInsertion(ExpectedLoc, "...");
1117 }
1118 for (SourceLocation &Loc : EllipsisLocs) {
1119 if (&Loc != ExpectedEllipsisLoc && Loc.isValid())
1120 D << FixItHint::CreateRemoval(Loc);
1121 }
1122 });
1123 }
1124 }
1125
1126 // Process the init-capture initializers now rather than delaying until we
1127 // form the lambda-expression so that they can be handled in the context
1128 // enclosing the lambda-expression, rather than in the context of the
1129 // lambda-expression itself.
1130 ParsedType InitCaptureType;
1131 if (Init.isUsable())
1132 Init = Actions.CorrectDelayedTyposInExpr(Init.get());
1133 if (Init.isUsable()) {
1134 NonTentativeAction([&] {
1135 // Get the pointer and store it in an lvalue, so we can use it as an
1136 // out argument.
1137 Expr *InitExpr = Init.get();
1138 // This performs any lvalue-to-rvalue conversions if necessary, which
1139 // can affect what gets captured in the containing decl-context.
1140 InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
1141 Loc, Kind == LCK_ByRef, EllipsisLoc, Id, InitKind, InitExpr);
1142 Init = InitExpr;
1143 });
1144 }
1145
1146 SourceLocation LocEnd = PrevTokLocation;
1147
1148 Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
1149 InitCaptureType, SourceRange(LocStart, LocEnd));
1150 }
1151
1152 T.consumeClose();
1153 Intro.Range.setEnd(T.getCloseLocation());
1154 return false;
1155}
1156
1157static void tryConsumeLambdaSpecifierToken(Parser &P,
1158 SourceLocation &MutableLoc,
1159 SourceLocation &ConstexprLoc,
1160 SourceLocation &ConstevalLoc,
1161 SourceLocation &DeclEndLoc) {
1162 assert(MutableLoc.isInvalid())(static_cast <bool> (MutableLoc.isInvalid()) ? void (0)
: __assert_fail ("MutableLoc.isInvalid()", "clang/lib/Parse/ParseExprCXX.cpp"
, 1162, __extension__ __PRETTY_FUNCTION__))
;
1163 assert(ConstexprLoc.isInvalid())(static_cast <bool> (ConstexprLoc.isInvalid()) ? void (
0) : __assert_fail ("ConstexprLoc.isInvalid()", "clang/lib/Parse/ParseExprCXX.cpp"
, 1163, __extension__ __PRETTY_FUNCTION__))
;
1164 // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
1165 // to the final of those locations. Emit an error if we have multiple
1166 // copies of those keywords and recover.
1167
1168 while (true) {
1169 switch (P.getCurToken().getKind()) {
1170 case tok::kw_mutable: {
1171 if (MutableLoc.isValid()) {
1172 P.Diag(P.getCurToken().getLocation(),
1173 diag::err_lambda_decl_specifier_repeated)
1174 << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1175 }
1176 MutableLoc = P.ConsumeToken();
1177 DeclEndLoc = MutableLoc;
1178 break /*switch*/;
1179 }
1180 case tok::kw_constexpr:
1181 if (ConstexprLoc.isValid()) {
1182 P.Diag(P.getCurToken().getLocation(),
1183 diag::err_lambda_decl_specifier_repeated)
1184 << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1185 }
1186 ConstexprLoc = P.ConsumeToken();
1187 DeclEndLoc = ConstexprLoc;
1188 break /*switch*/;
1189 case tok::kw_consteval:
1190 if (ConstevalLoc.isValid()) {
1191 P.Diag(P.getCurToken().getLocation(),
1192 diag::err_lambda_decl_specifier_repeated)
1193 << 2 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1194 }
1195 ConstevalLoc = P.ConsumeToken();
1196 DeclEndLoc = ConstevalLoc;
1197 break /*switch*/;
1198 default:
1199 return;
1200 }
1201 }
1202}
1203
1204static void
1205addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
1206 DeclSpec &DS) {
1207 if (ConstexprLoc.isValid()) {
1208 P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17
1209 ? diag::ext_constexpr_on_lambda_cxx17
1210 : diag::warn_cxx14_compat_constexpr_on_lambda);
1211 const char *PrevSpec = nullptr;
1212 unsigned DiagID = 0;
1213 DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, ConstexprLoc, PrevSpec,
1214 DiagID);
1215 assert(PrevSpec == nullptr && DiagID == 0 &&(static_cast <bool> (PrevSpec == nullptr && DiagID
== 0 && "Constexpr cannot have been set previously!"
) ? void (0) : __assert_fail ("PrevSpec == nullptr && DiagID == 0 && \"Constexpr cannot have been set previously!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1216, __extension__ __PRETTY_FUNCTION__
))
1216 "Constexpr cannot have been set previously!")(static_cast <bool> (PrevSpec == nullptr && DiagID
== 0 && "Constexpr cannot have been set previously!"
) ? void (0) : __assert_fail ("PrevSpec == nullptr && DiagID == 0 && \"Constexpr cannot have been set previously!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1216, __extension__ __PRETTY_FUNCTION__
))
;
1217 }
1218}
1219
1220static void addConstevalToLambdaDeclSpecifier(Parser &P,
1221 SourceLocation ConstevalLoc,
1222 DeclSpec &DS) {
1223 if (ConstevalLoc.isValid()) {
1224 P.Diag(ConstevalLoc, diag::warn_cxx20_compat_consteval);
1225 const char *PrevSpec = nullptr;
1226 unsigned DiagID = 0;
1227 DS.SetConstexprSpec(ConstexprSpecKind::Consteval, ConstevalLoc, PrevSpec,
1228 DiagID);
1229 if (DiagID != 0)
1230 P.Diag(ConstevalLoc, DiagID) << PrevSpec;
1231 }
1232}
1233
1234/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1235/// expression.
1236ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1237 LambdaIntroducer &Intro) {
1238 SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1239 Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1240
1241 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1242 "lambda expression parsing");
1243
1244
1245
1246 // FIXME: Call into Actions to add any init-capture declarations to the
1247 // scope while parsing the lambda-declarator and compound-statement.
1248
1249 // Parse lambda-declarator[opt].
1250 DeclSpec DS(AttrFactory);
1251 Declarator D(DS, DeclaratorContext::LambdaExpr);
1252 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1253 Actions.PushLambdaScope();
1254
1255 ParsedAttributes Attr(AttrFactory);
1256 if (getLangOpts().CUDA) {
1257 // In CUDA code, GNU attributes are allowed to appear immediately after the
1258 // "[...]", even if there is no "(...)" before the lambda body.
1259 MaybeParseGNUAttributes(D);
1260 }
1261
1262 // Helper to emit a warning if we see a CUDA host/device/global attribute
1263 // after '(...)'. nvcc doesn't accept this.
1264 auto WarnIfHasCUDATargetAttr = [&] {
1265 if (getLangOpts().CUDA)
1266 for (const ParsedAttr &A : Attr)
1267 if (A.getKind() == ParsedAttr::AT_CUDADevice ||
1268 A.getKind() == ParsedAttr::AT_CUDAHost ||
1269 A.getKind() == ParsedAttr::AT_CUDAGlobal)
1270 Diag(A.getLoc(), diag::warn_cuda_attr_lambda_position)
1271 << A.getAttrName()->getName();
1272 };
1273
1274 MultiParseScope TemplateParamScope(*this);
1275 if (Tok.is(tok::less)) {
1276 Diag(Tok, getLangOpts().CPlusPlus20
1277 ? diag::warn_cxx17_compat_lambda_template_parameter_list
1278 : diag::ext_lambda_template_parameter_list);
1279
1280 SmallVector<NamedDecl*, 4> TemplateParams;
1281 SourceLocation LAngleLoc, RAngleLoc;
1282 if (ParseTemplateParameters(TemplateParamScope,
1283 CurTemplateDepthTracker.getDepth(),
1284 TemplateParams, LAngleLoc, RAngleLoc)) {
1285 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1286 return ExprError();
1287 }
1288
1289 if (TemplateParams.empty()) {
1290 Diag(RAngleLoc,
1291 diag::err_lambda_template_parameter_list_empty);
1292 } else {
1293 ExprResult RequiresClause;
1294 if (TryConsumeToken(tok::kw_requires)) {
1295 RequiresClause =
1296 Actions.ActOnRequiresClause(ParseConstraintLogicalOrExpression(
1297 /*IsTrailingRequiresClause=*/false));
1298 if (RequiresClause.isInvalid())
1299 SkipUntil({tok::l_brace, tok::l_paren}, StopAtSemi | StopBeforeMatch);
1300 }
1301
1302 Actions.ActOnLambdaExplicitTemplateParameterList(
1303 LAngleLoc, TemplateParams, RAngleLoc, RequiresClause);
1304 ++CurTemplateDepthTracker;
1305 }
1306 }
1307
1308 // Implement WG21 P2173, which allows attributes immediately before the
1309 // lambda declarator and applies them to the corresponding function operator
1310 // or operator template declaration. We accept this as a conforming extension
1311 // in all language modes that support lambdas.
1312 if (isCXX11AttributeSpecifier()) {
1313 Diag(Tok, getLangOpts().CPlusPlus2b
1314 ? diag::warn_cxx20_compat_decl_attrs_on_lambda
1315 : diag::ext_decl_attrs_on_lambda);
1316 MaybeParseCXX11Attributes(D);
1317 }
1318
1319 TypeResult TrailingReturnType;
1320 SourceLocation TrailingReturnTypeLoc;
1321
1322 auto ParseLambdaSpecifiers =
1323 [&](SourceLocation LParenLoc, SourceLocation RParenLoc,
1324 MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo,
1325 SourceLocation EllipsisLoc) {
1326 SourceLocation DeclEndLoc = RParenLoc;
1327
1328 // GNU-style attributes must be parsed before the mutable specifier to
1329 // be compatible with GCC. MSVC-style attributes must be parsed before
1330 // the mutable specifier to be compatible with MSVC.
1331 MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr);
1332
1333 // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update
1334 // the DeclEndLoc.
1335 SourceLocation MutableLoc;
1336 SourceLocation ConstexprLoc;
1337 SourceLocation ConstevalLoc;
1338 tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
1339 ConstevalLoc, DeclEndLoc);
1340
1341 addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
1342 addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
1343 // Parse exception-specification[opt].
1344 ExceptionSpecificationType ESpecType = EST_None;
1345 SourceRange ESpecRange;
1346 SmallVector<ParsedType, 2> DynamicExceptions;
1347 SmallVector<SourceRange, 2> DynamicExceptionRanges;
1348 ExprResult NoexceptExpr;
1349 CachedTokens *ExceptionSpecTokens;
1350 ESpecType = tryParseExceptionSpecification(
1351 /*Delayed=*/false, ESpecRange, DynamicExceptions,
1352 DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens);
1353
1354 if (ESpecType != EST_None)
1355 DeclEndLoc = ESpecRange.getEnd();
1356
1357 // Parse attribute-specifier[opt].
1358 MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1359
1360 // Parse OpenCL addr space attribute.
1361 if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local,
1362 tok::kw___constant, tok::kw___generic)) {
1363 ParseOpenCLQualifiers(DS.getAttributes());
1364 ConsumeToken();
1365 }
1366
1367 SourceLocation FunLocalRangeEnd = DeclEndLoc;
1368
1369 // Parse trailing-return-type[opt].
1370 if (Tok.is(tok::arrow)) {
1371 FunLocalRangeEnd = Tok.getLocation();
1372 SourceRange Range;
1373 TrailingReturnType = ParseTrailingReturnType(
1374 Range, /*MayBeFollowedByDirectInit*/ false);
1375 TrailingReturnTypeLoc = Range.getBegin();
1376 if (Range.getEnd().isValid())
1377 DeclEndLoc = Range.getEnd();
1378 }
1379
1380 SourceLocation NoLoc;
1381 D.AddTypeInfo(
1382 DeclaratorChunk::getFunction(
1383 /*HasProto=*/true,
1384 /*IsAmbiguous=*/false, LParenLoc, ParamInfo.data(),
1385 ParamInfo.size(), EllipsisLoc, RParenLoc,
1386 /*RefQualifierIsLvalueRef=*/true,
1387 /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType, ESpecRange,
1388 DynamicExceptions.data(), DynamicExceptionRanges.data(),
1389 DynamicExceptions.size(),
1390 NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
1391 /*ExceptionSpecTokens*/ nullptr,
1392 /*DeclsInPrototype=*/None, LParenLoc, FunLocalRangeEnd, D,
1393 TrailingReturnType, TrailingReturnTypeLoc, &DS),
1394 std::move(Attr), DeclEndLoc);
1395 };
1396
1397 if (Tok.is(tok::l_paren)) {
1398 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
1399 Scope::FunctionDeclarationScope |
1400 Scope::DeclScope);
1401
1402 BalancedDelimiterTracker T(*this, tok::l_paren);
1403 T.consumeOpen();
1404 SourceLocation LParenLoc = T.getOpenLocation();
1405
1406 // Parse parameter-declaration-clause.
1407 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
1408 SourceLocation EllipsisLoc;
1409
1410 if (Tok.isNot(tok::r_paren)) {
1411 Actions.RecordParsingTemplateParameterDepth(
1412 CurTemplateDepthTracker.getOriginalDepth());
1413
1414 ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo,
1415 EllipsisLoc);
1416 // For a generic lambda, each 'auto' within the parameter declaration
1417 // clause creates a template type parameter, so increment the depth.
1418 // If we've parsed any explicit template parameters, then the depth will
1419 // have already been incremented. So we make sure that at most a single
1420 // depth level is added.
1421 if (Actions.getCurGenericLambda())
1422 CurTemplateDepthTracker.setAddedDepth(1);
1423 }
1424
1425 T.consumeClose();
1426
1427 // Parse lambda-specifiers.
1428 ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(),
1429 ParamInfo, EllipsisLoc);
1430
1431 // Parse requires-clause[opt].
1432 if (Tok.is(tok::kw_requires))
1433 ParseTrailingRequiresClause(D);
1434 } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1435 tok::kw_constexpr, tok::kw_consteval,
1436 tok::kw___private, tok::kw___global, tok::kw___local,
1437 tok::kw___constant, tok::kw___generic,
1438 tok::kw_requires, tok::kw_noexcept) ||
1439 (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
1440 if (!getLangOpts().CPlusPlus2b)
1441 // It's common to forget that one needs '()' before 'mutable', an
1442 // attribute specifier, the result type, or the requires clause. Deal with
1443 // this.
1444 Diag(Tok, diag::ext_lambda_missing_parens)
1445 << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
1446
1447 SourceLocation NoLoc;
1448 // Parse lambda-specifiers.
1449 std::vector<DeclaratorChunk::ParamInfo> EmptyParamInfo;
1450 ParseLambdaSpecifiers(/*LParenLoc=*/NoLoc, /*RParenLoc=*/NoLoc,
1451 EmptyParamInfo, /*EllipsisLoc=*/NoLoc);
1452 }
1453
1454 WarnIfHasCUDATargetAttr();
1455
1456 // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1457 // it.
1458 unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
1459 Scope::CompoundStmtScope;
1460 ParseScope BodyScope(this, ScopeFlags);
1461
1462 Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
1463
1464 // Parse compound-statement.
1465 if (!Tok.is(tok::l_brace)) {
1466 Diag(Tok, diag::err_expected_lambda_body);
1467 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1468 return ExprError();
1469 }
1470
1471 StmtResult Stmt(ParseCompoundStatementBody());
1472 BodyScope.Exit();
1473 TemplateParamScope.Exit();
1474
1475 if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
1476 return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
1477
1478 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1479 return ExprError();
1480}
1481
1482/// ParseCXXCasts - This handles the various ways to cast expressions to another
1483/// type.
1484///
1485/// postfix-expression: [C++ 5.2p1]
1486/// 'dynamic_cast' '<' type-name '>' '(' expression ')'
1487/// 'static_cast' '<' type-name '>' '(' expression ')'
1488/// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
1489/// 'const_cast' '<' type-name '>' '(' expression ')'
1490///
1491/// C++ for OpenCL s2.3.1 adds:
1492/// 'addrspace_cast' '<' type-name '>' '(' expression ')'
1493ExprResult Parser::ParseCXXCasts() {
1494 tok::TokenKind Kind = Tok.getKind();
1495 const char *CastName = nullptr; // For error messages
1496
1497 switch (Kind) {
1498 default: llvm_unreachable("Unknown C++ cast!")::llvm::llvm_unreachable_internal("Unknown C++ cast!", "clang/lib/Parse/ParseExprCXX.cpp"
, 1498)
;
1499 case tok::kw_addrspace_cast: CastName = "addrspace_cast"; break;
1500 case tok::kw_const_cast: CastName = "const_cast"; break;
1501 case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
1502 case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1503 case tok::kw_static_cast: CastName = "static_cast"; break;
1504 }
1505
1506 SourceLocation OpLoc = ConsumeToken();
1507 SourceLocation LAngleBracketLoc = Tok.getLocation();
1508
1509 // Check for "<::" which is parsed as "[:". If found, fix token stream,
1510 // diagnose error, suggest fix, and recover parsing.
1511 if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
1512 Token Next = NextToken();
1513 if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1514 FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1515 }
1516
1517 if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1518 return ExprError();
1519
1520 // Parse the common declaration-specifiers piece.
1521 DeclSpec DS(AttrFactory);
1522 ParseSpecifierQualifierList(DS);
1523
1524 // Parse the abstract-declarator, if present.
1525 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
1526 ParseDeclarator(DeclaratorInfo);
1527
1528 SourceLocation RAngleBracketLoc = Tok.getLocation();
1529
1530 if (ExpectAndConsume(tok::greater))
1531 return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1532
1533 BalancedDelimiterTracker T(*this, tok::l_paren);
1534
1535 if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
1536 return ExprError();
1537
1538 ExprResult Result = ParseExpression();
1539
1540 // Match the ')'.
1541 T.consumeClose();
1542
1543 if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
1544 Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
1545 LAngleBracketLoc, DeclaratorInfo,
1546 RAngleBracketLoc,
1547 T.getOpenLocation(), Result.get(),
1548 T.getCloseLocation());
1549
1550 return Result;
1551}
1552
1553/// ParseCXXTypeid - This handles the C++ typeid expression.
1554///
1555/// postfix-expression: [C++ 5.2p1]
1556/// 'typeid' '(' expression ')'
1557/// 'typeid' '(' type-id ')'
1558///
1559ExprResult Parser::ParseCXXTypeid() {
1560 assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!")(static_cast <bool> (Tok.is(tok::kw_typeid) && "Not 'typeid'!"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_typeid) && \"Not 'typeid'!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1560, __extension__ __PRETTY_FUNCTION__
))
;
1561
1562 SourceLocation OpLoc = ConsumeToken();
1563 SourceLocation LParenLoc, RParenLoc;
1564 BalancedDelimiterTracker T(*this, tok::l_paren);
1565
1566 // typeid expressions are always parenthesized.
1567 if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
1568 return ExprError();
1569 LParenLoc = T.getOpenLocation();
1570
1571 ExprResult Result;
1572
1573 // C++0x [expr.typeid]p3:
1574 // When typeid is applied to an expression other than an lvalue of a
1575 // polymorphic class type [...] The expression is an unevaluated
1576 // operand (Clause 5).
1577 //
1578 // Note that we can't tell whether the expression is an lvalue of a
1579 // polymorphic class type until after we've parsed the expression; we
1580 // speculatively assume the subexpression is unevaluated, and fix it up
1581 // later.
1582 //
1583 // We enter the unevaluated context before trying to determine whether we
1584 // have a type-id, because the tentative parse logic will try to resolve
1585 // names, and must treat them as unevaluated.
1586 EnterExpressionEvaluationContext Unevaluated(
1587 Actions, Sema::ExpressionEvaluationContext::Unevaluated,
1588 Sema::ReuseLambdaContextDecl);
1589
1590 if (isTypeIdInParens()) {
1591 TypeResult Ty = ParseTypeName();
1592
1593 // Match the ')'.
1594 T.consumeClose();
1595 RParenLoc = T.getCloseLocation();
1596 if (Ty.isInvalid() || RParenLoc.isInvalid())
1597 return ExprError();
1598
1599 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1600 Ty.get().getAsOpaquePtr(), RParenLoc);
1601 } else {
1602 Result = ParseExpression();
1603
1604 // Match the ')'.
1605 if (Result.isInvalid())
1606 SkipUntil(tok::r_paren, StopAtSemi);
1607 else {
1608 T.consumeClose();
1609 RParenLoc = T.getCloseLocation();
1610 if (RParenLoc.isInvalid())
1611 return ExprError();
1612
1613 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1614 Result.get(), RParenLoc);
1615 }
1616 }
1617
1618 return Result;
1619}
1620
1621/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1622///
1623/// '__uuidof' '(' expression ')'
1624/// '__uuidof' '(' type-id ')'
1625///
1626ExprResult Parser::ParseCXXUuidof() {
1627 assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!")(static_cast <bool> (Tok.is(tok::kw___uuidof) &&
"Not '__uuidof'!") ? void (0) : __assert_fail ("Tok.is(tok::kw___uuidof) && \"Not '__uuidof'!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1627, __extension__ __PRETTY_FUNCTION__
))
;
1628
1629 SourceLocation OpLoc = ConsumeToken();
1630 BalancedDelimiterTracker T(*this, tok::l_paren);
1631
1632 // __uuidof expressions are always parenthesized.
1633 if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1634 return ExprError();
1635
1636 ExprResult Result;
1637
1638 if (isTypeIdInParens()) {
1639 TypeResult Ty = ParseTypeName();
1640
1641 // Match the ')'.
1642 T.consumeClose();
1643
1644 if (Ty.isInvalid())
1645 return ExprError();
1646
1647 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1648 Ty.get().getAsOpaquePtr(),
1649 T.getCloseLocation());
1650 } else {
1651 EnterExpressionEvaluationContext Unevaluated(
1652 Actions, Sema::ExpressionEvaluationContext::Unevaluated);
1653 Result = ParseExpression();
1654
1655 // Match the ')'.
1656 if (Result.isInvalid())
1657 SkipUntil(tok::r_paren, StopAtSemi);
1658 else {
1659 T.consumeClose();
1660
1661 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1662 /*isType=*/false,
1663 Result.get(), T.getCloseLocation());
1664 }
1665 }
1666
1667 return Result;
1668}
1669
1670/// Parse a C++ pseudo-destructor expression after the base,
1671/// . or -> operator, and nested-name-specifier have already been
1672/// parsed. We're handling this fragment of the grammar:
1673///
1674/// postfix-expression: [C++2a expr.post]
1675/// postfix-expression . template[opt] id-expression
1676/// postfix-expression -> template[opt] id-expression
1677///
1678/// id-expression:
1679/// qualified-id
1680/// unqualified-id
1681///
1682/// qualified-id:
1683/// nested-name-specifier template[opt] unqualified-id
1684///
1685/// nested-name-specifier:
1686/// type-name ::
1687/// decltype-specifier :: FIXME: not implemented, but probably only
1688/// allowed in C++ grammar by accident
1689/// nested-name-specifier identifier ::
1690/// nested-name-specifier template[opt] simple-template-id ::
1691/// [...]
1692///
1693/// unqualified-id:
1694/// ~ type-name
1695/// ~ decltype-specifier
1696/// [...]
1697///
1698/// ... where the all but the last component of the nested-name-specifier
1699/// has already been parsed, and the base expression is not of a non-dependent
1700/// class type.
1701ExprResult
1702Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1703 tok::TokenKind OpKind,
1704 CXXScopeSpec &SS,
1705 ParsedType ObjectType) {
1706 // If the last component of the (optional) nested-name-specifier is
1707 // template[opt] simple-template-id, it has already been annotated.
1708 UnqualifiedId FirstTypeName;
1709 SourceLocation CCLoc;
1710 if (Tok.is(tok::identifier)) {
1711 FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1712 ConsumeToken();
1713 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail")(static_cast <bool> (Tok.is(tok::coloncolon) &&
"ParseOptionalCXXScopeSpecifier fail") ? void (0) : __assert_fail
("Tok.is(tok::coloncolon) &&\"ParseOptionalCXXScopeSpecifier fail\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1713, __extension__ __PRETTY_FUNCTION__
))
;
1714 CCLoc = ConsumeToken();
1715 } else if (Tok.is(tok::annot_template_id)) {
1716 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1717 // FIXME: Carry on and build an AST representation for tooling.
1718 if (TemplateId->isInvalid())
1719 return ExprError();
1720 FirstTypeName.setTemplateId(TemplateId);
1721 ConsumeAnnotationToken();
1722 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail")(static_cast <bool> (Tok.is(tok::coloncolon) &&
"ParseOptionalCXXScopeSpecifier fail") ? void (0) : __assert_fail
("Tok.is(tok::coloncolon) &&\"ParseOptionalCXXScopeSpecifier fail\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1722, __extension__ __PRETTY_FUNCTION__
))
;
1723 CCLoc = ConsumeToken();
1724 } else {
1725 assert(SS.isEmpty() && "missing last component of nested name specifier")(static_cast <bool> (SS.isEmpty() && "missing last component of nested name specifier"
) ? void (0) : __assert_fail ("SS.isEmpty() && \"missing last component of nested name specifier\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1725, __extension__ __PRETTY_FUNCTION__
))
;
1726 FirstTypeName.setIdentifier(nullptr, SourceLocation());
1727 }
1728
1729 // Parse the tilde.
1730 assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail")(static_cast <bool> (Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail"
) ? void (0) : __assert_fail ("Tok.is(tok::tilde) && \"ParseOptionalCXXScopeSpecifier fail\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1730, __extension__ __PRETTY_FUNCTION__
))
;
1731 SourceLocation TildeLoc = ConsumeToken();
1732
1733 if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid()) {
1734 DeclSpec DS(AttrFactory);
1735 ParseDecltypeSpecifier(DS);
1736 if (DS.getTypeSpecType() == TST_error)
1737 return ExprError();
1738 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1739 TildeLoc, DS);
1740 }
1741
1742 if (!Tok.is(tok::identifier)) {
1743 Diag(Tok, diag::err_destructor_tilde_identifier);
1744 return ExprError();
1745 }
1746
1747 // Parse the second type.
1748 UnqualifiedId SecondTypeName;
1749 IdentifierInfo *Name = Tok.getIdentifierInfo();
1750 SourceLocation NameLoc = ConsumeToken();
1751 SecondTypeName.setIdentifier(Name, NameLoc);
1752
1753 // If there is a '<', the second type name is a template-id. Parse
1754 // it as such.
1755 //
1756 // FIXME: This is not a context in which a '<' is assumed to start a template
1757 // argument list. This affects examples such as
1758 // void f(auto *p) { p->~X<int>(); }
1759 // ... but there's no ambiguity, and nowhere to write 'template' in such an
1760 // example, so we accept it anyway.
1761 if (Tok.is(tok::less) &&
1762 ParseUnqualifiedIdTemplateId(
1763 SS, ObjectType, Base && Base->containsErrors(), SourceLocation(),
1764 Name, NameLoc, false, SecondTypeName,
1765 /*AssumeTemplateId=*/true))
1766 return ExprError();
1767
1768 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1769 SS, FirstTypeName, CCLoc, TildeLoc,
1770 SecondTypeName);
1771}
1772
1773/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1774///
1775/// boolean-literal: [C++ 2.13.5]
1776/// 'true'
1777/// 'false'
1778ExprResult Parser::ParseCXXBoolLiteral() {
1779 tok::TokenKind Kind = Tok.getKind();
1780 return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1781}
1782
1783/// ParseThrowExpression - This handles the C++ throw expression.
1784///
1785/// throw-expression: [C++ 15]
1786/// 'throw' assignment-expression[opt]
1787ExprResult Parser::ParseThrowExpression() {
1788 assert(Tok.is(tok::kw_throw) && "Not throw!")(static_cast <bool> (Tok.is(tok::kw_throw) && "Not throw!"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_throw) && \"Not throw!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1788, __extension__ __PRETTY_FUNCTION__
))
;
1789 SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
1790
1791 // If the current token isn't the start of an assignment-expression,
1792 // then the expression is not present. This handles things like:
1793 // "C ? throw : (void)42", which is crazy but legal.
1794 switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
1795 case tok::semi:
1796 case tok::r_paren:
1797 case tok::r_square:
1798 case tok::r_brace:
1799 case tok::colon:
1800 case tok::comma:
1801 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
1802
1803 default:
1804 ExprResult Expr(ParseAssignmentExpression());
1805 if (Expr.isInvalid()) return Expr;
1806 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
1807 }
1808}
1809
1810/// Parse the C++ Coroutines co_yield expression.
1811///
1812/// co_yield-expression:
1813/// 'co_yield' assignment-expression[opt]
1814ExprResult Parser::ParseCoyieldExpression() {
1815 assert(Tok.is(tok::kw_co_yield) && "Not co_yield!")(static_cast <bool> (Tok.is(tok::kw_co_yield) &&
"Not co_yield!") ? void (0) : __assert_fail ("Tok.is(tok::kw_co_yield) && \"Not co_yield!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1815, __extension__ __PRETTY_FUNCTION__
))
;
1816
1817 SourceLocation Loc = ConsumeToken();
1818 ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
1819 : ParseAssignmentExpression();
1820 if (!Expr.isInvalid())
1821 Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
1822 return Expr;
1823}
1824
1825/// ParseCXXThis - This handles the C++ 'this' pointer.
1826///
1827/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1828/// a non-lvalue expression whose value is the address of the object for which
1829/// the function is called.
1830ExprResult Parser::ParseCXXThis() {
1831 assert(Tok.is(tok::kw_this) && "Not 'this'!")(static_cast <bool> (Tok.is(tok::kw_this) && "Not 'this'!"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_this) && \"Not 'this'!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1831, __extension__ __PRETTY_FUNCTION__
))
;
1832 SourceLocation ThisLoc = ConsumeToken();
1833 return Actions.ActOnCXXThis(ThisLoc);
1834}
1835
1836/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1837/// Can be interpreted either as function-style casting ("int(x)")
1838/// or class type construction ("ClassType(x,y,z)")
1839/// or creation of a value-initialized type ("int()").
1840/// See [C++ 5.2.3].
1841///
1842/// postfix-expression: [C++ 5.2p1]
1843/// simple-type-specifier '(' expression-list[opt] ')'
1844/// [C++0x] simple-type-specifier braced-init-list
1845/// typename-specifier '(' expression-list[opt] ')'
1846/// [C++0x] typename-specifier braced-init-list
1847///
1848/// In C++1z onwards, the type specifier can also be a template-name.
1849ExprResult
1850Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1851 Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCast);
1852 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
1853
1854 assert((Tok.is(tok::l_paren) ||(static_cast <bool> ((Tok.is(tok::l_paren) || (getLangOpts
().CPlusPlus11 && Tok.is(tok::l_brace))) && "Expected '(' or '{'!"
) ? void (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1856, __extension__ __PRETTY_FUNCTION__
))
1855 (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))(static_cast <bool> ((Tok.is(tok::l_paren) || (getLangOpts
().CPlusPlus11 && Tok.is(tok::l_brace))) && "Expected '(' or '{'!"
) ? void (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1856, __extension__ __PRETTY_FUNCTION__
))
1856 && "Expected '(' or '{'!")(static_cast <bool> ((Tok.is(tok::l_paren) || (getLangOpts
().CPlusPlus11 && Tok.is(tok::l_brace))) && "Expected '(' or '{'!"
) ? void (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1856, __extension__ __PRETTY_FUNCTION__
))
;
1857
1858 if (Tok.is(tok::l_brace)) {
1859 PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
1860 ExprResult Init = ParseBraceInitializer();
1861 if (Init.isInvalid())
1862 return Init;
1863 Expr *InitList = Init.get();
1864 return Actions.ActOnCXXTypeConstructExpr(
1865 TypeRep, InitList->getBeginLoc(), MultiExprArg(&InitList, 1),
1866 InitList->getEndLoc(), /*ListInitialization=*/true);
1867 } else {
1868 BalancedDelimiterTracker T(*this, tok::l_paren);
1869 T.consumeOpen();
1870
1871 PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
1872
1873 ExprVector Exprs;
1874 CommaLocsTy CommaLocs;
1875
1876 auto RunSignatureHelp = [&]() {
1877 QualType PreferredType;
1878 if (TypeRep)
1879 PreferredType = Actions.ProduceConstructorSignatureHelp(
1880 TypeRep.get()->getCanonicalTypeInternal(), DS.getEndLoc(), Exprs,
1881 T.getOpenLocation(), /*Braced=*/false);
1882 CalledSignatureHelp = true;
1883 return PreferredType;
1884 };
1885
1886 if (Tok.isNot(tok::r_paren)) {
1887 if (ParseExpressionList(Exprs, CommaLocs, [&] {
1888 PreferredType.enterFunctionArgument(Tok.getLocation(),
1889 RunSignatureHelp);
1890 })) {
1891 if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
1892 RunSignatureHelp();
1893 SkipUntil(tok::r_paren, StopAtSemi);
1894 return ExprError();
1895 }
1896 }
1897
1898 // Match the ')'.
1899 T.consumeClose();
1900
1901 // TypeRep could be null, if it references an invalid typedef.
1902 if (!TypeRep)
1903 return ExprError();
1904
1905 assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&(static_cast <bool> ((Exprs.size() == 0 || Exprs.size()
-1 == CommaLocs.size())&& "Unexpected number of commas!"
) ? void (0) : __assert_fail ("(Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& \"Unexpected number of commas!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1906, __extension__ __PRETTY_FUNCTION__
))
1906 "Unexpected number of commas!")(static_cast <bool> ((Exprs.size() == 0 || Exprs.size()
-1 == CommaLocs.size())&& "Unexpected number of commas!"
) ? void (0) : __assert_fail ("(Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& \"Unexpected number of commas!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1906, __extension__ __PRETTY_FUNCTION__
))
;
1907 return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1908 Exprs, T.getCloseLocation(),
1909 /*ListInitialization=*/false);
1910 }
1911}
1912
1913Parser::DeclGroupPtrTy
1914Parser::ParseAliasDeclarationInInitStatement(DeclaratorContext Context,
1915 ParsedAttributesWithRange &Attrs) {
1916 assert(Tok.is(tok::kw_using) && "Expected using")(static_cast <bool> (Tok.is(tok::kw_using) && "Expected using"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_using) && \"Expected using\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1916, __extension__ __PRETTY_FUNCTION__
))
;
1917 assert((Context == DeclaratorContext::ForInit ||(static_cast <bool> ((Context == DeclaratorContext::ForInit
|| Context == DeclaratorContext::SelectionInit) && "Unexpected Declarator Context"
) ? void (0) : __assert_fail ("(Context == DeclaratorContext::ForInit || Context == DeclaratorContext::SelectionInit) && \"Unexpected Declarator Context\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1919, __extension__ __PRETTY_FUNCTION__
))
1918 Context == DeclaratorContext::SelectionInit) &&(static_cast <bool> ((Context == DeclaratorContext::ForInit
|| Context == DeclaratorContext::SelectionInit) && "Unexpected Declarator Context"
) ? void (0) : __assert_fail ("(Context == DeclaratorContext::ForInit || Context == DeclaratorContext::SelectionInit) && \"Unexpected Declarator Context\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1919, __extension__ __PRETTY_FUNCTION__
))
1919 "Unexpected Declarator Context")(static_cast <bool> ((Context == DeclaratorContext::ForInit
|| Context == DeclaratorContext::SelectionInit) && "Unexpected Declarator Context"
) ? void (0) : __assert_fail ("(Context == DeclaratorContext::ForInit || Context == DeclaratorContext::SelectionInit) && \"Unexpected Declarator Context\""
, "clang/lib/Parse/ParseExprCXX.cpp", 1919, __extension__ __PRETTY_FUNCTION__
))
;
1920 DeclGroupPtrTy DG;
1921 SourceLocation DeclStart = ConsumeToken(), DeclEnd;
1922
1923 DG = ParseUsingDeclaration(Context, {}, DeclStart, DeclEnd, Attrs, AS_none);
1924 if (!DG)
1925 return DG;
1926
1927 Diag(DeclStart, !getLangOpts().CPlusPlus2b
1928 ? diag::ext_alias_in_init_statement
1929 : diag::warn_cxx20_alias_in_init_statement)
1930 << SourceRange(DeclStart, DeclEnd);
1931
1932 return DG;
1933}
1934
1935/// ParseCXXCondition - if/switch/while condition expression.
1936///
1937/// condition:
1938/// expression
1939/// type-specifier-seq declarator '=' assignment-expression
1940/// [C++11] type-specifier-seq declarator '=' initializer-clause
1941/// [C++11] type-specifier-seq declarator braced-init-list
1942/// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
1943/// brace-or-equal-initializer
1944/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1945/// '=' assignment-expression
1946///
1947/// In C++1z, a condition may in some contexts be preceded by an
1948/// optional init-statement. This function will parse that too.
1949///
1950/// \param InitStmt If non-null, an init-statement is permitted, and if present
1951/// will be parsed and stored here.
1952///
1953/// \param Loc The location of the start of the statement that requires this
1954/// condition, e.g., the "for" in a for loop.
1955///
1956/// \param MissingOK Whether an empty condition is acceptable here. Otherwise
1957/// it is considered an error to be recovered from.
1958///
1959/// \param FRI If non-null, a for range declaration is permitted, and if
1960/// present will be parsed and stored here, and a null result will be returned.
1961///
1962/// \param EnterForConditionScope If true, enter a continue/break scope at the
1963/// appropriate moment for a 'for' loop.
1964///
1965/// \returns The parsed condition.
1966Sema::ConditionResult
1967Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
1968 Sema::ConditionKind CK, bool MissingOK,
1969 ForRangeInfo *FRI, bool EnterForConditionScope) {
1970 // Helper to ensure we always enter a continue/break scope if requested.
1971 struct ForConditionScopeRAII {
1972 Scope *S;
1973 void enter(bool IsConditionVariable) {
1974 if (S) {
1975 S->AddFlags(Scope::BreakScope | Scope::ContinueScope);
1976 S->setIsConditionVarScope(IsConditionVariable);
1977 }
1978 }
1979 ~ForConditionScopeRAII() {
1980 if (S)
1981 S->setIsConditionVarScope(false);
1982 }
1983 } ForConditionScope{EnterForConditionScope
7.1
'EnterForConditionScope' is false
7.1
'EnterForConditionScope' is false
? getCurScope() : nullptr};
1
Assuming 'EnterForConditionScope' is false
2
'?' condition is false
8
'?' condition is false
1984
1985 ParenBraceBracketBalancer BalancerRAIIObj(*this);
1986 PreferredType.enterCondition(Actions, Tok.getLocation());
1987
1988 if (Tok.is(tok::code_completion)) {
3
Taking false branch
9
Calling 'Token::is'
12
Returning from 'Token::is'
13
Taking false branch
1989 cutOffParsing();
1990 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
1991 return Sema::ConditionError();
1992 }
1993
1994 ParsedAttributesWithRange attrs(AttrFactory);
1995 MaybeParseCXX11Attributes(attrs);
1996
1997 const auto WarnOnInit = [this, &CK] {
1998 Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
1999 ? diag::warn_cxx14_compat_init_statement
2000 : diag::ext_init_statement)
2001 << (CK == Sema::ConditionKind::Switch);
2002 };
2003
2004 // Determine what kind of thing we have.
2005 switch (isCXXConditionDeclarationOrInitStatement(InitStmt, FRI)) {
4
Control jumps to 'case InitStmtDecl:' at line 2043
14
Control jumps to 'case InitStmtDecl:' at line 2043
2006 case ConditionOrInitStatement::Expression: {
2007 // If this is a for loop, we're entering its condition.
2008 ForConditionScope.enter(/*IsConditionVariable=*/false);
2009
2010 ProhibitAttributes(attrs);
2011
2012 // We can have an empty expression here.
2013 // if (; true);
2014 if (InitStmt && Tok.is(tok::semi)) {
2015 WarnOnInit();
2016 SourceLocation SemiLoc = Tok.getLocation();
2017 if (!Tok.hasLeadingEmptyMacro() && !SemiLoc.isMacroID()) {
2018 Diag(SemiLoc, diag::warn_empty_init_statement)
2019 << (CK == Sema::ConditionKind::Switch)
2020 << FixItHint::CreateRemoval(SemiLoc);
2021 }
2022 ConsumeToken();
2023 *InitStmt = Actions.ActOnNullStmt(SemiLoc);
2024 return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
2025 }
2026
2027 // Parse the expression.
2028 ExprResult Expr = ParseExpression(); // expression
2029 if (Expr.isInvalid())
2030 return Sema::ConditionError();
2031
2032 if (InitStmt && Tok.is(tok::semi)) {
2033 WarnOnInit();
2034 *InitStmt = Actions.ActOnExprStmt(Expr.get());
2035 ConsumeToken();
2036 return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
2037 }
2038
2039 return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK,
2040 MissingOK);
2041 }
2042
2043 case ConditionOrInitStatement::InitStmtDecl: {
2044 WarnOnInit();
2045 DeclGroupPtrTy DG;
2046 SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
2047 if (Tok.is(tok::kw_using))
5
Taking false branch
15
Taking true branch
2048 DG = ParseAliasDeclarationInInitStatement(
2049 DeclaratorContext::SelectionInit, attrs);
2050 else
2051 DG = ParseSimpleDeclaration(DeclaratorContext::SelectionInit, DeclEnd,
2052 attrs, /*RequireSemi=*/true);
2053 *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
16
Called C++ object pointer is null
2054 return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
6
Passing null pointer value via 1st parameter 'InitStmt'
7
Calling 'Parser::ParseCXXCondition'
2055 }
2056
2057 case ConditionOrInitStatement::ForRangeDecl: {
2058 // This is 'for (init-stmt; for-range-decl : range-expr)'.
2059 // We're not actually in a for loop yet, so 'break' and 'continue' aren't
2060 // permitted here.
2061 assert(FRI && "should not parse a for range declaration here")(static_cast <bool> (FRI && "should not parse a for range declaration here"
) ? void (0) : __assert_fail ("FRI && \"should not parse a for range declaration here\""
, "clang/lib/Parse/ParseExprCXX.cpp", 2061, __extension__ __PRETTY_FUNCTION__
))
;
2062 SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
2063 DeclGroupPtrTy DG = ParseSimpleDeclaration(DeclaratorContext::ForInit,
2064 DeclEnd, attrs, false, FRI);
2065 FRI->LoopVar = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
2066 assert((FRI->ColonLoc.isValid() || !DG) &&(static_cast <bool> ((FRI->ColonLoc.isValid() || !DG
) && "cannot find for range declaration") ? void (0) :
__assert_fail ("(FRI->ColonLoc.isValid() || !DG) && \"cannot find for range declaration\""
, "clang/lib/Parse/ParseExprCXX.cpp", 2067, __extension__ __PRETTY_FUNCTION__
))
2067 "cannot find for range declaration")(static_cast <bool> ((FRI->ColonLoc.isValid() || !DG
) && "cannot find for range declaration") ? void (0) :
__assert_fail ("(FRI->ColonLoc.isValid() || !DG) && \"cannot find for range declaration\""
, "clang/lib/Parse/ParseExprCXX.cpp", 2067, __extension__ __PRETTY_FUNCTION__
))
;
2068 return Sema::ConditionResult();
2069 }
2070
2071 case ConditionOrInitStatement::ConditionDecl:
2072 case ConditionOrInitStatement::Error:
2073 break;
2074 }
2075
2076 // If this is a for loop, we're entering its condition.
2077 ForConditionScope.enter(/*IsConditionVariable=*/true);
2078
2079 // type-specifier-seq
2080 DeclSpec DS(AttrFactory);
2081 DS.takeAttributesFrom(attrs);
2082 ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition);
2083
2084 // declarator
2085 Declarator DeclaratorInfo(DS, DeclaratorContext::Condition);
2086 ParseDeclarator(DeclaratorInfo);
2087
2088 // simple-asm-expr[opt]
2089 if (Tok.is(tok::kw_asm)) {
2090 SourceLocation Loc;
2091 ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc));
2092 if (AsmLabel.isInvalid()) {
2093 SkipUntil(tok::semi, StopAtSemi);
2094 return Sema::ConditionError();
2095 }
2096 DeclaratorInfo.setAsmLabel(AsmLabel.get());
2097 DeclaratorInfo.SetRangeEnd(Loc);
2098 }
2099
2100 // If attributes are present, parse them.
2101 MaybeParseGNUAttributes(DeclaratorInfo);
2102
2103 // Type-check the declaration itself.
2104 DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
2105 DeclaratorInfo);
2106 if (Dcl.isInvalid())
2107 return Sema::ConditionError();
2108 Decl *DeclOut = Dcl.get();
2109
2110 // '=' assignment-expression
2111 // If a '==' or '+=' is found, suggest a fixit to '='.
2112 bool CopyInitialization = isTokenEqualOrEqualTypo();
2113 if (CopyInitialization)
2114 ConsumeToken();
2115
2116 ExprResult InitExpr = ExprError();
2117 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
2118 Diag(Tok.getLocation(),
2119 diag::warn_cxx98_compat_generalized_initializer_lists);
2120 InitExpr = ParseBraceInitializer();
2121 } else if (CopyInitialization) {
2122 PreferredType.enterVariableInit(Tok.getLocation(), DeclOut);
2123 InitExpr = ParseAssignmentExpression();
2124 } else if (Tok.is(tok::l_paren)) {
2125 // This was probably an attempt to initialize the variable.
2126 SourceLocation LParen = ConsumeParen(), RParen = LParen;
2127 if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
2128 RParen = ConsumeParen();
2129 Diag(DeclOut->getLocation(),
2130 diag::err_expected_init_in_condition_lparen)
2131 << SourceRange(LParen, RParen);
2132 } else {
2133 Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
2134 }
2135
2136 if (!InitExpr.isInvalid())
2137 Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
2138 else
2139 Actions.ActOnInitializerError(DeclOut);
2140
2141 Actions.FinalizeDeclaration(DeclOut);
2142 return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
2143}
2144
2145/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
2146/// This should only be called when the current token is known to be part of
2147/// simple-type-specifier.
2148///
2149/// simple-type-specifier:
2150/// '::'[opt] nested-name-specifier[opt] type-name
2151/// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
2152/// char
2153/// wchar_t
2154/// bool
2155/// short
2156/// int
2157/// long
2158/// signed
2159/// unsigned
2160/// float
2161/// double
2162/// void
2163/// [GNU] typeof-specifier
2164/// [C++0x] auto [TODO]
2165///
2166/// type-name:
2167/// class-name
2168/// enum-name
2169/// typedef-name
2170///
2171void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
2172 DS.SetRangeStart(Tok.getLocation());
2173 const char *PrevSpec;
2174 unsigned DiagID;
2175 SourceLocation Loc = Tok.getLocation();
2176 const clang::PrintingPolicy &Policy =
2177 Actions.getASTContext().getPrintingPolicy();
2178
2179 switch (Tok.getKind()) {
2180 case tok::identifier: // foo::bar
2181 case tok::coloncolon: // ::foo::bar
2182 llvm_unreachable("Annotation token should already be formed!")::llvm::llvm_unreachable_internal("Annotation token should already be formed!"
, "clang/lib/Parse/ParseExprCXX.cpp", 2182)
;
2183 default:
2184 llvm_unreachable("Not a simple-type-specifier token!")::llvm::llvm_unreachable_internal("Not a simple-type-specifier token!"
, "clang/lib/Parse/ParseExprCXX.cpp", 2184)
;
2185
2186 // type-name
2187 case tok::annot_typename: {
2188 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
2189 getTypeAnnotation(Tok), Policy);
2190 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2191 ConsumeAnnotationToken();
2192
2193 DS.Finish(Actions, Policy);
2194 return;
2195 }
2196
2197 case tok::kw__ExtInt:
2198 case tok::kw__BitInt: {
2199 DiagnoseBitIntUse(Tok);
2200 ExprResult ER = ParseExtIntegerArgument();
2201 if (ER.isInvalid())
2202 DS.SetTypeSpecError();
2203 else
2204 DS.SetBitIntType(Loc, ER.get(), PrevSpec, DiagID, Policy);
2205
2206 // Do this here because we have already consumed the close paren.
2207 DS.SetRangeEnd(PrevTokLocation);
2208 DS.Finish(Actions, Policy);
2209 return;
2210 }
2211
2212 // builtin types
2213 case tok::kw_short:
2214 DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec, DiagID,
2215 Policy);
2216 break;
2217 case tok::kw_long:
2218 DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec, DiagID,
2219 Policy);
2220 break;
2221 case tok::kw___int64:
2222 DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc, PrevSpec, DiagID,
2223 Policy);
2224 break;
2225 case tok::kw_signed:
2226 DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
2227 break;
2228 case tok::kw_unsigned:
2229 DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec, DiagID);
2230 break;
2231 case tok::kw_void:
2232 DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
2233 break;
2234 case tok::kw_char:
2235 DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
2236 break;
2237 case tok::kw_int:
2238 DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
2239 break;
2240 case tok::kw___int128:
2241 DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
2242 break;
2243 case tok::kw___bf16:
2244 DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec, DiagID, Policy);
2245 break;
2246 case tok::kw_half:
2247 DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
2248 break;
2249 case tok::kw_float:
2250 DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
2251 break;
2252 case tok::kw_double:
2253 DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
2254 break;
2255 case tok::kw__Float16:
2256 DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
2257 break;
2258 case tok::kw___float128:
2259 DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
2260 break;
2261 case tok::kw___ibm128:
2262 DS.SetTypeSpecType(DeclSpec::TST_ibm128, Loc, PrevSpec, DiagID, Policy);
2263 break;
2264 case tok::kw_wchar_t:
2265 DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
2266 break;
2267 case tok::kw_char8_t:
2268 DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec, DiagID, Policy);
2269 break;
2270 case tok::kw_char16_t:
2271 DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
2272 break;
2273 case tok::kw_char32_t:
2274 DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
2275 break;
2276 case tok::kw_bool:
2277 DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
2278 break;
2279#define GENERIC_IMAGE_TYPE(ImgType, Id) \
2280 case tok::kw_##ImgType##_t: \
2281 DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, DiagID, \
2282 Policy); \
2283 break;
2284#include "clang/Basic/OpenCLImageTypes.def"
2285
2286 case tok::annot_decltype:
2287 case tok::kw_decltype:
2288 DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
2289 return DS.Finish(Actions, Policy);
2290
2291 // GNU typeof support.
2292 case tok::kw_typeof:
2293 ParseTypeofSpecifier(DS);
2294 DS.Finish(Actions, Policy);
2295 return;
2296 }
2297 ConsumeAnyToken();
2298 DS.SetRangeEnd(PrevTokLocation);
2299 DS.Finish(Actions, Policy);
2300}
2301
2302/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
2303/// [dcl.name]), which is a non-empty sequence of type-specifiers,
2304/// e.g., "const short int". Note that the DeclSpec is *not* finished
2305/// by parsing the type-specifier-seq, because these sequences are
2306/// typically followed by some form of declarator. Returns true and
2307/// emits diagnostics if this is not a type-specifier-seq, false
2308/// otherwise.
2309///
2310/// type-specifier-seq: [C++ 8.1]
2311/// type-specifier type-specifier-seq[opt]
2312///
2313bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
2314 ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_type_specifier);
2315 DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
2316 return false;
2317}
2318
2319/// Finish parsing a C++ unqualified-id that is a template-id of
2320/// some form.
2321///
2322/// This routine is invoked when a '<' is encountered after an identifier or
2323/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
2324/// whether the unqualified-id is actually a template-id. This routine will
2325/// then parse the template arguments and form the appropriate template-id to
2326/// return to the caller.
2327///
2328/// \param SS the nested-name-specifier that precedes this template-id, if
2329/// we're actually parsing a qualified-id.
2330///
2331/// \param ObjectType if this unqualified-id occurs within a member access
2332/// expression, the type of the base object whose member is being accessed.
2333///
2334/// \param ObjectHadErrors this unqualified-id occurs within a member access
2335/// expression, indicates whether the original subexpressions had any errors.
2336///
2337/// \param Name for constructor and destructor names, this is the actual
2338/// identifier that may be a template-name.
2339///
2340/// \param NameLoc the location of the class-name in a constructor or
2341/// destructor.
2342///
2343/// \param EnteringContext whether we're entering the scope of the
2344/// nested-name-specifier.
2345///
2346/// \param Id as input, describes the template-name or operator-function-id
2347/// that precedes the '<'. If template arguments were parsed successfully,
2348/// will be updated with the template-id.
2349///
2350/// \param AssumeTemplateId When true, this routine will assume that the name
2351/// refers to a template without performing name lookup to verify.
2352///
2353/// \returns true if a parse error occurred, false otherwise.
2354bool Parser::ParseUnqualifiedIdTemplateId(
2355 CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
2356 SourceLocation TemplateKWLoc, IdentifierInfo *Name, SourceLocation NameLoc,
2357 bool EnteringContext, UnqualifiedId &Id, bool AssumeTemplateId) {
2358 assert(Tok.is(tok::less) && "Expected '<' to finish parsing a template-id")(static_cast <bool> (Tok.is(tok::less) && "Expected '<' to finish parsing a template-id"
) ? void (0) : __assert_fail ("Tok.is(tok::less) && \"Expected '<' to finish parsing a template-id\""
, "clang/lib/Parse/ParseExprCXX.cpp", 2358, __extension__ __PRETTY_FUNCTION__
))
;
2359
2360 TemplateTy Template;
2361 TemplateNameKind TNK = TNK_Non_template;
2362 switch (Id.getKind()) {
2363 case UnqualifiedIdKind::IK_Identifier:
2364 case UnqualifiedIdKind::IK_OperatorFunctionId:
2365 case UnqualifiedIdKind::IK_LiteralOperatorId:
2366 if (AssumeTemplateId) {
2367 // We defer the injected-class-name checks until we've found whether
2368 // this template-id is used to form a nested-name-specifier or not.
2369 TNK = Actions.ActOnTemplateName(getCurScope(), SS, TemplateKWLoc, Id,
2370 ObjectType, EnteringContext, Template,
2371 /*AllowInjectedClassName*/ true);
2372 } else {
2373 bool MemberOfUnknownSpecialization;
2374 TNK = Actions.isTemplateName(getCurScope(), SS,
2375 TemplateKWLoc.isValid(), Id,
2376 ObjectType, EnteringContext, Template,
2377 MemberOfUnknownSpecialization);
2378 // If lookup found nothing but we're assuming that this is a template
2379 // name, double-check that makes sense syntactically before committing
2380 // to it.
2381 if (TNK == TNK_Undeclared_template &&
2382 isTemplateArgumentList(0) == TPResult::False)
2383 return false;
2384
2385 if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
2386 ObjectType && isTemplateArgumentList(0) == TPResult::True) {
2387 // If we had errors before, ObjectType can be dependent even without any
2388 // templates, do not report missing template keyword in that case.
2389 if (!ObjectHadErrors) {
2390 // We have something like t->getAs<T>(), where getAs is a
2391 // member of an unknown specialization. However, this will only
2392 // parse correctly as a template, so suggest the keyword 'template'
2393 // before 'getAs' and treat this as a dependent template name.
2394 std::string Name;
2395 if (Id.getKind() == UnqualifiedIdKind::IK_Identifier)
2396 Name = std::string(Id.Identifier->getName());
2397 else {
2398 Name = "operator ";
2399 if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId)
2400 Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
2401 else
2402 Name += Id.Identifier->getName();
2403 }
2404 Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
2405 << Name
2406 << FixItHint::CreateInsertion(Id.StartLocation, "template ");
2407 }
2408 TNK = Actions.ActOnTemplateName(
2409 getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2410 Template, /*AllowInjectedClassName*/ true);
2411 } else if (TNK == TNK_Non_template) {
2412 return false;
2413 }
2414 }
2415 break;
2416
2417 case UnqualifiedIdKind::IK_ConstructorName: {
2418 UnqualifiedId TemplateName;
2419 bool MemberOfUnknownSpecialization;
2420 TemplateName.setIdentifier(Name, NameLoc);
2421 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2422 TemplateName, ObjectType,
2423 EnteringContext, Template,
2424 MemberOfUnknownSpecialization);
2425 if (TNK == TNK_Non_template)
2426 return false;
2427 break;
2428 }
2429
2430 case UnqualifiedIdKind::IK_DestructorName: {
2431 UnqualifiedId TemplateName;
2432 bool MemberOfUnknownSpecialization;
2433 TemplateName.setIdentifier(Name, NameLoc);
2434 if (ObjectType) {
2435 TNK = Actions.ActOnTemplateName(
2436 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2437 EnteringContext, Template, /*AllowInjectedClassName*/ true);
2438 } else {
2439 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2440 TemplateName, ObjectType,
2441 EnteringContext, Template,
2442 MemberOfUnknownSpecialization);
2443
2444 if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
2445 Diag(NameLoc, diag::err_destructor_template_id)
2446 << Name << SS.getRange();
2447 // Carry on to parse the template arguments before bailing out.
2448 }
2449 }
2450 break;
2451 }
2452
2453 default:
2454 return false;
2455 }
2456
2457 // Parse the enclosed template argument list.
2458 SourceLocation LAngleLoc, RAngleLoc;
2459 TemplateArgList TemplateArgs;
2460 if (ParseTemplateIdAfterTemplateName(true, LAngleLoc, TemplateArgs, RAngleLoc,
2461 Template))
2462 return true;
2463
2464 // If this is a non-template, we already issued a diagnostic.
2465 if (TNK == TNK_Non_template)
2466 return true;
2467
2468 if (Id.getKind() == UnqualifiedIdKind::IK_Identifier ||
2469 Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
2470 Id.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) {
2471 // Form a parsed representation of the template-id to be stored in the
2472 // UnqualifiedId.
2473
2474 // FIXME: Store name for literal operator too.
2475 IdentifierInfo *TemplateII =
2476 Id.getKind() == UnqualifiedIdKind::IK_Identifier ? Id.Identifier
2477 : nullptr;
2478 OverloadedOperatorKind OpKind =
2479 Id.getKind() == UnqualifiedIdKind::IK_Identifier
2480 ? OO_None
2481 : Id.OperatorFunctionId.Operator;
2482
2483 TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create(
2484 TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
2485 LAngleLoc, RAngleLoc, TemplateArgs, /*ArgsInvalid*/false, TemplateIds);
2486
2487 Id.setTemplateId(TemplateId);
2488 return false;
2489 }
2490
2491 // Bundle the template arguments together.
2492 ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
2493
2494 // Constructor and destructor names.
2495 TypeResult Type = Actions.ActOnTemplateIdType(
2496 getCurScope(), SS, TemplateKWLoc, Template, Name, NameLoc, LAngleLoc,
2497 TemplateArgsPtr, RAngleLoc, /*IsCtorOrDtorName=*/true);
2498 if (Type.isInvalid())
2499 return true;
2500
2501 if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
2502 Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2503 else
2504 Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2505
2506 return false;
2507}
2508
2509/// Parse an operator-function-id or conversion-function-id as part
2510/// of a C++ unqualified-id.
2511///
2512/// This routine is responsible only for parsing the operator-function-id or
2513/// conversion-function-id; it does not handle template arguments in any way.
2514///
2515/// \code
2516/// operator-function-id: [C++ 13.5]
2517/// 'operator' operator
2518///
2519/// operator: one of
2520/// new delete new[] delete[]
2521/// + - * / % ^ & | ~
2522/// ! = < > += -= *= /= %=
2523/// ^= &= |= << >> >>= <<= == !=
2524/// <= >= && || ++ -- , ->* ->
2525/// () [] <=>
2526///
2527/// conversion-function-id: [C++ 12.3.2]
2528/// operator conversion-type-id
2529///
2530/// conversion-type-id:
2531/// type-specifier-seq conversion-declarator[opt]
2532///
2533/// conversion-declarator:
2534/// ptr-operator conversion-declarator[opt]
2535/// \endcode
2536///
2537/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2538/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2539///
2540/// \param EnteringContext whether we are entering the scope of the
2541/// nested-name-specifier.
2542///
2543/// \param ObjectType if this unqualified-id occurs within a member access
2544/// expression, the type of the base object whose member is being accessed.
2545///
2546/// \param Result on a successful parse, contains the parsed unqualified-id.
2547///
2548/// \returns true if parsing fails, false otherwise.
2549bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2550 ParsedType ObjectType,
2551 UnqualifiedId &Result) {
2552 assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword")(static_cast <bool> (Tok.is(tok::kw_operator) &&
"Expected 'operator' keyword") ? void (0) : __assert_fail ("Tok.is(tok::kw_operator) && \"Expected 'operator' keyword\""
, "clang/lib/Parse/ParseExprCXX.cpp", 2552, __extension__ __PRETTY_FUNCTION__
))
;
2553
2554 // Consume the 'operator' keyword.
2555 SourceLocation KeywordLoc = ConsumeToken();
2556
2557 // Determine what kind of operator name we have.
2558 unsigned SymbolIdx = 0;
2559 SourceLocation SymbolLocations[3];
2560 OverloadedOperatorKind Op = OO_None;
2561 switch (Tok.getKind()) {
2562 case tok::kw_new:
2563 case tok::kw_delete: {
2564 bool isNew = Tok.getKind() == tok::kw_new;
2565 // Consume the 'new' or 'delete'.
2566 SymbolLocations[SymbolIdx++] = ConsumeToken();
2567 // Check for array new/delete.
2568 if (Tok.is(tok::l_square) &&
2569 (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
2570 // Consume the '[' and ']'.
2571 BalancedDelimiterTracker T(*this, tok::l_square);
2572 T.consumeOpen();
2573 T.consumeClose();
2574 if (T.getCloseLocation().isInvalid())
2575 return true;
2576
2577 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2578 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2579 Op = isNew? OO_Array_New : OO_Array_Delete;
2580 } else {
2581 Op = isNew? OO_New : OO_Delete;
2582 }
2583 break;
2584 }
2585
2586#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2587 case tok::Token: \
2588 SymbolLocations[SymbolIdx++] = ConsumeToken(); \
2589 Op = OO_##Name; \
2590 break;
2591#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2592#include "clang/Basic/OperatorKinds.def"
2593
2594 case tok::l_paren: {
2595 // Consume the '(' and ')'.
2596 BalancedDelimiterTracker T(*this, tok::l_paren);
2597 T.consumeOpen();
2598 T.consumeClose();
2599 if (T.getCloseLocation().isInvalid())
2600 return true;
2601
2602 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2603 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2604 Op = OO_Call;
2605 break;
2606 }
2607
2608 case tok::l_square: {
2609 // Consume the '[' and ']'.
2610 BalancedDelimiterTracker T(*this, tok::l_square);
2611 T.consumeOpen();
2612 T.consumeClose();
2613 if (T.getCloseLocation().isInvalid())
2614 return true;
2615
2616 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2617 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2618 Op = OO_Subscript;
2619 break;
2620 }
2621
2622 case tok::code_completion: {
2623 // Don't try to parse any further.
2624 cutOffParsing();
2625 // Code completion for the operator name.
2626 Actions.CodeCompleteOperatorName(getCurScope());
2627 return true;
2628 }
2629
2630 default:
2631 break;
2632 }
2633
2634 if (Op != OO_None) {
2635 // We have parsed an operator-function-id.
2636 Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2637 return false;
2638 }
2639
2640 // Parse a literal-operator-id.
2641 //
2642 // literal-operator-id: C++11 [over.literal]
2643 // operator string-literal identifier
2644 // operator user-defined-string-literal
2645
2646 if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
2647 Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
2648
2649 SourceLocation DiagLoc;
2650 unsigned DiagId = 0;
2651
2652 // We're past translation phase 6, so perform string literal concatenation
2653 // before checking for "".
2654 SmallVector<Token, 4> Toks;
2655 SmallVector<SourceLocation, 4> TokLocs;
2656 while (isTokenStringLiteral()) {
2657 if (!Tok.is(tok::string_literal) && !DiagId) {
2658 // C++11 [over.literal]p1:
2659 // The string-literal or user-defined-string-literal in a
2660 // literal-operator-id shall have no encoding-prefix [...].
2661 DiagLoc = Tok.getLocation();
2662 DiagId = diag::err_literal_operator_string_prefix;
2663 }
2664 Toks.push_back(Tok);
2665 TokLocs.push_back(ConsumeStringToken());
2666 }
2667
2668 StringLiteralParser Literal(Toks, PP);
2669 if (Literal.hadError)
2670 return true;
2671
2672 // Grab the literal operator's suffix, which will be either the next token
2673 // or a ud-suffix from the string literal.
2674 bool IsUDSuffix = !Literal.getUDSuffix().empty();
2675 IdentifierInfo *II = nullptr;
2676 SourceLocation SuffixLoc;
2677 if (IsUDSuffix) {
2678 II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2679 SuffixLoc =
2680 Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
2681 Literal.getUDSuffixOffset(),
2682 PP.getSourceManager(), getLangOpts());
2683 } else if (Tok.is(tok::identifier)) {
2684 II = Tok.getIdentifierInfo();
2685 SuffixLoc = ConsumeToken();
2686 TokLocs.push_back(SuffixLoc);
2687 } else {
2688 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
2689 return true;
2690 }
2691
2692 // The string literal must be empty.
2693 if (!Literal.GetString().empty() || Literal.Pascal) {
2694 // C++11 [over.literal]p1:
2695 // The string-literal or user-defined-string-literal in a
2696 // literal-operator-id shall [...] contain no characters
2697 // other than the implicit terminating '\0'.
2698 DiagLoc = TokLocs.front();
2699 DiagId = diag::err_literal_operator_string_not_empty;
2700 }
2701
2702 if (DiagId) {
2703 // This isn't a valid literal-operator-id, but we think we know
2704 // what the user meant. Tell them what they should have written.
2705 SmallString<32> Str;
2706 Str += "\"\"";
2707 Str += II->getName();
2708 Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2709 SourceRange(TokLocs.front(), TokLocs.back()), Str);
2710 }
2711
2712 Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
2713
2714 return Actions.checkLiteralOperatorId(SS, Result, IsUDSuffix);
2715 }
2716
2717 // Parse a conversion-function-id.
2718 //
2719 // conversion-function-id: [C++ 12.3.2]
2720 // operator conversion-type-id
2721 //
2722 // conversion-type-id:
2723 // type-specifier-seq conversion-declarator[opt]
2724 //
2725 // conversion-declarator:
2726 // ptr-operator conversion-declarator[opt]
2727
2728 // Parse the type-specifier-seq.
2729 DeclSpec DS(AttrFactory);
2730 if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
2731 return true;
2732
2733 // Parse the conversion-declarator, which is merely a sequence of
2734 // ptr-operators.
2735 Declarator D(DS, DeclaratorContext::ConversionId);
2736 ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2737
2738 // Finish up the type.
2739 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
2740 if (Ty.isInvalid())
2741 return true;
2742
2743 // Note that this is a conversion-function-id.
2744 Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2745 D.getSourceRange().getEnd());
2746 return false;
2747}
2748
2749/// Parse a C++ unqualified-id (or a C identifier), which describes the
2750/// name of an entity.
2751///
2752/// \code
2753/// unqualified-id: [C++ expr.prim.general]
2754/// identifier
2755/// operator-function-id
2756/// conversion-function-id
2757/// [C++0x] literal-operator-id [TODO]
2758/// ~ class-name
2759/// template-id
2760///
2761/// \endcode
2762///
2763/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2764/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2765///
2766/// \param ObjectType if this unqualified-id occurs within a member access
2767/// expression, the type of the base object whose member is being accessed.
2768///
2769/// \param ObjectHadErrors if this unqualified-id occurs within a member access
2770/// expression, indicates whether the original subexpressions had any errors.
2771/// When true, diagnostics for missing 'template' keyword will be supressed.
2772///
2773/// \param EnteringContext whether we are entering the scope of the
2774/// nested-name-specifier.
2775///
2776/// \param AllowDestructorName whether we allow parsing of a destructor name.
2777///
2778/// \param AllowConstructorName whether we allow parsing a constructor name.
2779///
2780/// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2781///
2782/// \param Result on a successful parse, contains the parsed unqualified-id.
2783///
2784/// \returns true if parsing fails, false otherwise.
2785bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType,
2786 bool ObjectHadErrors, bool EnteringContext,
2787 bool AllowDestructorName,
2788 bool AllowConstructorName,
2789 bool AllowDeductionGuide,
2790 SourceLocation *TemplateKWLoc,
2791 UnqualifiedId &Result) {
2792 if (TemplateKWLoc)
2793 *TemplateKWLoc = SourceLocation();
2794
2795 // Handle 'A::template B'. This is for template-ids which have not
2796 // already been annotated by ParseOptionalCXXScopeSpecifier().
2797 bool TemplateSpecified = false;
2798 if (Tok.is(tok::kw_template)) {
2799 if (TemplateKWLoc && (ObjectType || SS.isSet())) {
2800 TemplateSpecified = true;
2801 *TemplateKWLoc = ConsumeToken();
2802 } else {
2803 SourceLocation TemplateLoc = ConsumeToken();
2804 Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
2805 << FixItHint::CreateRemoval(TemplateLoc);
2806 }
2807 }
2808
2809 // unqualified-id:
2810 // identifier
2811 // template-id (when it hasn't already been annotated)
2812 if (Tok.is(tok::identifier)) {
2813 // Consume the identifier.
2814 IdentifierInfo *Id = Tok.getIdentifierInfo();
2815 SourceLocation IdLoc = ConsumeToken();
2816
2817 if (!getLangOpts().CPlusPlus) {
2818 // If we're not in C++, only identifiers matter. Record the
2819 // identifier and return.
2820 Result.setIdentifier(Id, IdLoc);
2821 return false;
2822 }
2823
2824 ParsedTemplateTy TemplateName;
2825 if (AllowConstructorName &&
2826 Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
2827 // We have parsed a constructor name.
2828 ParsedType Ty = Actions.getConstructorName(*Id, IdLoc, getCurScope(), SS,
2829 EnteringContext);
2830 if (!Ty)
2831 return true;
2832 Result.setConstructorName(Ty, IdLoc, IdLoc);
2833 } else if (getLangOpts().CPlusPlus17 &&
2834 AllowDeductionGuide && SS.isEmpty() &&
2835 Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
2836 &TemplateName)) {
2837 // We have parsed a template-name naming a deduction guide.
2838 Result.setDeductionGuideName(TemplateName, IdLoc);
2839 } else {
2840 // We have parsed an identifier.
2841 Result.setIdentifier(Id, IdLoc);
2842 }
2843
2844 // If the next token is a '<', we may have a template.
2845 TemplateTy Template;
2846 if (Tok.is(tok::less))
2847 return ParseUnqualifiedIdTemplateId(
2848 SS, ObjectType, ObjectHadErrors,
2849 TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), Id, IdLoc,
2850 EnteringContext, Result, TemplateSpecified);
2851 else if (TemplateSpecified &&
2852 Actions.ActOnTemplateName(
2853 getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
2854 EnteringContext, Template,
2855 /*AllowInjectedClassName*/ true) == TNK_Non_template)
2856 return true;
2857
2858 return false;
2859 }
2860
2861 // unqualified-id:
2862 // template-id (already parsed and annotated)
2863 if (Tok.is(tok::annot_template_id)) {
2864 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2865
2866 // FIXME: Consider passing invalid template-ids on to callers; they may
2867 // be able to recover better than we can.
2868 if (TemplateId->isInvalid()) {
2869 ConsumeAnnotationToken();
2870 return true;
2871 }
2872
2873 // If the template-name names the current class, then this is a constructor
2874 if (AllowConstructorName && TemplateId->Name &&
2875 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2876 if (SS.isSet()) {
2877 // C++ [class.qual]p2 specifies that a qualified template-name
2878 // is taken as the constructor name where a constructor can be
2879 // declared. Thus, the template arguments are extraneous, so
2880 // complain about them and remove them entirely.
2881 Diag(TemplateId->TemplateNameLoc,
2882 diag::err_out_of_line_constructor_template_id)
2883 << TemplateId->Name
2884 << FixItHint::CreateRemoval(
2885 SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2886 ParsedType Ty = Actions.getConstructorName(
2887 *TemplateId->Name, TemplateId->TemplateNameLoc, getCurScope(), SS,
2888 EnteringContext);
2889 if (!Ty)
2890 return true;
2891 Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2892 TemplateId->RAngleLoc);
2893 ConsumeAnnotationToken();
2894 return false;
2895 }
2896
2897 Result.setConstructorTemplateId(TemplateId);
2898 ConsumeAnnotationToken();
2899 return false;
2900 }
2901
2902 // We have already parsed a template-id; consume the annotation token as
2903 // our unqualified-id.
2904 Result.setTemplateId(TemplateId);
2905 SourceLocation TemplateLoc = TemplateId->TemplateKWLoc;
2906 if (TemplateLoc.isValid()) {
2907 if (TemplateKWLoc && (ObjectType || SS.isSet()))
2908 *TemplateKWLoc = TemplateLoc;
2909 else
2910 Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
2911 << FixItHint::CreateRemoval(TemplateLoc);
2912 }
2913 ConsumeAnnotationToken();
2914 return false;
2915 }
2916
2917 // unqualified-id:
2918 // operator-function-id
2919 // conversion-function-id
2920 if (Tok.is(tok::kw_operator)) {
2921 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2922 return true;
2923
2924 // If we have an operator-function-id or a literal-operator-id and the next
2925 // token is a '<', we may have a
2926 //
2927 // template-id:
2928 // operator-function-id < template-argument-list[opt] >
2929 TemplateTy Template;
2930 if ((Result.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
2931 Result.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) &&
2932 Tok.is(tok::less))
2933 return ParseUnqualifiedIdTemplateId(
2934 SS, ObjectType, ObjectHadErrors,
2935 TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), nullptr,
2936 SourceLocation(), EnteringContext, Result, TemplateSpecified);
2937 else if (TemplateSpecified &&
2938 Actions.ActOnTemplateName(
2939 getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
2940 EnteringContext, Template,
2941 /*AllowInjectedClassName*/ true) == TNK_Non_template)
2942 return true;
2943
2944 return false;
2945 }
2946
2947 if (getLangOpts().CPlusPlus &&
2948 (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
2949 // C++ [expr.unary.op]p10:
2950 // There is an ambiguity in the unary-expression ~X(), where X is a
2951 // class-name. The ambiguity is resolved in favor of treating ~ as a
2952 // unary complement rather than treating ~X as referring to a destructor.
2953
2954 // Parse the '~'.
2955 SourceLocation TildeLoc = ConsumeToken();
2956
2957 if (TemplateSpecified) {
2958 // C++ [temp.names]p3:
2959 // A name prefixed by the keyword template shall be a template-id [...]
2960 //
2961 // A template-id cannot begin with a '~' token. This would never work
2962 // anyway: x.~A<int>() would specify that the destructor is a template,
2963 // not that 'A' is a template.
2964 //
2965 // FIXME: Suggest replacing the attempted destructor name with a correct
2966 // destructor name and recover. (This is not trivial if this would become
2967 // a pseudo-destructor name).
2968 Diag(*TemplateKWLoc, diag::err_unexpected_template_in_destructor_name)
2969 << Tok.getLocation();
2970 return true;
2971 }
2972
2973 if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2974 DeclSpec DS(AttrFactory);
2975 SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2976 if (ParsedType Type =
2977 Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
2978 Result.setDestructorName(TildeLoc, Type, EndLoc);
2979 return false;
2980 }
2981 return true;
2982 }
2983
2984 // Parse the class-name.
2985 if (Tok.isNot(tok::identifier)) {
2986 Diag(Tok, diag::err_destructor_tilde_identifier);
2987 return true;
2988 }
2989
2990 // If the user wrote ~T::T, correct it to T::~T.
2991 DeclaratorScopeObj DeclScopeObj(*this, SS);
2992 if (NextToken().is(tok::coloncolon)) {
2993 // Don't let ParseOptionalCXXScopeSpecifier() "correct"
2994 // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
2995 // it will confuse this recovery logic.
2996 ColonProtectionRAIIObject ColonRAII(*this, false);
2997
2998 if (SS.isSet()) {
2999 AnnotateScopeToken(SS, /*NewAnnotation*/true);
3000 SS.clear();
3001 }
3002 if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, ObjectHadErrors,
3003 EnteringContext))
3004 return true;
3005 if (SS.isNotEmpty())
3006 ObjectType = nullptr;
3007 if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
3008 !SS.isSet()) {
3009 Diag(TildeLoc, diag::err_destructor_tilde_scope);
3010 return true;
3011 }
3012
3013 // Recover as if the tilde had been written before the identifier.
3014 Diag(TildeLoc, diag::err_destructor_tilde_scope)
3015 << FixItHint::CreateRemoval(TildeLoc)
3016 << FixItHint::CreateInsertion(Tok.getLocation(), "~");
3017
3018 // Temporarily enter the scope for the rest of this function.
3019 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
3020 DeclScopeObj.EnterDeclaratorScope();
3021 }
3022
3023 // Parse the class-name (or template-name in a simple-template-id).
3024 IdentifierInfo *ClassName = Tok.getIdentifierInfo();
3025 SourceLocation ClassNameLoc = ConsumeToken();
3026
3027 if (Tok.is(tok::less)) {
3028 Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
3029 return ParseUnqualifiedIdTemplateId(
3030 SS, ObjectType, ObjectHadErrors,
3031 TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), ClassName,
3032 ClassNameLoc, EnteringContext, Result, TemplateSpecified);
3033 }
3034
3035 // Note that this is a destructor name.
3036 ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
3037 ClassNameLoc, getCurScope(),
3038 SS, ObjectType,
3039 EnteringContext);
3040 if (!Ty)
3041 return true;
3042
3043 Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
3044 return false;
3045 }
3046
3047 Diag(Tok, diag::err_expected_unqualified_id)
3048 << getLangOpts().CPlusPlus;
3049 return true;
3050}
3051
3052/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
3053/// memory in a typesafe manner and call constructors.
3054///
3055/// This method is called to parse the new expression after the optional :: has
3056/// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
3057/// is its location. Otherwise, "Start" is the location of the 'new' token.
3058///
3059/// new-expression:
3060/// '::'[opt] 'new' new-placement[opt] new-type-id
3061/// new-initializer[opt]
3062/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3063/// new-initializer[opt]
3064///
3065/// new-placement:
3066/// '(' expression-list ')'
3067///
3068/// new-type-id:
3069/// type-specifier-seq new-declarator[opt]
3070/// [GNU] attributes type-specifier-seq new-declarator[opt]
3071///
3072/// new-declarator:
3073/// ptr-operator new-declarator[opt]
3074/// direct-new-declarator
3075///
3076/// new-initializer:
3077/// '(' expression-list[opt] ')'
3078/// [C++0x] braced-init-list
3079///
3080ExprResult
3081Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
3082 assert(Tok.is(tok::kw_new) && "expected 'new' token")(static_cast <bool> (Tok.is(tok::kw_new) && "expected 'new' token"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_new) && \"expected 'new' token\""
, "clang/lib/Parse/ParseExprCXX.cpp", 3082, __extension__ __PRETTY_FUNCTION__
))
;
3083 ConsumeToken(); // Consume 'new'
3084
3085 // A '(' now can be a new-placement or the '(' wrapping the type-id in the
3086 // second form of new-expression. It can't be a new-type-id.
3087
3088 ExprVector PlacementArgs;
3089 SourceLocation PlacementLParen, PlacementRParen;
3090
3091 SourceRange TypeIdParens;
3092 DeclSpec DS(AttrFactory);
3093 Declarator DeclaratorInfo(DS, DeclaratorContext::CXXNew);
3094 if (Tok.is(tok::l_paren)) {
3095 // If it turns out to be a placement, we change the type location.
3096 BalancedDelimiterTracker T(*this, tok::l_paren);
3097 T.consumeOpen();
3098 PlacementLParen = T.getOpenLocation();
3099 if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
3100 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3101 return ExprError();
3102 }
3103
3104 T.consumeClose();
3105 PlacementRParen = T.getCloseLocation();
3106 if (PlacementRParen.isInvalid()) {
3107 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3108 return ExprError();
3109 }
3110
3111 if (PlacementArgs.empty()) {
3112 // Reset the placement locations. There was no placement.
3113 TypeIdParens = T.getRange();
3114 PlacementLParen = PlacementRParen = SourceLocation();
3115 } else {
3116 // We still need the type.
3117 if (Tok.is(tok::l_paren)) {
3118 BalancedDelimiterTracker T(*this, tok::l_paren);
3119 T.consumeOpen();
3120 MaybeParseGNUAttributes(DeclaratorInfo);
3121 ParseSpecifierQualifierList(DS);
3122 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3123 ParseDeclarator(DeclaratorInfo);
3124 T.consumeClose();
3125 TypeIdParens = T.getRange();
3126 } else {
3127 MaybeParseGNUAttributes(DeclaratorInfo);
3128 if (ParseCXXTypeSpecifierSeq(DS))
3129 DeclaratorInfo.setInvalidType(true);
3130 else {
3131 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3132 ParseDeclaratorInternal(DeclaratorInfo,
3133 &Parser::ParseDirectNewDeclarator);
3134 }
3135 }
3136 }
3137 } else {
3138 // A new-type-id is a simplified type-id, where essentially the
3139 // direct-declarator is replaced by a direct-new-declarator.
3140 MaybeParseGNUAttributes(DeclaratorInfo);
3141 if (ParseCXXTypeSpecifierSeq(DS))
3142 DeclaratorInfo.setInvalidType(true);
3143 else {
3144 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3145 ParseDeclaratorInternal(DeclaratorInfo,
3146 &Parser::ParseDirectNewDeclarator);
3147 }
3148 }
3149 if (DeclaratorInfo.isInvalidType()) {
3150 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3151 return ExprError();
3152 }
3153
3154 ExprResult Initializer;
3155
3156 if (Tok.is(tok::l_paren)) {
3157 SourceLocation ConstructorLParen, ConstructorRParen;
3158 ExprVector ConstructorArgs;
3159 BalancedDelimiterTracker T(*this, tok::l_paren);
3160 T.consumeOpen();
3161 ConstructorLParen = T.getOpenLocation();
3162 if (Tok.isNot(tok::r_paren)) {
3163 CommaLocsTy CommaLocs;
3164 auto RunSignatureHelp = [&]() {
3165 ParsedType TypeRep =
3166 Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
3167 QualType PreferredType;
3168 // ActOnTypeName might adjust DeclaratorInfo and return a null type even
3169 // the passing DeclaratorInfo is valid, e.g. running SignatureHelp on
3170 // `new decltype(invalid) (^)`.
3171 if (TypeRep)
3172 PreferredType = Actions.ProduceConstructorSignatureHelp(
3173 TypeRep.get()->getCanonicalTypeInternal(),
3174 DeclaratorInfo.getEndLoc(), ConstructorArgs, ConstructorLParen,
3175 /*Braced=*/false);
3176 CalledSignatureHelp = true;
3177 return PreferredType;
3178 };
3179 if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
3180 PreferredType.enterFunctionArgument(Tok.getLocation(),
3181 RunSignatureHelp);
3182 })) {
3183 if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
3184 RunSignatureHelp();
3185 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3186 return ExprError();
3187 }
3188 }
3189 T.consumeClose();
3190 ConstructorRParen = T.getCloseLocation();
3191 if (ConstructorRParen.isInvalid()) {
3192 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3193 return ExprError();
3194 }
3195 Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
3196 ConstructorRParen,
3197 ConstructorArgs);
3198 } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
3199 Diag(Tok.getLocation(),
3200 diag::warn_cxx98_compat_generalized_initializer_lists);
3201 Initializer = ParseBraceInitializer();
3202 }
3203 if (Initializer.isInvalid())
3204 return Initializer;
3205
3206 return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
3207 PlacementArgs, PlacementRParen,
3208 TypeIdParens, DeclaratorInfo, Initializer.get());
3209}
3210
3211/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
3212/// passed to ParseDeclaratorInternal.
3213///
3214/// direct-new-declarator:
3215/// '[' expression[opt] ']'
3216/// direct-new-declarator '[' constant-expression ']'
3217///
3218void Parser::ParseDirectNewDeclarator(Declarator &D) {
3219 // Parse the array dimensions.
3220 bool First = true;
3221 while (Tok.is(tok::l_square)) {
3222 // An array-size expression can't start with a lambda.
3223 if (CheckProhibitedCXX11Attribute())
3224 continue;
3225
3226 BalancedDelimiterTracker T(*this, tok::l_square);
3227 T.consumeOpen();
3228
3229 ExprResult Size =
3230 First ? (Tok.is(tok::r_square) ? ExprResult() : ParseExpression())
3231 : ParseConstantExpression();
3232 if (Size.isInvalid()) {
3233 // Recover
3234 SkipUntil(tok::r_square, StopAtSemi);
3235 return;
3236 }
3237 First = false;
3238
3239 T.consumeClose();
3240
3241 // Attributes here appertain to the array type. C++11 [expr.new]p5.
3242 ParsedAttributes Attrs(AttrFactory);
3243 MaybeParseCXX11Attributes(Attrs);
3244
3245 D.AddTypeInfo(DeclaratorChunk::getArray(0,
3246 /*isStatic=*/false, /*isStar=*/false,
3247 Size.get(), T.getOpenLocation(),
3248 T.getCloseLocation()),
3249 std::move(Attrs), T.getCloseLocation());
3250
3251 if (T.getCloseLocation().isInvalid())
3252 return;
3253 }
3254}
3255
3256/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
3257/// This ambiguity appears in the syntax of the C++ new operator.
3258///
3259/// new-expression:
3260/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3261/// new-initializer[opt]
3262///
3263/// new-placement:
3264/// '(' expression-list ')'
3265///
3266bool Parser::ParseExpressionListOrTypeId(
3267 SmallVectorImpl<Expr*> &PlacementArgs,
3268 Declarator &D) {
3269 // The '(' was already consumed.
3270 if (isTypeIdInParens()) {
3271 ParseSpecifierQualifierList(D.getMutableDeclSpec());
3272 D.SetSourceRange(D.getDeclSpec().getSourceRange());
3273 ParseDeclarator(D);
3274 return D.isInvalidType();
3275 }
3276
3277 // It's not a type, it has to be an expression list.
3278 // Discard the comma locations - ActOnCXXNew has enough parameters.
3279 CommaLocsTy CommaLocs;
3280 return ParseExpressionList(PlacementArgs, CommaLocs);
3281}
3282
3283/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
3284/// to free memory allocated by new.
3285///
3286/// This method is called to parse the 'delete' expression after the optional
3287/// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
3288/// and "Start" is its location. Otherwise, "Start" is the location of the
3289/// 'delete' token.
3290///
3291/// delete-expression:
3292/// '::'[opt] 'delete' cast-expression
3293/// '::'[opt] 'delete' '[' ']' cast-expression
3294ExprResult
3295Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
3296 assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword")(static_cast <bool> (Tok.is(tok::kw_delete) && "Expected 'delete' keyword"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_delete) && \"Expected 'delete' keyword\""
, "clang/lib/Parse/ParseExprCXX.cpp", 3296, __extension__ __PRETTY_FUNCTION__
))
;
3297 ConsumeToken(); // Consume 'delete'
3298
3299 // Array delete?
3300 bool ArrayDelete = false;
3301 if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
3302 // C++11 [expr.delete]p1:
3303 // Whenever the delete keyword is followed by empty square brackets, it
3304 // shall be interpreted as [array delete].
3305 // [Footnote: A lambda expression with a lambda-introducer that consists
3306 // of empty square brackets can follow the delete keyword if
3307 // the lambda expression is enclosed in parentheses.]
3308
3309 const Token Next = GetLookAheadToken(2);
3310
3311 // Basic lookahead to check if we have a lambda expression.
3312 if (Next.isOneOf(tok::l_brace, tok::less) ||
3313 (Next.is(tok::l_paren) &&
3314 (GetLookAheadToken(3).is(tok::r_paren) ||
3315 (GetLookAheadToken(3).is(tok::identifier) &&
3316 GetLookAheadToken(4).is(tok::identifier))))) {
3317 TentativeParsingAction TPA(*this);
3318 SourceLocation LSquareLoc = Tok.getLocation();
3319 SourceLocation RSquareLoc = NextToken().getLocation();
3320
3321 // SkipUntil can't skip pairs of </*...*/>; don't emit a FixIt in this
3322 // case.
3323 SkipUntil({tok::l_brace, tok::less}, StopBeforeMatch);
3324 SourceLocation RBraceLoc;
3325 bool EmitFixIt = false;
3326 if (Tok.is(tok::l_brace)) {
3327 ConsumeBrace();
3328 SkipUntil(tok::r_brace, StopBeforeMatch);
3329 RBraceLoc = Tok.getLocation();
3330 EmitFixIt = true;
3331 }
3332
3333 TPA.Revert();
3334
3335 if (EmitFixIt)
3336 Diag(Start, diag::err_lambda_after_delete)
3337 << SourceRange(Start, RSquareLoc)
3338 << FixItHint::CreateInsertion(LSquareLoc, "(")
3339 << FixItHint::CreateInsertion(
3340 Lexer::getLocForEndOfToken(
3341 RBraceLoc, 0, Actions.getSourceManager(), getLangOpts()),
3342 ")");
3343 else
3344 Diag(Start, diag::err_lambda_after_delete)
3345 << SourceRange(Start, RSquareLoc);
3346
3347 // Warn that the non-capturing lambda isn't surrounded by parentheses
3348 // to disambiguate it from 'delete[]'.
3349 ExprResult Lambda = ParseLambdaExpression();
3350 if (Lambda.isInvalid())
3351 return ExprError();
3352
3353 // Evaluate any postfix expressions used on the lambda.
3354 Lambda = ParsePostfixExpressionSuffix(Lambda);
3355 if (Lambda.isInvalid())
3356 return ExprError();
3357 return Actions.ActOnCXXDelete(Start, UseGlobal, /*ArrayForm=*/false,
3358 Lambda.get());
3359 }
3360
3361 ArrayDelete = true;
3362 BalancedDelimiterTracker T(*this, tok::l_square);
3363
3364 T.consumeOpen();
3365 T.consumeClose();
3366 if (T.getCloseLocation().isInvalid())
3367 return ExprError();
3368 }
3369
3370 ExprResult Operand(ParseCastExpression(AnyCastExpr));
3371 if (Operand.isInvalid())
3372 return Operand;
3373
3374 return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
3375}
3376
3377/// ParseRequiresExpression - Parse a C++2a requires-expression.
3378/// C++2a [expr.prim.req]p1
3379/// A requires-expression provides a concise way to express requirements on
3380/// template arguments. A requirement is one that can be checked by name
3381/// lookup (6.4) or by checking properties of types and expressions.
3382///
3383/// requires-expression:
3384/// 'requires' requirement-parameter-list[opt] requirement-body
3385///
3386/// requirement-parameter-list:
3387/// '(' parameter-declaration-clause[opt] ')'
3388///
3389/// requirement-body:
3390/// '{' requirement-seq '}'
3391///
3392/// requirement-seq:
3393/// requirement
3394/// requirement-seq requirement
3395///
3396/// requirement:
3397/// simple-requirement
3398/// type-requirement
3399/// compound-requirement
3400/// nested-requirement
3401ExprResult Parser::ParseRequiresExpression() {
3402 assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword")(static_cast <bool> (Tok.is(tok::kw_requires) &&
"Expected 'requires' keyword") ? void (0) : __assert_fail ("Tok.is(tok::kw_requires) && \"Expected 'requires' keyword\""
, "clang/lib/Parse/ParseExprCXX.cpp", 3402, __extension__ __PRETTY_FUNCTION__
))
;
3403 SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires'
3404
3405 llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls;
3406 if (Tok.is(tok::l_paren)) {
3407 // requirement parameter list is present.
3408 ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope |
3409 Scope::DeclScope);
3410 BalancedDelimiterTracker Parens(*this, tok::l_paren);
3411 Parens.consumeOpen();
3412 if (!Tok.is(tok::r_paren)) {
3413 ParsedAttributes FirstArgAttrs(getAttrFactory());
3414 SourceLocation EllipsisLoc;
3415 llvm::SmallVector<DeclaratorChunk::ParamInfo, 2> LocalParameters;
3416 ParseParameterDeclarationClause(DeclaratorContext::RequiresExpr,
3417 FirstArgAttrs, LocalParameters,
3418 EllipsisLoc);
3419 if (EllipsisLoc.isValid())
3420 Diag(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis);
3421 for (auto &ParamInfo : LocalParameters)
3422 LocalParameterDecls.push_back(cast<ParmVarDecl>(ParamInfo.Param));
3423 }
3424 Parens.consumeClose();
3425 }
3426
3427 BalancedDelimiterTracker Braces(*this, tok::l_brace);
3428 if (Braces.expectAndConsume())
3429 return ExprError();
3430
3431 // Start of requirement list
3432 llvm::SmallVector<concepts::Requirement *, 2> Requirements;
3433
3434 // C++2a [expr.prim.req]p2
3435 // Expressions appearing within a requirement-body are unevaluated operands.
3436 EnterExpressionEvaluationContext Ctx(
3437 Actions, Sema::ExpressionEvaluationContext::Unevaluated);
3438
3439 ParseScope BodyScope(this, Scope::DeclScope);
3440 RequiresExprBodyDecl *Body = Actions.ActOnStartRequiresExpr(
3441 RequiresKWLoc, LocalParameterDecls, getCurScope());
3442
3443 if (Tok.is(tok::r_brace)) {
3444 // Grammar does not allow an empty body.
3445 // requirement-body:
3446 // { requirement-seq }
3447 // requirement-seq:
3448 // requirement
3449 // requirement-seq requirement
3450 Diag(Tok, diag::err_empty_requires_expr);
3451 // Continue anyway and produce a requires expr with no requirements.
3452 } else {
3453 while (!Tok.is(tok::r_brace)) {
3454 switch (Tok.getKind()) {
3455 case tok::l_brace: {
3456 // Compound requirement
3457 // C++ [expr.prim.req.compound]
3458 // compound-requirement:
3459 // '{' expression '}' 'noexcept'[opt]
3460 // return-type-requirement[opt] ';'
3461 // return-type-requirement:
3462 // trailing-return-type
3463 // '->' cv-qualifier-seq[opt] constrained-parameter
3464 // cv-qualifier-seq[opt] abstract-declarator[opt]
3465 BalancedDelimiterTracker ExprBraces(*this, tok::l_brace);
3466 ExprBraces.consumeOpen();
3467 ExprResult Expression =
3468 Actions.CorrectDelayedTyposInExpr(ParseExpression());
3469 if (!Expression.isUsable()) {
3470 ExprBraces.skipToEnd();
3471 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3472 break;
3473 }
3474 if (ExprBraces.consumeClose())
3475 ExprBraces.skipToEnd();
3476
3477 concepts::Requirement *Req = nullptr;
3478 SourceLocation NoexceptLoc;
3479 TryConsumeToken(tok::kw_noexcept, NoexceptLoc);
3480 if (Tok.is(tok::semi)) {
3481 Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc);
3482 if (Req)
3483 Requirements.push_back(Req);
3484 break;
3485 }
3486 if (!TryConsumeToken(tok::arrow))
3487 // User probably forgot the arrow, remind them and try to continue.
3488 Diag(Tok, diag::err_requires_expr_missing_arrow)
3489 << FixItHint::CreateInsertion(Tok.getLocation(), "->");
3490 // Try to parse a 'type-constraint'
3491 if (TryAnnotateTypeConstraint()) {
3492 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3493 break;
3494 }
3495 if (!isTypeConstraintAnnotation()) {
3496 Diag(Tok, diag::err_requires_expr_expected_type_constraint);
3497 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3498 break;
3499 }
3500 CXXScopeSpec SS;
3501 if (Tok.is(tok::annot_cxxscope)) {
3502 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
3503 Tok.getAnnotationRange(),
3504 SS);
3505 ConsumeAnnotationToken();
3506 }
3507
3508 Req = Actions.ActOnCompoundRequirement(
3509 Expression.get(), NoexceptLoc, SS, takeTemplateIdAnnotation(Tok),
3510 TemplateParameterDepth);
3511 ConsumeAnnotationToken();
3512 if (Req)
3513 Requirements.push_back(Req);
3514 break;
3515 }
3516 default: {
3517 bool PossibleRequiresExprInSimpleRequirement = false;
3518 if (Tok.is(tok::kw_requires)) {
3519 auto IsNestedRequirement = [&] {
3520 RevertingTentativeParsingAction TPA(*this);
3521 ConsumeToken(); // 'requires'
3522 if (Tok.is(tok::l_brace))
3523 // This is a requires expression
3524 // requires (T t) {
3525 // requires { t++; };
3526 // ... ^
3527 // }
3528 return false;
3529 if (Tok.is(tok::l_paren)) {
3530 // This might be the parameter list of a requires expression
3531 ConsumeParen();
3532 auto Res = TryParseParameterDeclarationClause();
3533 if (Res != TPResult::False) {
3534 // Skip to the closing parenthesis
3535 // FIXME: Don't traverse these tokens twice (here and in
3536 // TryParseParameterDeclarationClause).
3537 unsigned Depth = 1;
3538 while (Depth != 0) {
3539 if (Tok.is(tok::l_paren))
3540 Depth++;
3541 else if (Tok.is(tok::r_paren))
3542 Depth--;
3543 ConsumeAnyToken();
3544 }
3545 // requires (T t) {
3546 // requires () ?
3547 // ... ^
3548 // - OR -
3549 // requires (int x) ?
3550 // ... ^
3551 // }
3552 if (Tok.is(tok::l_brace))
3553 // requires (...) {
3554 // ^ - a requires expression as a
3555 // simple-requirement.
3556 return false;
3557 }
3558 }
3559 return true;
3560 };
3561 if (IsNestedRequirement()) {
3562 ConsumeToken();
3563 // Nested requirement
3564 // C++ [expr.prim.req.nested]
3565 // nested-requirement:
3566 // 'requires' constraint-expression ';'
3567 ExprResult ConstraintExpr =
3568 Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression());
3569 if (ConstraintExpr.isInvalid() || !ConstraintExpr.isUsable()) {
3570 SkipUntil(tok::semi, tok::r_brace,
3571 SkipUntilFlags::StopBeforeMatch);
3572 break;
3573 }
3574 if (auto *Req =
3575 Actions.ActOnNestedRequirement(ConstraintExpr.get()))
3576 Requirements.push_back(Req);
3577 else {
3578 SkipUntil(tok::semi, tok::r_brace,
3579 SkipUntilFlags::StopBeforeMatch);
3580 break;
3581 }
3582 break;
3583 } else
3584 PossibleRequiresExprInSimpleRequirement = true;
3585 } else if (Tok.is(tok::kw_typename)) {
3586 // This might be 'typename T::value_type;' (a type requirement) or
3587 // 'typename T::value_type{};' (a simple requirement).
3588 TentativeParsingAction TPA(*this);
3589
3590 // We need to consume the typename to allow 'requires { typename a; }'
3591 SourceLocation TypenameKWLoc = ConsumeToken();
3592 if (TryAnnotateOptionalCXXScopeToken()) {
3593 TPA.Commit();
3594 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3595 break;
3596 }
3597 CXXScopeSpec SS;
3598 if (Tok.is(tok::annot_cxxscope)) {
3599 Actions.RestoreNestedNameSpecifierAnnotation(
3600 Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
3601 ConsumeAnnotationToken();
3602 }
3603
3604 if (Tok.isOneOf(tok::identifier, tok::annot_template_id) &&
3605 !NextToken().isOneOf(tok::l_brace, tok::l_paren)) {
3606 TPA.Commit();
3607 SourceLocation NameLoc = Tok.getLocation();
3608 IdentifierInfo *II = nullptr;
3609 TemplateIdAnnotation *TemplateId = nullptr;
3610 if (Tok.is(tok::identifier)) {
3611 II = Tok.getIdentifierInfo();
3612 ConsumeToken();
3613 } else {
3614 TemplateId = takeTemplateIdAnnotation(Tok);
3615 ConsumeAnnotationToken();
3616 if (TemplateId->isInvalid())
3617 break;
3618 }
3619
3620 if (auto *Req = Actions.ActOnTypeRequirement(TypenameKWLoc, SS,
3621 NameLoc, II,
3622 TemplateId)) {
3623 Requirements.push_back(Req);
3624 }
3625 break;
3626 }
3627 TPA.Revert();
3628 }
3629 // Simple requirement
3630 // C++ [expr.prim.req.simple]
3631 // simple-requirement:
3632 // expression ';'
3633 SourceLocation StartLoc = Tok.getLocation();
3634 ExprResult Expression =
3635 Actions.CorrectDelayedTyposInExpr(ParseExpression());
3636 if (!Expression.isUsable()) {
3637 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3638 break;
3639 }
3640 if (!Expression.isInvalid() && PossibleRequiresExprInSimpleRequirement)
3641 Diag(StartLoc, diag::err_requires_expr_in_simple_requirement)
3642 << FixItHint::CreateInsertion(StartLoc, "requires");
3643 if (auto *Req = Actions.ActOnSimpleRequirement(Expression.get()))
3644 Requirements.push_back(Req);
3645 else {
3646 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3647 break;
3648 }
3649 // User may have tried to put some compound requirement stuff here
3650 if (Tok.is(tok::kw_noexcept)) {
3651 Diag(Tok, diag::err_requires_expr_simple_requirement_noexcept)
3652 << FixItHint::CreateInsertion(StartLoc, "{")
3653 << FixItHint::CreateInsertion(Tok.getLocation(), "}");
3654 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3655 break;
3656 }
3657 break;
3658 }
3659 }
3660 if (ExpectAndConsumeSemi(diag::err_expected_semi_requirement)) {
3661 SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3662 TryConsumeToken(tok::semi);
3663 break;
3664 }
3665 }
3666 if (Requirements.empty()) {
3667 // Don't emit an empty requires expr here to avoid confusing the user with
3668 // other diagnostics quoting an empty requires expression they never
3669 // wrote.
3670 Braces.consumeClose();
3671 Actions.ActOnFinishRequiresExpr();
3672 return ExprError();
3673 }
3674 }
3675 Braces.consumeClose();
3676 Actions.ActOnFinishRequiresExpr();
3677 return Actions.ActOnRequiresExpr(RequiresKWLoc, Body, LocalParameterDecls,
3678 Requirements, Braces.getCloseLocation());
3679}
3680
3681static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
3682 switch (kind) {
3683 default: llvm_unreachable("Not a known type trait")::llvm::llvm_unreachable_internal("Not a known type trait", "clang/lib/Parse/ParseExprCXX.cpp"
, 3683)
;
3684#define TYPE_TRAIT_1(Spelling, Name, Key) \
3685case tok::kw_ ## Spelling: return UTT_ ## Name;
3686#define TYPE_TRAIT_2(Spelling, Name, Key) \
3687case tok::kw_ ## Spelling: return BTT_ ## Name;
3688#include "clang/Basic/TokenKinds.def"
3689#define TYPE_TRAIT_N(Spelling, Name, Key) \
3690 case tok::kw_ ## Spelling: return TT_ ## Name;
3691#include "clang/Basic/TokenKinds.def"
3692 }
3693}
3694
3695static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
3696 switch (kind) {
3697 default:
3698 llvm_unreachable("Not a known array type trait")::llvm::llvm_unreachable_internal("Not a known array type trait"
, "clang/lib/Parse/ParseExprCXX.cpp", 3698)
;
3699#define ARRAY_TYPE_TRAIT(Spelling, Name, Key) \
3700 case tok::kw_##Spelling: \
3701 return ATT_##Name;
3702#include "clang/Basic/TokenKinds.def"
3703 }
3704}
3705
3706static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
3707 switch (kind) {
3708 default:
3709 llvm_unreachable("Not a known unary expression trait.")::llvm::llvm_unreachable_internal("Not a known unary expression trait."
, "clang/lib/Parse/ParseExprCXX.cpp", 3709)
;
3710#define EXPRESSION_TRAIT(Spelling, Name, Key) \
3711 case tok::kw_##Spelling: \
3712 return ET_##Name;
3713#include "clang/Basic/TokenKinds.def"
3714 }
3715}
3716
3717static unsigned TypeTraitArity(tok::TokenKind kind) {
3718 switch (kind) {
3719 default: llvm_unreachable("Not a known type trait")::llvm::llvm_unreachable_internal("Not a known type trait", "clang/lib/Parse/ParseExprCXX.cpp"
, 3719)
;
3720#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
3721#include "clang/Basic/TokenKinds.def"
3722 }
3723}
3724
3725/// Parse the built-in type-trait pseudo-functions that allow
3726/// implementation of the TR1/C++11 type traits templates.
3727///
3728/// primary-expression:
3729/// unary-type-trait '(' type-id ')'
3730/// binary-type-trait '(' type-id ',' type-id ')'
3731/// type-trait '(' type-id-seq ')'
3732///
3733/// type-id-seq:
3734/// type-id ...[opt] type-id-seq[opt]
3735///
3736ExprResult Parser::ParseTypeTrait() {
3737 tok::TokenKind Kind = Tok.getKind();
3738 unsigned Arity = TypeTraitArity(Kind);
3739
3740 SourceLocation Loc = ConsumeToken();
3741
3742 BalancedDelimiterTracker Parens(*this, tok::l_paren);
3743 if (Parens.expectAndConsume())
3744 return ExprError();
3745
3746 SmallVector<ParsedType, 2> Args;
3747 do {
3748 // Parse the next type.
3749 TypeResult Ty = ParseTypeName();
3750 if (Ty.isInvalid()) {
3751 Parens.skipToEnd();
3752 return ExprError();
3753 }
3754
3755 // Parse the ellipsis, if present.
3756 if (Tok.is(tok::ellipsis)) {
3757 Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
3758 if (Ty.isInvalid()) {
3759 Parens.skipToEnd();
3760 return ExprError();
3761 }
3762 }
3763
3764 // Add this type to the list of arguments.
3765 Args.push_back(Ty.get());
3766 } while (TryConsumeToken(tok::comma));
3767
3768 if (Parens.consumeClose())
3769 return ExprError();
3770
3771 SourceLocation EndLoc = Parens.getCloseLocation();
3772
3773 if (Arity && Args.size() != Arity) {
3774 Diag(EndLoc, diag::err_type_trait_arity)
3775 << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
3776 return ExprError();
3777 }
3778
3779 if (!Arity && Args.empty()) {
3780 Diag(EndLoc, diag::err_type_trait_arity)
3781 << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
3782 return ExprError();
3783 }
3784
3785 return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
3786}
3787
3788/// ParseArrayTypeTrait - Parse the built-in array type-trait
3789/// pseudo-functions.
3790///
3791/// primary-expression:
3792/// [Embarcadero] '__array_rank' '(' type-id ')'
3793/// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
3794///
3795ExprResult Parser::ParseArrayTypeTrait() {
3796 ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
3797 SourceLocation Loc = ConsumeToken();
3798
3799 BalancedDelimiterTracker T(*this, tok::l_paren);
3800 if (T.expectAndConsume())
3801 return ExprError();
3802
3803 TypeResult Ty = ParseTypeName();
3804 if (Ty.isInvalid()) {
3805 SkipUntil(tok::comma, StopAtSemi);
3806 SkipUntil(tok::r_paren, StopAtSemi);
3807 return ExprError();
3808 }
3809
3810 switch (ATT) {
3811 case ATT_ArrayRank: {
3812 T.consumeClose();
3813 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
3814 T.getCloseLocation());
3815 }
3816 case ATT_ArrayExtent: {
3817 if (ExpectAndConsume(tok::comma)) {
3818 SkipUntil(tok::r_paren, StopAtSemi);
3819 return ExprError();
3820 }
3821
3822 ExprResult DimExpr = ParseExpression();
3823 T.consumeClose();
3824
3825 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
3826 T.getCloseLocation());
3827 }
3828 }
3829 llvm_unreachable("Invalid ArrayTypeTrait!")::llvm::llvm_unreachable_internal("Invalid ArrayTypeTrait!", "clang/lib/Parse/ParseExprCXX.cpp"
, 3829)
;
3830}
3831
3832/// ParseExpressionTrait - Parse built-in expression-trait
3833/// pseudo-functions like __is_lvalue_expr( xxx ).
3834///
3835/// primary-expression:
3836/// [Embarcadero] expression-trait '(' expression ')'
3837///
3838ExprResult Parser::ParseExpressionTrait() {
3839 ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
3840 SourceLocation Loc = ConsumeToken();
3841
3842 BalancedDelimiterTracker T(*this, tok::l_paren);
3843 if (T.expectAndConsume())
3844 return ExprError();
3845
3846 ExprResult Expr = ParseExpression();
3847
3848 T.consumeClose();
3849
3850 return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
3851 T.getCloseLocation());
3852}
3853
3854
3855/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3856/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3857/// based on the context past the parens.
3858ExprResult
3859Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3860 ParsedType &CastTy,
3861 BalancedDelimiterTracker &Tracker,
3862 ColonProtectionRAIIObject &ColonProt) {
3863 assert(getLangOpts().CPlusPlus && "Should only be called for C++!")(static_cast <bool> (getLangOpts().CPlusPlus &&
"Should only be called for C++!") ? void (0) : __assert_fail
("getLangOpts().CPlusPlus && \"Should only be called for C++!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 3863, __extension__ __PRETTY_FUNCTION__
))
;
3864 assert(ExprType == CastExpr && "Compound literals are not ambiguous!")(static_cast <bool> (ExprType == CastExpr && "Compound literals are not ambiguous!"
) ? void (0) : __assert_fail ("ExprType == CastExpr && \"Compound literals are not ambiguous!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 3864, __extension__ __PRETTY_FUNCTION__
))
;
3865 assert(isTypeIdInParens() && "Not a type-id!")(static_cast <bool> (isTypeIdInParens() && "Not a type-id!"
) ? void (0) : __assert_fail ("isTypeIdInParens() && \"Not a type-id!\""
, "clang/lib/Parse/ParseExprCXX.cpp", 3865, __extension__ __PRETTY_FUNCTION__
))
;
3866
3867 ExprResult Result(true);
3868 CastTy = nullptr;
3869
3870 // We need to disambiguate a very ugly part of the C++ syntax:
3871 //
3872 // (T())x; - type-id
3873 // (T())*x; - type-id
3874 // (T())/x; - expression
3875 // (T()); - expression
3876 //
3877 // The bad news is that we cannot use the specialized tentative parser, since
3878 // it can only verify that the thing inside the parens can be parsed as
3879 // type-id, it is not useful for determining the context past the parens.
3880 //
3881 // The good news is that the parser can disambiguate this part without
3882 // making any unnecessary Action calls.
3883 //
3884 // It uses a scheme similar to parsing inline methods. The parenthesized
3885 // tokens are cached, the context that follows is determined (possibly by
3886 // parsing a cast-expression), and then we re-introduce the cached tokens
3887 // into the token stream and parse them appropriately.
3888
3889 ParenParseOption ParseAs;
3890 CachedTokens Toks;
3891
3892 // Store the tokens of the parentheses. We will parse them after we determine
3893 // the context that follows them.
3894 if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3895 // We didn't find the ')' we expected.
3896 Tracker.consumeClose();
3897 return ExprError();
3898 }
3899
3900 if (Tok.is(tok::l_brace)) {
3901 ParseAs = CompoundLiteral;
3902 } else {
3903 bool NotCastExpr;
3904 if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
3905 NotCastExpr = true;
3906 } else {
3907 // Try parsing the cast-expression that may follow.
3908 // If it is not a cast-expression, NotCastExpr will be true and no token
3909 // will be consumed.
3910 ColonProt.restore();
3911 Result = ParseCastExpression(AnyCastExpr,
3912 false/*isAddressofOperand*/,
3913 NotCastExpr,
3914 // type-id has priority.
3915 IsTypeCast);
3916 }
3917
3918 // If we parsed a cast-expression, it's really a type-id, otherwise it's
3919 // an expression.
3920 ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
3921 }
3922
3923 // Create a fake EOF to mark end of Toks buffer.
3924 Token AttrEnd;
3925 AttrEnd.startToken();
3926 AttrEnd.setKind(tok::eof);
3927 AttrEnd.setLocation(Tok.getLocation());
3928 AttrEnd.setEofData(Toks.data());
3929 Toks.push_back(AttrEnd);
3930
3931 // The current token should go after the cached tokens.
3932 Toks.push_back(Tok);
3933 // Re-enter the stored parenthesized tokens into the token stream, so we may
3934 // parse them now.
3935 PP.EnterTokenStream(Toks, /*DisableMacroExpansion*/ true,
3936 /*IsReinject*/ true);
3937 // Drop the current token and bring the first cached one. It's the same token
3938 // as when we entered this function.
3939 ConsumeAnyToken();
3940
3941 if (ParseAs >= CompoundLiteral) {
3942 // Parse the type declarator.
3943 DeclSpec DS(AttrFactory);
3944 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
3945 {
3946 ColonProtectionRAIIObject InnerColonProtection(*this);
3947 ParseSpecifierQualifierList(DS);
3948 ParseDeclarator(DeclaratorInfo);
3949 }
3950
3951 // Match the ')'.
3952 Tracker.consumeClose();
3953 ColonProt.restore();
3954
3955 // Consume EOF marker for Toks buffer.
3956 assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())(static_cast <bool> (Tok.is(tok::eof) && Tok.getEofData
() == AttrEnd.getEofData()) ? void (0) : __assert_fail ("Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()"
, "clang/lib/Parse/ParseExprCXX.cpp", 3956, __extension__ __PRETTY_FUNCTION__
))
;
3957 ConsumeAnyToken();
3958
3959 if (ParseAs == CompoundLiteral) {
3960 ExprType = CompoundLiteral;
3961 if (DeclaratorInfo.isInvalidType())
3962 return ExprError();
3963
3964 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
3965 return ParseCompoundLiteralExpression(Ty.get(),
3966 Tracker.getOpenLocation(),
3967 Tracker.getCloseLocation());
3968 }
3969
3970 // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
3971 assert(ParseAs == CastExpr)(static_cast <bool> (ParseAs == CastExpr) ? void (0) : __assert_fail
("ParseAs == CastExpr", "clang/lib/Parse/ParseExprCXX.cpp", 3971
, __extension__ __PRETTY_FUNCTION__))
;
3972
3973 if (DeclaratorInfo.isInvalidType())
3974 return ExprError();
3975
3976 // Result is what ParseCastExpression returned earlier.
3977 if (!Result.isInvalid())
3978 Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
3979 DeclaratorInfo, CastTy,
3980 Tracker.getCloseLocation(), Result.get());
3981 return Result;
3982 }
3983
3984 // Not a compound literal, and not followed by a cast-expression.
3985 assert(ParseAs == SimpleExpr)(static_cast <bool> (ParseAs == SimpleExpr) ? void (0) :
__assert_fail ("ParseAs == SimpleExpr", "clang/lib/Parse/ParseExprCXX.cpp"
, 3985, __extension__ __PRETTY_FUNCTION__))
;
3986
3987 ExprType = SimpleExpr;
3988 Result = ParseExpression();
3989 if (!Result.isInvalid() && Tok.is(tok::r_paren))
3990 Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
3991 Tok.getLocation(), Result.get());
3992
3993 // Match the ')'.
3994 if (Result.isInvalid()) {
3995 while (Tok.isNot(tok::eof))
3996 ConsumeAnyToken();
3997 assert(Tok.getEofData() == AttrEnd.getEofData())(static_cast <bool> (Tok.getEofData() == AttrEnd.getEofData
()) ? void (0) : __assert_fail ("Tok.getEofData() == AttrEnd.getEofData()"
, "clang/lib/Parse/ParseExprCXX.cpp", 3997, __extension__ __PRETTY_FUNCTION__
))
;
3998 ConsumeAnyToken();
3999 return ExprError();
4000 }
4001
4002 Tracker.consumeClose();
4003 // Consume EOF marker for Toks buffer.
4004 assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())(static_cast <bool> (Tok.is(tok::eof) && Tok.getEofData
() == AttrEnd.getEofData()) ? void (0) : __assert_fail ("Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()"
, "clang/lib/Parse/ParseExprCXX.cpp", 4004, __extension__ __PRETTY_FUNCTION__
))
;
4005 ConsumeAnyToken();
4006 return Result;
4007}
4008
4009/// Parse a __builtin_bit_cast(T, E).
4010ExprResult Parser::ParseBuiltinBitCast() {
4011 SourceLocation KWLoc = ConsumeToken();
4012
4013 BalancedDelimiterTracker T(*this, tok::l_paren);
4014 if (T.expectAndConsume(diag::err_expected_lparen_after, "__builtin_bit_cast"))
4015 return ExprError();
4016
4017 // Parse the common declaration-specifiers piece.
4018 DeclSpec DS(AttrFactory);
4019 ParseSpecifierQualifierList(DS);
4020
4021 // Parse the abstract-declarator, if present.
4022 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
4023 ParseDeclarator(DeclaratorInfo);
4024
4025 if (ExpectAndConsume(tok::comma)) {
4026 Diag(Tok.getLocation(), diag::err_expected) << tok::comma;
4027 SkipUntil(tok::r_paren, StopAtSemi);
4028 return ExprError();
4029 }
4030
4031 ExprResult Operand = ParseExpression();
4032
4033 if (T.consumeClose())
4034 return ExprError();
4035
4036 if (Operand.isInvalid() || DeclaratorInfo.isInvalidType())
4037 return ExprError();
4038
4039 return Actions.ActOnBuiltinBitCastExpr(KWLoc, DeclaratorInfo, Operand,
4040 T.getCloseLocation());
4041}

/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/clang/include/clang/Lex/Token.h

1//===--- Token.h - Token interface ------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the Token interface.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LEX_TOKEN_H
14#define LLVM_CLANG_LEX_TOKEN_H
15
16#include "clang/Basic/SourceLocation.h"
17#include "clang/Basic/TokenKinds.h"
18#include "llvm/ADT/StringRef.h"
19#include <cassert>
20
21namespace clang {
22
23class IdentifierInfo;
24
25/// Token - This structure provides full information about a lexed token.
26/// It is not intended to be space efficient, it is intended to return as much
27/// information as possible about each returned token. This is expected to be
28/// compressed into a smaller form if memory footprint is important.
29///
30/// The parser can create a special "annotation token" representing a stream of
31/// tokens that were parsed and semantically resolved, e.g.: "foo::MyClass<int>"
32/// can be represented by a single typename annotation token that carries
33/// information about the SourceRange of the tokens and the type object.
34class Token {
35 /// The location of the token. This is actually a SourceLocation.
36 SourceLocation::UIntTy Loc;
37
38 // Conceptually these next two fields could be in a union. However, this
39 // causes gcc 4.2 to pessimize LexTokenInternal, a very performance critical
40 // routine. Keeping as separate members with casts until a more beautiful fix
41 // presents itself.
42
43 /// UintData - This holds either the length of the token text, when
44 /// a normal token, or the end of the SourceRange when an annotation
45 /// token.
46 SourceLocation::UIntTy UintData;
47
48 /// PtrData - This is a union of four different pointer types, which depends
49 /// on what type of token this is:
50 /// Identifiers, keywords, etc:
51 /// This is an IdentifierInfo*, which contains the uniqued identifier
52 /// spelling.
53 /// Literals: isLiteral() returns true.
54 /// This is a pointer to the start of the token in a text buffer, which
55 /// may be dirty (have trigraphs / escaped newlines).
56 /// Annotations (resolved type names, C++ scopes, etc): isAnnotation().
57 /// This is a pointer to sema-specific data for the annotation token.
58 /// Eof:
59 // This is a pointer to a Decl.
60 /// Other:
61 /// This is null.
62 void *PtrData;
63
64 /// Kind - The actual flavor of token this is.
65 tok::TokenKind Kind;
66
67 /// Flags - Bits we track about this token, members of the TokenFlags enum.
68 unsigned short Flags;
69
70public:
71 // Various flags set per token:
72 enum TokenFlags {
73 StartOfLine = 0x01, // At start of line or only after whitespace
74 // (considering the line after macro expansion).
75 LeadingSpace = 0x02, // Whitespace exists before this token (considering
76 // whitespace after macro expansion).
77 DisableExpand = 0x04, // This identifier may never be macro expanded.
78 NeedsCleaning = 0x08, // Contained an escaped newline or trigraph.
79 LeadingEmptyMacro = 0x10, // Empty macro exists before this token.
80 HasUDSuffix = 0x20, // This string or character literal has a ud-suffix.
81 HasUCN = 0x40, // This identifier contains a UCN.
82 IgnoredComma = 0x80, // This comma is not a macro argument separator (MS).
83 StringifiedInMacro = 0x100, // This string or character literal is formed by
84 // macro stringizing or charizing operator.
85 CommaAfterElided = 0x200, // The comma following this token was elided (MS).
86 IsEditorPlaceholder = 0x400, // This identifier is a placeholder.
87 IsReinjected = 0x800, // A phase 4 token that was produced before and
88 // re-added, e.g. via EnterTokenStream. Annotation
89 // tokens are *not* reinjected.
90 };
91
92 tok::TokenKind getKind() const { return Kind; }
93 void setKind(tok::TokenKind K) { Kind = K; }
94
95 /// is/isNot - Predicates to check if this token is a specific kind, as in
96 /// "if (Tok.is(tok::l_brace)) {...}".
97 bool is(tok::TokenKind K) const { return Kind == K; }
10
Assuming 'K' is not equal to field 'Kind'
11
Returning zero, which participates in a condition later
98 bool isNot(tok::TokenKind K) const { return Kind != K; }
99 bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const {
100 return is(K1) || is(K2);
101 }
102 template <typename... Ts>
103 bool isOneOf(tok::TokenKind K1, tok::TokenKind K2, Ts... Ks) const {
104 return is(K1) || isOneOf(K2, Ks...);
105 }
106
107 /// Return true if this is a raw identifier (when lexing
108 /// in raw mode) or a non-keyword identifier (when lexing in non-raw mode).
109 bool isAnyIdentifier() const {
110 return tok::isAnyIdentifier(getKind());
111 }
112
113 /// Return true if this is a "literal", like a numeric
114 /// constant, string, etc.
115 bool isLiteral() const {
116 return tok::isLiteral(getKind());
117 }
118
119 /// Return true if this is any of tok::annot_* kind tokens.
120 bool isAnnotation() const {
121 return tok::isAnnotation(getKind());
122 }
123
124 /// Return a source location identifier for the specified
125 /// offset in the current file.
126 SourceLocation getLocation() const {
127 return SourceLocation::getFromRawEncoding(Loc);
128 }
129 unsigned getLength() const {
130 assert(!isAnnotation() && "Annotation tokens have no length field")(static_cast <bool> (!isAnnotation() && "Annotation tokens have no length field"
) ? void (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "clang/include/clang/Lex/Token.h", 130, __extension__ __PRETTY_FUNCTION__
))
;
131 return UintData;
132 }
133
134 void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
135 void setLength(unsigned Len) {
136 assert(!isAnnotation() && "Annotation tokens have no length field")(static_cast <bool> (!isAnnotation() && "Annotation tokens have no length field"
) ? void (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "clang/include/clang/Lex/Token.h", 136, __extension__ __PRETTY_FUNCTION__
))
;
137 UintData = Len;
138 }
139
140 SourceLocation getAnnotationEndLoc() const {
141 assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "clang/include/clang/Lex/Token.h", 141, __extension__ __PRETTY_FUNCTION__
))
;
142 return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
143 }
144 void setAnnotationEndLoc(SourceLocation L) {
145 assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "clang/include/clang/Lex/Token.h", 145, __extension__ __PRETTY_FUNCTION__
))
;
146 UintData = L.getRawEncoding();
147 }
148
149 SourceLocation getLastLoc() const {
150 return isAnnotation() ? getAnnotationEndLoc() : getLocation();
151 }
152
153 SourceLocation getEndLoc() const {
154 return isAnnotation() ? getAnnotationEndLoc()
155 : getLocation().getLocWithOffset(getLength());
156 }
157
158 /// SourceRange of the group of tokens that this annotation token
159 /// represents.
160 SourceRange getAnnotationRange() const {
161 return SourceRange(getLocation(), getAnnotationEndLoc());
162 }
163 void setAnnotationRange(SourceRange R) {
164 setLocation(R.getBegin());
165 setAnnotationEndLoc(R.getEnd());
166 }
167
168 const char *getName() const { return tok::getTokenName(Kind); }
169
170 /// Reset all flags to cleared.
171 void startToken() {
172 Kind = tok::unknown;
173 Flags = 0;
174 PtrData = nullptr;
175 UintData = 0;
176 Loc = SourceLocation().getRawEncoding();
177 }
178
179 IdentifierInfo *getIdentifierInfo() const {
180 assert(isNot(tok::raw_identifier) &&(static_cast <bool> (isNot(tok::raw_identifier) &&
"getIdentifierInfo() on a tok::raw_identifier token!") ? void
(0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "clang/include/clang/Lex/Token.h", 181, __extension__ __PRETTY_FUNCTION__
))
181 "getIdentifierInfo() on a tok::raw_identifier token!")(static_cast <bool> (isNot(tok::raw_identifier) &&
"getIdentifierInfo() on a tok::raw_identifier token!") ? void
(0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "clang/include/clang/Lex/Token.h", 181, __extension__ __PRETTY_FUNCTION__
))
;
182 assert(!isAnnotation() &&(static_cast <bool> (!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? void (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "clang/include/clang/Lex/Token.h", 183, __extension__ __PRETTY_FUNCTION__
))
183 "getIdentifierInfo() on an annotation token!")(static_cast <bool> (!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? void (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "clang/include/clang/Lex/Token.h", 183, __extension__ __PRETTY_FUNCTION__
))
;
184 if (isLiteral()) return nullptr;
185 if (is(tok::eof)) return nullptr;
186 return (IdentifierInfo*) PtrData;
187 }
188 void setIdentifierInfo(IdentifierInfo *II) {
189 PtrData = (void*) II;
190 }
191
192 const void *getEofData() const {
193 assert(is(tok::eof))(static_cast <bool> (is(tok::eof)) ? void (0) : __assert_fail
("is(tok::eof)", "clang/include/clang/Lex/Token.h", 193, __extension__
__PRETTY_FUNCTION__))
;
194 return reinterpret_cast<const void *>(PtrData);
195 }
196 void setEofData(const void *D) {
197 assert(is(tok::eof))(static_cast <bool> (is(tok::eof)) ? void (0) : __assert_fail
("is(tok::eof)", "clang/include/clang/Lex/Token.h", 197, __extension__
__PRETTY_FUNCTION__))
;
198 assert(!PtrData)(static_cast <bool> (!PtrData) ? void (0) : __assert_fail
("!PtrData", "clang/include/clang/Lex/Token.h", 198, __extension__
__PRETTY_FUNCTION__))
;
199 PtrData = const_cast<void *>(D);
200 }
201
202 /// getRawIdentifier - For a raw identifier token (i.e., an identifier
203 /// lexed in raw mode), returns a reference to the text substring in the
204 /// buffer if known.
205 StringRef getRawIdentifier() const {
206 assert(is(tok::raw_identifier))(static_cast <bool> (is(tok::raw_identifier)) ? void (0
) : __assert_fail ("is(tok::raw_identifier)", "clang/include/clang/Lex/Token.h"
, 206, __extension__ __PRETTY_FUNCTION__))
;
207 return StringRef(reinterpret_cast<const char *>(PtrData), getLength());
208 }
209 void setRawIdentifierData(const char *Ptr) {
210 assert(is(tok::raw_identifier))(static_cast <bool> (is(tok::raw_identifier)) ? void (0
) : __assert_fail ("is(tok::raw_identifier)", "clang/include/clang/Lex/Token.h"
, 210, __extension__ __PRETTY_FUNCTION__))
;
211 PtrData = const_cast<char*>(Ptr);
212 }
213
214 /// getLiteralData - For a literal token (numeric constant, string, etc), this
215 /// returns a pointer to the start of it in the text buffer if known, null
216 /// otherwise.
217 const char *getLiteralData() const {
218 assert(isLiteral() && "Cannot get literal data of non-literal")(static_cast <bool> (isLiteral() && "Cannot get literal data of non-literal"
) ? void (0) : __assert_fail ("isLiteral() && \"Cannot get literal data of non-literal\""
, "clang/include/clang/Lex/Token.h", 218, __extension__ __PRETTY_FUNCTION__
))
;
219 return reinterpret_cast<const char*>(PtrData);
220 }
221 void setLiteralData(const char *Ptr) {
222 assert(isLiteral() && "Cannot set literal data of non-literal")(static_cast <bool> (isLiteral() && "Cannot set literal data of non-literal"
) ? void (0) : __assert_fail ("isLiteral() && \"Cannot set literal data of non-literal\""
, "clang/include/clang/Lex/Token.h", 222, __extension__ __PRETTY_FUNCTION__
))
;
223 PtrData = const_cast<char*>(Ptr);
224 }
225
226 void *getAnnotationValue() const {
227 assert(isAnnotation() && "Used AnnotVal on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotVal on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "clang/include/clang/Lex/Token.h", 227, __extension__ __PRETTY_FUNCTION__
))
;
228 return PtrData;
229 }
230 void setAnnotationValue(void *val) {
231 assert(isAnnotation() && "Used AnnotVal on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotVal on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "clang/include/clang/Lex/Token.h", 231, __extension__ __PRETTY_FUNCTION__
))
;
232 PtrData = val;
233 }
234
235 /// Set the specified flag.
236 void setFlag(TokenFlags Flag) {
237 Flags |= Flag;
238 }
239
240 /// Get the specified flag.
241 bool getFlag(TokenFlags Flag) const {
242 return (Flags & Flag) != 0;
243 }
244
245 /// Unset the specified flag.
246 void clearFlag(TokenFlags Flag) {
247 Flags &= ~Flag;
248 }
249
250 /// Return the internal represtation of the flags.
251 ///
252 /// This is only intended for low-level operations such as writing tokens to
253 /// disk.
254 unsigned getFlags() const {
255 return Flags;
256 }
257
258 /// Set a flag to either true or false.
259 void setFlagValue(TokenFlags Flag, bool Val) {
260 if (Val)
261 setFlag(Flag);
262 else
263 clearFlag(Flag);
264 }
265
266 /// isAtStartOfLine - Return true if this token is at the start of a line.
267 ///
268 bool isAtStartOfLine() const { return getFlag(StartOfLine); }
269
270 /// Return true if this token has whitespace before it.
271 ///
272 bool hasLeadingSpace() const { return getFlag(LeadingSpace); }
273
274 /// Return true if this identifier token should never
275 /// be expanded in the future, due to C99 6.10.3.4p2.
276 bool isExpandDisabled() const { return getFlag(DisableExpand); }
277
278 /// Return true if we have an ObjC keyword identifier.
279 bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const;
280
281 /// Return the ObjC keyword kind.
282 tok::ObjCKeywordKind getObjCKeywordID() const;
283
284 /// Return true if this token has trigraphs or escaped newlines in it.
285 bool needsCleaning() const { return getFlag(NeedsCleaning); }
286
287 /// Return true if this token has an empty macro before it.
288 ///
289 bool hasLeadingEmptyMacro() const { return getFlag(LeadingEmptyMacro); }
290
291 /// Return true if this token is a string or character literal which
292 /// has a ud-suffix.
293 bool hasUDSuffix() const { return getFlag(HasUDSuffix); }
294
295 /// Returns true if this token contains a universal character name.
296 bool hasUCN() const { return getFlag(HasUCN); }
297
298 /// Returns true if this token is formed by macro by stringizing or charizing
299 /// operator.
300 bool stringifiedInMacro() const { return getFlag(StringifiedInMacro); }
301
302 /// Returns true if the comma after this token was elided.
303 bool commaAfterElided() const { return getFlag(CommaAfterElided); }
304
305 /// Returns true if this token is an editor placeholder.
306 ///
307 /// Editor placeholders are produced by the code-completion engine and are
308 /// represented as characters between '<#' and '#>' in the source code. The
309 /// lexer uses identifier tokens to represent placeholders.
310 bool isEditorPlaceholder() const { return getFlag(IsEditorPlaceholder); }
311};
312
313/// Information about the conditional stack (\#if directives)
314/// currently active.
315struct PPConditionalInfo {
316 /// Location where the conditional started.
317 SourceLocation IfLoc;
318
319 /// True if this was contained in a skipping directive, e.g.,
320 /// in a "\#if 0" block.
321 bool WasSkipping;
322
323 /// True if we have emitted tokens already, and now we're in
324 /// an \#else block or something. Only useful in Skipping blocks.
325 bool FoundNonSkip;
326
327 /// True if we've seen a \#else in this block. If so,
328 /// \#elif/\#else directives are not allowed.
329 bool FoundElse;
330};
331
332} // end namespace clang
333
334#endif // LLVM_CLANG_LEX_TOKEN_H