1//===--- ParseTentative.cpp - Ambiguity Resolution 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 tentative parsing portions of the Parser
10// interfaces, for ambiguity resolution.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Parse/Parser.h"
15#include "clang/Parse/ParseDiagnostic.h"
16#include "clang/Sema/ParsedTemplate.h"
17using namespace clang;
18
19/// isCXXDeclarationStatement - C++-specialized function that disambiguates
20/// between a declaration or an expression statement, when parsing function
21/// bodies. Returns true for declaration, false for expression.
22///
23/// declaration-statement:
24/// block-declaration
25///
26/// block-declaration:
27/// simple-declaration
28/// asm-definition
29/// namespace-alias-definition
30/// using-declaration
31/// using-directive
32/// [C++0x] static_assert-declaration
33///
34/// asm-definition:
35/// 'asm' '(' string-literal ')' ';'
36///
37/// namespace-alias-definition:
38/// 'namespace' identifier = qualified-namespace-specifier ';'
39///
40/// using-declaration:
41/// 'using' typename[opt] '::'[opt] nested-name-specifier
42/// unqualified-id ';'
43/// 'using' '::' unqualified-id ;
44///
45/// using-directive:
46/// 'using' 'namespace' '::'[opt] nested-name-specifier[opt]
47/// namespace-name ';'
48///
49bool Parser::isCXXDeclarationStatement(
50 bool DisambiguatingWithExpression /*=false*/) {
51 assert(getLangOpts().CPlusPlus && "Must be called for C++ only.");
52
53 switch (Tok.getKind()) {
54 // asm-definition
55 case tok::kw_asm:
56 // namespace-alias-definition
57 case tok::kw_namespace:
58 // using-declaration
59 // using-directive
60 case tok::kw_using:
61 // static_assert-declaration
62 case tok::kw_static_assert:
63 case tok::kw__Static_assert:
64 return true;
65 case tok::coloncolon:
66 case tok::identifier: {
67 if (DisambiguatingWithExpression) {
68 RevertingTentativeParsingAction TPA(*this);
69 // Parse the C++ scope specifier.
70 CXXScopeSpec SS;
71 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
72 /*ObjectHasErrors=*/false,
73 /*EnteringContext=*/true);
74
75 switch (Tok.getKind()) {
76 case tok::identifier: {
77 IdentifierInfo *II = Tok.getIdentifierInfo();
78 bool isDeductionGuide = Actions.isDeductionGuideName(
79 S: getCurScope(), Name: *II, NameLoc: Tok.getLocation(), SS, /*Template=*/nullptr);
80 if (Actions.isCurrentClassName(II: *II, S: getCurScope(), SS: &SS) ||
81 isDeductionGuide) {
82 if (isConstructorDeclarator(
83 /*Unqualified=*/SS.isEmpty(), DeductionGuide: isDeductionGuide,
84 /*IsFriend=*/DeclSpec::FriendSpecified::No))
85 return true;
86 } else if (SS.isNotEmpty()) {
87 // If the scope is not empty, it could alternatively be something like
88 // a typedef or using declaration. That declaration might be private
89 // in the global context, which would be diagnosed by calling into
90 // isCXXSimpleDeclaration, but may actually be fine in the context of
91 // member functions and static variable definitions. Check if the next
92 // token is also an identifier and assume a declaration.
93 // We cannot check if the scopes match because the declarations could
94 // involve namespaces and friend declarations.
95 if (NextToken().is(K: tok::identifier))
96 return true;
97 }
98 break;
99 }
100 case tok::kw_operator:
101 return true;
102 case tok::tilde:
103 return true;
104 default:
105 break;
106 }
107 }
108 }
109 [[fallthrough]];
110 // simple-declaration
111 default:
112 return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/false);
113 }
114}
115
116/// isCXXSimpleDeclaration - C++-specialized function that disambiguates
117/// between a simple-declaration or an expression-statement.
118/// If during the disambiguation process a parsing error is encountered,
119/// the function returns true to let the declaration parsing code handle it.
120/// Returns false if the statement is disambiguated as expression.
121///
122/// simple-declaration:
123/// decl-specifier-seq init-declarator-list[opt] ';'
124/// decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
125/// brace-or-equal-initializer ';' [C++17]
126///
127/// (if AllowForRangeDecl specified)
128/// for ( for-range-declaration : for-range-initializer ) statement
129///
130/// for-range-declaration:
131/// decl-specifier-seq declarator
132/// decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
133///
134/// In any of the above cases there can be a preceding attribute-specifier-seq,
135/// but the caller is expected to handle that.
136bool Parser::isCXXSimpleDeclaration(bool AllowForRangeDecl) {
137 // C++ 6.8p1:
138 // There is an ambiguity in the grammar involving expression-statements and
139 // declarations: An expression-statement with a function-style explicit type
140 // conversion (5.2.3) as its leftmost subexpression can be indistinguishable
141 // from a declaration where the first declarator starts with a '('. In those
142 // cases the statement is a declaration. [Note: To disambiguate, the whole
143 // statement might have to be examined to determine if it is an
144 // expression-statement or a declaration].
145
146 // C++ 6.8p3:
147 // The disambiguation is purely syntactic; that is, the meaning of the names
148 // occurring in such a statement, beyond whether they are type-names or not,
149 // is not generally used in or changed by the disambiguation. Class
150 // templates are instantiated as necessary to determine if a qualified name
151 // is a type-name. Disambiguation precedes parsing, and a statement
152 // disambiguated as a declaration may be an ill-formed declaration.
153
154 // We don't have to parse all of the decl-specifier-seq part. There's only
155 // an ambiguity if the first decl-specifier is
156 // simple-type-specifier/typename-specifier followed by a '(', which may
157 // indicate a function-style cast expression.
158 // isCXXDeclarationSpecifier will return TPResult::Ambiguous only in such
159 // a case.
160
161 bool InvalidAsDeclaration = false;
162 TPResult TPR = isCXXDeclarationSpecifier(
163 AllowImplicitTypename: ImplicitTypenameContext::No, BracedCastResult: TPResult::False, InvalidAsDeclSpec: &InvalidAsDeclaration);
164 if (TPR != TPResult::Ambiguous)
165 return TPR != TPResult::False; // Returns true for TPResult::True or
166 // TPResult::Error.
167
168 // FIXME: TryParseSimpleDeclaration doesn't look past the first initializer,
169 // and so gets some cases wrong. We can't carry on if we've already seen
170 // something which makes this statement invalid as a declaration in this case,
171 // since it can cause us to misparse valid code. Revisit this once
172 // TryParseInitDeclaratorList is fixed.
173 if (InvalidAsDeclaration)
174 return false;
175
176 // FIXME: Add statistics about the number of ambiguous statements encountered
177 // and how they were resolved (number of declarations+number of expressions).
178
179 // Ok, we have a simple-type-specifier/typename-specifier followed by a '(',
180 // or an identifier which doesn't resolve as anything. We need tentative
181 // parsing...
182
183 {
184 RevertingTentativeParsingAction PA(*this);
185 TPR = TryParseSimpleDeclaration(AllowForRangeDecl);
186 }
187
188 // In case of an error, let the declaration parsing code handle it.
189 if (TPR == TPResult::Error)
190 return true;
191
192 // Declarations take precedence over expressions.
193 if (TPR == TPResult::Ambiguous)
194 TPR = TPResult::True;
195
196 assert(TPR == TPResult::True || TPR == TPResult::False);
197 return TPR == TPResult::True;
198}
199
200/// Try to consume a token sequence that we've already identified as
201/// (potentially) starting a decl-specifier.
202Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
203 switch (Tok.getKind()) {
204 case tok::kw__Atomic:
205 if (NextToken().isNot(K: tok::l_paren)) {
206 ConsumeToken();
207 break;
208 }
209 [[fallthrough]];
210 case tok::kw_typeof:
211 case tok::kw___attribute:
212#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
213#include "clang/Basic/TransformTypeTraits.def"
214 {
215 ConsumeToken();
216 if (Tok.isNot(K: tok::l_paren))
217 return TPResult::Error;
218 ConsumeParen();
219 if (!SkipUntil(T: tok::r_paren))
220 return TPResult::Error;
221 break;
222 }
223
224 case tok::kw_class:
225 case tok::kw_struct:
226 case tok::kw_union:
227 case tok::kw___interface:
228 case tok::kw_enum:
229 // elaborated-type-specifier:
230 // class-key attribute-specifier-seq[opt]
231 // nested-name-specifier[opt] identifier
232 // class-key nested-name-specifier[opt] template[opt] simple-template-id
233 // enum nested-name-specifier[opt] identifier
234 //
235 // FIXME: We don't support class-specifiers nor enum-specifiers here.
236 ConsumeToken();
237
238 // Skip attributes.
239 if (!TrySkipAttributes())
240 return TPResult::Error;
241
242 if (TryAnnotateOptionalCXXScopeToken())
243 return TPResult::Error;
244 if (Tok.is(K: tok::annot_cxxscope))
245 ConsumeAnnotationToken();
246 if (Tok.is(K: tok::identifier))
247 ConsumeToken();
248 else if (Tok.is(K: tok::annot_template_id))
249 ConsumeAnnotationToken();
250 else
251 return TPResult::Error;
252 break;
253
254 case tok::annot_cxxscope:
255 ConsumeAnnotationToken();
256 [[fallthrough]];
257 default:
258 ConsumeAnyToken();
259
260 if (getLangOpts().ObjC && Tok.is(K: tok::less))
261 return TryParseProtocolQualifiers();
262 break;
263 }
264
265 return TPResult::Ambiguous;
266}
267
268/// simple-declaration:
269/// decl-specifier-seq init-declarator-list[opt] ';'
270///
271/// (if AllowForRangeDecl specified)
272/// for ( for-range-declaration : for-range-initializer ) statement
273/// for-range-declaration:
274/// attribute-specifier-seqopt type-specifier-seq declarator
275///
276Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
277 bool DeclSpecifierIsAuto = Tok.is(K: tok::kw_auto);
278 if (TryConsumeDeclarationSpecifier() == TPResult::Error)
279 return TPResult::Error;
280
281 // Two decl-specifiers in a row conclusively disambiguate this as being a
282 // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
283 // overwhelmingly common case that the next token is a '('.
284 if (Tok.isNot(K: tok::l_paren)) {
285 TPResult TPR = isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No);
286 if (TPR == TPResult::Ambiguous)
287 return TPResult::True;
288 if (TPR == TPResult::True || TPR == TPResult::Error)
289 return TPR;
290 assert(TPR == TPResult::False);
291 }
292
293 TPResult TPR = TryParseInitDeclaratorList(
294 /*mayHaveTrailingReturnType=*/MayHaveTrailingReturnType: DeclSpecifierIsAuto);
295 if (TPR != TPResult::Ambiguous)
296 return TPR;
297
298 if (Tok.isNot(K: tok::semi) && (!AllowForRangeDecl || Tok.isNot(K: tok::colon)))
299 return TPResult::False;
300
301 return TPResult::Ambiguous;
302}
303
304/// Tentatively parse an init-declarator-list in order to disambiguate it from
305/// an expression.
306///
307/// init-declarator-list:
308/// init-declarator
309/// init-declarator-list ',' init-declarator
310///
311/// init-declarator:
312/// declarator initializer[opt]
313/// [GNU] declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
314///
315/// initializer:
316/// brace-or-equal-initializer
317/// '(' expression-list ')'
318///
319/// brace-or-equal-initializer:
320/// '=' initializer-clause
321/// [C++11] braced-init-list
322///
323/// initializer-clause:
324/// assignment-expression
325/// braced-init-list
326///
327/// braced-init-list:
328/// '{' initializer-list ','[opt] '}'
329/// '{' '}'
330///
331Parser::TPResult
332Parser::TryParseInitDeclaratorList(bool MayHaveTrailingReturnType) {
333 while (true) {
334 // declarator
335 TPResult TPR = TryParseDeclarator(
336 /*mayBeAbstract=*/false,
337 /*mayHaveIdentifier=*/true,
338 /*mayHaveDirectInit=*/false,
339 /*mayHaveTrailingReturnType=*/MayHaveTrailingReturnType);
340 if (TPR != TPResult::Ambiguous)
341 return TPR;
342
343 // [GNU] simple-asm-expr[opt] attributes[opt]
344 if (Tok.isOneOf(K1: tok::kw_asm, K2: tok::kw___attribute))
345 return TPResult::True;
346
347 // initializer[opt]
348 if (Tok.is(K: tok::l_paren)) {
349 // Parse through the parens.
350 ConsumeParen();
351 if (!SkipUntil(T: tok::r_paren, Flags: StopAtSemi))
352 return TPResult::Error;
353 } else if (Tok.is(K: tok::l_brace)) {
354 // A left-brace here is sufficient to disambiguate the parse; an
355 // expression can never be followed directly by a braced-init-list.
356 return TPResult::True;
357 } else if (Tok.is(K: tok::equal) || isTokIdentifier_in()) {
358 // MSVC and g++ won't examine the rest of declarators if '=' is
359 // encountered; they just conclude that we have a declaration.
360 // EDG parses the initializer completely, which is the proper behavior
361 // for this case.
362 //
363 // At present, Clang follows MSVC and g++, since the parser does not have
364 // the ability to parse an expression fully without recording the
365 // results of that parse.
366 // FIXME: Handle this case correctly.
367 //
368 // Also allow 'in' after an Objective-C declaration as in:
369 // for (int (^b)(void) in array). Ideally this should be done in the
370 // context of parsing for-init-statement of a foreach statement only. But,
371 // in any other context 'in' is invalid after a declaration and parser
372 // issues the error regardless of outcome of this decision.
373 // FIXME: Change if above assumption does not hold.
374 return TPResult::True;
375 }
376
377 if (!TryConsumeToken(Expected: tok::comma))
378 break;
379 }
380
381 return TPResult::Ambiguous;
382}
383
384struct Parser::ConditionDeclarationOrInitStatementState {
385 Parser &P;
386 bool CanBeExpression = true;
387 bool CanBeCondition = true;
388 bool CanBeInitStatement;
389 bool CanBeForRangeDecl;
390
391 ConditionDeclarationOrInitStatementState(Parser &P, bool CanBeInitStatement,
392 bool CanBeForRangeDecl)
393 : P(P), CanBeInitStatement(CanBeInitStatement),
394 CanBeForRangeDecl(CanBeForRangeDecl) {}
395
396 bool resolved() {
397 return CanBeExpression + CanBeCondition + CanBeInitStatement +
398 CanBeForRangeDecl < 2;
399 }
400
401 void markNotExpression() {
402 CanBeExpression = false;
403
404 if (!resolved()) {
405 // FIXME: Unify the parsing codepaths for condition variables and
406 // simple-declarations so that we don't need to eagerly figure out which
407 // kind we have here. (Just parse init-declarators until we reach a
408 // semicolon or right paren.)
409 RevertingTentativeParsingAction PA(P);
410 if (CanBeForRangeDecl) {
411 // Skip until we hit a ')', ';', or a ':' with no matching '?'.
412 // The final case is a for range declaration, the rest are not.
413 unsigned QuestionColonDepth = 0;
414 while (true) {
415 P.SkipUntil(Toks: {tok::r_paren, tok::semi, tok::question, tok::colon},
416 Flags: StopBeforeMatch);
417 if (P.Tok.is(K: tok::question))
418 ++QuestionColonDepth;
419 else if (P.Tok.is(K: tok::colon)) {
420 if (QuestionColonDepth)
421 --QuestionColonDepth;
422 else {
423 CanBeCondition = CanBeInitStatement = false;
424 return;
425 }
426 } else {
427 CanBeForRangeDecl = false;
428 break;
429 }
430 P.ConsumeToken();
431 }
432 } else {
433 // Just skip until we hit a ')' or ';'.
434 P.SkipUntil(T1: tok::r_paren, T2: tok::semi, Flags: StopBeforeMatch);
435 }
436 if (P.Tok.isNot(K: tok::r_paren))
437 CanBeCondition = CanBeForRangeDecl = false;
438 if (P.Tok.isNot(K: tok::semi))
439 CanBeInitStatement = false;
440 }
441 }
442
443 bool markNotCondition() {
444 CanBeCondition = false;
445 return resolved();
446 }
447
448 bool markNotForRangeDecl() {
449 CanBeForRangeDecl = false;
450 return resolved();
451 }
452
453 bool update(TPResult IsDecl) {
454 switch (IsDecl) {
455 case TPResult::True:
456 markNotExpression();
457 assert(resolved() && "can't continue after tentative parsing bails out");
458 break;
459 case TPResult::False:
460 CanBeCondition = CanBeInitStatement = CanBeForRangeDecl = false;
461 break;
462 case TPResult::Ambiguous:
463 break;
464 case TPResult::Error:
465 CanBeExpression = CanBeCondition = CanBeInitStatement =
466 CanBeForRangeDecl = false;
467 break;
468 }
469 return resolved();
470 }
471
472 ConditionOrInitStatement result() const {
473 assert(CanBeExpression + CanBeCondition + CanBeInitStatement +
474 CanBeForRangeDecl < 2 &&
475 "result called but not yet resolved");
476 if (CanBeExpression)
477 return ConditionOrInitStatement::Expression;
478 if (CanBeCondition)
479 return ConditionOrInitStatement::ConditionDecl;
480 if (CanBeInitStatement)
481 return ConditionOrInitStatement::InitStmtDecl;
482 if (CanBeForRangeDecl)
483 return ConditionOrInitStatement::ForRangeDecl;
484 return ConditionOrInitStatement::Error;
485 }
486};
487
488bool Parser::isEnumBase(bool AllowSemi) {
489 assert(Tok.is(tok::colon) && "should be looking at the ':'");
490
491 RevertingTentativeParsingAction PA(*this);
492 // ':'
493 ConsumeToken();
494
495 // type-specifier-seq
496 bool InvalidAsDeclSpec = false;
497 // FIXME: We could disallow non-type decl-specifiers here, but it makes no
498 // difference: those specifiers are ill-formed regardless of the
499 // interpretation.
500 TPResult R = isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No,
501 /*BracedCastResult=*/TPResult::True,
502 InvalidAsDeclSpec: &InvalidAsDeclSpec);
503 if (R == TPResult::Ambiguous) {
504 // We either have a decl-specifier followed by '(' or an undeclared
505 // identifier.
506 if (TryConsumeDeclarationSpecifier() == TPResult::Error)
507 return true;
508
509 // If we get to the end of the enum-base, we hit either a '{' or a ';'.
510 // Don't bother checking the enumerator-list.
511 if (Tok.is(K: tok::l_brace) || (AllowSemi && Tok.is(K: tok::semi)))
512 return true;
513
514 // A second decl-specifier unambiguously indicatges an enum-base.
515 R = isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No, BracedCastResult: TPResult::True,
516 InvalidAsDeclSpec: &InvalidAsDeclSpec);
517 }
518
519 return R != TPResult::False;
520}
521
522/// Disambiguates between a declaration in a condition, a
523/// simple-declaration in an init-statement, and an expression for
524/// a condition of a if/switch statement.
525///
526/// condition:
527/// expression
528/// type-specifier-seq declarator '=' assignment-expression
529/// [C++11] type-specifier-seq declarator '=' initializer-clause
530/// [C++11] type-specifier-seq declarator braced-init-list
531/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
532/// '=' assignment-expression
533/// simple-declaration:
534/// decl-specifier-seq init-declarator-list[opt] ';'
535///
536/// Note that, unlike isCXXSimpleDeclaration, we must disambiguate all the way
537/// to the ';' to disambiguate cases like 'int(x))' (an expression) from
538/// 'int(x);' (a simple-declaration in an init-statement).
539Parser::ConditionOrInitStatement
540Parser::isCXXConditionDeclarationOrInitStatement(bool CanBeInitStatement,
541 bool CanBeForRangeDecl) {
542 ConditionDeclarationOrInitStatementState State(*this, CanBeInitStatement,
543 CanBeForRangeDecl);
544
545 if (CanBeInitStatement && Tok.is(K: tok::kw_using))
546 return ConditionOrInitStatement::InitStmtDecl;
547 if (State.update(IsDecl: isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No)))
548 return State.result();
549
550 // It might be a declaration; we need tentative parsing.
551 RevertingTentativeParsingAction PA(*this);
552
553 // FIXME: A tag definition unambiguously tells us this is an init-statement.
554 bool MayHaveTrailingReturnType = Tok.is(K: tok::kw_auto);
555 if (State.update(IsDecl: TryConsumeDeclarationSpecifier()))
556 return State.result();
557 assert(Tok.is(tok::l_paren) && "Expected '('");
558
559 while (true) {
560 // Consume a declarator.
561 if (State.update(IsDecl: TryParseDeclarator(
562 /*mayBeAbstract=*/false,
563 /*mayHaveIdentifier=*/true,
564 /*mayHaveDirectInit=*/false,
565 /*mayHaveTrailingReturnType=*/MayHaveTrailingReturnType)))
566 return State.result();
567
568 // Attributes, asm label, or an initializer imply this is not an expression.
569 // FIXME: Disambiguate properly after an = instead of assuming that it's a
570 // valid declaration.
571 if (Tok.isOneOf(K1: tok::equal, Ks: tok::kw_asm, Ks: tok::kw___attribute) ||
572 (getLangOpts().CPlusPlus11 && Tok.is(K: tok::l_brace))) {
573 State.markNotExpression();
574 return State.result();
575 }
576
577 // A colon here identifies a for-range declaration.
578 if (State.CanBeForRangeDecl && Tok.is(K: tok::colon))
579 return ConditionOrInitStatement::ForRangeDecl;
580
581 // At this point, it can't be a condition any more, because a condition
582 // must have a brace-or-equal-initializer.
583 if (State.markNotCondition())
584 return State.result();
585
586 // Likewise, it can't be a for-range declaration any more.
587 if (State.markNotForRangeDecl())
588 return State.result();
589
590 // A parenthesized initializer could be part of an expression or a
591 // simple-declaration.
592 if (Tok.is(K: tok::l_paren)) {
593 ConsumeParen();
594 SkipUntil(T: tok::r_paren, Flags: StopAtSemi);
595 }
596
597 if (!TryConsumeToken(Expected: tok::comma))
598 break;
599 }
600
601 // We reached the end. If it can now be some kind of decl, then it is.
602 if (State.CanBeCondition && Tok.is(K: tok::r_paren))
603 return ConditionOrInitStatement::ConditionDecl;
604 else if (State.CanBeInitStatement && Tok.is(K: tok::semi))
605 return ConditionOrInitStatement::InitStmtDecl;
606 else
607 return ConditionOrInitStatement::Expression;
608}
609
610 /// Determine whether the next set of tokens contains a type-id.
611 ///
612 /// The context parameter states what context we're parsing right
613 /// now, which affects how this routine copes with the token
614 /// following the type-id. If the context is TypeIdInParens, we have
615 /// already parsed the '(' and we will cease lookahead when we hit
616 /// the corresponding ')'. If the context is
617 /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
618 /// before this template argument, and will cease lookahead when we
619 /// hit a '>', '>>' (in C++0x), or ','; or, in C++0x, an ellipsis immediately
620 /// preceding such. Returns true for a type-id and false for an expression.
621 /// If during the disambiguation process a parsing error is encountered,
622 /// the function returns true to let the declaration parsing code handle it.
623 ///
624 /// type-id:
625 /// type-specifier-seq abstract-declarator[opt]
626 ///
627bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
628
629 isAmbiguous = false;
630
631 // C++ 8.2p2:
632 // The ambiguity arising from the similarity between a function-style cast and
633 // a type-id can occur in different contexts. The ambiguity appears as a
634 // choice between a function-style cast expression and a declaration of a
635 // type. The resolution is that any construct that could possibly be a type-id
636 // in its syntactic context shall be considered a type-id.
637
638 TPResult TPR = isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No);
639 if (TPR != TPResult::Ambiguous)
640 return TPR != TPResult::False; // Returns true for TPResult::True or
641 // TPResult::Error.
642
643 // FIXME: Add statistics about the number of ambiguous statements encountered
644 // and how they were resolved (number of declarations+number of expressions).
645
646 // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
647 // We need tentative parsing...
648
649 RevertingTentativeParsingAction PA(*this);
650 bool MayHaveTrailingReturnType = Tok.is(K: tok::kw_auto);
651
652 // type-specifier-seq
653 TryConsumeDeclarationSpecifier();
654 assert(Tok.is(tok::l_paren) && "Expected '('");
655
656 // declarator
657 TPR = TryParseDeclarator(mayBeAbstract: true /*mayBeAbstract*/, mayHaveIdentifier: false /*mayHaveIdentifier*/,
658 /*mayHaveDirectInit=*/false,
659 mayHaveTrailingReturnType: MayHaveTrailingReturnType);
660
661 // In case of an error, let the declaration parsing code handle it.
662 if (TPR == TPResult::Error)
663 TPR = TPResult::True;
664
665 if (TPR == TPResult::Ambiguous) {
666 // We are supposed to be inside parens, so if after the abstract declarator
667 // we encounter a ')' this is a type-id, otherwise it's an expression.
668 if (Context == TypeIdInParens && Tok.is(K: tok::r_paren)) {
669 TPR = TPResult::True;
670 isAmbiguous = true;
671 // We are supposed to be inside the first operand to a _Generic selection
672 // expression, so if we find a comma after the declarator, we've found a
673 // type and not an expression.
674 } else if (Context == TypeIdAsGenericSelectionArgument && Tok.is(K: tok::comma)) {
675 TPR = TPResult::True;
676 isAmbiguous = true;
677 // We are supposed to be inside a template argument, so if after
678 // the abstract declarator we encounter a '>', '>>' (in C++0x), or
679 // ','; or, in C++0x, an ellipsis immediately preceding such, this
680 // is a type-id. Otherwise, it's an expression.
681 } else if (Context == TypeIdAsTemplateArgument &&
682 (Tok.isOneOf(K1: tok::greater, K2: tok::comma) ||
683 (getLangOpts().CPlusPlus11 &&
684 (Tok.isOneOf(K1: tok::greatergreater,
685 K2: tok::greatergreatergreater) ||
686 (Tok.is(K: tok::ellipsis) &&
687 NextToken().isOneOf(K1: tok::greater, Ks: tok::greatergreater,
688 Ks: tok::greatergreatergreater,
689 Ks: tok::comma)))))) {
690 TPR = TPResult::True;
691 isAmbiguous = true;
692
693 } else if (Context == TypeIdInTrailingReturnType) {
694 TPR = TPResult::True;
695 isAmbiguous = true;
696 } else
697 TPR = TPResult::False;
698 }
699
700 assert(TPR == TPResult::True || TPR == TPResult::False);
701 return TPR == TPResult::True;
702}
703
704/// Returns true if this is a C++11 attribute-specifier. Per
705/// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
706/// always introduce an attribute. In Objective-C++11, this rule does not
707/// apply if either '[' begins a message-send.
708///
709/// If Disambiguate is true, we try harder to determine whether a '[[' starts
710/// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
711///
712/// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
713/// Obj-C message send or the start of an attribute. Otherwise, we assume it
714/// is not an Obj-C message send.
715///
716/// C++11 [dcl.attr.grammar]:
717///
718/// attribute-specifier:
719/// '[' '[' attribute-list ']' ']'
720/// alignment-specifier
721///
722/// attribute-list:
723/// attribute[opt]
724/// attribute-list ',' attribute[opt]
725/// attribute '...'
726/// attribute-list ',' attribute '...'
727///
728/// attribute:
729/// attribute-token attribute-argument-clause[opt]
730///
731/// attribute-token:
732/// identifier
733/// identifier '::' identifier
734///
735/// attribute-argument-clause:
736/// '(' balanced-token-seq ')'
737Parser::CXX11AttributeKind
738Parser::isCXX11AttributeSpecifier(bool Disambiguate,
739 bool OuterMightBeMessageSend) {
740 // alignas is an attribute specifier in C++ but not in C23.
741 if (Tok.is(K: tok::kw_alignas) && !getLangOpts().C23)
742 return CAK_AttributeSpecifier;
743
744 if (Tok.isRegularKeywordAttribute())
745 return CAK_AttributeSpecifier;
746
747 if (Tok.isNot(K: tok::l_square) || NextToken().isNot(K: tok::l_square))
748 return CAK_NotAttributeSpecifier;
749
750 // No tentative parsing if we don't need to look for ']]' or a lambda.
751 if (!Disambiguate && !getLangOpts().ObjC)
752 return CAK_AttributeSpecifier;
753
754 // '[[using ns: ...]]' is an attribute.
755 if (GetLookAheadToken(N: 2).is(K: tok::kw_using))
756 return CAK_AttributeSpecifier;
757
758 RevertingTentativeParsingAction PA(*this);
759
760 // Opening brackets were checked for above.
761 ConsumeBracket();
762
763 if (!getLangOpts().ObjC) {
764 ConsumeBracket();
765
766 bool IsAttribute = SkipUntil(T: tok::r_square);
767 IsAttribute &= Tok.is(K: tok::r_square);
768
769 return IsAttribute ? CAK_AttributeSpecifier : CAK_InvalidAttributeSpecifier;
770 }
771
772 // In Obj-C++11, we need to distinguish four situations:
773 // 1a) int x[[attr]]; C++11 attribute.
774 // 1b) [[attr]]; C++11 statement attribute.
775 // 2) int x[[obj](){ return 1; }()]; Lambda in array size/index.
776 // 3a) int x[[obj get]]; Message send in array size/index.
777 // 3b) [[Class alloc] init]; Message send in message send.
778 // 4) [[obj]{ return self; }() doStuff]; Lambda in message send.
779 // (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
780
781 // Check to see if this is a lambda-expression.
782 // FIXME: If this disambiguation is too slow, fold the tentative lambda parse
783 // into the tentative attribute parse below.
784 {
785 RevertingTentativeParsingAction LambdaTPA(*this);
786 LambdaIntroducer Intro;
787 LambdaIntroducerTentativeParse Tentative;
788 if (ParseLambdaIntroducer(Intro, Tentative: &Tentative)) {
789 // We hit a hard error after deciding this was not an attribute.
790 // FIXME: Don't parse and annotate expressions when disambiguating
791 // against an attribute.
792 return CAK_NotAttributeSpecifier;
793 }
794
795 switch (Tentative) {
796 case LambdaIntroducerTentativeParse::MessageSend:
797 // Case 3: The inner construct is definitely a message send, so the
798 // outer construct is definitely not an attribute.
799 return CAK_NotAttributeSpecifier;
800
801 case LambdaIntroducerTentativeParse::Success:
802 case LambdaIntroducerTentativeParse::Incomplete:
803 // This is a lambda-introducer or attribute-specifier.
804 if (Tok.is(K: tok::r_square))
805 // Case 1: C++11 attribute.
806 return CAK_AttributeSpecifier;
807
808 if (OuterMightBeMessageSend)
809 // Case 4: Lambda in message send.
810 return CAK_NotAttributeSpecifier;
811
812 // Case 2: Lambda in array size / index.
813 return CAK_InvalidAttributeSpecifier;
814
815 case LambdaIntroducerTentativeParse::Invalid:
816 // No idea what this is; we couldn't parse it as a lambda-introducer.
817 // Might still be an attribute-specifier or a message send.
818 break;
819 }
820 }
821
822 ConsumeBracket();
823
824 // If we don't have a lambda-introducer, then we have an attribute or a
825 // message-send.
826 bool IsAttribute = true;
827 while (Tok.isNot(K: tok::r_square)) {
828 if (Tok.is(K: tok::comma)) {
829 // Case 1: Stray commas can only occur in attributes.
830 return CAK_AttributeSpecifier;
831 }
832
833 // Parse the attribute-token, if present.
834 // C++11 [dcl.attr.grammar]:
835 // If a keyword or an alternative token that satisfies the syntactic
836 // requirements of an identifier is contained in an attribute-token,
837 // it is considered an identifier.
838 SourceLocation Loc;
839 if (!TryParseCXX11AttributeIdentifier(Loc)) {
840 IsAttribute = false;
841 break;
842 }
843 if (Tok.is(K: tok::coloncolon)) {
844 ConsumeToken();
845 if (!TryParseCXX11AttributeIdentifier(Loc)) {
846 IsAttribute = false;
847 break;
848 }
849 }
850
851 // Parse the attribute-argument-clause, if present.
852 if (Tok.is(K: tok::l_paren)) {
853 ConsumeParen();
854 if (!SkipUntil(T: tok::r_paren)) {
855 IsAttribute = false;
856 break;
857 }
858 }
859
860 TryConsumeToken(Expected: tok::ellipsis);
861
862 if (!TryConsumeToken(Expected: tok::comma))
863 break;
864 }
865
866 // An attribute must end ']]'.
867 if (IsAttribute) {
868 if (Tok.is(K: tok::r_square)) {
869 ConsumeBracket();
870 IsAttribute = Tok.is(K: tok::r_square);
871 } else {
872 IsAttribute = false;
873 }
874 }
875
876 if (IsAttribute)
877 // Case 1: C++11 statement attribute.
878 return CAK_AttributeSpecifier;
879
880 // Case 3: Message send.
881 return CAK_NotAttributeSpecifier;
882}
883
884bool Parser::TrySkipAttributes() {
885 while (Tok.isOneOf(K1: tok::l_square, Ks: tok::kw___attribute, Ks: tok::kw___declspec,
886 Ks: tok::kw_alignas) ||
887 Tok.isRegularKeywordAttribute()) {
888 if (Tok.is(K: tok::l_square)) {
889 ConsumeBracket();
890 if (Tok.isNot(K: tok::l_square))
891 return false;
892 ConsumeBracket();
893 if (!SkipUntil(T: tok::r_square) || Tok.isNot(K: tok::r_square))
894 return false;
895 // Note that explicitly checking for `[[` and `]]` allows to fail as
896 // expected in the case of the Objective-C message send syntax.
897 ConsumeBracket();
898 } else if (Tok.isRegularKeywordAttribute() &&
899 !doesKeywordAttributeTakeArgs(Kind: Tok.getKind())) {
900 ConsumeToken();
901 } else {
902 ConsumeToken();
903 if (Tok.isNot(K: tok::l_paren))
904 return false;
905 ConsumeParen();
906 if (!SkipUntil(T: tok::r_paren))
907 return false;
908 }
909 }
910
911 return true;
912}
913
914Parser::TPResult Parser::TryParsePtrOperatorSeq() {
915 while (true) {
916 if (TryAnnotateOptionalCXXScopeToken(EnteringContext: true))
917 return TPResult::Error;
918
919 if (Tok.isOneOf(K1: tok::star, Ks: tok::amp, Ks: tok::caret, Ks: tok::ampamp) ||
920 (Tok.is(K: tok::annot_cxxscope) && NextToken().is(K: tok::star))) {
921 // ptr-operator
922 ConsumeAnyToken();
923
924 // Skip attributes.
925 if (!TrySkipAttributes())
926 return TPResult::Error;
927
928 while (Tok.isOneOf(K1: tok::kw_const, Ks: tok::kw_volatile, Ks: tok::kw_restrict,
929 Ks: tok::kw__Nonnull, Ks: tok::kw__Nullable,
930 Ks: tok::kw__Nullable_result, Ks: tok::kw__Null_unspecified,
931 Ks: tok::kw__Atomic))
932 ConsumeToken();
933 } else {
934 return TPResult::True;
935 }
936 }
937}
938
939/// operator-function-id:
940/// 'operator' operator
941///
942/// operator: one of
943/// new delete new[] delete[] + - * / % ^ [...]
944///
945/// conversion-function-id:
946/// 'operator' conversion-type-id
947///
948/// conversion-type-id:
949/// type-specifier-seq conversion-declarator[opt]
950///
951/// conversion-declarator:
952/// ptr-operator conversion-declarator[opt]
953///
954/// literal-operator-id:
955/// 'operator' string-literal identifier
956/// 'operator' user-defined-string-literal
957Parser::TPResult Parser::TryParseOperatorId() {
958 assert(Tok.is(tok::kw_operator));
959 ConsumeToken();
960
961 // Maybe this is an operator-function-id.
962 switch (Tok.getKind()) {
963 case tok::kw_new: case tok::kw_delete:
964 ConsumeToken();
965 if (Tok.is(K: tok::l_square) && NextToken().is(K: tok::r_square)) {
966 ConsumeBracket();
967 ConsumeBracket();
968 }
969 return TPResult::True;
970
971#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemOnly) \
972 case tok::Token:
973#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemOnly)
974#include "clang/Basic/OperatorKinds.def"
975 ConsumeToken();
976 return TPResult::True;
977
978 case tok::l_square:
979 if (NextToken().is(K: tok::r_square)) {
980 ConsumeBracket();
981 ConsumeBracket();
982 return TPResult::True;
983 }
984 break;
985
986 case tok::l_paren:
987 if (NextToken().is(K: tok::r_paren)) {
988 ConsumeParen();
989 ConsumeParen();
990 return TPResult::True;
991 }
992 break;
993
994 default:
995 break;
996 }
997
998 // Maybe this is a literal-operator-id.
999 if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
1000 bool FoundUDSuffix = false;
1001 do {
1002 FoundUDSuffix |= Tok.hasUDSuffix();
1003 ConsumeStringToken();
1004 } while (isTokenStringLiteral());
1005
1006 if (!FoundUDSuffix) {
1007 if (Tok.is(K: tok::identifier))
1008 ConsumeToken();
1009 else
1010 return TPResult::Error;
1011 }
1012 return TPResult::True;
1013 }
1014
1015 // Maybe this is a conversion-function-id.
1016 bool AnyDeclSpecifiers = false;
1017 while (true) {
1018 TPResult TPR = isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No);
1019 if (TPR == TPResult::Error)
1020 return TPR;
1021 if (TPR == TPResult::False) {
1022 if (!AnyDeclSpecifiers)
1023 return TPResult::Error;
1024 break;
1025 }
1026 if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1027 return TPResult::Error;
1028 AnyDeclSpecifiers = true;
1029 }
1030 return TryParsePtrOperatorSeq();
1031}
1032
1033/// declarator:
1034/// direct-declarator
1035/// ptr-operator declarator
1036///
1037/// direct-declarator:
1038/// declarator-id
1039/// direct-declarator '(' parameter-declaration-clause ')'
1040/// cv-qualifier-seq[opt] exception-specification[opt]
1041/// direct-declarator '[' constant-expression[opt] ']'
1042/// '(' declarator ')'
1043/// [GNU] '(' attributes declarator ')'
1044///
1045/// abstract-declarator:
1046/// ptr-operator abstract-declarator[opt]
1047/// direct-abstract-declarator
1048///
1049/// direct-abstract-declarator:
1050/// direct-abstract-declarator[opt]
1051/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1052/// exception-specification[opt]
1053/// direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
1054/// '(' abstract-declarator ')'
1055/// [C++0x] ...
1056///
1057/// ptr-operator:
1058/// '*' cv-qualifier-seq[opt]
1059/// '&'
1060/// [C++0x] '&&' [TODO]
1061/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
1062///
1063/// cv-qualifier-seq:
1064/// cv-qualifier cv-qualifier-seq[opt]
1065///
1066/// cv-qualifier:
1067/// 'const'
1068/// 'volatile'
1069///
1070/// declarator-id:
1071/// '...'[opt] id-expression
1072///
1073/// id-expression:
1074/// unqualified-id
1075/// qualified-id [TODO]
1076///
1077/// unqualified-id:
1078/// identifier
1079/// operator-function-id
1080/// conversion-function-id
1081/// literal-operator-id
1082/// '~' class-name [TODO]
1083/// '~' decltype-specifier [TODO]
1084/// template-id [TODO]
1085///
1086Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
1087 bool mayHaveIdentifier,
1088 bool mayHaveDirectInit,
1089 bool mayHaveTrailingReturnType) {
1090 // declarator:
1091 // direct-declarator
1092 // ptr-operator declarator
1093 if (TryParsePtrOperatorSeq() == TPResult::Error)
1094 return TPResult::Error;
1095
1096 // direct-declarator:
1097 // direct-abstract-declarator:
1098 if (Tok.is(K: tok::ellipsis))
1099 ConsumeToken();
1100
1101 if ((Tok.isOneOf(K1: tok::identifier, K2: tok::kw_operator) ||
1102 (Tok.is(K: tok::annot_cxxscope) && (NextToken().is(K: tok::identifier) ||
1103 NextToken().is(K: tok::kw_operator)))) &&
1104 mayHaveIdentifier) {
1105 // declarator-id
1106 if (Tok.is(K: tok::annot_cxxscope)) {
1107 CXXScopeSpec SS;
1108 Actions.RestoreNestedNameSpecifierAnnotation(
1109 Annotation: Tok.getAnnotationValue(), AnnotationRange: Tok.getAnnotationRange(), SS);
1110 if (SS.isInvalid())
1111 return TPResult::Error;
1112 ConsumeAnnotationToken();
1113 } else if (Tok.is(K: tok::identifier)) {
1114 TentativelyDeclaredIdentifiers.push_back(Elt: Tok.getIdentifierInfo());
1115 }
1116 if (Tok.is(K: tok::kw_operator)) {
1117 if (TryParseOperatorId() == TPResult::Error)
1118 return TPResult::Error;
1119 } else
1120 ConsumeToken();
1121 } else if (Tok.is(K: tok::l_paren)) {
1122 ConsumeParen();
1123 if (mayBeAbstract &&
1124 (Tok.is(K: tok::r_paren) || // 'int()' is a function.
1125 // 'int(...)' is a function.
1126 (Tok.is(K: tok::ellipsis) && NextToken().is(K: tok::r_paren)) ||
1127 isDeclarationSpecifier(
1128 AllowImplicitTypename: ImplicitTypenameContext::No))) { // 'int(int)' is a function.
1129 // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1130 // exception-specification[opt]
1131 TPResult TPR = TryParseFunctionDeclarator(MayHaveTrailingReturnType: mayHaveTrailingReturnType);
1132 if (TPR != TPResult::Ambiguous)
1133 return TPR;
1134 } else {
1135 // '(' declarator ')'
1136 // '(' attributes declarator ')'
1137 // '(' abstract-declarator ')'
1138 if (Tok.isOneOf(K1: tok::kw___attribute, Ks: tok::kw___declspec, Ks: tok::kw___cdecl,
1139 Ks: tok::kw___stdcall, Ks: tok::kw___fastcall, Ks: tok::kw___thiscall,
1140 Ks: tok::kw___regcall, Ks: tok::kw___vectorcall))
1141 return TPResult::True; // attributes indicate declaration
1142 TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
1143 if (TPR != TPResult::Ambiguous)
1144 return TPR;
1145 if (Tok.isNot(K: tok::r_paren))
1146 return TPResult::False;
1147 ConsumeParen();
1148 }
1149 } else if (!mayBeAbstract) {
1150 return TPResult::False;
1151 }
1152
1153 if (mayHaveDirectInit)
1154 return TPResult::Ambiguous;
1155
1156 while (true) {
1157 TPResult TPR(TPResult::Ambiguous);
1158
1159 if (Tok.is(K: tok::l_paren)) {
1160 // Check whether we have a function declarator or a possible ctor-style
1161 // initializer that follows the declarator. Note that ctor-style
1162 // initializers are not possible in contexts where abstract declarators
1163 // are allowed.
1164 if (!mayBeAbstract && !isCXXFunctionDeclarator())
1165 break;
1166
1167 // direct-declarator '(' parameter-declaration-clause ')'
1168 // cv-qualifier-seq[opt] exception-specification[opt]
1169 ConsumeParen();
1170 TPR = TryParseFunctionDeclarator(MayHaveTrailingReturnType: mayHaveTrailingReturnType);
1171 } else if (Tok.is(K: tok::l_square)) {
1172 // direct-declarator '[' constant-expression[opt] ']'
1173 // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
1174 TPR = TryParseBracketDeclarator();
1175 } else if (Tok.is(K: tok::kw_requires)) {
1176 // declarator requires-clause
1177 // A requires clause indicates a function declaration.
1178 TPR = TPResult::True;
1179 } else {
1180 break;
1181 }
1182
1183 if (TPR != TPResult::Ambiguous)
1184 return TPR;
1185 }
1186
1187 return TPResult::Ambiguous;
1188}
1189
1190bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
1191 return llvm::is_contained(Range&: TentativelyDeclaredIdentifiers, Element: II);
1192}
1193
1194namespace {
1195class TentativeParseCCC final : public CorrectionCandidateCallback {
1196public:
1197 TentativeParseCCC(const Token &Next) {
1198 WantRemainingKeywords = false;
1199 WantTypeSpecifiers =
1200 Next.isOneOf(K1: tok::l_paren, Ks: tok::r_paren, Ks: tok::greater, Ks: tok::l_brace,
1201 Ks: tok::identifier, Ks: tok::comma);
1202 }
1203
1204 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1205 // Reject any candidate that only resolves to instance members since they
1206 // aren't viable as standalone identifiers instead of member references.
1207 if (Candidate.isResolved() && !Candidate.isKeyword() &&
1208 llvm::all_of(Range: Candidate,
1209 P: [](NamedDecl *ND) { return ND->isCXXInstanceMember(); }))
1210 return false;
1211
1212 return CorrectionCandidateCallback::ValidateCandidate(candidate: Candidate);
1213 }
1214
1215 std::unique_ptr<CorrectionCandidateCallback> clone() override {
1216 return std::make_unique<TentativeParseCCC>(args&: *this);
1217 }
1218};
1219}
1220/// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
1221/// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
1222/// be either a decl-specifier or a function-style cast, and TPResult::Error
1223/// if a parsing error was found and reported.
1224///
1225/// If InvalidAsDeclSpec is not null, some cases that would be ill-formed as
1226/// declaration specifiers but possibly valid as some other kind of construct
1227/// return TPResult::Ambiguous instead of TPResult::False. When this happens,
1228/// the intent is to keep trying to disambiguate, on the basis that we might
1229/// find a better reason to treat this construct as a declaration later on.
1230/// When this happens and the name could possibly be valid in some other
1231/// syntactic context, *InvalidAsDeclSpec is set to 'true'. The current cases
1232/// that trigger this are:
1233///
1234/// * When parsing X::Y (with no 'typename') where X is dependent
1235/// * When parsing X<Y> where X is undeclared
1236///
1237/// decl-specifier:
1238/// storage-class-specifier
1239/// type-specifier
1240/// function-specifier
1241/// 'friend'
1242/// 'typedef'
1243/// [C++11] 'constexpr'
1244/// [C++20] 'consteval'
1245/// [GNU] attributes declaration-specifiers[opt]
1246///
1247/// storage-class-specifier:
1248/// 'register'
1249/// 'static'
1250/// 'extern'
1251/// 'mutable'
1252/// 'auto'
1253/// [GNU] '__thread'
1254/// [C++11] 'thread_local'
1255/// [C11] '_Thread_local'
1256///
1257/// function-specifier:
1258/// 'inline'
1259/// 'virtual'
1260/// 'explicit'
1261///
1262/// typedef-name:
1263/// identifier
1264///
1265/// type-specifier:
1266/// simple-type-specifier
1267/// class-specifier
1268/// enum-specifier
1269/// elaborated-type-specifier
1270/// typename-specifier
1271/// cv-qualifier
1272///
1273/// simple-type-specifier:
1274/// '::'[opt] nested-name-specifier[opt] type-name
1275/// '::'[opt] nested-name-specifier 'template'
1276/// simple-template-id [TODO]
1277/// 'char'
1278/// 'wchar_t'
1279/// 'bool'
1280/// 'short'
1281/// 'int'
1282/// 'long'
1283/// 'signed'
1284/// 'unsigned'
1285/// 'float'
1286/// 'double'
1287/// 'void'
1288/// [GNU] typeof-specifier
1289/// [GNU] '_Complex'
1290/// [C++11] 'auto'
1291/// [GNU] '__auto_type'
1292/// [C++11] 'decltype' ( expression )
1293/// [C++1y] 'decltype' ( 'auto' )
1294///
1295/// type-name:
1296/// class-name
1297/// enum-name
1298/// typedef-name
1299///
1300/// elaborated-type-specifier:
1301/// class-key '::'[opt] nested-name-specifier[opt] identifier
1302/// class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
1303/// simple-template-id
1304/// 'enum' '::'[opt] nested-name-specifier[opt] identifier
1305///
1306/// enum-name:
1307/// identifier
1308///
1309/// enum-specifier:
1310/// 'enum' identifier[opt] '{' enumerator-list[opt] '}'
1311/// 'enum' identifier[opt] '{' enumerator-list ',' '}'
1312///
1313/// class-specifier:
1314/// class-head '{' member-specification[opt] '}'
1315///
1316/// class-head:
1317/// class-key identifier[opt] base-clause[opt]
1318/// class-key nested-name-specifier identifier base-clause[opt]
1319/// class-key nested-name-specifier[opt] simple-template-id
1320/// base-clause[opt]
1321///
1322/// class-key:
1323/// 'class'
1324/// 'struct'
1325/// 'union'
1326///
1327/// cv-qualifier:
1328/// 'const'
1329/// 'volatile'
1330/// [GNU] restrict
1331///
1332Parser::TPResult
1333Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
1334 Parser::TPResult BracedCastResult,
1335 bool *InvalidAsDeclSpec) {
1336 auto IsPlaceholderSpecifier = [&](TemplateIdAnnotation *TemplateId,
1337 int Lookahead) {
1338 // We have a placeholder-constraint (we check for 'auto' or 'decltype' to
1339 // distinguish 'C<int>;' from 'C<int> auto c = 1;')
1340 return TemplateId->Kind == TNK_Concept_template &&
1341 (GetLookAheadToken(N: Lookahead + 1)
1342 .isOneOf(K1: tok::kw_auto, Ks: tok::kw_decltype,
1343 // If we have an identifier here, the user probably
1344 // forgot the 'auto' in the placeholder constraint,
1345 // e.g. 'C<int> x = 2;' This will be diagnosed nicely
1346 // later, so disambiguate as a declaration.
1347 Ks: tok::identifier,
1348 // CVR qualifierslikely the same situation for the
1349 // user, so let this be diagnosed nicely later. We
1350 // cannot handle references here, as `C<int> & Other`
1351 // and `C<int> && Other` are both legal.
1352 Ks: tok::kw_const, Ks: tok::kw_volatile, Ks: tok::kw_restrict) ||
1353 // While `C<int> && Other` is legal, doing so while not specifying a
1354 // template argument is NOT, so see if we can fix up in that case at
1355 // minimum. Concepts require at least 1 template parameter, so we
1356 // can count on the argument count.
1357 // FIXME: In the future, we migth be able to have SEMA look up the
1358 // declaration for this concept, and see how many template
1359 // parameters it has. If the concept isn't fully specified, it is
1360 // possibly a situation where we want deduction, such as:
1361 // `BinaryConcept<int> auto f = bar();`
1362 (TemplateId->NumArgs == 0 &&
1363 GetLookAheadToken(N: Lookahead + 1).isOneOf(K1: tok::amp, K2: tok::ampamp)));
1364 };
1365 switch (Tok.getKind()) {
1366 case tok::identifier: {
1367 if (GetLookAheadToken(N: 1).is(K: tok::ellipsis) &&
1368 GetLookAheadToken(N: 2).is(K: tok::l_square)) {
1369
1370 if (TryAnnotateTypeOrScopeToken())
1371 return TPResult::Error;
1372 if (Tok.is(K: tok::identifier))
1373 return TPResult::False;
1374 return isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No,
1375 BracedCastResult, InvalidAsDeclSpec);
1376 }
1377
1378 // Check for need to substitute AltiVec __vector keyword
1379 // for "vector" identifier.
1380 if (TryAltiVecVectorToken())
1381 return TPResult::True;
1382
1383 const Token &Next = NextToken();
1384 // In 'foo bar', 'foo' is always a type name outside of Objective-C.
1385 if (!getLangOpts().ObjC && Next.is(K: tok::identifier))
1386 return TPResult::True;
1387
1388 // If this identifier was reverted from a token ID, and the next token
1389 // is a '(', we assume it to be a use of a type trait, so this
1390 // can never be a type name.
1391 if (Next.is(K: tok::l_paren) &&
1392 Tok.getIdentifierInfo()->hasRevertedTokenIDToIdentifier() &&
1393 isRevertibleTypeTrait(Id: Tok.getIdentifierInfo())) {
1394 return TPResult::False;
1395 }
1396
1397 if (Next.isNot(K: tok::coloncolon) && Next.isNot(K: tok::less)) {
1398 // Determine whether this is a valid expression. If not, we will hit
1399 // a parse error one way or another. In that case, tell the caller that
1400 // this is ambiguous. Typo-correct to type and expression keywords and
1401 // to types and identifiers, in order to try to recover from errors.
1402 TentativeParseCCC CCC(Next);
1403 switch (TryAnnotateName(CCC: &CCC)) {
1404 case ANK_Error:
1405 return TPResult::Error;
1406 case ANK_TentativeDecl:
1407 return TPResult::False;
1408 case ANK_TemplateName:
1409 // In C++17, this could be a type template for class template argument
1410 // deduction. Try to form a type annotation for it. If we're in a
1411 // template template argument, we'll undo this when checking the
1412 // validity of the argument.
1413 if (getLangOpts().CPlusPlus17) {
1414 if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename))
1415 return TPResult::Error;
1416 if (Tok.isNot(K: tok::identifier))
1417 break;
1418 }
1419
1420 // A bare type template-name which can't be a template template
1421 // argument is an error, and was probably intended to be a type.
1422 return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1423 case ANK_Unresolved:
1424 return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
1425 case ANK_Success:
1426 break;
1427 }
1428 assert(Tok.isNot(tok::identifier) &&
1429 "TryAnnotateName succeeded without producing an annotation");
1430 } else {
1431 // This might possibly be a type with a dependent scope specifier and
1432 // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1433 // since it will annotate as a primary expression, and we want to use the
1434 // "missing 'typename'" logic.
1435 if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename))
1436 return TPResult::Error;
1437 // If annotation failed, assume it's a non-type.
1438 // FIXME: If this happens due to an undeclared identifier, treat it as
1439 // ambiguous.
1440 if (Tok.is(K: tok::identifier))
1441 return TPResult::False;
1442 }
1443
1444 // We annotated this token as something. Recurse to handle whatever we got.
1445 return isCXXDeclarationSpecifier(AllowImplicitTypename, BracedCastResult,
1446 InvalidAsDeclSpec);
1447 }
1448
1449 case tok::kw_typename: // typename T::type
1450 // Annotate typenames and C++ scope specifiers. If we get one, just
1451 // recurse to handle whatever we get.
1452 if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename: ImplicitTypenameContext::Yes))
1453 return TPResult::Error;
1454 return isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::Yes,
1455 BracedCastResult, InvalidAsDeclSpec);
1456
1457 case tok::kw_auto: {
1458 if (!getLangOpts().CPlusPlus23)
1459 return TPResult::True;
1460 if (NextToken().is(K: tok::l_brace))
1461 return TPResult::False;
1462 if (NextToken().is(K: tok::l_paren))
1463 return TPResult::Ambiguous;
1464 return TPResult::True;
1465 }
1466
1467 case tok::coloncolon: { // ::foo::bar
1468 const Token &Next = NextToken();
1469 if (Next.isOneOf(K1: tok::kw_new, // ::new
1470 K2: tok::kw_delete)) // ::delete
1471 return TPResult::False;
1472 [[fallthrough]];
1473 }
1474 case tok::kw___super:
1475 case tok::kw_decltype:
1476 // Annotate typenames and C++ scope specifiers. If we get one, just
1477 // recurse to handle whatever we get.
1478 if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename))
1479 return TPResult::Error;
1480 return isCXXDeclarationSpecifier(AllowImplicitTypename, BracedCastResult,
1481 InvalidAsDeclSpec);
1482
1483 // decl-specifier:
1484 // storage-class-specifier
1485 // type-specifier
1486 // function-specifier
1487 // 'friend'
1488 // 'typedef'
1489 // 'constexpr'
1490 case tok::kw_friend:
1491 case tok::kw_typedef:
1492 case tok::kw_constexpr:
1493 case tok::kw_consteval:
1494 case tok::kw_constinit:
1495 // storage-class-specifier
1496 case tok::kw_register:
1497 case tok::kw_static:
1498 case tok::kw_extern:
1499 case tok::kw_mutable:
1500 case tok::kw___thread:
1501 case tok::kw_thread_local:
1502 case tok::kw__Thread_local:
1503 // function-specifier
1504 case tok::kw_inline:
1505 case tok::kw_virtual:
1506 case tok::kw_explicit:
1507
1508 // Modules
1509 case tok::kw___module_private__:
1510
1511 // Debugger support
1512 case tok::kw___unknown_anytype:
1513
1514 // type-specifier:
1515 // simple-type-specifier
1516 // class-specifier
1517 // enum-specifier
1518 // elaborated-type-specifier
1519 // typename-specifier
1520 // cv-qualifier
1521
1522 // class-specifier
1523 // elaborated-type-specifier
1524 case tok::kw_class:
1525 case tok::kw_struct:
1526 case tok::kw_union:
1527 case tok::kw___interface:
1528 // enum-specifier
1529 case tok::kw_enum:
1530 // cv-qualifier
1531 case tok::kw_const:
1532 case tok::kw_volatile:
1533 return TPResult::True;
1534
1535 // OpenCL address space qualifiers
1536 case tok::kw_private:
1537 if (!getLangOpts().OpenCL)
1538 return TPResult::False;
1539 [[fallthrough]];
1540 case tok::kw___private:
1541 case tok::kw___local:
1542 case tok::kw___global:
1543 case tok::kw___constant:
1544 case tok::kw___generic:
1545 // OpenCL access qualifiers
1546 case tok::kw___read_only:
1547 case tok::kw___write_only:
1548 case tok::kw___read_write:
1549 // OpenCL pipe
1550 case tok::kw_pipe:
1551
1552 // HLSL address space qualifiers
1553 case tok::kw_groupshared:
1554 case tok::kw_in:
1555 case tok::kw_inout:
1556 case tok::kw_out:
1557
1558 // GNU
1559 case tok::kw_restrict:
1560 case tok::kw__Complex:
1561 case tok::kw___attribute:
1562 case tok::kw___auto_type:
1563 return TPResult::True;
1564
1565 // Microsoft
1566 case tok::kw___declspec:
1567 case tok::kw___cdecl:
1568 case tok::kw___stdcall:
1569 case tok::kw___fastcall:
1570 case tok::kw___thiscall:
1571 case tok::kw___regcall:
1572 case tok::kw___vectorcall:
1573 case tok::kw___w64:
1574 case tok::kw___sptr:
1575 case tok::kw___uptr:
1576 case tok::kw___ptr64:
1577 case tok::kw___ptr32:
1578 case tok::kw___forceinline:
1579 case tok::kw___unaligned:
1580 case tok::kw__Nonnull:
1581 case tok::kw__Nullable:
1582 case tok::kw__Nullable_result:
1583 case tok::kw__Null_unspecified:
1584 case tok::kw___kindof:
1585 return TPResult::True;
1586
1587 // WebAssemblyFuncref
1588 case tok::kw___funcref:
1589 return TPResult::True;
1590
1591 // Borland
1592 case tok::kw___pascal:
1593 return TPResult::True;
1594
1595 // AltiVec
1596 case tok::kw___vector:
1597 return TPResult::True;
1598
1599 case tok::kw_this: {
1600 // Try to parse a C++23 Explicit Object Parameter
1601 // We do that in all language modes to produce a better diagnostic.
1602 if (getLangOpts().CPlusPlus) {
1603 RevertingTentativeParsingAction PA(*this);
1604 ConsumeToken();
1605 return isCXXDeclarationSpecifier(AllowImplicitTypename, BracedCastResult,
1606 InvalidAsDeclSpec);
1607 }
1608 return TPResult::False;
1609 }
1610 case tok::annot_template_id: {
1611 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(tok: Tok);
1612 // If lookup for the template-name found nothing, don't assume we have a
1613 // definitive disambiguation result yet.
1614 if ((TemplateId->hasInvalidName() ||
1615 TemplateId->Kind == TNK_Undeclared_template) &&
1616 InvalidAsDeclSpec) {
1617 // 'template-id(' can be a valid expression but not a valid decl spec if
1618 // the template-name is not declared, but we don't consider this to be a
1619 // definitive disambiguation. In any other context, it's an error either
1620 // way.
1621 *InvalidAsDeclSpec = NextToken().is(K: tok::l_paren);
1622 return TPResult::Ambiguous;
1623 }
1624 if (TemplateId->hasInvalidName())
1625 return TPResult::Error;
1626 if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/0))
1627 return TPResult::True;
1628 if (TemplateId->Kind != TNK_Type_template)
1629 return TPResult::False;
1630 CXXScopeSpec SS;
1631 AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
1632 assert(Tok.is(tok::annot_typename));
1633 goto case_typename;
1634 }
1635
1636 case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1637 // We've already annotated a scope; try to annotate a type.
1638 if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename))
1639 return TPResult::Error;
1640 if (!Tok.is(K: tok::annot_typename)) {
1641 if (Tok.is(K: tok::annot_cxxscope) &&
1642 NextToken().is(K: tok::annot_template_id)) {
1643 TemplateIdAnnotation *TemplateId =
1644 takeTemplateIdAnnotation(tok: NextToken());
1645 if (TemplateId->hasInvalidName()) {
1646 if (InvalidAsDeclSpec) {
1647 *InvalidAsDeclSpec = NextToken().is(K: tok::l_paren);
1648 return TPResult::Ambiguous;
1649 }
1650 return TPResult::Error;
1651 }
1652 if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/1))
1653 return TPResult::True;
1654 }
1655 // If the next token is an identifier or a type qualifier, then this
1656 // can't possibly be a valid expression either.
1657 if (Tok.is(K: tok::annot_cxxscope) && NextToken().is(K: tok::identifier)) {
1658 CXXScopeSpec SS;
1659 Actions.RestoreNestedNameSpecifierAnnotation(Annotation: Tok.getAnnotationValue(),
1660 AnnotationRange: Tok.getAnnotationRange(),
1661 SS);
1662 if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1663 RevertingTentativeParsingAction PA(*this);
1664 ConsumeAnnotationToken();
1665 ConsumeToken();
1666 bool isIdentifier = Tok.is(K: tok::identifier);
1667 TPResult TPR = TPResult::False;
1668 if (!isIdentifier)
1669 TPR = isCXXDeclarationSpecifier(
1670 AllowImplicitTypename, BracedCastResult, InvalidAsDeclSpec);
1671
1672 if (isIdentifier ||
1673 TPR == TPResult::True || TPR == TPResult::Error)
1674 return TPResult::Error;
1675
1676 if (InvalidAsDeclSpec) {
1677 // We can't tell whether this is a missing 'typename' or a valid
1678 // expression.
1679 *InvalidAsDeclSpec = true;
1680 return TPResult::Ambiguous;
1681 } else {
1682 // In MS mode, if InvalidAsDeclSpec is not provided, and the tokens
1683 // are or the form *) or &) *> or &> &&>, this can't be an expression.
1684 // The typename must be missing.
1685 if (getLangOpts().MSVCCompat) {
1686 if (((Tok.is(K: tok::amp) || Tok.is(K: tok::star)) &&
1687 (NextToken().is(K: tok::r_paren) ||
1688 NextToken().is(K: tok::greater))) ||
1689 (Tok.is(K: tok::ampamp) && NextToken().is(K: tok::greater)))
1690 return TPResult::True;
1691 }
1692 }
1693 } else {
1694 // Try to resolve the name. If it doesn't exist, assume it was
1695 // intended to name a type and keep disambiguating.
1696 switch (TryAnnotateName(/*CCC=*/nullptr, AllowImplicitTypename)) {
1697 case ANK_Error:
1698 return TPResult::Error;
1699 case ANK_TentativeDecl:
1700 return TPResult::False;
1701 case ANK_TemplateName:
1702 // In C++17, this could be a type template for class template
1703 // argument deduction.
1704 if (getLangOpts().CPlusPlus17) {
1705 if (TryAnnotateTypeOrScopeToken())
1706 return TPResult::Error;
1707 // If we annotated then the current token should not still be ::
1708 // FIXME we may want to also check for tok::annot_typename but
1709 // currently don't have a test case.
1710 if (Tok.isNot(K: tok::annot_cxxscope))
1711 break;
1712 }
1713
1714 // A bare type template-name which can't be a template template
1715 // argument is an error, and was probably intended to be a type.
1716 // In C++17, this could be class template argument deduction.
1717 return (getLangOpts().CPlusPlus17 || GreaterThanIsOperator)
1718 ? TPResult::True
1719 : TPResult::False;
1720 case ANK_Unresolved:
1721 return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
1722 case ANK_Success:
1723 break;
1724 }
1725
1726 // Annotated it, check again.
1727 assert(Tok.isNot(tok::annot_cxxscope) ||
1728 NextToken().isNot(tok::identifier));
1729 return isCXXDeclarationSpecifier(AllowImplicitTypename,
1730 BracedCastResult, InvalidAsDeclSpec);
1731 }
1732 }
1733 return TPResult::False;
1734 }
1735 // If that succeeded, fallthrough into the generic simple-type-id case.
1736 [[fallthrough]];
1737
1738 // The ambiguity resides in a simple-type-specifier/typename-specifier
1739 // followed by a '('. The '(' could either be the start of:
1740 //
1741 // direct-declarator:
1742 // '(' declarator ')'
1743 //
1744 // direct-abstract-declarator:
1745 // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1746 // exception-specification[opt]
1747 // '(' abstract-declarator ')'
1748 //
1749 // or part of a function-style cast expression:
1750 //
1751 // simple-type-specifier '(' expression-list[opt] ')'
1752 //
1753
1754 // simple-type-specifier:
1755
1756 case tok::annot_typename:
1757 case_typename:
1758 // In Objective-C, we might have a protocol-qualified type.
1759 if (getLangOpts().ObjC && NextToken().is(K: tok::less)) {
1760 // Tentatively parse the protocol qualifiers.
1761 RevertingTentativeParsingAction PA(*this);
1762 ConsumeAnyToken(); // The type token
1763
1764 TPResult TPR = TryParseProtocolQualifiers();
1765 bool isFollowedByParen = Tok.is(K: tok::l_paren);
1766 bool isFollowedByBrace = Tok.is(K: tok::l_brace);
1767
1768 if (TPR == TPResult::Error)
1769 return TPResult::Error;
1770
1771 if (isFollowedByParen)
1772 return TPResult::Ambiguous;
1773
1774 if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1775 return BracedCastResult;
1776
1777 return TPResult::True;
1778 }
1779
1780 [[fallthrough]];
1781
1782 case tok::kw_char:
1783 case tok::kw_wchar_t:
1784 case tok::kw_char8_t:
1785 case tok::kw_char16_t:
1786 case tok::kw_char32_t:
1787 case tok::kw_bool:
1788 case tok::kw_short:
1789 case tok::kw_int:
1790 case tok::kw_long:
1791 case tok::kw___int64:
1792 case tok::kw___int128:
1793 case tok::kw_signed:
1794 case tok::kw_unsigned:
1795 case tok::kw_half:
1796 case tok::kw_float:
1797 case tok::kw_double:
1798 case tok::kw___bf16:
1799 case tok::kw__Float16:
1800 case tok::kw___float128:
1801 case tok::kw___ibm128:
1802 case tok::kw_void:
1803 case tok::annot_decltype:
1804 case tok::kw__Accum:
1805 case tok::kw__Fract:
1806 case tok::kw__Sat:
1807 case tok::annot_pack_indexing_type:
1808#define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1809#include "clang/Basic/OpenCLImageTypes.def"
1810 if (NextToken().is(K: tok::l_paren))
1811 return TPResult::Ambiguous;
1812
1813 // This is a function-style cast in all cases we disambiguate other than
1814 // one:
1815 // struct S {
1816 // enum E : int { a = 4 }; // enum
1817 // enum E : int { 4 }; // bit-field
1818 // };
1819 if (getLangOpts().CPlusPlus11 && NextToken().is(K: tok::l_brace))
1820 return BracedCastResult;
1821
1822 if (isStartOfObjCClassMessageMissingOpenBracket())
1823 return TPResult::False;
1824
1825 return TPResult::True;
1826
1827 // GNU typeof support.
1828 case tok::kw_typeof: {
1829 if (NextToken().isNot(K: tok::l_paren))
1830 return TPResult::True;
1831
1832 RevertingTentativeParsingAction PA(*this);
1833
1834 TPResult TPR = TryParseTypeofSpecifier();
1835 bool isFollowedByParen = Tok.is(K: tok::l_paren);
1836 bool isFollowedByBrace = Tok.is(K: tok::l_brace);
1837
1838 if (TPR == TPResult::Error)
1839 return TPResult::Error;
1840
1841 if (isFollowedByParen)
1842 return TPResult::Ambiguous;
1843
1844 if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1845 return BracedCastResult;
1846
1847 return TPResult::True;
1848 }
1849
1850#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
1851#include "clang/Basic/TransformTypeTraits.def"
1852 return TPResult::True;
1853
1854 // C11 _Alignas
1855 case tok::kw__Alignas:
1856 return TPResult::True;
1857 // C11 _Atomic
1858 case tok::kw__Atomic:
1859 return TPResult::True;
1860
1861 case tok::kw__BitInt:
1862 case tok::kw__ExtInt: {
1863 if (NextToken().isNot(K: tok::l_paren))
1864 return TPResult::Error;
1865 RevertingTentativeParsingAction PA(*this);
1866 ConsumeToken();
1867 ConsumeParen();
1868
1869 if (!SkipUntil(T: tok::r_paren, Flags: StopAtSemi))
1870 return TPResult::Error;
1871
1872 if (Tok.is(K: tok::l_paren))
1873 return TPResult::Ambiguous;
1874
1875 if (getLangOpts().CPlusPlus11 && Tok.is(K: tok::l_brace))
1876 return BracedCastResult;
1877
1878 return TPResult::True;
1879 }
1880 default:
1881 return TPResult::False;
1882 }
1883}
1884
1885bool Parser::isCXXDeclarationSpecifierAType() {
1886 switch (Tok.getKind()) {
1887 // typename-specifier
1888 case tok::annot_decltype:
1889 case tok::annot_pack_indexing_type:
1890 case tok::annot_template_id:
1891 case tok::annot_typename:
1892 case tok::kw_typeof:
1893#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
1894#include "clang/Basic/TransformTypeTraits.def"
1895 return true;
1896
1897 // elaborated-type-specifier
1898 case tok::kw_class:
1899 case tok::kw_struct:
1900 case tok::kw_union:
1901 case tok::kw___interface:
1902 case tok::kw_enum:
1903 return true;
1904
1905 // simple-type-specifier
1906 case tok::kw_char:
1907 case tok::kw_wchar_t:
1908 case tok::kw_char8_t:
1909 case tok::kw_char16_t:
1910 case tok::kw_char32_t:
1911 case tok::kw_bool:
1912 case tok::kw_short:
1913 case tok::kw_int:
1914 case tok::kw__ExtInt:
1915 case tok::kw__BitInt:
1916 case tok::kw_long:
1917 case tok::kw___int64:
1918 case tok::kw___int128:
1919 case tok::kw_signed:
1920 case tok::kw_unsigned:
1921 case tok::kw_half:
1922 case tok::kw_float:
1923 case tok::kw_double:
1924 case tok::kw___bf16:
1925 case tok::kw__Float16:
1926 case tok::kw___float128:
1927 case tok::kw___ibm128:
1928 case tok::kw_void:
1929 case tok::kw___unknown_anytype:
1930 case tok::kw___auto_type:
1931 case tok::kw__Accum:
1932 case tok::kw__Fract:
1933 case tok::kw__Sat:
1934#define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1935#include "clang/Basic/OpenCLImageTypes.def"
1936 return true;
1937
1938 case tok::kw_auto:
1939 return getLangOpts().CPlusPlus11;
1940
1941 case tok::kw__Atomic:
1942 // "_Atomic foo"
1943 return NextToken().is(K: tok::l_paren);
1944
1945 default:
1946 return false;
1947 }
1948}
1949
1950/// [GNU] typeof-specifier:
1951/// 'typeof' '(' expressions ')'
1952/// 'typeof' '(' type-name ')'
1953///
1954Parser::TPResult Parser::TryParseTypeofSpecifier() {
1955 assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1956 ConsumeToken();
1957
1958 assert(Tok.is(tok::l_paren) && "Expected '('");
1959 // Parse through the parens after 'typeof'.
1960 ConsumeParen();
1961 if (!SkipUntil(T: tok::r_paren, Flags: StopAtSemi))
1962 return TPResult::Error;
1963
1964 return TPResult::Ambiguous;
1965}
1966
1967/// [ObjC] protocol-qualifiers:
1968//// '<' identifier-list '>'
1969Parser::TPResult Parser::TryParseProtocolQualifiers() {
1970 assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1971 ConsumeToken();
1972 do {
1973 if (Tok.isNot(K: tok::identifier))
1974 return TPResult::Error;
1975 ConsumeToken();
1976
1977 if (Tok.is(K: tok::comma)) {
1978 ConsumeToken();
1979 continue;
1980 }
1981
1982 if (Tok.is(K: tok::greater)) {
1983 ConsumeToken();
1984 return TPResult::Ambiguous;
1985 }
1986 } while (false);
1987
1988 return TPResult::Error;
1989}
1990
1991/// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1992/// a constructor-style initializer, when parsing declaration statements.
1993/// Returns true for function declarator and false for constructor-style
1994/// initializer.
1995/// If during the disambiguation process a parsing error is encountered,
1996/// the function returns true to let the declaration parsing code handle it.
1997///
1998/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1999/// exception-specification[opt]
2000///
2001bool Parser::isCXXFunctionDeclarator(
2002 bool *IsAmbiguous, ImplicitTypenameContext AllowImplicitTypename) {
2003
2004 // C++ 8.2p1:
2005 // The ambiguity arising from the similarity between a function-style cast and
2006 // a declaration mentioned in 6.8 can also occur in the context of a
2007 // declaration. In that context, the choice is between a function declaration
2008 // with a redundant set of parentheses around a parameter name and an object
2009 // declaration with a function-style cast as the initializer. Just as for the
2010 // ambiguities mentioned in 6.8, the resolution is to consider any construct
2011 // that could possibly be a declaration a declaration.
2012
2013 RevertingTentativeParsingAction PA(*this);
2014
2015 ConsumeParen();
2016 bool InvalidAsDeclaration = false;
2017 TPResult TPR = TryParseParameterDeclarationClause(
2018 InvalidAsDeclaration: &InvalidAsDeclaration, /*VersusTemplateArgument=*/VersusTemplateArg: false,
2019 AllowImplicitTypename);
2020 if (TPR == TPResult::Ambiguous) {
2021 if (Tok.isNot(K: tok::r_paren))
2022 TPR = TPResult::False;
2023 else {
2024 const Token &Next = NextToken();
2025 if (Next.isOneOf(K1: tok::amp, Ks: tok::ampamp, Ks: tok::kw_const, Ks: tok::kw_volatile,
2026 Ks: tok::kw_throw, Ks: tok::kw_noexcept, Ks: tok::l_square,
2027 Ks: tok::l_brace, Ks: tok::kw_try, Ks: tok::equal, Ks: tok::arrow) ||
2028 isCXX11VirtSpecifier(Tok: Next))
2029 // The next token cannot appear after a constructor-style initializer,
2030 // and can appear next in a function definition. This must be a function
2031 // declarator.
2032 TPR = TPResult::True;
2033 else if (InvalidAsDeclaration)
2034 // Use the absence of 'typename' as a tie-breaker.
2035 TPR = TPResult::False;
2036 }
2037 }
2038
2039 if (IsAmbiguous && TPR == TPResult::Ambiguous)
2040 *IsAmbiguous = true;
2041
2042 // In case of an error, let the declaration parsing code handle it.
2043 return TPR != TPResult::False;
2044}
2045
2046/// parameter-declaration-clause:
2047/// parameter-declaration-list[opt] '...'[opt]
2048/// parameter-declaration-list ',' '...'
2049///
2050/// parameter-declaration-list:
2051/// parameter-declaration
2052/// parameter-declaration-list ',' parameter-declaration
2053///
2054/// parameter-declaration:
2055/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
2056/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
2057/// '=' assignment-expression
2058/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
2059/// attributes[opt]
2060/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
2061/// attributes[opt] '=' assignment-expression
2062///
2063Parser::TPResult Parser::TryParseParameterDeclarationClause(
2064 bool *InvalidAsDeclaration, bool VersusTemplateArgument,
2065 ImplicitTypenameContext AllowImplicitTypename) {
2066
2067 if (Tok.is(K: tok::r_paren))
2068 return TPResult::Ambiguous;
2069
2070 // parameter-declaration-list[opt] '...'[opt]
2071 // parameter-declaration-list ',' '...'
2072 //
2073 // parameter-declaration-list:
2074 // parameter-declaration
2075 // parameter-declaration-list ',' parameter-declaration
2076 //
2077 while (true) {
2078 // '...'[opt]
2079 if (Tok.is(K: tok::ellipsis)) {
2080 ConsumeToken();
2081 if (Tok.is(K: tok::r_paren))
2082 return TPResult::True; // '...)' is a sign of a function declarator.
2083 else
2084 return TPResult::False;
2085 }
2086
2087 // An attribute-specifier-seq here is a sign of a function declarator.
2088 if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
2089 /*OuterMightBeMessageSend*/true))
2090 return TPResult::True;
2091
2092 ParsedAttributes attrs(AttrFactory);
2093 MaybeParseMicrosoftAttributes(Attrs&: attrs);
2094
2095 // decl-specifier-seq
2096 // A parameter-declaration's initializer must be preceded by an '=', so
2097 // decl-specifier-seq '{' is not a parameter in C++11.
2098 TPResult TPR = isCXXDeclarationSpecifier(
2099 AllowImplicitTypename, BracedCastResult: TPResult::False, InvalidAsDeclSpec: InvalidAsDeclaration);
2100 // A declaration-specifier (not followed by '(' or '{') means this can't be
2101 // an expression, but it could still be a template argument.
2102 if (TPR != TPResult::Ambiguous &&
2103 !(VersusTemplateArgument && TPR == TPResult::True))
2104 return TPR;
2105
2106 bool SeenType = false;
2107 bool DeclarationSpecifierIsAuto = Tok.is(K: tok::kw_auto);
2108 do {
2109 SeenType |= isCXXDeclarationSpecifierAType();
2110 if (TryConsumeDeclarationSpecifier() == TPResult::Error)
2111 return TPResult::Error;
2112
2113 // If we see a parameter name, this can't be a template argument.
2114 if (SeenType && Tok.is(K: tok::identifier))
2115 return TPResult::True;
2116
2117 TPR = isCXXDeclarationSpecifier(AllowImplicitTypename, BracedCastResult: TPResult::False,
2118 InvalidAsDeclSpec: InvalidAsDeclaration);
2119 if (TPR == TPResult::Error)
2120 return TPR;
2121
2122 // Two declaration-specifiers means this can't be an expression.
2123 if (TPR == TPResult::True && !VersusTemplateArgument)
2124 return TPR;
2125 } while (TPR != TPResult::False);
2126
2127 // declarator
2128 // abstract-declarator[opt]
2129 TPR = TryParseDeclarator(
2130 /*mayBeAbstract=*/true,
2131 /*mayHaveIdentifier=*/true,
2132 /*mayHaveDirectInit=*/false,
2133 /*mayHaveTrailingReturnType=*/DeclarationSpecifierIsAuto);
2134 if (TPR != TPResult::Ambiguous)
2135 return TPR;
2136
2137 // [GNU] attributes[opt]
2138 if (Tok.is(K: tok::kw___attribute))
2139 return TPResult::True;
2140
2141 // If we're disambiguating a template argument in a default argument in
2142 // a class definition versus a parameter declaration, an '=' here
2143 // disambiguates the parse one way or the other.
2144 // If this is a parameter, it must have a default argument because
2145 // (a) the previous parameter did, and
2146 // (b) this must be the first declaration of the function, so we can't
2147 // inherit any default arguments from elsewhere.
2148 // FIXME: If we reach a ')' without consuming any '>'s, then this must
2149 // also be a function parameter (that's missing its default argument).
2150 if (VersusTemplateArgument)
2151 return Tok.is(K: tok::equal) ? TPResult::True : TPResult::False;
2152
2153 if (Tok.is(K: tok::equal)) {
2154 // '=' assignment-expression
2155 // Parse through assignment-expression.
2156 if (!SkipUntil(T1: tok::comma, T2: tok::r_paren, Flags: StopAtSemi | StopBeforeMatch))
2157 return TPResult::Error;
2158 }
2159
2160 if (Tok.is(K: tok::ellipsis)) {
2161 ConsumeToken();
2162 if (Tok.is(K: tok::r_paren))
2163 return TPResult::True; // '...)' is a sign of a function declarator.
2164 else
2165 return TPResult::False;
2166 }
2167
2168 if (!TryConsumeToken(Expected: tok::comma))
2169 break;
2170 }
2171
2172 return TPResult::Ambiguous;
2173}
2174
2175/// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
2176/// parsing as a function declarator.
2177/// If TryParseFunctionDeclarator fully parsed the function declarator, it will
2178/// return TPResult::Ambiguous, otherwise it will return either False() or
2179/// Error().
2180///
2181/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
2182/// exception-specification[opt]
2183///
2184/// exception-specification:
2185/// 'throw' '(' type-id-list[opt] ')'
2186///
2187Parser::TPResult
2188Parser::TryParseFunctionDeclarator(bool MayHaveTrailingReturnType) {
2189 // The '(' is already parsed.
2190
2191 TPResult TPR = TryParseParameterDeclarationClause();
2192 if (TPR == TPResult::Ambiguous && Tok.isNot(K: tok::r_paren))
2193 TPR = TPResult::False;
2194
2195 if (TPR == TPResult::False || TPR == TPResult::Error)
2196 return TPR;
2197
2198 // Parse through the parens.
2199 if (!SkipUntil(T: tok::r_paren, Flags: StopAtSemi))
2200 return TPResult::Error;
2201
2202 // cv-qualifier-seq
2203 while (Tok.isOneOf(K1: tok::kw_const, Ks: tok::kw_volatile, Ks: tok::kw___unaligned,
2204 Ks: tok::kw_restrict))
2205 ConsumeToken();
2206
2207 // ref-qualifier[opt]
2208 if (Tok.isOneOf(K1: tok::amp, K2: tok::ampamp))
2209 ConsumeToken();
2210
2211 // exception-specification
2212 if (Tok.is(K: tok::kw_throw)) {
2213 ConsumeToken();
2214 if (Tok.isNot(K: tok::l_paren))
2215 return TPResult::Error;
2216
2217 // Parse through the parens after 'throw'.
2218 ConsumeParen();
2219 if (!SkipUntil(T: tok::r_paren, Flags: StopAtSemi))
2220 return TPResult::Error;
2221 }
2222 if (Tok.is(K: tok::kw_noexcept)) {
2223 ConsumeToken();
2224 // Possibly an expression as well.
2225 if (Tok.is(K: tok::l_paren)) {
2226 // Find the matching rparen.
2227 ConsumeParen();
2228 if (!SkipUntil(T: tok::r_paren, Flags: StopAtSemi))
2229 return TPResult::Error;
2230 }
2231 }
2232
2233 // attribute-specifier-seq
2234 if (!TrySkipAttributes())
2235 return TPResult::Ambiguous;
2236
2237 // trailing-return-type
2238 if (Tok.is(K: tok::arrow) && MayHaveTrailingReturnType) {
2239 if (TPR == TPResult::True)
2240 return TPR;
2241 ConsumeToken();
2242 if (Tok.is(K: tok::identifier) && NameAfterArrowIsNonType()) {
2243 return TPResult::False;
2244 }
2245 if (isCXXTypeId(Context: TentativeCXXTypeIdContext::TypeIdInTrailingReturnType))
2246 return TPResult::True;
2247 }
2248
2249 return TPResult::Ambiguous;
2250}
2251
2252// When parsing an identifier after an arrow it may be a member expression,
2253// in which case we should not annotate it as an independant expression
2254// so we just lookup that name, if it's not a type the construct is not
2255// a function declaration.
2256bool Parser::NameAfterArrowIsNonType() {
2257 assert(Tok.is(tok::identifier));
2258 Token Next = NextToken();
2259 if (Next.is(K: tok::coloncolon))
2260 return false;
2261 IdentifierInfo *Name = Tok.getIdentifierInfo();
2262 SourceLocation NameLoc = Tok.getLocation();
2263 CXXScopeSpec SS;
2264 TentativeParseCCC CCC(Next);
2265 Sema::NameClassification Classification =
2266 Actions.ClassifyName(S: getCurScope(), SS, Name, NameLoc, NextToken: Next, CCC: &CCC);
2267 switch (Classification.getKind()) {
2268 case Sema::NC_OverloadSet:
2269 case Sema::NC_NonType:
2270 case Sema::NC_VarTemplate:
2271 case Sema::NC_FunctionTemplate:
2272 return true;
2273 default:
2274 break;
2275 }
2276 return false;
2277}
2278
2279/// '[' constant-expression[opt] ']'
2280///
2281Parser::TPResult Parser::TryParseBracketDeclarator() {
2282 ConsumeBracket();
2283
2284 // A constant-expression cannot begin with a '{', but the
2285 // expr-or-braced-init-list of a postfix-expression can.
2286 if (Tok.is(K: tok::l_brace))
2287 return TPResult::False;
2288
2289 if (!SkipUntil(T1: tok::r_square, T2: tok::comma, Flags: StopAtSemi | StopBeforeMatch))
2290 return TPResult::Error;
2291
2292 // If we hit a comma before the ']', this is not a constant-expression,
2293 // but might still be the expr-or-braced-init-list of a postfix-expression.
2294 if (Tok.isNot(K: tok::r_square))
2295 return TPResult::False;
2296
2297 ConsumeBracket();
2298 return TPResult::Ambiguous;
2299}
2300
2301/// Determine whether we might be looking at the '<' template-argument-list '>'
2302/// of a template-id or simple-template-id, rather than a less-than comparison.
2303/// This will often fail and produce an ambiguity, but should never be wrong
2304/// if it returns True or False.
2305Parser::TPResult Parser::isTemplateArgumentList(unsigned TokensToSkip) {
2306 if (!TokensToSkip) {
2307 if (Tok.isNot(K: tok::less))
2308 return TPResult::False;
2309 if (NextToken().is(K: tok::greater))
2310 return TPResult::True;
2311 }
2312
2313 RevertingTentativeParsingAction PA(*this);
2314
2315 while (TokensToSkip) {
2316 ConsumeAnyToken();
2317 --TokensToSkip;
2318 }
2319
2320 if (!TryConsumeToken(Expected: tok::less))
2321 return TPResult::False;
2322
2323 // We can't do much to tell an expression apart from a template-argument,
2324 // but one good distinguishing factor is that a "decl-specifier" not
2325 // followed by '(' or '{' can't appear in an expression.
2326 bool InvalidAsTemplateArgumentList = false;
2327 if (isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No, BracedCastResult: TPResult::False,
2328 InvalidAsDeclSpec: &InvalidAsTemplateArgumentList) ==
2329 TPResult::True)
2330 return TPResult::True;
2331 if (InvalidAsTemplateArgumentList)
2332 return TPResult::False;
2333
2334 // FIXME: In many contexts, X<thing1, Type> can only be a
2335 // template-argument-list. But that's not true in general:
2336 //
2337 // using b = int;
2338 // void f() {
2339 // int a = A<B, b, c = C>D; // OK, declares b, not a template-id.
2340 //
2341 // X<Y<0, int> // ', int>' might be end of X's template argument list
2342 //
2343 // We might be able to disambiguate a few more cases if we're careful.
2344
2345 // A template-argument-list must be terminated by a '>'.
2346 if (SkipUntil(Toks: {tok::greater, tok::greatergreater, tok::greatergreatergreater},
2347 Flags: StopAtSemi | StopBeforeMatch))
2348 return TPResult::Ambiguous;
2349 return TPResult::False;
2350}
2351
2352/// Determine whether we might be looking at the '(' of a C++20 explicit(bool)
2353/// in an earlier language mode.
2354Parser::TPResult Parser::isExplicitBool() {
2355 assert(Tok.is(tok::l_paren) && "expected to be looking at a '(' token");
2356
2357 RevertingTentativeParsingAction PA(*this);
2358 ConsumeParen();
2359
2360 // We can only have 'explicit' on a constructor, conversion function, or
2361 // deduction guide. The declarator of a deduction guide cannot be
2362 // parenthesized, so we know this isn't a deduction guide. So the only
2363 // thing we need to check for is some number of parens followed by either
2364 // the current class name or 'operator'.
2365 while (Tok.is(K: tok::l_paren))
2366 ConsumeParen();
2367
2368 if (TryAnnotateOptionalCXXScopeToken())
2369 return TPResult::Error;
2370
2371 // Class-scope constructor and conversion function names can't really be
2372 // qualified, but we get better diagnostics if we assume they can be.
2373 CXXScopeSpec SS;
2374 if (Tok.is(K: tok::annot_cxxscope)) {
2375 Actions.RestoreNestedNameSpecifierAnnotation(Annotation: Tok.getAnnotationValue(),
2376 AnnotationRange: Tok.getAnnotationRange(),
2377 SS);
2378 ConsumeAnnotationToken();
2379 }
2380
2381 // 'explicit(operator' might be explicit(bool) or the declaration of a
2382 // conversion function, but it's probably a conversion function.
2383 if (Tok.is(K: tok::kw_operator))
2384 return TPResult::Ambiguous;
2385
2386 // If this can't be a constructor name, it can only be explicit(bool).
2387 if (Tok.isNot(K: tok::identifier) && Tok.isNot(K: tok::annot_template_id))
2388 return TPResult::True;
2389 if (!Actions.isCurrentClassName(II: Tok.is(K: tok::identifier)
2390 ? *Tok.getIdentifierInfo()
2391 : *takeTemplateIdAnnotation(tok: Tok)->Name,
2392 S: getCurScope(), SS: &SS))
2393 return TPResult::True;
2394 // Formally, we must have a right-paren after the constructor name to match
2395 // the grammar for a constructor. But clang permits a parenthesized
2396 // constructor declarator, so also allow a constructor declarator to follow
2397 // with no ')' token after the constructor name.
2398 if (!NextToken().is(K: tok::r_paren) &&
2399 !isConstructorDeclarator(/*Unqualified=*/SS.isEmpty(),
2400 /*DeductionGuide=*/false))
2401 return TPResult::True;
2402
2403 // Might be explicit(bool) or a parenthesized constructor name.
2404 return TPResult::Ambiguous;
2405}
2406