blob: b26181f08eade62ba8cca97c2e81256d5c1bc62e [file] [log] [blame]
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001//===--- ParseTentative.cpp - Ambiguity Resolution Parsing ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the tentative parsing portions of the Parser
11// interfaces, for ambiguity resolution.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Parse/Parser.h"
16#include "clang/Parse/ParseDiagnostic.h"
17#include "clang/Sema/ParsedTemplate.h"
18using namespace clang;
19
20/// isCXXDeclarationStatement - C++-specialized function that disambiguates
21/// between a declaration or an expression statement, when parsing function
22/// bodies. Returns true for declaration, false for expression.
23///
24/// declaration-statement:
25/// block-declaration
26///
27/// block-declaration:
28/// simple-declaration
29/// asm-definition
30/// namespace-alias-definition
31/// using-declaration
32/// using-directive
33/// [C++0x] static_assert-declaration
34///
35/// asm-definition:
36/// 'asm' '(' string-literal ')' ';'
37///
38/// namespace-alias-definition:
39/// 'namespace' identifier = qualified-namespace-specifier ';'
40///
41/// using-declaration:
42/// 'using' typename[opt] '::'[opt] nested-name-specifier
43/// unqualified-id ';'
44/// 'using' '::' unqualified-id ;
45///
46/// using-directive:
47/// 'using' 'namespace' '::'[opt] nested-name-specifier[opt]
48/// namespace-name ';'
49///
50bool Parser::isCXXDeclarationStatement() {
51 switch (Tok.getKind()) {
52 // asm-definition
53 case tok::kw_asm:
54 // namespace-alias-definition
55 case tok::kw_namespace:
56 // using-declaration
57 // using-directive
58 case tok::kw_using:
59 // static_assert-declaration
60 case tok::kw_static_assert:
61 case tok::kw__Static_assert:
62 return true;
63 // simple-declaration
64 default:
65 return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/false);
66 }
67}
68
69/// isCXXSimpleDeclaration - C++-specialized function that disambiguates
70/// between a simple-declaration or an expression-statement.
71/// If during the disambiguation process a parsing error is encountered,
72/// the function returns true to let the declaration parsing code handle it.
73/// Returns false if the statement is disambiguated as expression.
74///
75/// simple-declaration:
76/// decl-specifier-seq init-declarator-list[opt] ';'
77///
78/// (if AllowForRangeDecl specified)
79/// for ( for-range-declaration : for-range-initializer ) statement
80/// for-range-declaration:
81/// attribute-specifier-seqopt type-specifier-seq declarator
82bool Parser::isCXXSimpleDeclaration(bool AllowForRangeDecl) {
83 // C++ 6.8p1:
84 // There is an ambiguity in the grammar involving expression-statements and
85 // declarations: An expression-statement with a function-style explicit type
86 // conversion (5.2.3) as its leftmost subexpression can be indistinguishable
87 // from a declaration where the first declarator starts with a '('. In those
88 // cases the statement is a declaration. [Note: To disambiguate, the whole
89 // statement might have to be examined to determine if it is an
90 // expression-statement or a declaration].
91
92 // C++ 6.8p3:
93 // The disambiguation is purely syntactic; that is, the meaning of the names
94 // occurring in such a statement, beyond whether they are type-names or not,
95 // is not generally used in or changed by the disambiguation. Class
96 // templates are instantiated as necessary to determine if a qualified name
97 // is a type-name. Disambiguation precedes parsing, and a statement
98 // disambiguated as a declaration may be an ill-formed declaration.
99
100 // We don't have to parse all of the decl-specifier-seq part. There's only
101 // an ambiguity if the first decl-specifier is
102 // simple-type-specifier/typename-specifier followed by a '(', which may
103 // indicate a function-style cast expression.
104 // isCXXDeclarationSpecifier will return TPResult::Ambiguous() only in such
105 // a case.
106
107 bool InvalidAsDeclaration = false;
108 TPResult TPR = isCXXDeclarationSpecifier(TPResult::False(),
109 &InvalidAsDeclaration);
110 if (TPR != TPResult::Ambiguous())
111 return TPR != TPResult::False(); // Returns true for TPResult::True() or
112 // TPResult::Error().
113
114 // FIXME: TryParseSimpleDeclaration doesn't look past the first initializer,
115 // and so gets some cases wrong. We can't carry on if we've already seen
116 // something which makes this statement invalid as a declaration in this case,
117 // since it can cause us to misparse valid code. Revisit this once
118 // TryParseInitDeclaratorList is fixed.
119 if (InvalidAsDeclaration)
120 return false;
121
122 // FIXME: Add statistics about the number of ambiguous statements encountered
123 // and how they were resolved (number of declarations+number of expressions).
124
125 // Ok, we have a simple-type-specifier/typename-specifier followed by a '(',
126 // or an identifier which doesn't resolve as anything. We need tentative
127 // parsing...
128
129 TentativeParsingAction PA(*this);
130 TPR = TryParseSimpleDeclaration(AllowForRangeDecl);
131 PA.Revert();
132
133 // In case of an error, let the declaration parsing code handle it.
134 if (TPR == TPResult::Error())
135 return true;
136
137 // Declarations take precedence over expressions.
138 if (TPR == TPResult::Ambiguous())
139 TPR = TPResult::True();
140
141 assert(TPR == TPResult::True() || TPR == TPResult::False());
142 return TPR == TPResult::True();
143}
144
145/// simple-declaration:
146/// decl-specifier-seq init-declarator-list[opt] ';'
147///
148/// (if AllowForRangeDecl specified)
149/// for ( for-range-declaration : for-range-initializer ) statement
150/// for-range-declaration:
151/// attribute-specifier-seqopt type-specifier-seq declarator
152///
153Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
154 if (Tok.is(tok::kw_typeof))
155 TryParseTypeofSpecifier();
156 else {
157 if (Tok.is(tok::annot_cxxscope))
158 ConsumeToken();
159 ConsumeToken();
160
161 if (getLangOpts().ObjC1 && Tok.is(tok::less))
162 TryParseProtocolQualifiers();
163 }
164
165 // Two decl-specifiers in a row conclusively disambiguate this as being a
166 // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
167 // overwhelmingly common case that the next token is a '('.
168 if (Tok.isNot(tok::l_paren)) {
169 TPResult TPR = isCXXDeclarationSpecifier();
170 if (TPR == TPResult::Ambiguous())
171 return TPResult::True();
172 if (TPR == TPResult::True() || TPR == TPResult::Error())
173 return TPR;
174 assert(TPR == TPResult::False());
175 }
176
177 TPResult TPR = TryParseInitDeclaratorList();
178 if (TPR != TPResult::Ambiguous())
179 return TPR;
180
181 if (Tok.isNot(tok::semi) && (!AllowForRangeDecl || Tok.isNot(tok::colon)))
182 return TPResult::False();
183
184 return TPResult::Ambiguous();
185}
186
187/// init-declarator-list:
188/// init-declarator
189/// init-declarator-list ',' init-declarator
190///
191/// init-declarator:
192/// declarator initializer[opt]
193/// [GNU] declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
194///
195/// initializer:
196/// '=' initializer-clause
197/// '(' expression-list ')'
198///
199/// initializer-clause:
200/// assignment-expression
201/// '{' initializer-list ','[opt] '}'
202/// '{' '}'
203///
204Parser::TPResult Parser::TryParseInitDeclaratorList() {
205 while (1) {
206 // declarator
207 TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
208 if (TPR != TPResult::Ambiguous())
209 return TPR;
210
211 // [GNU] simple-asm-expr[opt] attributes[opt]
212 if (Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
213 return TPResult::True();
214
215 // initializer[opt]
216 if (Tok.is(tok::l_paren)) {
217 // Parse through the parens.
218 ConsumeParen();
219 if (!SkipUntil(tok::r_paren))
220 return TPResult::Error();
221 } else if (Tok.is(tok::equal) || isTokIdentifier_in()) {
222 // MSVC and g++ won't examine the rest of declarators if '=' is
223 // encountered; they just conclude that we have a declaration.
224 // EDG parses the initializer completely, which is the proper behavior
225 // for this case.
226 //
227 // At present, Clang follows MSVC and g++, since the parser does not have
228 // the ability to parse an expression fully without recording the
229 // results of that parse.
230 // Also allow 'in' after on objective-c declaration as in:
231 // for (int (^b)(void) in array). Ideally this should be done in the
232 // context of parsing for-init-statement of a foreach statement only. But,
233 // in any other context 'in' is invalid after a declaration and parser
234 // issues the error regardless of outcome of this decision.
235 // FIXME. Change if above assumption does not hold.
236 return TPResult::True();
237 }
238
239 if (Tok.isNot(tok::comma))
240 break;
241 ConsumeToken(); // the comma.
242 }
243
244 return TPResult::Ambiguous();
245}
246
247/// isCXXConditionDeclaration - Disambiguates between a declaration or an
248/// expression for a condition of a if/switch/while/for statement.
249/// If during the disambiguation process a parsing error is encountered,
250/// the function returns true to let the declaration parsing code handle it.
251///
252/// condition:
253/// expression
254/// type-specifier-seq declarator '=' assignment-expression
255/// [C++11] type-specifier-seq declarator '=' initializer-clause
256/// [C++11] type-specifier-seq declarator braced-init-list
257/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
258/// '=' assignment-expression
259///
260bool Parser::isCXXConditionDeclaration() {
261 TPResult TPR = isCXXDeclarationSpecifier();
262 if (TPR != TPResult::Ambiguous())
263 return TPR != TPResult::False(); // Returns true for TPResult::True() or
264 // TPResult::Error().
265
266 // FIXME: Add statistics about the number of ambiguous statements encountered
267 // and how they were resolved (number of declarations+number of expressions).
268
269 // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
270 // We need tentative parsing...
271
272 TentativeParsingAction PA(*this);
273
274 // type-specifier-seq
275 if (Tok.is(tok::kw_typeof))
276 TryParseTypeofSpecifier();
277 else {
278 ConsumeToken();
279
280 if (getLangOpts().ObjC1 && Tok.is(tok::less))
281 TryParseProtocolQualifiers();
282 }
283 assert(Tok.is(tok::l_paren) && "Expected '('");
284
285 // declarator
286 TPR = TryParseDeclarator(false/*mayBeAbstract*/);
287
288 // In case of an error, let the declaration parsing code handle it.
289 if (TPR == TPResult::Error())
290 TPR = TPResult::True();
291
292 if (TPR == TPResult::Ambiguous()) {
293 // '='
294 // [GNU] simple-asm-expr[opt] attributes[opt]
295 if (Tok.is(tok::equal) ||
296 Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
297 TPR = TPResult::True();
298 else if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace))
299 TPR = TPResult::True();
300 else
301 TPR = TPResult::False();
302 }
303
304 PA.Revert();
305
306 assert(TPR == TPResult::True() || TPR == TPResult::False());
307 return TPR == TPResult::True();
308}
309
310 /// \brief Determine whether the next set of tokens contains a type-id.
311 ///
312 /// The context parameter states what context we're parsing right
313 /// now, which affects how this routine copes with the token
314 /// following the type-id. If the context is TypeIdInParens, we have
315 /// already parsed the '(' and we will cease lookahead when we hit
316 /// the corresponding ')'. If the context is
317 /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
318 /// before this template argument, and will cease lookahead when we
319 /// hit a '>', '>>' (in C++0x), or ','. Returns true for a type-id
320 /// and false for an expression. If during the disambiguation
321 /// process a parsing error is encountered, the function returns
322 /// true to let the declaration parsing code handle it.
323 ///
324 /// type-id:
325 /// type-specifier-seq abstract-declarator[opt]
326 ///
327bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
328
329 isAmbiguous = false;
330
331 // C++ 8.2p2:
332 // The ambiguity arising from the similarity between a function-style cast and
333 // a type-id can occur in different contexts. The ambiguity appears as a
334 // choice between a function-style cast expression and a declaration of a
335 // type. The resolution is that any construct that could possibly be a type-id
336 // in its syntactic context shall be considered a type-id.
337
338 TPResult TPR = isCXXDeclarationSpecifier();
339 if (TPR != TPResult::Ambiguous())
340 return TPR != TPResult::False(); // Returns true for TPResult::True() or
341 // TPResult::Error().
342
343 // FIXME: Add statistics about the number of ambiguous statements encountered
344 // and how they were resolved (number of declarations+number of expressions).
345
346 // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
347 // We need tentative parsing...
348
349 TentativeParsingAction PA(*this);
350
351 // type-specifier-seq
352 if (Tok.is(tok::kw_typeof))
353 TryParseTypeofSpecifier();
354 else {
355 ConsumeToken();
356
357 if (getLangOpts().ObjC1 && Tok.is(tok::less))
358 TryParseProtocolQualifiers();
359 }
360
361 assert(Tok.is(tok::l_paren) && "Expected '('");
362
363 // declarator
364 TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
365
366 // In case of an error, let the declaration parsing code handle it.
367 if (TPR == TPResult::Error())
368 TPR = TPResult::True();
369
370 if (TPR == TPResult::Ambiguous()) {
371 // We are supposed to be inside parens, so if after the abstract declarator
372 // we encounter a ')' this is a type-id, otherwise it's an expression.
373 if (Context == TypeIdInParens && Tok.is(tok::r_paren)) {
374 TPR = TPResult::True();
375 isAmbiguous = true;
376
377 // We are supposed to be inside a template argument, so if after
378 // the abstract declarator we encounter a '>', '>>' (in C++0x), or
379 // ',', this is a type-id. Otherwise, it's an expression.
380 } else if (Context == TypeIdAsTemplateArgument &&
381 (Tok.is(tok::greater) || Tok.is(tok::comma) ||
382 (getLangOpts().CPlusPlus0x && Tok.is(tok::greatergreater)))) {
383 TPR = TPResult::True();
384 isAmbiguous = true;
385
386 } else
387 TPR = TPResult::False();
388 }
389
390 PA.Revert();
391
392 assert(TPR == TPResult::True() || TPR == TPResult::False());
393 return TPR == TPResult::True();
394}
395
396/// \brief Returns true if this is a C++11 attribute-specifier. Per
397/// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
398/// always introduce an attribute. In Objective-C++11, this rule does not
399/// apply if either '[' begins a message-send.
400///
401/// If Disambiguate is true, we try harder to determine whether a '[[' starts
402/// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
403///
404/// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
405/// Obj-C message send or the start of an attribute. Otherwise, we assume it
406/// is not an Obj-C message send.
407///
408/// C++11 [dcl.attr.grammar]:
409///
410/// attribute-specifier:
411/// '[' '[' attribute-list ']' ']'
412/// alignment-specifier
413///
414/// attribute-list:
415/// attribute[opt]
416/// attribute-list ',' attribute[opt]
417/// attribute '...'
418/// attribute-list ',' attribute '...'
419///
420/// attribute:
421/// attribute-token attribute-argument-clause[opt]
422///
423/// attribute-token:
424/// identifier
425/// identifier '::' identifier
426///
427/// attribute-argument-clause:
428/// '(' balanced-token-seq ')'
429Parser::CXX11AttributeKind
430Parser::isCXX11AttributeSpecifier(bool Disambiguate,
431 bool OuterMightBeMessageSend) {
432 if (Tok.is(tok::kw_alignas))
433 return CAK_AttributeSpecifier;
434
435 if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
436 return CAK_NotAttributeSpecifier;
437
438 // No tentative parsing if we don't need to look for ']]' or a lambda.
439 if (!Disambiguate && !getLangOpts().ObjC1)
440 return CAK_AttributeSpecifier;
441
442 TentativeParsingAction PA(*this);
443
444 // Opening brackets were checked for above.
445 ConsumeBracket();
446
447 // Outside Obj-C++11, treat anything with a matching ']]' as an attribute.
448 if (!getLangOpts().ObjC1) {
449 ConsumeBracket();
450
451 bool IsAttribute = SkipUntil(tok::r_square, false);
452 IsAttribute &= Tok.is(tok::r_square);
453
454 PA.Revert();
455
456 return IsAttribute ? CAK_AttributeSpecifier : CAK_InvalidAttributeSpecifier;
457 }
458
459 // In Obj-C++11, we need to distinguish four situations:
460 // 1a) int x[[attr]]; C++11 attribute.
461 // 1b) [[attr]]; C++11 statement attribute.
462 // 2) int x[[obj](){ return 1; }()]; Lambda in array size/index.
463 // 3a) int x[[obj get]]; Message send in array size/index.
464 // 3b) [[Class alloc] init]; Message send in message send.
465 // 4) [[obj]{ return self; }() doStuff]; Lambda in message send.
466 // (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
467
468 // If we have a lambda-introducer, then this is definitely not a message send.
469 // FIXME: If this disambiguation is too slow, fold the tentative lambda parse
470 // into the tentative attribute parse below.
471 LambdaIntroducer Intro;
472 if (!TryParseLambdaIntroducer(Intro)) {
473 // A lambda cannot end with ']]', and an attribute must.
474 bool IsAttribute = Tok.is(tok::r_square);
475
476 PA.Revert();
477
478 if (IsAttribute)
479 // Case 1: C++11 attribute.
480 return CAK_AttributeSpecifier;
481
482 if (OuterMightBeMessageSend)
483 // Case 4: Lambda in message send.
484 return CAK_NotAttributeSpecifier;
485
486 // Case 2: Lambda in array size / index.
487 return CAK_InvalidAttributeSpecifier;
488 }
489
490 ConsumeBracket();
491
492 // If we don't have a lambda-introducer, then we have an attribute or a
493 // message-send.
494 bool IsAttribute = true;
495 while (Tok.isNot(tok::r_square)) {
496 if (Tok.is(tok::comma)) {
497 // Case 1: Stray commas can only occur in attributes.
498 PA.Revert();
499 return CAK_AttributeSpecifier;
500 }
501
502 // Parse the attribute-token, if present.
503 // C++11 [dcl.attr.grammar]:
504 // If a keyword or an alternative token that satisfies the syntactic
505 // requirements of an identifier is contained in an attribute-token,
506 // it is considered an identifier.
507 SourceLocation Loc;
508 if (!TryParseCXX11AttributeIdentifier(Loc)) {
509 IsAttribute = false;
510 break;
511 }
512 if (Tok.is(tok::coloncolon)) {
513 ConsumeToken();
514 if (!TryParseCXX11AttributeIdentifier(Loc)) {
515 IsAttribute = false;
516 break;
517 }
518 }
519
520 // Parse the attribute-argument-clause, if present.
521 if (Tok.is(tok::l_paren)) {
522 ConsumeParen();
523 if (!SkipUntil(tok::r_paren, false)) {
524 IsAttribute = false;
525 break;
526 }
527 }
528
529 if (Tok.is(tok::ellipsis))
530 ConsumeToken();
531
532 if (Tok.isNot(tok::comma))
533 break;
534
535 ConsumeToken();
536 }
537
538 // An attribute must end ']]'.
539 if (IsAttribute) {
540 if (Tok.is(tok::r_square)) {
541 ConsumeBracket();
542 IsAttribute = Tok.is(tok::r_square);
543 } else {
544 IsAttribute = false;
545 }
546 }
547
548 PA.Revert();
549
550 if (IsAttribute)
551 // Case 1: C++11 statement attribute.
552 return CAK_AttributeSpecifier;
553
554 // Case 3: Message send.
555 return CAK_NotAttributeSpecifier;
556}
557
558/// declarator:
559/// direct-declarator
560/// ptr-operator declarator
561///
562/// direct-declarator:
563/// declarator-id
564/// direct-declarator '(' parameter-declaration-clause ')'
565/// cv-qualifier-seq[opt] exception-specification[opt]
566/// direct-declarator '[' constant-expression[opt] ']'
567/// '(' declarator ')'
568/// [GNU] '(' attributes declarator ')'
569///
570/// abstract-declarator:
571/// ptr-operator abstract-declarator[opt]
572/// direct-abstract-declarator
573/// ...
574///
575/// direct-abstract-declarator:
576/// direct-abstract-declarator[opt]
577/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
578/// exception-specification[opt]
579/// direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
580/// '(' abstract-declarator ')'
581///
582/// ptr-operator:
583/// '*' cv-qualifier-seq[opt]
584/// '&'
585/// [C++0x] '&&' [TODO]
586/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
587///
588/// cv-qualifier-seq:
589/// cv-qualifier cv-qualifier-seq[opt]
590///
591/// cv-qualifier:
592/// 'const'
593/// 'volatile'
594///
595/// declarator-id:
596/// '...'[opt] id-expression
597///
598/// id-expression:
599/// unqualified-id
600/// qualified-id [TODO]
601///
602/// unqualified-id:
603/// identifier
604/// operator-function-id [TODO]
605/// conversion-function-id [TODO]
606/// '~' class-name [TODO]
607/// template-id [TODO]
608///
609Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
610 bool mayHaveIdentifier) {
611 // declarator:
612 // direct-declarator
613 // ptr-operator declarator
614
615 while (1) {
616 if (Tok.is(tok::coloncolon) || Tok.is(tok::identifier))
617 if (TryAnnotateCXXScopeToken(true))
618 return TPResult::Error();
619
620 if (Tok.is(tok::star) || Tok.is(tok::amp) || Tok.is(tok::caret) ||
621 Tok.is(tok::ampamp) ||
622 (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
623 // ptr-operator
624 ConsumeToken();
625 while (Tok.is(tok::kw_const) ||
626 Tok.is(tok::kw_volatile) ||
627 Tok.is(tok::kw_restrict))
628 ConsumeToken();
629 } else {
630 break;
631 }
632 }
633
634 // direct-declarator:
635 // direct-abstract-declarator:
636 if (Tok.is(tok::ellipsis))
637 ConsumeToken();
638
639 if ((Tok.is(tok::identifier) ||
640 (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) &&
641 mayHaveIdentifier) {
642 // declarator-id
643 if (Tok.is(tok::annot_cxxscope))
644 ConsumeToken();
645 else
646 TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
647 ConsumeToken();
648 } else if (Tok.is(tok::l_paren)) {
649 ConsumeParen();
650 if (mayBeAbstract &&
651 (Tok.is(tok::r_paren) || // 'int()' is a function.
652 // 'int(...)' is a function.
653 (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
654 isDeclarationSpecifier())) { // 'int(int)' is a function.
655 // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
656 // exception-specification[opt]
657 TPResult TPR = TryParseFunctionDeclarator();
658 if (TPR != TPResult::Ambiguous())
659 return TPR;
660 } else {
661 // '(' declarator ')'
662 // '(' attributes declarator ')'
663 // '(' abstract-declarator ')'
664 if (Tok.is(tok::kw___attribute) ||
665 Tok.is(tok::kw___declspec) ||
666 Tok.is(tok::kw___cdecl) ||
667 Tok.is(tok::kw___stdcall) ||
668 Tok.is(tok::kw___fastcall) ||
669 Tok.is(tok::kw___thiscall) ||
670 Tok.is(tok::kw___unaligned))
671 return TPResult::True(); // attributes indicate declaration
672 TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
673 if (TPR != TPResult::Ambiguous())
674 return TPR;
675 if (Tok.isNot(tok::r_paren))
676 return TPResult::False();
677 ConsumeParen();
678 }
679 } else if (!mayBeAbstract) {
680 return TPResult::False();
681 }
682
683 while (1) {
684 TPResult TPR(TPResult::Ambiguous());
685
686 // abstract-declarator: ...
687 if (Tok.is(tok::ellipsis))
688 ConsumeToken();
689
690 if (Tok.is(tok::l_paren)) {
691 // Check whether we have a function declarator or a possible ctor-style
692 // initializer that follows the declarator. Note that ctor-style
693 // initializers are not possible in contexts where abstract declarators
694 // are allowed.
695 if (!mayBeAbstract && !isCXXFunctionDeclarator())
696 break;
697
698 // direct-declarator '(' parameter-declaration-clause ')'
699 // cv-qualifier-seq[opt] exception-specification[opt]
700 ConsumeParen();
701 TPR = TryParseFunctionDeclarator();
702 } else if (Tok.is(tok::l_square)) {
703 // direct-declarator '[' constant-expression[opt] ']'
704 // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
705 TPR = TryParseBracketDeclarator();
706 } else {
707 break;
708 }
709
710 if (TPR != TPResult::Ambiguous())
711 return TPR;
712 }
713
714 return TPResult::Ambiguous();
715}
716
717Parser::TPResult
718Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
719 switch (Kind) {
720 // Obviously starts an expression.
721 case tok::numeric_constant:
722 case tok::char_constant:
723 case tok::wide_char_constant:
724 case tok::utf16_char_constant:
725 case tok::utf32_char_constant:
726 case tok::string_literal:
727 case tok::wide_string_literal:
728 case tok::utf8_string_literal:
729 case tok::utf16_string_literal:
730 case tok::utf32_string_literal:
731 case tok::l_square:
732 case tok::l_paren:
733 case tok::amp:
734 case tok::ampamp:
735 case tok::star:
736 case tok::plus:
737 case tok::plusplus:
738 case tok::minus:
739 case tok::minusminus:
740 case tok::tilde:
741 case tok::exclaim:
742 case tok::kw_sizeof:
743 case tok::kw___func__:
744 case tok::kw_const_cast:
745 case tok::kw_delete:
746 case tok::kw_dynamic_cast:
747 case tok::kw_false:
748 case tok::kw_new:
749 case tok::kw_operator:
750 case tok::kw_reinterpret_cast:
751 case tok::kw_static_cast:
752 case tok::kw_this:
753 case tok::kw_throw:
754 case tok::kw_true:
755 case tok::kw_typeid:
756 case tok::kw_alignof:
757 case tok::kw_noexcept:
758 case tok::kw_nullptr:
759 case tok::kw__Alignof:
760 case tok::kw___null:
761 case tok::kw___alignof:
762 case tok::kw___builtin_choose_expr:
763 case tok::kw___builtin_offsetof:
764 case tok::kw___builtin_types_compatible_p:
765 case tok::kw___builtin_va_arg:
766 case tok::kw___imag:
767 case tok::kw___real:
768 case tok::kw___FUNCTION__:
769 case tok::kw_L__FUNCTION__:
770 case tok::kw___PRETTY_FUNCTION__:
771 case tok::kw___has_nothrow_assign:
772 case tok::kw___has_nothrow_copy:
773 case tok::kw___has_nothrow_constructor:
774 case tok::kw___has_trivial_assign:
775 case tok::kw___has_trivial_copy:
776 case tok::kw___has_trivial_constructor:
777 case tok::kw___has_trivial_destructor:
778 case tok::kw___has_virtual_destructor:
779 case tok::kw___is_abstract:
780 case tok::kw___is_base_of:
781 case tok::kw___is_class:
782 case tok::kw___is_convertible_to:
783 case tok::kw___is_empty:
784 case tok::kw___is_enum:
785 case tok::kw___is_interface_class:
786 case tok::kw___is_final:
787 case tok::kw___is_literal:
788 case tok::kw___is_literal_type:
789 case tok::kw___is_pod:
790 case tok::kw___is_polymorphic:
791 case tok::kw___is_trivial:
792 case tok::kw___is_trivially_assignable:
793 case tok::kw___is_trivially_constructible:
794 case tok::kw___is_trivially_copyable:
795 case tok::kw___is_union:
796 case tok::kw___uuidof:
797 return TPResult::True();
798
799 // Obviously starts a type-specifier-seq:
800 case tok::kw_char:
801 case tok::kw_const:
802 case tok::kw_double:
803 case tok::kw_enum:
804 case tok::kw_half:
805 case tok::kw_float:
806 case tok::kw_int:
807 case tok::kw_long:
808 case tok::kw___int64:
809 case tok::kw___int128:
810 case tok::kw_restrict:
811 case tok::kw_short:
812 case tok::kw_signed:
813 case tok::kw_struct:
814 case tok::kw_union:
815 case tok::kw_unsigned:
816 case tok::kw_void:
817 case tok::kw_volatile:
818 case tok::kw__Bool:
819 case tok::kw__Complex:
820 case tok::kw_class:
821 case tok::kw_typename:
822 case tok::kw_wchar_t:
823 case tok::kw_char16_t:
824 case tok::kw_char32_t:
825 case tok::kw___underlying_type:
826 case tok::kw_thread_local:
827 case tok::kw__Decimal32:
828 case tok::kw__Decimal64:
829 case tok::kw__Decimal128:
830 case tok::kw___thread:
831 case tok::kw_typeof:
832 case tok::kw___cdecl:
833 case tok::kw___stdcall:
834 case tok::kw___fastcall:
835 case tok::kw___thiscall:
836 case tok::kw___unaligned:
837 case tok::kw___vector:
838 case tok::kw___pixel:
839 case tok::kw__Atomic:
840 case tok::kw___unknown_anytype:
841 return TPResult::False();
842
843 default:
844 break;
845 }
846
847 return TPResult::Ambiguous();
848}
849
850bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
851 return std::find(TentativelyDeclaredIdentifiers.begin(),
852 TentativelyDeclaredIdentifiers.end(), II)
853 != TentativelyDeclaredIdentifiers.end();
854}
855
856/// isCXXDeclarationSpecifier - Returns TPResult::True() if it is a declaration
857/// specifier, TPResult::False() if it is not, TPResult::Ambiguous() if it could
858/// be either a decl-specifier or a function-style cast, and TPResult::Error()
859/// if a parsing error was found and reported.
860///
861/// If HasMissingTypename is provided, a name with a dependent scope specifier
862/// will be treated as ambiguous if the 'typename' keyword is missing. If this
863/// happens, *HasMissingTypename will be set to 'true'. This will also be used
864/// as an indicator that undeclared identifiers (which will trigger a later
865/// parse error) should be treated as types. Returns TPResult::Ambiguous() in
866/// such cases.
867///
868/// decl-specifier:
869/// storage-class-specifier
870/// type-specifier
871/// function-specifier
872/// 'friend'
873/// 'typedef'
874/// [C++0x] 'constexpr'
875/// [GNU] attributes declaration-specifiers[opt]
876///
877/// storage-class-specifier:
878/// 'register'
879/// 'static'
880/// 'extern'
881/// 'mutable'
882/// 'auto'
883/// [GNU] '__thread'
884///
885/// function-specifier:
886/// 'inline'
887/// 'virtual'
888/// 'explicit'
889///
890/// typedef-name:
891/// identifier
892///
893/// type-specifier:
894/// simple-type-specifier
895/// class-specifier
896/// enum-specifier
897/// elaborated-type-specifier
898/// typename-specifier
899/// cv-qualifier
900///
901/// simple-type-specifier:
902/// '::'[opt] nested-name-specifier[opt] type-name
903/// '::'[opt] nested-name-specifier 'template'
904/// simple-template-id [TODO]
905/// 'char'
906/// 'wchar_t'
907/// 'bool'
908/// 'short'
909/// 'int'
910/// 'long'
911/// 'signed'
912/// 'unsigned'
913/// 'float'
914/// 'double'
915/// 'void'
916/// [GNU] typeof-specifier
917/// [GNU] '_Complex'
918/// [C++0x] 'auto' [TODO]
919/// [C++0x] 'decltype' ( expression )
920///
921/// type-name:
922/// class-name
923/// enum-name
924/// typedef-name
925///
926/// elaborated-type-specifier:
927/// class-key '::'[opt] nested-name-specifier[opt] identifier
928/// class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
929/// simple-template-id
930/// 'enum' '::'[opt] nested-name-specifier[opt] identifier
931///
932/// enum-name:
933/// identifier
934///
935/// enum-specifier:
936/// 'enum' identifier[opt] '{' enumerator-list[opt] '}'
937/// 'enum' identifier[opt] '{' enumerator-list ',' '}'
938///
939/// class-specifier:
940/// class-head '{' member-specification[opt] '}'
941///
942/// class-head:
943/// class-key identifier[opt] base-clause[opt]
944/// class-key nested-name-specifier identifier base-clause[opt]
945/// class-key nested-name-specifier[opt] simple-template-id
946/// base-clause[opt]
947///
948/// class-key:
949/// 'class'
950/// 'struct'
951/// 'union'
952///
953/// cv-qualifier:
954/// 'const'
955/// 'volatile'
956/// [GNU] restrict
957///
958Parser::TPResult
959Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
960 bool *HasMissingTypename) {
961 switch (Tok.getKind()) {
962 case tok::identifier: {
963 // Check for need to substitute AltiVec __vector keyword
964 // for "vector" identifier.
965 if (TryAltiVecVectorToken())
966 return TPResult::True();
967
968 const Token &Next = NextToken();
969 // In 'foo bar', 'foo' is always a type name outside of Objective-C.
970 if (!getLangOpts().ObjC1 && Next.is(tok::identifier))
971 return TPResult::True();
972
973 if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
974 // Determine whether this is a valid expression. If not, we will hit
975 // a parse error one way or another. In that case, tell the caller that
976 // this is ambiguous. Typo-correct to type and expression keywords and
977 // to types and identifiers, in order to try to recover from errors.
978 CorrectionCandidateCallback TypoCorrection;
979 TypoCorrection.WantRemainingKeywords = false;
980 switch (TryAnnotateName(false /* no nested name specifier */,
981 &TypoCorrection)) {
982 case ANK_Error:
983 return TPResult::Error();
984 case ANK_TentativeDecl:
985 return TPResult::False();
986 case ANK_TemplateName:
987 // A bare type template-name which can't be a template template
988 // argument is an error, and was probably intended to be a type.
989 return GreaterThanIsOperator ? TPResult::True() : TPResult::False();
990 case ANK_Unresolved:
991 return HasMissingTypename ? TPResult::Ambiguous() : TPResult::False();
992 case ANK_Success:
993 break;
994 }
995 assert(Tok.isNot(tok::identifier) &&
996 "TryAnnotateName succeeded without producing an annotation");
997 } else {
998 // This might possibly be a type with a dependent scope specifier and
999 // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1000 // since it will annotate as a primary expression, and we want to use the
1001 // "missing 'typename'" logic.
1002 if (TryAnnotateTypeOrScopeToken())
1003 return TPResult::Error();
1004 // If annotation failed, assume it's a non-type.
1005 // FIXME: If this happens due to an undeclared identifier, treat it as
1006 // ambiguous.
1007 if (Tok.is(tok::identifier))
1008 return TPResult::False();
1009 }
1010
1011 // We annotated this token as something. Recurse to handle whatever we got.
1012 return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1013 }
1014
1015 case tok::kw_typename: // typename T::type
1016 // Annotate typenames and C++ scope specifiers. If we get one, just
1017 // recurse to handle whatever we get.
1018 if (TryAnnotateTypeOrScopeToken())
1019 return TPResult::Error();
1020 return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1021
1022 case tok::coloncolon: { // ::foo::bar
1023 const Token &Next = NextToken();
1024 if (Next.is(tok::kw_new) || // ::new
1025 Next.is(tok::kw_delete)) // ::delete
1026 return TPResult::False();
1027 }
1028 // Fall through.
1029 case tok::kw_decltype:
1030 // Annotate typenames and C++ scope specifiers. If we get one, just
1031 // recurse to handle whatever we get.
1032 if (TryAnnotateTypeOrScopeToken())
1033 return TPResult::Error();
1034 return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1035
1036 // decl-specifier:
1037 // storage-class-specifier
1038 // type-specifier
1039 // function-specifier
1040 // 'friend'
1041 // 'typedef'
1042 // 'constexpr'
1043 case tok::kw_friend:
1044 case tok::kw_typedef:
1045 case tok::kw_constexpr:
1046 // storage-class-specifier
1047 case tok::kw_register:
1048 case tok::kw_static:
1049 case tok::kw_extern:
1050 case tok::kw_mutable:
1051 case tok::kw_auto:
1052 case tok::kw___thread:
1053 // function-specifier
1054 case tok::kw_inline:
1055 case tok::kw_virtual:
1056 case tok::kw_explicit:
1057
1058 // Modules
1059 case tok::kw___module_private__:
1060
1061 // Debugger support
1062 case tok::kw___unknown_anytype:
1063
1064 // type-specifier:
1065 // simple-type-specifier
1066 // class-specifier
1067 // enum-specifier
1068 // elaborated-type-specifier
1069 // typename-specifier
1070 // cv-qualifier
1071
1072 // class-specifier
1073 // elaborated-type-specifier
1074 case tok::kw_class:
1075 case tok::kw_struct:
1076 case tok::kw_union:
1077 // enum-specifier
1078 case tok::kw_enum:
1079 // cv-qualifier
1080 case tok::kw_const:
1081 case tok::kw_volatile:
1082
1083 // GNU
1084 case tok::kw_restrict:
1085 case tok::kw__Complex:
1086 case tok::kw___attribute:
1087 return TPResult::True();
1088
1089 // Microsoft
1090 case tok::kw___declspec:
1091 case tok::kw___cdecl:
1092 case tok::kw___stdcall:
1093 case tok::kw___fastcall:
1094 case tok::kw___thiscall:
1095 case tok::kw___w64:
1096 case tok::kw___ptr64:
1097 case tok::kw___ptr32:
1098 case tok::kw___forceinline:
1099 case tok::kw___unaligned:
1100 return TPResult::True();
1101
1102 // Borland
1103 case tok::kw___pascal:
1104 return TPResult::True();
1105
1106 // AltiVec
1107 case tok::kw___vector:
1108 return TPResult::True();
1109
1110 case tok::annot_template_id: {
1111 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1112 if (TemplateId->Kind != TNK_Type_template)
1113 return TPResult::False();
1114 CXXScopeSpec SS;
1115 AnnotateTemplateIdTokenAsType();
1116 assert(Tok.is(tok::annot_typename));
1117 goto case_typename;
1118 }
1119
1120 case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1121 // We've already annotated a scope; try to annotate a type.
1122 if (TryAnnotateTypeOrScopeToken())
1123 return TPResult::Error();
1124 if (!Tok.is(tok::annot_typename)) {
1125 // If the next token is an identifier or a type qualifier, then this
1126 // can't possibly be a valid expression either.
1127 if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1128 CXXScopeSpec SS;
1129 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1130 Tok.getAnnotationRange(),
1131 SS);
1132 if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1133 TentativeParsingAction PA(*this);
1134 ConsumeToken();
1135 ConsumeToken();
1136 bool isIdentifier = Tok.is(tok::identifier);
1137 TPResult TPR = TPResult::False();
1138 if (!isIdentifier)
1139 TPR = isCXXDeclarationSpecifier(BracedCastResult,
1140 HasMissingTypename);
1141 PA.Revert();
1142
1143 if (isIdentifier ||
1144 TPR == TPResult::True() || TPR == TPResult::Error())
1145 return TPResult::Error();
1146
1147 if (HasMissingTypename) {
1148 // We can't tell whether this is a missing 'typename' or a valid
1149 // expression.
1150 *HasMissingTypename = true;
1151 return TPResult::Ambiguous();
1152 }
1153 } else {
1154 // Try to resolve the name. If it doesn't exist, assume it was
1155 // intended to name a type and keep disambiguating.
1156 switch (TryAnnotateName(false /* SS is not dependent */)) {
1157 case ANK_Error:
1158 return TPResult::Error();
1159 case ANK_TentativeDecl:
1160 return TPResult::False();
1161 case ANK_TemplateName:
1162 // A bare type template-name which can't be a template template
1163 // argument is an error, and was probably intended to be a type.
1164 return GreaterThanIsOperator ? TPResult::True() : TPResult::False();
1165 case ANK_Unresolved:
1166 return HasMissingTypename ? TPResult::Ambiguous()
1167 : TPResult::False();
1168 case ANK_Success:
1169 // Annotated it, check again.
1170 assert(Tok.isNot(tok::annot_cxxscope) ||
1171 NextToken().isNot(tok::identifier));
1172 return isCXXDeclarationSpecifier(BracedCastResult,
1173 HasMissingTypename);
1174 }
1175 }
1176 }
1177 return TPResult::False();
1178 }
1179 // If that succeeded, fallthrough into the generic simple-type-id case.
1180
1181 // The ambiguity resides in a simple-type-specifier/typename-specifier
1182 // followed by a '('. The '(' could either be the start of:
1183 //
1184 // direct-declarator:
1185 // '(' declarator ')'
1186 //
1187 // direct-abstract-declarator:
1188 // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1189 // exception-specification[opt]
1190 // '(' abstract-declarator ')'
1191 //
1192 // or part of a function-style cast expression:
1193 //
1194 // simple-type-specifier '(' expression-list[opt] ')'
1195 //
1196
1197 // simple-type-specifier:
1198
1199 case tok::annot_typename:
1200 case_typename:
1201 // In Objective-C, we might have a protocol-qualified type.
1202 if (getLangOpts().ObjC1 && NextToken().is(tok::less)) {
1203 // Tentatively parse the
1204 TentativeParsingAction PA(*this);
1205 ConsumeToken(); // The type token
1206
1207 TPResult TPR = TryParseProtocolQualifiers();
1208 bool isFollowedByParen = Tok.is(tok::l_paren);
1209 bool isFollowedByBrace = Tok.is(tok::l_brace);
1210
1211 PA.Revert();
1212
1213 if (TPR == TPResult::Error())
1214 return TPResult::Error();
1215
1216 if (isFollowedByParen)
1217 return TPResult::Ambiguous();
1218
1219 if (getLangOpts().CPlusPlus0x && isFollowedByBrace)
1220 return BracedCastResult;
1221
1222 return TPResult::True();
1223 }
1224
1225 case tok::kw_char:
1226 case tok::kw_wchar_t:
1227 case tok::kw_char16_t:
1228 case tok::kw_char32_t:
1229 case tok::kw_bool:
1230 case tok::kw_short:
1231 case tok::kw_int:
1232 case tok::kw_long:
1233 case tok::kw___int64:
1234 case tok::kw___int128:
1235 case tok::kw_signed:
1236 case tok::kw_unsigned:
1237 case tok::kw_half:
1238 case tok::kw_float:
1239 case tok::kw_double:
1240 case tok::kw_void:
1241 case tok::annot_decltype:
1242 if (NextToken().is(tok::l_paren))
1243 return TPResult::Ambiguous();
1244
1245 // This is a function-style cast in all cases we disambiguate other than
1246 // one:
1247 // struct S {
1248 // enum E : int { a = 4 }; // enum
1249 // enum E : int { 4 }; // bit-field
1250 // };
1251 if (getLangOpts().CPlusPlus0x && NextToken().is(tok::l_brace))
1252 return BracedCastResult;
1253
1254 if (isStartOfObjCClassMessageMissingOpenBracket())
1255 return TPResult::False();
1256
1257 return TPResult::True();
1258
1259 // GNU typeof support.
1260 case tok::kw_typeof: {
1261 if (NextToken().isNot(tok::l_paren))
1262 return TPResult::True();
1263
1264 TentativeParsingAction PA(*this);
1265
1266 TPResult TPR = TryParseTypeofSpecifier();
1267 bool isFollowedByParen = Tok.is(tok::l_paren);
1268 bool isFollowedByBrace = Tok.is(tok::l_brace);
1269
1270 PA.Revert();
1271
1272 if (TPR == TPResult::Error())
1273 return TPResult::Error();
1274
1275 if (isFollowedByParen)
1276 return TPResult::Ambiguous();
1277
1278 if (getLangOpts().CPlusPlus0x && isFollowedByBrace)
1279 return BracedCastResult;
1280
1281 return TPResult::True();
1282 }
1283
1284 // C++0x type traits support
1285 case tok::kw___underlying_type:
1286 return TPResult::True();
1287
1288 // C11 _Atomic
1289 case tok::kw__Atomic:
1290 return TPResult::True();
1291
1292 default:
1293 return TPResult::False();
1294 }
1295}
1296
1297/// [GNU] typeof-specifier:
1298/// 'typeof' '(' expressions ')'
1299/// 'typeof' '(' type-name ')'
1300///
1301Parser::TPResult Parser::TryParseTypeofSpecifier() {
1302 assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1303 ConsumeToken();
1304
1305 assert(Tok.is(tok::l_paren) && "Expected '('");
1306 // Parse through the parens after 'typeof'.
1307 ConsumeParen();
1308 if (!SkipUntil(tok::r_paren))
1309 return TPResult::Error();
1310
1311 return TPResult::Ambiguous();
1312}
1313
1314/// [ObjC] protocol-qualifiers:
1315//// '<' identifier-list '>'
1316Parser::TPResult Parser::TryParseProtocolQualifiers() {
1317 assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1318 ConsumeToken();
1319 do {
1320 if (Tok.isNot(tok::identifier))
1321 return TPResult::Error();
1322 ConsumeToken();
1323
1324 if (Tok.is(tok::comma)) {
1325 ConsumeToken();
1326 continue;
1327 }
1328
1329 if (Tok.is(tok::greater)) {
1330 ConsumeToken();
1331 return TPResult::Ambiguous();
1332 }
1333 } while (false);
1334
1335 return TPResult::Error();
1336}
1337
1338Parser::TPResult
1339Parser::TryParseDeclarationSpecifier(bool *HasMissingTypename) {
1340 TPResult TPR = isCXXDeclarationSpecifier(TPResult::False(),
1341 HasMissingTypename);
1342 if (TPR != TPResult::Ambiguous())
1343 return TPR;
1344
1345 if (Tok.is(tok::kw_typeof))
1346 TryParseTypeofSpecifier();
1347 else {
1348 if (Tok.is(tok::annot_cxxscope))
1349 ConsumeToken();
1350 ConsumeToken();
1351
1352 if (getLangOpts().ObjC1 && Tok.is(tok::less))
1353 TryParseProtocolQualifiers();
1354 }
1355
1356 return TPResult::Ambiguous();
1357}
1358
1359/// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1360/// a constructor-style initializer, when parsing declaration statements.
1361/// Returns true for function declarator and false for constructor-style
1362/// initializer.
1363/// If during the disambiguation process a parsing error is encountered,
1364/// the function returns true to let the declaration parsing code handle it.
1365///
1366/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1367/// exception-specification[opt]
1368///
1369bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1370
1371 // C++ 8.2p1:
1372 // The ambiguity arising from the similarity between a function-style cast and
1373 // a declaration mentioned in 6.8 can also occur in the context of a
1374 // declaration. In that context, the choice is between a function declaration
1375 // with a redundant set of parentheses around a parameter name and an object
1376 // declaration with a function-style cast as the initializer. Just as for the
1377 // ambiguities mentioned in 6.8, the resolution is to consider any construct
1378 // that could possibly be a declaration a declaration.
1379
1380 TentativeParsingAction PA(*this);
1381
1382 ConsumeParen();
1383 bool InvalidAsDeclaration = false;
1384 TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1385 if (TPR == TPResult::Ambiguous()) {
1386 if (Tok.isNot(tok::r_paren))
1387 TPR = TPResult::False();
1388 else {
1389 const Token &Next = NextToken();
1390 if (Next.is(tok::amp) || Next.is(tok::ampamp) ||
1391 Next.is(tok::kw_const) || Next.is(tok::kw_volatile) ||
1392 Next.is(tok::kw_throw) || Next.is(tok::kw_noexcept) ||
1393 Next.is(tok::l_square) || isCXX0XVirtSpecifier(Next) ||
1394 Next.is(tok::l_brace) || Next.is(tok::kw_try) ||
1395 Next.is(tok::equal) || Next.is(tok::arrow))
1396 // The next token cannot appear after a constructor-style initializer,
1397 // and can appear next in a function definition. This must be a function
1398 // declarator.
1399 TPR = TPResult::True();
1400 else if (InvalidAsDeclaration)
1401 // Use the absence of 'typename' as a tie-breaker.
1402 TPR = TPResult::False();
1403 }
1404 }
1405
1406 PA.Revert();
1407
1408 if (IsAmbiguous && TPR == TPResult::Ambiguous())
1409 *IsAmbiguous = true;
1410
1411 // In case of an error, let the declaration parsing code handle it.
1412 return TPR != TPResult::False();
1413}
1414
1415/// parameter-declaration-clause:
1416/// parameter-declaration-list[opt] '...'[opt]
1417/// parameter-declaration-list ',' '...'
1418///
1419/// parameter-declaration-list:
1420/// parameter-declaration
1421/// parameter-declaration-list ',' parameter-declaration
1422///
1423/// parameter-declaration:
1424/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1425/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1426/// '=' assignment-expression
1427/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1428/// attributes[opt]
1429/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1430/// attributes[opt] '=' assignment-expression
1431///
1432Parser::TPResult
1433Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration) {
1434
1435 if (Tok.is(tok::r_paren))
1436 return TPResult::Ambiguous();
1437
1438 // parameter-declaration-list[opt] '...'[opt]
1439 // parameter-declaration-list ',' '...'
1440 //
1441 // parameter-declaration-list:
1442 // parameter-declaration
1443 // parameter-declaration-list ',' parameter-declaration
1444 //
1445 while (1) {
1446 // '...'[opt]
1447 if (Tok.is(tok::ellipsis)) {
1448 ConsumeToken();
1449 if (Tok.is(tok::r_paren))
1450 return TPResult::True(); // '...)' is a sign of a function declarator.
1451 else
1452 return TPResult::False();
1453 }
1454
1455 // An attribute-specifier-seq here is a sign of a function declarator.
1456 if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1457 /*OuterMightBeMessageSend*/true))
1458 return TPResult::True();
1459
1460 ParsedAttributes attrs(AttrFactory);
1461 MaybeParseMicrosoftAttributes(attrs);
1462
1463 // decl-specifier-seq
1464 // A parameter-declaration's initializer must be preceded by an '=', so
1465 // decl-specifier-seq '{' is not a parameter in C++11.
1466 TPResult TPR = TryParseDeclarationSpecifier(InvalidAsDeclaration);
1467 if (TPR != TPResult::Ambiguous())
1468 return TPR;
1469
1470 // declarator
1471 // abstract-declarator[opt]
1472 TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1473 if (TPR != TPResult::Ambiguous())
1474 return TPR;
1475
1476 // [GNU] attributes[opt]
1477 if (Tok.is(tok::kw___attribute))
1478 return TPResult::True();
1479
1480 if (Tok.is(tok::equal)) {
1481 // '=' assignment-expression
1482 // Parse through assignment-expression.
1483 if (!SkipUntil(tok::comma, tok::r_paren, true/*StopAtSemi*/,
1484 true/*DontConsume*/))
1485 return TPResult::Error();
1486 }
1487
1488 if (Tok.is(tok::ellipsis)) {
1489 ConsumeToken();
1490 if (Tok.is(tok::r_paren))
1491 return TPResult::True(); // '...)' is a sign of a function declarator.
1492 else
1493 return TPResult::False();
1494 }
1495
1496 if (Tok.isNot(tok::comma))
1497 break;
1498 ConsumeToken(); // the comma.
1499 }
1500
1501 return TPResult::Ambiguous();
1502}
1503
1504/// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1505/// parsing as a function declarator.
1506/// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1507/// return TPResult::Ambiguous(), otherwise it will return either False() or
1508/// Error().
1509///
1510/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1511/// exception-specification[opt]
1512///
1513/// exception-specification:
1514/// 'throw' '(' type-id-list[opt] ')'
1515///
1516Parser::TPResult Parser::TryParseFunctionDeclarator() {
1517
1518 // The '(' is already parsed.
1519
1520 TPResult TPR = TryParseParameterDeclarationClause();
1521 if (TPR == TPResult::Ambiguous() && Tok.isNot(tok::r_paren))
1522 TPR = TPResult::False();
1523
1524 if (TPR == TPResult::False() || TPR == TPResult::Error())
1525 return TPR;
1526
1527 // Parse through the parens.
1528 if (!SkipUntil(tok::r_paren))
1529 return TPResult::Error();
1530
1531 // cv-qualifier-seq
1532 while (Tok.is(tok::kw_const) ||
1533 Tok.is(tok::kw_volatile) ||
1534 Tok.is(tok::kw_restrict) )
1535 ConsumeToken();
1536
1537 // ref-qualifier[opt]
1538 if (Tok.is(tok::amp) || Tok.is(tok::ampamp))
1539 ConsumeToken();
1540
1541 // exception-specification
1542 if (Tok.is(tok::kw_throw)) {
1543 ConsumeToken();
1544 if (Tok.isNot(tok::l_paren))
1545 return TPResult::Error();
1546
1547 // Parse through the parens after 'throw'.
1548 ConsumeParen();
1549 if (!SkipUntil(tok::r_paren))
1550 return TPResult::Error();
1551 }
1552 if (Tok.is(tok::kw_noexcept)) {
1553 ConsumeToken();
1554 // Possibly an expression as well.
1555 if (Tok.is(tok::l_paren)) {
1556 // Find the matching rparen.
1557 ConsumeParen();
1558 if (!SkipUntil(tok::r_paren))
1559 return TPResult::Error();
1560 }
1561 }
1562
1563 return TPResult::Ambiguous();
1564}
1565
1566/// '[' constant-expression[opt] ']'
1567///
1568Parser::TPResult Parser::TryParseBracketDeclarator() {
1569 ConsumeBracket();
1570 if (!SkipUntil(tok::r_square))
1571 return TPResult::Error();
1572
1573 return TPResult::Ambiguous();
1574}