Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name 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 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/tools/clang/lib/Parse -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Parse -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/tools/clang/lib/Parse -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-12-09-002921-48462-1 -x c++ /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Parse/ParseExprCXX.cpp

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

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/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 unsigned 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 unsigned 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; }
6
Assuming 'K' is not equal to field 'Kind'
7
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")((!isAnnotation() && "Annotation tokens have no length field"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 130, __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")((!isAnnotation() && "Annotation tokens have no length field"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 136, __PRETTY_FUNCTION__))
;
137 UintData = Len;
138 }
139
140 SourceLocation getAnnotationEndLoc() const {
141 assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 141, __PRETTY_FUNCTION__))
;
142 return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
143 }
144 void setAnnotationEndLoc(SourceLocation L) {
145 assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 145, __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) &&((isNot(tok::raw_identifier) && "getIdentifierInfo() on a tok::raw_identifier token!"
) ? static_cast<void> (0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 181, __PRETTY_FUNCTION__))
181 "getIdentifierInfo() on a tok::raw_identifier token!")((isNot(tok::raw_identifier) && "getIdentifierInfo() on a tok::raw_identifier token!"
) ? static_cast<void> (0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 181, __PRETTY_FUNCTION__))
;
182 assert(!isAnnotation() &&((!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 183, __PRETTY_FUNCTION__))
183 "getIdentifierInfo() on an annotation token!")((!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 183, __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))((is(tok::eof)) ? static_cast<void> (0) : __assert_fail
("is(tok::eof)", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 193, __PRETTY_FUNCTION__))
;
194 return reinterpret_cast<const void *>(PtrData);
195 }
196 void setEofData(const void *D) {
197 assert(is(tok::eof))((is(tok::eof)) ? static_cast<void> (0) : __assert_fail
("is(tok::eof)", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 197, __PRETTY_FUNCTION__))
;
198 assert(!PtrData)((!PtrData) ? static_cast<void> (0) : __assert_fail ("!PtrData"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 198, __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))((is(tok::raw_identifier)) ? static_cast<void> (0) : __assert_fail
("is(tok::raw_identifier)", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 206, __PRETTY_FUNCTION__))
;
207 return StringRef(reinterpret_cast<const char *>(PtrData), getLength());
208 }
209 void setRawIdentifierData(const char *Ptr) {
210 assert(is(tok::raw_identifier))((is(tok::raw_identifier)) ? static_cast<void> (0) : __assert_fail
("is(tok::raw_identifier)", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 210, __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")((isLiteral() && "Cannot get literal data of non-literal"
) ? static_cast<void> (0) : __assert_fail ("isLiteral() && \"Cannot get literal data of non-literal\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 218, __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")((isLiteral() && "Cannot set literal data of non-literal"
) ? static_cast<void> (0) : __assert_fail ("isLiteral() && \"Cannot set literal data of non-literal\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 222, __PRETTY_FUNCTION__))
;
223 PtrData = const_cast<char*>(Ptr);
224 }
225
226 void *getAnnotationValue() const {
227 assert(isAnnotation() && "Used AnnotVal on non-annotation token")((isAnnotation() && "Used AnnotVal on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 227, __PRETTY_FUNCTION__))
;
228 return PtrData;
229 }
230 void setAnnotationValue(void *val) {
231 assert(isAnnotation() && "Used AnnotVal on non-annotation token")((isAnnotation() && "Used AnnotVal on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/include/clang/Lex/Token.h"
, 231, __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