1//===--- 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/// Try to consume a token sequence that we've already identified as
146/// (potentially) starting a decl-specifier.
147Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
148  switch (Tok.getKind()) {
149  case tok::kw__Atomic:
150    if (NextToken().isNot(tok::l_paren)) {
151      ConsumeToken();
152      break;
153    }
154    // Fall through.
155  case tok::kw_typeof:
156  case tok::kw___attribute:
157  case tok::kw___underlying_type: {
158    ConsumeToken();
159    if (Tok.isNot(tok::l_paren))
160      return TPResult::Error;
161    ConsumeParen();
162    if (!SkipUntil(tok::r_paren))
163      return TPResult::Error;
164    break;
165  }
166
167  case tok::kw_class:
168  case tok::kw_struct:
169  case tok::kw_union:
170  case tok::kw___interface:
171  case tok::kw_enum:
172    // elaborated-type-specifier:
173    //     class-key attribute-specifier-seq[opt]
174    //         nested-name-specifier[opt] identifier
175    //     class-key nested-name-specifier[opt] template[opt] simple-template-id
176    //     enum nested-name-specifier[opt] identifier
177    //
178    // FIXME: We don't support class-specifiers nor enum-specifiers here.
179    ConsumeToken();
180
181    // Skip attributes.
182    while (Tok.is(tok::l_square) || Tok.is(tok::kw___attribute) ||
183           Tok.is(tok::kw___declspec) || Tok.is(tok::kw_alignas)) {
184      if (Tok.is(tok::l_square)) {
185        ConsumeBracket();
186        if (!SkipUntil(tok::r_square))
187          return TPResult::Error;
188      } else {
189        ConsumeToken();
190        if (Tok.isNot(tok::l_paren))
191          return TPResult::Error;
192        ConsumeParen();
193        if (!SkipUntil(tok::r_paren))
194          return TPResult::Error;
195      }
196    }
197
198    if (TryAnnotateCXXScopeToken())
199      return TPResult::Error;
200    if (Tok.is(tok::annot_cxxscope))
201      ConsumeToken();
202    if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id))
203      return TPResult::Error;
204    ConsumeToken();
205    break;
206
207  case tok::annot_cxxscope:
208    ConsumeToken();
209    // Fall through.
210  default:
211    ConsumeToken();
212
213    if (getLangOpts().ObjC1 && Tok.is(tok::less))
214      return TryParseProtocolQualifiers();
215    break;
216  }
217
218  return TPResult::Ambiguous;
219}
220
221/// simple-declaration:
222///   decl-specifier-seq init-declarator-list[opt] ';'
223///
224/// (if AllowForRangeDecl specified)
225/// for ( for-range-declaration : for-range-initializer ) statement
226/// for-range-declaration:
227///    attribute-specifier-seqopt type-specifier-seq declarator
228///
229Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
230  if (TryConsumeDeclarationSpecifier() == TPResult::Error)
231    return TPResult::Error;
232
233  // Two decl-specifiers in a row conclusively disambiguate this as being a
234  // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
235  // overwhelmingly common case that the next token is a '('.
236  if (Tok.isNot(tok::l_paren)) {
237    TPResult TPR = isCXXDeclarationSpecifier();
238    if (TPR == TPResult::Ambiguous)
239      return TPResult::True;
240    if (TPR == TPResult::True || TPR == TPResult::Error)
241      return TPR;
242    assert(TPR == TPResult::False);
243  }
244
245  TPResult TPR = TryParseInitDeclaratorList();
246  if (TPR != TPResult::Ambiguous)
247    return TPR;
248
249  if (Tok.isNot(tok::semi) && (!AllowForRangeDecl || Tok.isNot(tok::colon)))
250    return TPResult::False;
251
252  return TPResult::Ambiguous;
253}
254
255/// Tentatively parse an init-declarator-list in order to disambiguate it from
256/// an expression.
257///
258///       init-declarator-list:
259///         init-declarator
260///         init-declarator-list ',' init-declarator
261///
262///       init-declarator:
263///         declarator initializer[opt]
264/// [GNU]   declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
265///
266///       initializer:
267///         brace-or-equal-initializer
268///         '(' expression-list ')'
269///
270///       brace-or-equal-initializer:
271///         '=' initializer-clause
272/// [C++11] braced-init-list
273///
274///       initializer-clause:
275///         assignment-expression
276///         braced-init-list
277///
278///       braced-init-list:
279///         '{' initializer-list ','[opt] '}'
280///         '{' '}'
281///
282Parser::TPResult Parser::TryParseInitDeclaratorList() {
283  while (1) {
284    // declarator
285    TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
286    if (TPR != TPResult::Ambiguous)
287      return TPR;
288
289    // [GNU] simple-asm-expr[opt] attributes[opt]
290    if (Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
291      return TPResult::True;
292
293    // initializer[opt]
294    if (Tok.is(tok::l_paren)) {
295      // Parse through the parens.
296      ConsumeParen();
297      if (!SkipUntil(tok::r_paren, StopAtSemi))
298        return TPResult::Error;
299    } else if (Tok.is(tok::l_brace)) {
300      // A left-brace here is sufficient to disambiguate the parse; an
301      // expression can never be followed directly by a braced-init-list.
302      return TPResult::True;
303    } else if (Tok.is(tok::equal) || isTokIdentifier_in()) {
304      // MSVC and g++ won't examine the rest of declarators if '=' is
305      // encountered; they just conclude that we have a declaration.
306      // EDG parses the initializer completely, which is the proper behavior
307      // for this case.
308      //
309      // At present, Clang follows MSVC and g++, since the parser does not have
310      // the ability to parse an expression fully without recording the
311      // results of that parse.
312      // FIXME: Handle this case correctly.
313      //
314      // Also allow 'in' after an Objective-C declaration as in:
315      // for (int (^b)(void) in array). Ideally this should be done in the
316      // context of parsing for-init-statement of a foreach statement only. But,
317      // in any other context 'in' is invalid after a declaration and parser
318      // issues the error regardless of outcome of this decision.
319      // FIXME: Change if above assumption does not hold.
320      return TPResult::True;
321    }
322
323    if (!TryConsumeToken(tok::comma))
324      break;
325  }
326
327  return TPResult::Ambiguous;
328}
329
330/// isCXXConditionDeclaration - Disambiguates between a declaration or an
331/// expression for a condition of a if/switch/while/for statement.
332/// If during the disambiguation process a parsing error is encountered,
333/// the function returns true to let the declaration parsing code handle it.
334///
335///       condition:
336///         expression
337///         type-specifier-seq declarator '=' assignment-expression
338/// [C++11] type-specifier-seq declarator '=' initializer-clause
339/// [C++11] type-specifier-seq declarator braced-init-list
340/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
341///             '=' assignment-expression
342///
343bool Parser::isCXXConditionDeclaration() {
344  TPResult TPR = isCXXDeclarationSpecifier();
345  if (TPR != TPResult::Ambiguous)
346    return TPR != TPResult::False; // Returns true for TPResult::True or
347                                   // TPResult::Error.
348
349  // FIXME: Add statistics about the number of ambiguous statements encountered
350  // and how they were resolved (number of declarations+number of expressions).
351
352  // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
353  // We need tentative parsing...
354
355  TentativeParsingAction PA(*this);
356
357  // type-specifier-seq
358  TryConsumeDeclarationSpecifier();
359  assert(Tok.is(tok::l_paren) && "Expected '('");
360
361  // declarator
362  TPR = TryParseDeclarator(false/*mayBeAbstract*/);
363
364  // In case of an error, let the declaration parsing code handle it.
365  if (TPR == TPResult::Error)
366    TPR = TPResult::True;
367
368  if (TPR == TPResult::Ambiguous) {
369    // '='
370    // [GNU] simple-asm-expr[opt] attributes[opt]
371    if (Tok.is(tok::equal)  ||
372        Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute))
373      TPR = TPResult::True;
374    else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
375      TPR = TPResult::True;
376    else
377      TPR = TPResult::False;
378  }
379
380  PA.Revert();
381
382  assert(TPR == TPResult::True || TPR == TPResult::False);
383  return TPR == TPResult::True;
384}
385
386  /// \brief Determine whether the next set of tokens contains a type-id.
387  ///
388  /// The context parameter states what context we're parsing right
389  /// now, which affects how this routine copes with the token
390  /// following the type-id. If the context is TypeIdInParens, we have
391  /// already parsed the '(' and we will cease lookahead when we hit
392  /// the corresponding ')'. If the context is
393  /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
394  /// before this template argument, and will cease lookahead when we
395  /// hit a '>', '>>' (in C++0x), or ','. Returns true for a type-id
396  /// and false for an expression.  If during the disambiguation
397  /// process a parsing error is encountered, the function returns
398  /// true to let the declaration parsing code handle it.
399  ///
400  /// type-id:
401  ///   type-specifier-seq abstract-declarator[opt]
402  ///
403bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
404
405  isAmbiguous = false;
406
407  // C++ 8.2p2:
408  // The ambiguity arising from the similarity between a function-style cast and
409  // a type-id can occur in different contexts. The ambiguity appears as a
410  // choice between a function-style cast expression and a declaration of a
411  // type. The resolution is that any construct that could possibly be a type-id
412  // in its syntactic context shall be considered a type-id.
413
414  TPResult TPR = isCXXDeclarationSpecifier();
415  if (TPR != TPResult::Ambiguous)
416    return TPR != TPResult::False; // Returns true for TPResult::True or
417                                     // TPResult::Error.
418
419  // FIXME: Add statistics about the number of ambiguous statements encountered
420  // and how they were resolved (number of declarations+number of expressions).
421
422  // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
423  // We need tentative parsing...
424
425  TentativeParsingAction PA(*this);
426
427  // type-specifier-seq
428  TryConsumeDeclarationSpecifier();
429  assert(Tok.is(tok::l_paren) && "Expected '('");
430
431  // declarator
432  TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
433
434  // In case of an error, let the declaration parsing code handle it.
435  if (TPR == TPResult::Error)
436    TPR = TPResult::True;
437
438  if (TPR == TPResult::Ambiguous) {
439    // We are supposed to be inside parens, so if after the abstract declarator
440    // we encounter a ')' this is a type-id, otherwise it's an expression.
441    if (Context == TypeIdInParens && Tok.is(tok::r_paren)) {
442      TPR = TPResult::True;
443      isAmbiguous = true;
444
445    // We are supposed to be inside a template argument, so if after
446    // the abstract declarator we encounter a '>', '>>' (in C++0x), or
447    // ',', this is a type-id. Otherwise, it's an expression.
448    } else if (Context == TypeIdAsTemplateArgument &&
449               (Tok.is(tok::greater) || Tok.is(tok::comma) ||
450                (getLangOpts().CPlusPlus11 && Tok.is(tok::greatergreater)))) {
451      TPR = TPResult::True;
452      isAmbiguous = true;
453
454    } else
455      TPR = TPResult::False;
456  }
457
458  PA.Revert();
459
460  assert(TPR == TPResult::True || TPR == TPResult::False);
461  return TPR == TPResult::True;
462}
463
464/// \brief Returns true if this is a C++11 attribute-specifier. Per
465/// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
466/// always introduce an attribute. In Objective-C++11, this rule does not
467/// apply if either '[' begins a message-send.
468///
469/// If Disambiguate is true, we try harder to determine whether a '[[' starts
470/// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
471///
472/// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
473/// Obj-C message send or the start of an attribute. Otherwise, we assume it
474/// is not an Obj-C message send.
475///
476/// C++11 [dcl.attr.grammar]:
477///
478///     attribute-specifier:
479///         '[' '[' attribute-list ']' ']'
480///         alignment-specifier
481///
482///     attribute-list:
483///         attribute[opt]
484///         attribute-list ',' attribute[opt]
485///         attribute '...'
486///         attribute-list ',' attribute '...'
487///
488///     attribute:
489///         attribute-token attribute-argument-clause[opt]
490///
491///     attribute-token:
492///         identifier
493///         identifier '::' identifier
494///
495///     attribute-argument-clause:
496///         '(' balanced-token-seq ')'
497Parser::CXX11AttributeKind
498Parser::isCXX11AttributeSpecifier(bool Disambiguate,
499                                  bool OuterMightBeMessageSend) {
500  if (Tok.is(tok::kw_alignas))
501    return CAK_AttributeSpecifier;
502
503  if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
504    return CAK_NotAttributeSpecifier;
505
506  // No tentative parsing if we don't need to look for ']]' or a lambda.
507  if (!Disambiguate && !getLangOpts().ObjC1)
508    return CAK_AttributeSpecifier;
509
510  TentativeParsingAction PA(*this);
511
512  // Opening brackets were checked for above.
513  ConsumeBracket();
514
515  // Outside Obj-C++11, treat anything with a matching ']]' as an attribute.
516  if (!getLangOpts().ObjC1) {
517    ConsumeBracket();
518
519    bool IsAttribute = SkipUntil(tok::r_square);
520    IsAttribute &= Tok.is(tok::r_square);
521
522    PA.Revert();
523
524    return IsAttribute ? CAK_AttributeSpecifier : CAK_InvalidAttributeSpecifier;
525  }
526
527  // In Obj-C++11, we need to distinguish four situations:
528  //  1a) int x[[attr]];                     C++11 attribute.
529  //  1b) [[attr]];                          C++11 statement attribute.
530  //   2) int x[[obj](){ return 1; }()];     Lambda in array size/index.
531  //  3a) int x[[obj get]];                  Message send in array size/index.
532  //  3b) [[Class alloc] init];              Message send in message send.
533  //   4) [[obj]{ return self; }() doStuff]; Lambda in message send.
534  // (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
535
536  // If we have a lambda-introducer, then this is definitely not a message send.
537  // FIXME: If this disambiguation is too slow, fold the tentative lambda parse
538  // into the tentative attribute parse below.
539  LambdaIntroducer Intro;
540  if (!TryParseLambdaIntroducer(Intro)) {
541    // A lambda cannot end with ']]', and an attribute must.
542    bool IsAttribute = Tok.is(tok::r_square);
543
544    PA.Revert();
545
546    if (IsAttribute)
547      // Case 1: C++11 attribute.
548      return CAK_AttributeSpecifier;
549
550    if (OuterMightBeMessageSend)
551      // Case 4: Lambda in message send.
552      return CAK_NotAttributeSpecifier;
553
554    // Case 2: Lambda in array size / index.
555    return CAK_InvalidAttributeSpecifier;
556  }
557
558  ConsumeBracket();
559
560  // If we don't have a lambda-introducer, then we have an attribute or a
561  // message-send.
562  bool IsAttribute = true;
563  while (Tok.isNot(tok::r_square)) {
564    if (Tok.is(tok::comma)) {
565      // Case 1: Stray commas can only occur in attributes.
566      PA.Revert();
567      return CAK_AttributeSpecifier;
568    }
569
570    // Parse the attribute-token, if present.
571    // C++11 [dcl.attr.grammar]:
572    //   If a keyword or an alternative token that satisfies the syntactic
573    //   requirements of an identifier is contained in an attribute-token,
574    //   it is considered an identifier.
575    SourceLocation Loc;
576    if (!TryParseCXX11AttributeIdentifier(Loc)) {
577      IsAttribute = false;
578      break;
579    }
580    if (Tok.is(tok::coloncolon)) {
581      ConsumeToken();
582      if (!TryParseCXX11AttributeIdentifier(Loc)) {
583        IsAttribute = false;
584        break;
585      }
586    }
587
588    // Parse the attribute-argument-clause, if present.
589    if (Tok.is(tok::l_paren)) {
590      ConsumeParen();
591      if (!SkipUntil(tok::r_paren)) {
592        IsAttribute = false;
593        break;
594      }
595    }
596
597    TryConsumeToken(tok::ellipsis);
598
599    if (!TryConsumeToken(tok::comma))
600      break;
601  }
602
603  // An attribute must end ']]'.
604  if (IsAttribute) {
605    if (Tok.is(tok::r_square)) {
606      ConsumeBracket();
607      IsAttribute = Tok.is(tok::r_square);
608    } else {
609      IsAttribute = false;
610    }
611  }
612
613  PA.Revert();
614
615  if (IsAttribute)
616    // Case 1: C++11 statement attribute.
617    return CAK_AttributeSpecifier;
618
619  // Case 3: Message send.
620  return CAK_NotAttributeSpecifier;
621}
622
623Parser::TPResult Parser::TryParsePtrOperatorSeq() {
624  while (true) {
625    if (Tok.is(tok::coloncolon) || Tok.is(tok::identifier))
626      if (TryAnnotateCXXScopeToken(true))
627        return TPResult::Error;
628
629    if (Tok.is(tok::star) || Tok.is(tok::amp) || Tok.is(tok::caret) ||
630        Tok.is(tok::ampamp) ||
631        (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
632      // ptr-operator
633      ConsumeToken();
634      while (Tok.is(tok::kw_const)    ||
635             Tok.is(tok::kw_volatile) ||
636             Tok.is(tok::kw_restrict))
637        ConsumeToken();
638    } else {
639      return TPResult::True;
640    }
641  }
642}
643
644///         operator-function-id:
645///           'operator' operator
646///
647///         operator: one of
648///           new  delete  new[]  delete[]  +  -  *  /  %  ^  [...]
649///
650///         conversion-function-id:
651///           'operator' conversion-type-id
652///
653///         conversion-type-id:
654///           type-specifier-seq conversion-declarator[opt]
655///
656///         conversion-declarator:
657///           ptr-operator conversion-declarator[opt]
658///
659///         literal-operator-id:
660///           'operator' string-literal identifier
661///           'operator' user-defined-string-literal
662Parser::TPResult Parser::TryParseOperatorId() {
663  assert(Tok.is(tok::kw_operator));
664  ConsumeToken();
665
666  // Maybe this is an operator-function-id.
667  switch (Tok.getKind()) {
668  case tok::kw_new: case tok::kw_delete:
669    ConsumeToken();
670    if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
671      ConsumeBracket();
672      ConsumeBracket();
673    }
674    return TPResult::True;
675
676#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemOnly) \
677  case tok::Token:
678#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemOnly)
679#include "clang/Basic/OperatorKinds.def"
680    ConsumeToken();
681    return TPResult::True;
682
683  case tok::l_square:
684    if (NextToken().is(tok::r_square)) {
685      ConsumeBracket();
686      ConsumeBracket();
687      return TPResult::True;
688    }
689    break;
690
691  case tok::l_paren:
692    if (NextToken().is(tok::r_paren)) {
693      ConsumeParen();
694      ConsumeParen();
695      return TPResult::True;
696    }
697    break;
698
699  default:
700    break;
701  }
702
703  // Maybe this is a literal-operator-id.
704  if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
705    bool FoundUDSuffix = false;
706    do {
707      FoundUDSuffix |= Tok.hasUDSuffix();
708      ConsumeStringToken();
709    } while (isTokenStringLiteral());
710
711    if (!FoundUDSuffix) {
712      if (Tok.is(tok::identifier))
713        ConsumeToken();
714      else
715        return TPResult::Error;
716    }
717    return TPResult::True;
718  }
719
720  // Maybe this is a conversion-function-id.
721  bool AnyDeclSpecifiers = false;
722  while (true) {
723    TPResult TPR = isCXXDeclarationSpecifier();
724    if (TPR == TPResult::Error)
725      return TPR;
726    if (TPR == TPResult::False) {
727      if (!AnyDeclSpecifiers)
728        return TPResult::Error;
729      break;
730    }
731    if (TryConsumeDeclarationSpecifier() == TPResult::Error)
732      return TPResult::Error;
733    AnyDeclSpecifiers = true;
734  }
735  return TryParsePtrOperatorSeq();
736}
737
738///         declarator:
739///           direct-declarator
740///           ptr-operator declarator
741///
742///         direct-declarator:
743///           declarator-id
744///           direct-declarator '(' parameter-declaration-clause ')'
745///                 cv-qualifier-seq[opt] exception-specification[opt]
746///           direct-declarator '[' constant-expression[opt] ']'
747///           '(' declarator ')'
748/// [GNU]     '(' attributes declarator ')'
749///
750///         abstract-declarator:
751///           ptr-operator abstract-declarator[opt]
752///           direct-abstract-declarator
753///           ...
754///
755///         direct-abstract-declarator:
756///           direct-abstract-declarator[opt]
757///           '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
758///                 exception-specification[opt]
759///           direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
760///           '(' abstract-declarator ')'
761///
762///         ptr-operator:
763///           '*' cv-qualifier-seq[opt]
764///           '&'
765/// [C++0x]   '&&'                                                        [TODO]
766///           '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
767///
768///         cv-qualifier-seq:
769///           cv-qualifier cv-qualifier-seq[opt]
770///
771///         cv-qualifier:
772///           'const'
773///           'volatile'
774///
775///         declarator-id:
776///           '...'[opt] id-expression
777///
778///         id-expression:
779///           unqualified-id
780///           qualified-id                                                [TODO]
781///
782///         unqualified-id:
783///           identifier
784///           operator-function-id
785///           conversion-function-id
786///           literal-operator-id
787///           '~' class-name                                              [TODO]
788///           '~' decltype-specifier                                      [TODO]
789///           template-id                                                 [TODO]
790///
791Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
792                                            bool mayHaveIdentifier) {
793  // declarator:
794  //   direct-declarator
795  //   ptr-operator declarator
796  if (TryParsePtrOperatorSeq() == TPResult::Error)
797    return TPResult::Error;
798
799  // direct-declarator:
800  // direct-abstract-declarator:
801  if (Tok.is(tok::ellipsis))
802    ConsumeToken();
803
804  if ((Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
805       (Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) ||
806                                        NextToken().is(tok::kw_operator)))) &&
807      mayHaveIdentifier) {
808    // declarator-id
809    if (Tok.is(tok::annot_cxxscope))
810      ConsumeToken();
811    else if (Tok.is(tok::identifier))
812      TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
813    if (Tok.is(tok::kw_operator)) {
814      if (TryParseOperatorId() == TPResult::Error)
815        return TPResult::Error;
816    } else
817      ConsumeToken();
818  } else if (Tok.is(tok::l_paren)) {
819    ConsumeParen();
820    if (mayBeAbstract &&
821        (Tok.is(tok::r_paren) ||       // 'int()' is a function.
822         // 'int(...)' is a function.
823         (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
824         isDeclarationSpecifier())) {   // 'int(int)' is a function.
825      // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
826      //        exception-specification[opt]
827      TPResult TPR = TryParseFunctionDeclarator();
828      if (TPR != TPResult::Ambiguous)
829        return TPR;
830    } else {
831      // '(' declarator ')'
832      // '(' attributes declarator ')'
833      // '(' abstract-declarator ')'
834      if (Tok.is(tok::kw___attribute) ||
835          Tok.is(tok::kw___declspec) ||
836          Tok.is(tok::kw___cdecl) ||
837          Tok.is(tok::kw___stdcall) ||
838          Tok.is(tok::kw___fastcall) ||
839          Tok.is(tok::kw___thiscall) ||
840          Tok.is(tok::kw___unaligned))
841        return TPResult::True; // attributes indicate declaration
842      TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
843      if (TPR != TPResult::Ambiguous)
844        return TPR;
845      if (Tok.isNot(tok::r_paren))
846        return TPResult::False;
847      ConsumeParen();
848    }
849  } else if (!mayBeAbstract) {
850    return TPResult::False;
851  }
852
853  while (1) {
854    TPResult TPR(TPResult::Ambiguous);
855
856    // abstract-declarator: ...
857    if (Tok.is(tok::ellipsis))
858      ConsumeToken();
859
860    if (Tok.is(tok::l_paren)) {
861      // Check whether we have a function declarator or a possible ctor-style
862      // initializer that follows the declarator. Note that ctor-style
863      // initializers are not possible in contexts where abstract declarators
864      // are allowed.
865      if (!mayBeAbstract && !isCXXFunctionDeclarator())
866        break;
867
868      // direct-declarator '(' parameter-declaration-clause ')'
869      //        cv-qualifier-seq[opt] exception-specification[opt]
870      ConsumeParen();
871      TPR = TryParseFunctionDeclarator();
872    } else if (Tok.is(tok::l_square)) {
873      // direct-declarator '[' constant-expression[opt] ']'
874      // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
875      TPR = TryParseBracketDeclarator();
876    } else {
877      break;
878    }
879
880    if (TPR != TPResult::Ambiguous)
881      return TPR;
882  }
883
884  return TPResult::Ambiguous;
885}
886
887Parser::TPResult
888Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
889  switch (Kind) {
890  // Obviously starts an expression.
891  case tok::numeric_constant:
892  case tok::char_constant:
893  case tok::wide_char_constant:
894  case tok::utf16_char_constant:
895  case tok::utf32_char_constant:
896  case tok::string_literal:
897  case tok::wide_string_literal:
898  case tok::utf8_string_literal:
899  case tok::utf16_string_literal:
900  case tok::utf32_string_literal:
901  case tok::l_square:
902  case tok::l_paren:
903  case tok::amp:
904  case tok::ampamp:
905  case tok::star:
906  case tok::plus:
907  case tok::plusplus:
908  case tok::minus:
909  case tok::minusminus:
910  case tok::tilde:
911  case tok::exclaim:
912  case tok::kw_sizeof:
913  case tok::kw___func__:
914  case tok::kw_const_cast:
915  case tok::kw_delete:
916  case tok::kw_dynamic_cast:
917  case tok::kw_false:
918  case tok::kw_new:
919  case tok::kw_operator:
920  case tok::kw_reinterpret_cast:
921  case tok::kw_static_cast:
922  case tok::kw_this:
923  case tok::kw_throw:
924  case tok::kw_true:
925  case tok::kw_typeid:
926  case tok::kw_alignof:
927  case tok::kw_noexcept:
928  case tok::kw_nullptr:
929  case tok::kw__Alignof:
930  case tok::kw___null:
931  case tok::kw___alignof:
932  case tok::kw___builtin_choose_expr:
933  case tok::kw___builtin_offsetof:
934  case tok::kw___builtin_va_arg:
935  case tok::kw___imag:
936  case tok::kw___real:
937  case tok::kw___FUNCTION__:
938  case tok::kw___FUNCDNAME__:
939  case tok::kw___FUNCSIG__:
940  case tok::kw_L__FUNCTION__:
941  case tok::kw___PRETTY_FUNCTION__:
942  case tok::kw___uuidof:
943#define TYPE_TRAIT(N,Spelling,K) \
944  case tok::kw_##Spelling:
945#include "clang/Basic/TokenKinds.def"
946    return TPResult::True;
947
948  // Obviously starts a type-specifier-seq:
949  case tok::kw_char:
950  case tok::kw_const:
951  case tok::kw_double:
952  case tok::kw_enum:
953  case tok::kw_half:
954  case tok::kw_float:
955  case tok::kw_int:
956  case tok::kw_long:
957  case tok::kw___int64:
958  case tok::kw___int128:
959  case tok::kw_restrict:
960  case tok::kw_short:
961  case tok::kw_signed:
962  case tok::kw_struct:
963  case tok::kw_union:
964  case tok::kw_unsigned:
965  case tok::kw_void:
966  case tok::kw_volatile:
967  case tok::kw__Bool:
968  case tok::kw__Complex:
969  case tok::kw_class:
970  case tok::kw_typename:
971  case tok::kw_wchar_t:
972  case tok::kw_char16_t:
973  case tok::kw_char32_t:
974  case tok::kw__Decimal32:
975  case tok::kw__Decimal64:
976  case tok::kw__Decimal128:
977  case tok::kw___interface:
978  case tok::kw___thread:
979  case tok::kw_thread_local:
980  case tok::kw__Thread_local:
981  case tok::kw_typeof:
982  case tok::kw___underlying_type:
983  case tok::kw___cdecl:
984  case tok::kw___stdcall:
985  case tok::kw___fastcall:
986  case tok::kw___thiscall:
987  case tok::kw___unaligned:
988  case tok::kw___vector:
989  case tok::kw___pixel:
990  case tok::kw__Atomic:
991  case tok::kw___unknown_anytype:
992    return TPResult::False;
993
994  default:
995    break;
996  }
997
998  return TPResult::Ambiguous;
999}
1000
1001bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
1002  return std::find(TentativelyDeclaredIdentifiers.begin(),
1003                   TentativelyDeclaredIdentifiers.end(), II)
1004      != TentativelyDeclaredIdentifiers.end();
1005}
1006
1007/// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
1008/// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
1009/// be either a decl-specifier or a function-style cast, and TPResult::Error
1010/// if a parsing error was found and reported.
1011///
1012/// If HasMissingTypename is provided, a name with a dependent scope specifier
1013/// will be treated as ambiguous if the 'typename' keyword is missing. If this
1014/// happens, *HasMissingTypename will be set to 'true'. This will also be used
1015/// as an indicator that undeclared identifiers (which will trigger a later
1016/// parse error) should be treated as types. Returns TPResult::Ambiguous in
1017/// such cases.
1018///
1019///         decl-specifier:
1020///           storage-class-specifier
1021///           type-specifier
1022///           function-specifier
1023///           'friend'
1024///           'typedef'
1025/// [C++11]   'constexpr'
1026/// [GNU]     attributes declaration-specifiers[opt]
1027///
1028///         storage-class-specifier:
1029///           'register'
1030///           'static'
1031///           'extern'
1032///           'mutable'
1033///           'auto'
1034/// [GNU]     '__thread'
1035/// [C++11]   'thread_local'
1036/// [C11]     '_Thread_local'
1037///
1038///         function-specifier:
1039///           'inline'
1040///           'virtual'
1041///           'explicit'
1042///
1043///         typedef-name:
1044///           identifier
1045///
1046///         type-specifier:
1047///           simple-type-specifier
1048///           class-specifier
1049///           enum-specifier
1050///           elaborated-type-specifier
1051///           typename-specifier
1052///           cv-qualifier
1053///
1054///         simple-type-specifier:
1055///           '::'[opt] nested-name-specifier[opt] type-name
1056///           '::'[opt] nested-name-specifier 'template'
1057///                 simple-template-id                              [TODO]
1058///           'char'
1059///           'wchar_t'
1060///           'bool'
1061///           'short'
1062///           'int'
1063///           'long'
1064///           'signed'
1065///           'unsigned'
1066///           'float'
1067///           'double'
1068///           'void'
1069/// [GNU]     typeof-specifier
1070/// [GNU]     '_Complex'
1071/// [C++11]   'auto'
1072/// [C++11]   'decltype' ( expression )
1073/// [C++1y]   'decltype' ( 'auto' )
1074///
1075///         type-name:
1076///           class-name
1077///           enum-name
1078///           typedef-name
1079///
1080///         elaborated-type-specifier:
1081///           class-key '::'[opt] nested-name-specifier[opt] identifier
1082///           class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
1083///               simple-template-id
1084///           'enum' '::'[opt] nested-name-specifier[opt] identifier
1085///
1086///         enum-name:
1087///           identifier
1088///
1089///         enum-specifier:
1090///           'enum' identifier[opt] '{' enumerator-list[opt] '}'
1091///           'enum' identifier[opt] '{' enumerator-list ',' '}'
1092///
1093///         class-specifier:
1094///           class-head '{' member-specification[opt] '}'
1095///
1096///         class-head:
1097///           class-key identifier[opt] base-clause[opt]
1098///           class-key nested-name-specifier identifier base-clause[opt]
1099///           class-key nested-name-specifier[opt] simple-template-id
1100///               base-clause[opt]
1101///
1102///         class-key:
1103///           'class'
1104///           'struct'
1105///           'union'
1106///
1107///         cv-qualifier:
1108///           'const'
1109///           'volatile'
1110/// [GNU]     restrict
1111///
1112Parser::TPResult
1113Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
1114                                  bool *HasMissingTypename) {
1115  switch (Tok.getKind()) {
1116  case tok::identifier: {
1117    // Check for need to substitute AltiVec __vector keyword
1118    // for "vector" identifier.
1119    if (TryAltiVecVectorToken())
1120      return TPResult::True;
1121
1122    const Token &Next = NextToken();
1123    // In 'foo bar', 'foo' is always a type name outside of Objective-C.
1124    if (!getLangOpts().ObjC1 && Next.is(tok::identifier))
1125      return TPResult::True;
1126
1127    if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
1128      // Determine whether this is a valid expression. If not, we will hit
1129      // a parse error one way or another. In that case, tell the caller that
1130      // this is ambiguous. Typo-correct to type and expression keywords and
1131      // to types and identifiers, in order to try to recover from errors.
1132      CorrectionCandidateCallback TypoCorrection;
1133      TypoCorrection.WantRemainingKeywords = false;
1134      TypoCorrection.WantTypeSpecifiers = Next.isNot(tok::arrow);
1135      switch (TryAnnotateName(false /* no nested name specifier */,
1136                              &TypoCorrection)) {
1137      case ANK_Error:
1138        return TPResult::Error;
1139      case ANK_TentativeDecl:
1140        return TPResult::False;
1141      case ANK_TemplateName:
1142        // A bare type template-name which can't be a template template
1143        // argument is an error, and was probably intended to be a type.
1144        return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1145      case ANK_Unresolved:
1146        return HasMissingTypename ? TPResult::Ambiguous : TPResult::False;
1147      case ANK_Success:
1148        break;
1149      }
1150      assert(Tok.isNot(tok::identifier) &&
1151             "TryAnnotateName succeeded without producing an annotation");
1152    } else {
1153      // This might possibly be a type with a dependent scope specifier and
1154      // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1155      // since it will annotate as a primary expression, and we want to use the
1156      // "missing 'typename'" logic.
1157      if (TryAnnotateTypeOrScopeToken())
1158        return TPResult::Error;
1159      // If annotation failed, assume it's a non-type.
1160      // FIXME: If this happens due to an undeclared identifier, treat it as
1161      // ambiguous.
1162      if (Tok.is(tok::identifier))
1163        return TPResult::False;
1164    }
1165
1166    // We annotated this token as something. Recurse to handle whatever we got.
1167    return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1168  }
1169
1170  case tok::kw_typename:  // typename T::type
1171    // Annotate typenames and C++ scope specifiers.  If we get one, just
1172    // recurse to handle whatever we get.
1173    if (TryAnnotateTypeOrScopeToken())
1174      return TPResult::Error;
1175    return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1176
1177  case tok::coloncolon: {    // ::foo::bar
1178    const Token &Next = NextToken();
1179    if (Next.is(tok::kw_new) ||    // ::new
1180        Next.is(tok::kw_delete))   // ::delete
1181      return TPResult::False;
1182  }
1183    // Fall through.
1184  case tok::kw_decltype:
1185    // Annotate typenames and C++ scope specifiers.  If we get one, just
1186    // recurse to handle whatever we get.
1187    if (TryAnnotateTypeOrScopeToken())
1188      return TPResult::Error;
1189    return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1190
1191    // decl-specifier:
1192    //   storage-class-specifier
1193    //   type-specifier
1194    //   function-specifier
1195    //   'friend'
1196    //   'typedef'
1197    //   'constexpr'
1198  case tok::kw_friend:
1199  case tok::kw_typedef:
1200  case tok::kw_constexpr:
1201    // storage-class-specifier
1202  case tok::kw_register:
1203  case tok::kw_static:
1204  case tok::kw_extern:
1205  case tok::kw_mutable:
1206  case tok::kw_auto:
1207  case tok::kw___thread:
1208  case tok::kw_thread_local:
1209  case tok::kw__Thread_local:
1210    // function-specifier
1211  case tok::kw_inline:
1212  case tok::kw_virtual:
1213  case tok::kw_explicit:
1214
1215    // Modules
1216  case tok::kw___module_private__:
1217
1218    // Debugger support
1219  case tok::kw___unknown_anytype:
1220
1221    // type-specifier:
1222    //   simple-type-specifier
1223    //   class-specifier
1224    //   enum-specifier
1225    //   elaborated-type-specifier
1226    //   typename-specifier
1227    //   cv-qualifier
1228
1229    // class-specifier
1230    // elaborated-type-specifier
1231  case tok::kw_class:
1232  case tok::kw_struct:
1233  case tok::kw_union:
1234  case tok::kw___interface:
1235    // enum-specifier
1236  case tok::kw_enum:
1237    // cv-qualifier
1238  case tok::kw_const:
1239  case tok::kw_volatile:
1240
1241    // GNU
1242  case tok::kw_restrict:
1243  case tok::kw__Complex:
1244  case tok::kw___attribute:
1245    return TPResult::True;
1246
1247    // Microsoft
1248  case tok::kw___declspec:
1249  case tok::kw___cdecl:
1250  case tok::kw___stdcall:
1251  case tok::kw___fastcall:
1252  case tok::kw___thiscall:
1253  case tok::kw___w64:
1254  case tok::kw___sptr:
1255  case tok::kw___uptr:
1256  case tok::kw___ptr64:
1257  case tok::kw___ptr32:
1258  case tok::kw___forceinline:
1259  case tok::kw___unaligned:
1260    return TPResult::True;
1261
1262    // Borland
1263  case tok::kw___pascal:
1264    return TPResult::True;
1265
1266    // AltiVec
1267  case tok::kw___vector:
1268    return TPResult::True;
1269
1270  case tok::annot_template_id: {
1271    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1272    if (TemplateId->Kind != TNK_Type_template)
1273      return TPResult::False;
1274    CXXScopeSpec SS;
1275    AnnotateTemplateIdTokenAsType();
1276    assert(Tok.is(tok::annot_typename));
1277    goto case_typename;
1278  }
1279
1280  case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1281    // We've already annotated a scope; try to annotate a type.
1282    if (TryAnnotateTypeOrScopeToken())
1283      return TPResult::Error;
1284    if (!Tok.is(tok::annot_typename)) {
1285      // If the next token is an identifier or a type qualifier, then this
1286      // can't possibly be a valid expression either.
1287      if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1288        CXXScopeSpec SS;
1289        Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1290                                                     Tok.getAnnotationRange(),
1291                                                     SS);
1292        if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1293          TentativeParsingAction PA(*this);
1294          ConsumeToken();
1295          ConsumeToken();
1296          bool isIdentifier = Tok.is(tok::identifier);
1297          TPResult TPR = TPResult::False;
1298          if (!isIdentifier)
1299            TPR = isCXXDeclarationSpecifier(BracedCastResult,
1300                                            HasMissingTypename);
1301          PA.Revert();
1302
1303          if (isIdentifier ||
1304              TPR == TPResult::True || TPR == TPResult::Error)
1305            return TPResult::Error;
1306
1307          if (HasMissingTypename) {
1308            // We can't tell whether this is a missing 'typename' or a valid
1309            // expression.
1310            *HasMissingTypename = true;
1311            return TPResult::Ambiguous;
1312          }
1313        } else {
1314          // Try to resolve the name. If it doesn't exist, assume it was
1315          // intended to name a type and keep disambiguating.
1316          switch (TryAnnotateName(false /* SS is not dependent */)) {
1317          case ANK_Error:
1318            return TPResult::Error;
1319          case ANK_TentativeDecl:
1320            return TPResult::False;
1321          case ANK_TemplateName:
1322            // A bare type template-name which can't be a template template
1323            // argument is an error, and was probably intended to be a type.
1324            return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1325          case ANK_Unresolved:
1326            return HasMissingTypename ? TPResult::Ambiguous
1327                                      : TPResult::False;
1328          case ANK_Success:
1329            // Annotated it, check again.
1330            assert(Tok.isNot(tok::annot_cxxscope) ||
1331                   NextToken().isNot(tok::identifier));
1332            return isCXXDeclarationSpecifier(BracedCastResult,
1333                                             HasMissingTypename);
1334          }
1335        }
1336      }
1337      return TPResult::False;
1338    }
1339    // If that succeeded, fallthrough into the generic simple-type-id case.
1340
1341    // The ambiguity resides in a simple-type-specifier/typename-specifier
1342    // followed by a '('. The '(' could either be the start of:
1343    //
1344    //   direct-declarator:
1345    //     '(' declarator ')'
1346    //
1347    //   direct-abstract-declarator:
1348    //     '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1349    //              exception-specification[opt]
1350    //     '(' abstract-declarator ')'
1351    //
1352    // or part of a function-style cast expression:
1353    //
1354    //     simple-type-specifier '(' expression-list[opt] ')'
1355    //
1356
1357    // simple-type-specifier:
1358
1359  case tok::annot_typename:
1360  case_typename:
1361    // In Objective-C, we might have a protocol-qualified type.
1362    if (getLangOpts().ObjC1 && NextToken().is(tok::less)) {
1363      // Tentatively parse the
1364      TentativeParsingAction PA(*this);
1365      ConsumeToken(); // The type token
1366
1367      TPResult TPR = TryParseProtocolQualifiers();
1368      bool isFollowedByParen = Tok.is(tok::l_paren);
1369      bool isFollowedByBrace = Tok.is(tok::l_brace);
1370
1371      PA.Revert();
1372
1373      if (TPR == TPResult::Error)
1374        return TPResult::Error;
1375
1376      if (isFollowedByParen)
1377        return TPResult::Ambiguous;
1378
1379      if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1380        return BracedCastResult;
1381
1382      return TPResult::True;
1383    }
1384
1385  case tok::kw_char:
1386  case tok::kw_wchar_t:
1387  case tok::kw_char16_t:
1388  case tok::kw_char32_t:
1389  case tok::kw_bool:
1390  case tok::kw_short:
1391  case tok::kw_int:
1392  case tok::kw_long:
1393  case tok::kw___int64:
1394  case tok::kw___int128:
1395  case tok::kw_signed:
1396  case tok::kw_unsigned:
1397  case tok::kw_half:
1398  case tok::kw_float:
1399  case tok::kw_double:
1400  case tok::kw_void:
1401  case tok::annot_decltype:
1402    if (NextToken().is(tok::l_paren))
1403      return TPResult::Ambiguous;
1404
1405    // This is a function-style cast in all cases we disambiguate other than
1406    // one:
1407    //   struct S {
1408    //     enum E : int { a = 4 }; // enum
1409    //     enum E : int { 4 };     // bit-field
1410    //   };
1411    if (getLangOpts().CPlusPlus11 && NextToken().is(tok::l_brace))
1412      return BracedCastResult;
1413
1414    if (isStartOfObjCClassMessageMissingOpenBracket())
1415      return TPResult::False;
1416
1417    return TPResult::True;
1418
1419  // GNU typeof support.
1420  case tok::kw_typeof: {
1421    if (NextToken().isNot(tok::l_paren))
1422      return TPResult::True;
1423
1424    TentativeParsingAction PA(*this);
1425
1426    TPResult TPR = TryParseTypeofSpecifier();
1427    bool isFollowedByParen = Tok.is(tok::l_paren);
1428    bool isFollowedByBrace = Tok.is(tok::l_brace);
1429
1430    PA.Revert();
1431
1432    if (TPR == TPResult::Error)
1433      return TPResult::Error;
1434
1435    if (isFollowedByParen)
1436      return TPResult::Ambiguous;
1437
1438    if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1439      return BracedCastResult;
1440
1441    return TPResult::True;
1442  }
1443
1444  // C++0x type traits support
1445  case tok::kw___underlying_type:
1446    return TPResult::True;
1447
1448  // C11 _Atomic
1449  case tok::kw__Atomic:
1450    return TPResult::True;
1451
1452  default:
1453    return TPResult::False;
1454  }
1455}
1456
1457bool Parser::isCXXDeclarationSpecifierAType() {
1458  switch (Tok.getKind()) {
1459    // typename-specifier
1460  case tok::annot_decltype:
1461  case tok::annot_template_id:
1462  case tok::annot_typename:
1463  case tok::kw_typeof:
1464  case tok::kw___underlying_type:
1465    return true;
1466
1467    // elaborated-type-specifier
1468  case tok::kw_class:
1469  case tok::kw_struct:
1470  case tok::kw_union:
1471  case tok::kw___interface:
1472  case tok::kw_enum:
1473    return true;
1474
1475    // simple-type-specifier
1476  case tok::kw_char:
1477  case tok::kw_wchar_t:
1478  case tok::kw_char16_t:
1479  case tok::kw_char32_t:
1480  case tok::kw_bool:
1481  case tok::kw_short:
1482  case tok::kw_int:
1483  case tok::kw_long:
1484  case tok::kw___int64:
1485  case tok::kw___int128:
1486  case tok::kw_signed:
1487  case tok::kw_unsigned:
1488  case tok::kw_half:
1489  case tok::kw_float:
1490  case tok::kw_double:
1491  case tok::kw_void:
1492  case tok::kw___unknown_anytype:
1493    return true;
1494
1495  case tok::kw_auto:
1496    return getLangOpts().CPlusPlus11;
1497
1498  case tok::kw__Atomic:
1499    // "_Atomic foo"
1500    return NextToken().is(tok::l_paren);
1501
1502  default:
1503    return false;
1504  }
1505}
1506
1507/// [GNU] typeof-specifier:
1508///         'typeof' '(' expressions ')'
1509///         'typeof' '(' type-name ')'
1510///
1511Parser::TPResult Parser::TryParseTypeofSpecifier() {
1512  assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1513  ConsumeToken();
1514
1515  assert(Tok.is(tok::l_paren) && "Expected '('");
1516  // Parse through the parens after 'typeof'.
1517  ConsumeParen();
1518  if (!SkipUntil(tok::r_paren, StopAtSemi))
1519    return TPResult::Error;
1520
1521  return TPResult::Ambiguous;
1522}
1523
1524/// [ObjC] protocol-qualifiers:
1525////         '<' identifier-list '>'
1526Parser::TPResult Parser::TryParseProtocolQualifiers() {
1527  assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1528  ConsumeToken();
1529  do {
1530    if (Tok.isNot(tok::identifier))
1531      return TPResult::Error;
1532    ConsumeToken();
1533
1534    if (Tok.is(tok::comma)) {
1535      ConsumeToken();
1536      continue;
1537    }
1538
1539    if (Tok.is(tok::greater)) {
1540      ConsumeToken();
1541      return TPResult::Ambiguous;
1542    }
1543  } while (false);
1544
1545  return TPResult::Error;
1546}
1547
1548/// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1549/// a constructor-style initializer, when parsing declaration statements.
1550/// Returns true for function declarator and false for constructor-style
1551/// initializer.
1552/// If during the disambiguation process a parsing error is encountered,
1553/// the function returns true to let the declaration parsing code handle it.
1554///
1555/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1556///         exception-specification[opt]
1557///
1558bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1559
1560  // C++ 8.2p1:
1561  // The ambiguity arising from the similarity between a function-style cast and
1562  // a declaration mentioned in 6.8 can also occur in the context of a
1563  // declaration. In that context, the choice is between a function declaration
1564  // with a redundant set of parentheses around a parameter name and an object
1565  // declaration with a function-style cast as the initializer. Just as for the
1566  // ambiguities mentioned in 6.8, the resolution is to consider any construct
1567  // that could possibly be a declaration a declaration.
1568
1569  TentativeParsingAction PA(*this);
1570
1571  ConsumeParen();
1572  bool InvalidAsDeclaration = false;
1573  TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1574  if (TPR == TPResult::Ambiguous) {
1575    if (Tok.isNot(tok::r_paren))
1576      TPR = TPResult::False;
1577    else {
1578      const Token &Next = NextToken();
1579      if (Next.is(tok::amp) || Next.is(tok::ampamp) ||
1580          Next.is(tok::kw_const) || Next.is(tok::kw_volatile) ||
1581          Next.is(tok::kw_throw) || Next.is(tok::kw_noexcept) ||
1582          Next.is(tok::l_square) || isCXX11VirtSpecifier(Next) ||
1583          Next.is(tok::l_brace) || Next.is(tok::kw_try) ||
1584          Next.is(tok::equal) || Next.is(tok::arrow))
1585        // The next token cannot appear after a constructor-style initializer,
1586        // and can appear next in a function definition. This must be a function
1587        // declarator.
1588        TPR = TPResult::True;
1589      else if (InvalidAsDeclaration)
1590        // Use the absence of 'typename' as a tie-breaker.
1591        TPR = TPResult::False;
1592    }
1593  }
1594
1595  PA.Revert();
1596
1597  if (IsAmbiguous && TPR == TPResult::Ambiguous)
1598    *IsAmbiguous = true;
1599
1600  // In case of an error, let the declaration parsing code handle it.
1601  return TPR != TPResult::False;
1602}
1603
1604/// parameter-declaration-clause:
1605///   parameter-declaration-list[opt] '...'[opt]
1606///   parameter-declaration-list ',' '...'
1607///
1608/// parameter-declaration-list:
1609///   parameter-declaration
1610///   parameter-declaration-list ',' parameter-declaration
1611///
1612/// parameter-declaration:
1613///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1614///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1615///     '=' assignment-expression
1616///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1617///     attributes[opt]
1618///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1619///     attributes[opt] '=' assignment-expression
1620///
1621Parser::TPResult
1622Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
1623                                           bool VersusTemplateArgument) {
1624
1625  if (Tok.is(tok::r_paren))
1626    return TPResult::Ambiguous;
1627
1628  //   parameter-declaration-list[opt] '...'[opt]
1629  //   parameter-declaration-list ',' '...'
1630  //
1631  // parameter-declaration-list:
1632  //   parameter-declaration
1633  //   parameter-declaration-list ',' parameter-declaration
1634  //
1635  while (1) {
1636    // '...'[opt]
1637    if (Tok.is(tok::ellipsis)) {
1638      ConsumeToken();
1639      if (Tok.is(tok::r_paren))
1640        return TPResult::True; // '...)' is a sign of a function declarator.
1641      else
1642        return TPResult::False;
1643    }
1644
1645    // An attribute-specifier-seq here is a sign of a function declarator.
1646    if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1647                                  /*OuterMightBeMessageSend*/true))
1648      return TPResult::True;
1649
1650    ParsedAttributes attrs(AttrFactory);
1651    MaybeParseMicrosoftAttributes(attrs);
1652
1653    // decl-specifier-seq
1654    // A parameter-declaration's initializer must be preceded by an '=', so
1655    // decl-specifier-seq '{' is not a parameter in C++11.
1656    TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
1657                                             InvalidAsDeclaration);
1658
1659    if (VersusTemplateArgument && TPR == TPResult::True) {
1660      // Consume the decl-specifier-seq. We have to look past it, since a
1661      // type-id might appear here in a template argument.
1662      bool SeenType = false;
1663      do {
1664        SeenType |= isCXXDeclarationSpecifierAType();
1665        if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1666          return TPResult::Error;
1667
1668        // If we see a parameter name, this can't be a template argument.
1669        if (SeenType && Tok.is(tok::identifier))
1670          return TPResult::True;
1671
1672        TPR = isCXXDeclarationSpecifier(TPResult::False,
1673                                        InvalidAsDeclaration);
1674        if (TPR == TPResult::Error)
1675          return TPR;
1676      } while (TPR != TPResult::False);
1677    } else if (TPR == TPResult::Ambiguous) {
1678      // Disambiguate what follows the decl-specifier.
1679      if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1680        return TPResult::Error;
1681    } else
1682      return TPR;
1683
1684    // declarator
1685    // abstract-declarator[opt]
1686    TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1687    if (TPR != TPResult::Ambiguous)
1688      return TPR;
1689
1690    // [GNU] attributes[opt]
1691    if (Tok.is(tok::kw___attribute))
1692      return TPResult::True;
1693
1694    // If we're disambiguating a template argument in a default argument in
1695    // a class definition versus a parameter declaration, an '=' here
1696    // disambiguates the parse one way or the other.
1697    // If this is a parameter, it must have a default argument because
1698    //   (a) the previous parameter did, and
1699    //   (b) this must be the first declaration of the function, so we can't
1700    //       inherit any default arguments from elsewhere.
1701    // If we see an ')', then we've reached the end of a
1702    // parameter-declaration-clause, and the last param is missing its default
1703    // argument.
1704    if (VersusTemplateArgument)
1705      return (Tok.is(tok::equal) || Tok.is(tok::r_paren)) ? TPResult::True
1706                                                          : TPResult::False;
1707
1708    if (Tok.is(tok::equal)) {
1709      // '=' assignment-expression
1710      // Parse through assignment-expression.
1711      // FIXME: assignment-expression may contain an unparenthesized comma.
1712      if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
1713        return TPResult::Error;
1714    }
1715
1716    if (Tok.is(tok::ellipsis)) {
1717      ConsumeToken();
1718      if (Tok.is(tok::r_paren))
1719        return TPResult::True; // '...)' is a sign of a function declarator.
1720      else
1721        return TPResult::False;
1722    }
1723
1724    if (!TryConsumeToken(tok::comma))
1725      break;
1726  }
1727
1728  return TPResult::Ambiguous;
1729}
1730
1731/// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1732/// parsing as a function declarator.
1733/// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1734/// return TPResult::Ambiguous, otherwise it will return either False() or
1735/// Error().
1736///
1737/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1738///         exception-specification[opt]
1739///
1740/// exception-specification:
1741///   'throw' '(' type-id-list[opt] ')'
1742///
1743Parser::TPResult Parser::TryParseFunctionDeclarator() {
1744
1745  // The '(' is already parsed.
1746
1747  TPResult TPR = TryParseParameterDeclarationClause();
1748  if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
1749    TPR = TPResult::False;
1750
1751  if (TPR == TPResult::False || TPR == TPResult::Error)
1752    return TPR;
1753
1754  // Parse through the parens.
1755  if (!SkipUntil(tok::r_paren, StopAtSemi))
1756    return TPResult::Error;
1757
1758  // cv-qualifier-seq
1759  while (Tok.is(tok::kw_const)    ||
1760         Tok.is(tok::kw_volatile) ||
1761         Tok.is(tok::kw_restrict)   )
1762    ConsumeToken();
1763
1764  // ref-qualifier[opt]
1765  if (Tok.is(tok::amp) || Tok.is(tok::ampamp))
1766    ConsumeToken();
1767
1768  // exception-specification
1769  if (Tok.is(tok::kw_throw)) {
1770    ConsumeToken();
1771    if (Tok.isNot(tok::l_paren))
1772      return TPResult::Error;
1773
1774    // Parse through the parens after 'throw'.
1775    ConsumeParen();
1776    if (!SkipUntil(tok::r_paren, StopAtSemi))
1777      return TPResult::Error;
1778  }
1779  if (Tok.is(tok::kw_noexcept)) {
1780    ConsumeToken();
1781    // Possibly an expression as well.
1782    if (Tok.is(tok::l_paren)) {
1783      // Find the matching rparen.
1784      ConsumeParen();
1785      if (!SkipUntil(tok::r_paren, StopAtSemi))
1786        return TPResult::Error;
1787    }
1788  }
1789
1790  return TPResult::Ambiguous;
1791}
1792
1793/// '[' constant-expression[opt] ']'
1794///
1795Parser::TPResult Parser::TryParseBracketDeclarator() {
1796  ConsumeBracket();
1797  if (!SkipUntil(tok::r_square, StopAtSemi))
1798    return TPResult::Error;
1799
1800  return TPResult::Ambiguous;
1801}
1802