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/// 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_final:
786  case tok::kw___is_literal:
787  case tok::kw___is_literal_type:
788  case tok::kw___is_pod:
789  case tok::kw___is_polymorphic:
790  case tok::kw___is_trivial:
791  case tok::kw___is_trivially_assignable:
792  case tok::kw___is_trivially_constructible:
793  case tok::kw___is_trivially_copyable:
794  case tok::kw___is_union:
795  case tok::kw___uuidof:
796    return TPResult::True();
797
798  // Obviously starts a type-specifier-seq:
799  case tok::kw_char:
800  case tok::kw_const:
801  case tok::kw_double:
802  case tok::kw_enum:
803  case tok::kw_half:
804  case tok::kw_float:
805  case tok::kw_int:
806  case tok::kw_long:
807  case tok::kw___int64:
808  case tok::kw___int128:
809  case tok::kw_restrict:
810  case tok::kw_short:
811  case tok::kw_signed:
812  case tok::kw_struct:
813  case tok::kw_union:
814  case tok::kw_unsigned:
815  case tok::kw_void:
816  case tok::kw_volatile:
817  case tok::kw__Bool:
818  case tok::kw__Complex:
819  case tok::kw_class:
820  case tok::kw_typename:
821  case tok::kw_wchar_t:
822  case tok::kw_char16_t:
823  case tok::kw_char32_t:
824  case tok::kw___underlying_type:
825  case tok::kw_thread_local:
826  case tok::kw__Decimal32:
827  case tok::kw__Decimal64:
828  case tok::kw__Decimal128:
829  case tok::kw___thread:
830  case tok::kw_typeof:
831  case tok::kw___cdecl:
832  case tok::kw___stdcall:
833  case tok::kw___fastcall:
834  case tok::kw___thiscall:
835  case tok::kw___unaligned:
836  case tok::kw___vector:
837  case tok::kw___pixel:
838  case tok::kw__Atomic:
839    return TPResult::False();
840
841  default:
842    break;
843  }
844
845  return TPResult::Ambiguous();
846}
847
848bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
849  return std::find(TentativelyDeclaredIdentifiers.begin(),
850                   TentativelyDeclaredIdentifiers.end(), II)
851      != TentativelyDeclaredIdentifiers.end();
852}
853
854/// isCXXDeclarationSpecifier - Returns TPResult::True() if it is a declaration
855/// specifier, TPResult::False() if it is not, TPResult::Ambiguous() if it could
856/// be either a decl-specifier or a function-style cast, and TPResult::Error()
857/// if a parsing error was found and reported.
858///
859/// If HasMissingTypename is provided, a name with a dependent scope specifier
860/// will be treated as ambiguous if the 'typename' keyword is missing. If this
861/// happens, *HasMissingTypename will be set to 'true'. This will also be used
862/// as an indicator that undeclared identifiers (which will trigger a later
863/// parse error) should be treated as types. Returns TPResult::Ambiguous() in
864/// such cases.
865///
866///         decl-specifier:
867///           storage-class-specifier
868///           type-specifier
869///           function-specifier
870///           'friend'
871///           'typedef'
872/// [C++0x]   'constexpr'
873/// [GNU]     attributes declaration-specifiers[opt]
874///
875///         storage-class-specifier:
876///           'register'
877///           'static'
878///           'extern'
879///           'mutable'
880///           'auto'
881/// [GNU]     '__thread'
882///
883///         function-specifier:
884///           'inline'
885///           'virtual'
886///           'explicit'
887///
888///         typedef-name:
889///           identifier
890///
891///         type-specifier:
892///           simple-type-specifier
893///           class-specifier
894///           enum-specifier
895///           elaborated-type-specifier
896///           typename-specifier
897///           cv-qualifier
898///
899///         simple-type-specifier:
900///           '::'[opt] nested-name-specifier[opt] type-name
901///           '::'[opt] nested-name-specifier 'template'
902///                 simple-template-id                              [TODO]
903///           'char'
904///           'wchar_t'
905///           'bool'
906///           'short'
907///           'int'
908///           'long'
909///           'signed'
910///           'unsigned'
911///           'float'
912///           'double'
913///           'void'
914/// [GNU]     typeof-specifier
915/// [GNU]     '_Complex'
916/// [C++0x]   'auto'                                                [TODO]
917/// [C++0x]   'decltype' ( expression )
918///
919///         type-name:
920///           class-name
921///           enum-name
922///           typedef-name
923///
924///         elaborated-type-specifier:
925///           class-key '::'[opt] nested-name-specifier[opt] identifier
926///           class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
927///               simple-template-id
928///           'enum' '::'[opt] nested-name-specifier[opt] identifier
929///
930///         enum-name:
931///           identifier
932///
933///         enum-specifier:
934///           'enum' identifier[opt] '{' enumerator-list[opt] '}'
935///           'enum' identifier[opt] '{' enumerator-list ',' '}'
936///
937///         class-specifier:
938///           class-head '{' member-specification[opt] '}'
939///
940///         class-head:
941///           class-key identifier[opt] base-clause[opt]
942///           class-key nested-name-specifier identifier base-clause[opt]
943///           class-key nested-name-specifier[opt] simple-template-id
944///               base-clause[opt]
945///
946///         class-key:
947///           'class'
948///           'struct'
949///           'union'
950///
951///         cv-qualifier:
952///           'const'
953///           'volatile'
954/// [GNU]     restrict
955///
956Parser::TPResult
957Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
958                                  bool *HasMissingTypename) {
959  switch (Tok.getKind()) {
960  case tok::identifier: {
961    // Check for need to substitute AltiVec __vector keyword
962    // for "vector" identifier.
963    if (TryAltiVecVectorToken())
964      return TPResult::True();
965
966    const Token &Next = NextToken();
967    // In 'foo bar', 'foo' is always a type name outside of Objective-C.
968    if (!getLangOpts().ObjC1 && Next.is(tok::identifier))
969      return TPResult::True();
970
971    if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
972      // Determine whether this is a valid expression. If not, we will hit
973      // a parse error one way or another. In that case, tell the caller that
974      // this is ambiguous. Typo-correct to type and expression keywords and
975      // to types and identifiers, in order to try to recover from errors.
976      CorrectionCandidateCallback TypoCorrection;
977      TypoCorrection.WantRemainingKeywords = false;
978      switch (TryAnnotateName(false /* no nested name specifier */,
979                              &TypoCorrection)) {
980      case ANK_Error:
981        return TPResult::Error();
982      case ANK_TentativeDecl:
983        return TPResult::False();
984      case ANK_TemplateName:
985        // A bare type template-name which can't be a template template
986        // argument is an error, and was probably intended to be a type.
987        return GreaterThanIsOperator ? TPResult::True() : TPResult::False();
988      case ANK_Unresolved:
989        return HasMissingTypename ? TPResult::Ambiguous() : TPResult::False();
990      case ANK_Success:
991        break;
992      }
993      assert(Tok.isNot(tok::identifier) &&
994             "TryAnnotateName succeeded without producing an annotation");
995    } else {
996      // This might possibly be a type with a dependent scope specifier and
997      // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
998      // since it will annotate as a primary expression, and we want to use the
999      // "missing 'typename'" logic.
1000      if (TryAnnotateTypeOrScopeToken())
1001        return TPResult::Error();
1002      // If annotation failed, assume it's a non-type.
1003      // FIXME: If this happens due to an undeclared identifier, treat it as
1004      // ambiguous.
1005      if (Tok.is(tok::identifier))
1006        return TPResult::False();
1007    }
1008
1009    // We annotated this token as something. Recurse to handle whatever we got.
1010    return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1011  }
1012
1013  case tok::kw_typename:  // typename T::type
1014    // Annotate typenames and C++ scope specifiers.  If we get one, just
1015    // recurse to handle whatever we get.
1016    if (TryAnnotateTypeOrScopeToken())
1017      return TPResult::Error();
1018    return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1019
1020  case tok::coloncolon: {    // ::foo::bar
1021    const Token &Next = NextToken();
1022    if (Next.is(tok::kw_new) ||    // ::new
1023        Next.is(tok::kw_delete))   // ::delete
1024      return TPResult::False();
1025  }
1026    // Fall through.
1027  case tok::kw_decltype:
1028    // Annotate typenames and C++ scope specifiers.  If we get one, just
1029    // recurse to handle whatever we get.
1030    if (TryAnnotateTypeOrScopeToken())
1031      return TPResult::Error();
1032    return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1033
1034    // decl-specifier:
1035    //   storage-class-specifier
1036    //   type-specifier
1037    //   function-specifier
1038    //   'friend'
1039    //   'typedef'
1040    //   'constexpr'
1041  case tok::kw_friend:
1042  case tok::kw_typedef:
1043  case tok::kw_constexpr:
1044    // storage-class-specifier
1045  case tok::kw_register:
1046  case tok::kw_static:
1047  case tok::kw_extern:
1048  case tok::kw_mutable:
1049  case tok::kw_auto:
1050  case tok::kw___thread:
1051    // function-specifier
1052  case tok::kw_inline:
1053  case tok::kw_virtual:
1054  case tok::kw_explicit:
1055
1056    // Modules
1057  case tok::kw___module_private__:
1058
1059    // type-specifier:
1060    //   simple-type-specifier
1061    //   class-specifier
1062    //   enum-specifier
1063    //   elaborated-type-specifier
1064    //   typename-specifier
1065    //   cv-qualifier
1066
1067    // class-specifier
1068    // elaborated-type-specifier
1069  case tok::kw_class:
1070  case tok::kw_struct:
1071  case tok::kw_union:
1072    // enum-specifier
1073  case tok::kw_enum:
1074    // cv-qualifier
1075  case tok::kw_const:
1076  case tok::kw_volatile:
1077
1078    // GNU
1079  case tok::kw_restrict:
1080  case tok::kw__Complex:
1081  case tok::kw___attribute:
1082    return TPResult::True();
1083
1084    // Microsoft
1085  case tok::kw___declspec:
1086  case tok::kw___cdecl:
1087  case tok::kw___stdcall:
1088  case tok::kw___fastcall:
1089  case tok::kw___thiscall:
1090  case tok::kw___w64:
1091  case tok::kw___ptr64:
1092  case tok::kw___ptr32:
1093  case tok::kw___forceinline:
1094  case tok::kw___unaligned:
1095    return TPResult::True();
1096
1097    // Borland
1098  case tok::kw___pascal:
1099    return TPResult::True();
1100
1101    // AltiVec
1102  case tok::kw___vector:
1103    return TPResult::True();
1104
1105  case tok::annot_template_id: {
1106    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1107    if (TemplateId->Kind != TNK_Type_template)
1108      return TPResult::False();
1109    CXXScopeSpec SS;
1110    AnnotateTemplateIdTokenAsType();
1111    assert(Tok.is(tok::annot_typename));
1112    goto case_typename;
1113  }
1114
1115  case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1116    // We've already annotated a scope; try to annotate a type.
1117    if (TryAnnotateTypeOrScopeToken())
1118      return TPResult::Error();
1119    if (!Tok.is(tok::annot_typename)) {
1120      // If the next token is an identifier or a type qualifier, then this
1121      // can't possibly be a valid expression either.
1122      if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1123        CXXScopeSpec SS;
1124        Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1125                                                     Tok.getAnnotationRange(),
1126                                                     SS);
1127        if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1128          TentativeParsingAction PA(*this);
1129          ConsumeToken();
1130          ConsumeToken();
1131          bool isIdentifier = Tok.is(tok::identifier);
1132          TPResult TPR = TPResult::False();
1133          if (!isIdentifier)
1134            TPR = isCXXDeclarationSpecifier(BracedCastResult,
1135                                            HasMissingTypename);
1136          PA.Revert();
1137
1138          if (isIdentifier ||
1139              TPR == TPResult::True() || TPR == TPResult::Error())
1140            return TPResult::Error();
1141
1142          if (HasMissingTypename) {
1143            // We can't tell whether this is a missing 'typename' or a valid
1144            // expression.
1145            *HasMissingTypename = true;
1146            return TPResult::Ambiguous();
1147          }
1148        } else {
1149          // Try to resolve the name. If it doesn't exist, assume it was
1150          // intended to name a type and keep disambiguating.
1151          switch (TryAnnotateName(false /* SS is not dependent */)) {
1152          case ANK_Error:
1153            return TPResult::Error();
1154          case ANK_TentativeDecl:
1155            return TPResult::False();
1156          case ANK_TemplateName:
1157            // A bare type template-name which can't be a template template
1158            // argument is an error, and was probably intended to be a type.
1159            return GreaterThanIsOperator ? TPResult::True() : TPResult::False();
1160          case ANK_Unresolved:
1161            return HasMissingTypename ? TPResult::Ambiguous()
1162                                      : TPResult::False();
1163          case ANK_Success:
1164            // Annotated it, check again.
1165            assert(Tok.isNot(tok::annot_cxxscope) ||
1166                   NextToken().isNot(tok::identifier));
1167            return isCXXDeclarationSpecifier(BracedCastResult,
1168                                             HasMissingTypename);
1169          }
1170        }
1171      }
1172      return TPResult::False();
1173    }
1174    // If that succeeded, fallthrough into the generic simple-type-id case.
1175
1176    // The ambiguity resides in a simple-type-specifier/typename-specifier
1177    // followed by a '('. The '(' could either be the start of:
1178    //
1179    //   direct-declarator:
1180    //     '(' declarator ')'
1181    //
1182    //   direct-abstract-declarator:
1183    //     '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1184    //              exception-specification[opt]
1185    //     '(' abstract-declarator ')'
1186    //
1187    // or part of a function-style cast expression:
1188    //
1189    //     simple-type-specifier '(' expression-list[opt] ')'
1190    //
1191
1192    // simple-type-specifier:
1193
1194  case tok::annot_typename:
1195  case_typename:
1196    // In Objective-C, we might have a protocol-qualified type.
1197    if (getLangOpts().ObjC1 && NextToken().is(tok::less)) {
1198      // Tentatively parse the
1199      TentativeParsingAction PA(*this);
1200      ConsumeToken(); // The type token
1201
1202      TPResult TPR = TryParseProtocolQualifiers();
1203      bool isFollowedByParen = Tok.is(tok::l_paren);
1204      bool isFollowedByBrace = Tok.is(tok::l_brace);
1205
1206      PA.Revert();
1207
1208      if (TPR == TPResult::Error())
1209        return TPResult::Error();
1210
1211      if (isFollowedByParen)
1212        return TPResult::Ambiguous();
1213
1214      if (getLangOpts().CPlusPlus0x && isFollowedByBrace)
1215        return BracedCastResult;
1216
1217      return TPResult::True();
1218    }
1219
1220  case tok::kw_char:
1221  case tok::kw_wchar_t:
1222  case tok::kw_char16_t:
1223  case tok::kw_char32_t:
1224  case tok::kw_bool:
1225  case tok::kw_short:
1226  case tok::kw_int:
1227  case tok::kw_long:
1228  case tok::kw___int64:
1229  case tok::kw___int128:
1230  case tok::kw_signed:
1231  case tok::kw_unsigned:
1232  case tok::kw_half:
1233  case tok::kw_float:
1234  case tok::kw_double:
1235  case tok::kw_void:
1236  case tok::annot_decltype:
1237    if (NextToken().is(tok::l_paren))
1238      return TPResult::Ambiguous();
1239
1240    // This is a function-style cast in all cases we disambiguate other than
1241    // one:
1242    //   struct S {
1243    //     enum E : int { a = 4 }; // enum
1244    //     enum E : int { 4 };     // bit-field
1245    //   };
1246    if (getLangOpts().CPlusPlus0x && NextToken().is(tok::l_brace))
1247      return BracedCastResult;
1248
1249    if (isStartOfObjCClassMessageMissingOpenBracket())
1250      return TPResult::False();
1251
1252    return TPResult::True();
1253
1254  // GNU typeof support.
1255  case tok::kw_typeof: {
1256    if (NextToken().isNot(tok::l_paren))
1257      return TPResult::True();
1258
1259    TentativeParsingAction PA(*this);
1260
1261    TPResult TPR = TryParseTypeofSpecifier();
1262    bool isFollowedByParen = Tok.is(tok::l_paren);
1263    bool isFollowedByBrace = Tok.is(tok::l_brace);
1264
1265    PA.Revert();
1266
1267    if (TPR == TPResult::Error())
1268      return TPResult::Error();
1269
1270    if (isFollowedByParen)
1271      return TPResult::Ambiguous();
1272
1273    if (getLangOpts().CPlusPlus0x && isFollowedByBrace)
1274      return BracedCastResult;
1275
1276    return TPResult::True();
1277  }
1278
1279  // C++0x type traits support
1280  case tok::kw___underlying_type:
1281    return TPResult::True();
1282
1283  // C11 _Atomic
1284  case tok::kw__Atomic:
1285    return TPResult::True();
1286
1287  default:
1288    return TPResult::False();
1289  }
1290}
1291
1292/// [GNU] typeof-specifier:
1293///         'typeof' '(' expressions ')'
1294///         'typeof' '(' type-name ')'
1295///
1296Parser::TPResult Parser::TryParseTypeofSpecifier() {
1297  assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1298  ConsumeToken();
1299
1300  assert(Tok.is(tok::l_paren) && "Expected '('");
1301  // Parse through the parens after 'typeof'.
1302  ConsumeParen();
1303  if (!SkipUntil(tok::r_paren))
1304    return TPResult::Error();
1305
1306  return TPResult::Ambiguous();
1307}
1308
1309/// [ObjC] protocol-qualifiers:
1310////         '<' identifier-list '>'
1311Parser::TPResult Parser::TryParseProtocolQualifiers() {
1312  assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1313  ConsumeToken();
1314  do {
1315    if (Tok.isNot(tok::identifier))
1316      return TPResult::Error();
1317    ConsumeToken();
1318
1319    if (Tok.is(tok::comma)) {
1320      ConsumeToken();
1321      continue;
1322    }
1323
1324    if (Tok.is(tok::greater)) {
1325      ConsumeToken();
1326      return TPResult::Ambiguous();
1327    }
1328  } while (false);
1329
1330  return TPResult::Error();
1331}
1332
1333Parser::TPResult
1334Parser::TryParseDeclarationSpecifier(bool *HasMissingTypename) {
1335  TPResult TPR = isCXXDeclarationSpecifier(TPResult::False(),
1336                                           HasMissingTypename);
1337  if (TPR != TPResult::Ambiguous())
1338    return TPR;
1339
1340  if (Tok.is(tok::kw_typeof))
1341    TryParseTypeofSpecifier();
1342  else {
1343    if (Tok.is(tok::annot_cxxscope))
1344      ConsumeToken();
1345    ConsumeToken();
1346
1347    if (getLangOpts().ObjC1 && Tok.is(tok::less))
1348      TryParseProtocolQualifiers();
1349  }
1350
1351  return TPResult::Ambiguous();
1352}
1353
1354/// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1355/// a constructor-style initializer, when parsing declaration statements.
1356/// Returns true for function declarator and false for constructor-style
1357/// initializer.
1358/// If during the disambiguation process a parsing error is encountered,
1359/// the function returns true to let the declaration parsing code handle it.
1360///
1361/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1362///         exception-specification[opt]
1363///
1364bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1365
1366  // C++ 8.2p1:
1367  // The ambiguity arising from the similarity between a function-style cast and
1368  // a declaration mentioned in 6.8 can also occur in the context of a
1369  // declaration. In that context, the choice is between a function declaration
1370  // with a redundant set of parentheses around a parameter name and an object
1371  // declaration with a function-style cast as the initializer. Just as for the
1372  // ambiguities mentioned in 6.8, the resolution is to consider any construct
1373  // that could possibly be a declaration a declaration.
1374
1375  TentativeParsingAction PA(*this);
1376
1377  ConsumeParen();
1378  bool InvalidAsDeclaration = false;
1379  TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1380  if (TPR == TPResult::Ambiguous()) {
1381    if (Tok.isNot(tok::r_paren))
1382      TPR = TPResult::False();
1383    else {
1384      const Token &Next = NextToken();
1385      if (Next.is(tok::amp) || Next.is(tok::ampamp) ||
1386          Next.is(tok::kw_const) || Next.is(tok::kw_volatile) ||
1387          Next.is(tok::kw_throw) || Next.is(tok::kw_noexcept) ||
1388          Next.is(tok::l_square) || isCXX0XVirtSpecifier(Next) ||
1389          Next.is(tok::l_brace) || Next.is(tok::kw_try) ||
1390          Next.is(tok::equal) || Next.is(tok::arrow))
1391        // The next token cannot appear after a constructor-style initializer,
1392        // and can appear next in a function definition. This must be a function
1393        // declarator.
1394        TPR = TPResult::True();
1395      else if (InvalidAsDeclaration)
1396        // Use the absence of 'typename' as a tie-breaker.
1397        TPR = TPResult::False();
1398    }
1399  }
1400
1401  PA.Revert();
1402
1403  if (IsAmbiguous && TPR == TPResult::Ambiguous())
1404    *IsAmbiguous = true;
1405
1406  // In case of an error, let the declaration parsing code handle it.
1407  return TPR != TPResult::False();
1408}
1409
1410/// parameter-declaration-clause:
1411///   parameter-declaration-list[opt] '...'[opt]
1412///   parameter-declaration-list ',' '...'
1413///
1414/// parameter-declaration-list:
1415///   parameter-declaration
1416///   parameter-declaration-list ',' parameter-declaration
1417///
1418/// parameter-declaration:
1419///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1420///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1421///     '=' assignment-expression
1422///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1423///     attributes[opt]
1424///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1425///     attributes[opt] '=' assignment-expression
1426///
1427Parser::TPResult
1428Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration) {
1429
1430  if (Tok.is(tok::r_paren))
1431    return TPResult::Ambiguous();
1432
1433  //   parameter-declaration-list[opt] '...'[opt]
1434  //   parameter-declaration-list ',' '...'
1435  //
1436  // parameter-declaration-list:
1437  //   parameter-declaration
1438  //   parameter-declaration-list ',' parameter-declaration
1439  //
1440  while (1) {
1441    // '...'[opt]
1442    if (Tok.is(tok::ellipsis)) {
1443      ConsumeToken();
1444      if (Tok.is(tok::r_paren))
1445        return TPResult::True(); // '...)' is a sign of a function declarator.
1446      else
1447        return TPResult::False();
1448    }
1449
1450    // An attribute-specifier-seq here is a sign of a function declarator.
1451    if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1452                                  /*OuterMightBeMessageSend*/true))
1453      return TPResult::True();
1454
1455    ParsedAttributes attrs(AttrFactory);
1456    MaybeParseMicrosoftAttributes(attrs);
1457
1458    // decl-specifier-seq
1459    // A parameter-declaration's initializer must be preceded by an '=', so
1460    // decl-specifier-seq '{' is not a parameter in C++11.
1461    TPResult TPR = TryParseDeclarationSpecifier(InvalidAsDeclaration);
1462    if (TPR != TPResult::Ambiguous())
1463      return TPR;
1464
1465    // declarator
1466    // abstract-declarator[opt]
1467    TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1468    if (TPR != TPResult::Ambiguous())
1469      return TPR;
1470
1471    // [GNU] attributes[opt]
1472    if (Tok.is(tok::kw___attribute))
1473      return TPResult::True();
1474
1475    if (Tok.is(tok::equal)) {
1476      // '=' assignment-expression
1477      // Parse through assignment-expression.
1478      if (!SkipUntil(tok::comma, tok::r_paren, true/*StopAtSemi*/,
1479                     true/*DontConsume*/))
1480        return TPResult::Error();
1481    }
1482
1483    if (Tok.is(tok::ellipsis)) {
1484      ConsumeToken();
1485      if (Tok.is(tok::r_paren))
1486        return TPResult::True(); // '...)' is a sign of a function declarator.
1487      else
1488        return TPResult::False();
1489    }
1490
1491    if (Tok.isNot(tok::comma))
1492      break;
1493    ConsumeToken(); // the comma.
1494  }
1495
1496  return TPResult::Ambiguous();
1497}
1498
1499/// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1500/// parsing as a function declarator.
1501/// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1502/// return TPResult::Ambiguous(), otherwise it will return either False() or
1503/// Error().
1504///
1505/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1506///         exception-specification[opt]
1507///
1508/// exception-specification:
1509///   'throw' '(' type-id-list[opt] ')'
1510///
1511Parser::TPResult Parser::TryParseFunctionDeclarator() {
1512
1513  // The '(' is already parsed.
1514
1515  TPResult TPR = TryParseParameterDeclarationClause();
1516  if (TPR == TPResult::Ambiguous() && Tok.isNot(tok::r_paren))
1517    TPR = TPResult::False();
1518
1519  if (TPR == TPResult::False() || TPR == TPResult::Error())
1520    return TPR;
1521
1522  // Parse through the parens.
1523  if (!SkipUntil(tok::r_paren))
1524    return TPResult::Error();
1525
1526  // cv-qualifier-seq
1527  while (Tok.is(tok::kw_const)    ||
1528         Tok.is(tok::kw_volatile) ||
1529         Tok.is(tok::kw_restrict)   )
1530    ConsumeToken();
1531
1532  // ref-qualifier[opt]
1533  if (Tok.is(tok::amp) || Tok.is(tok::ampamp))
1534    ConsumeToken();
1535
1536  // exception-specification
1537  if (Tok.is(tok::kw_throw)) {
1538    ConsumeToken();
1539    if (Tok.isNot(tok::l_paren))
1540      return TPResult::Error();
1541
1542    // Parse through the parens after 'throw'.
1543    ConsumeParen();
1544    if (!SkipUntil(tok::r_paren))
1545      return TPResult::Error();
1546  }
1547  if (Tok.is(tok::kw_noexcept)) {
1548    ConsumeToken();
1549    // Possibly an expression as well.
1550    if (Tok.is(tok::l_paren)) {
1551      // Find the matching rparen.
1552      ConsumeParen();
1553      if (!SkipUntil(tok::r_paren))
1554        return TPResult::Error();
1555    }
1556  }
1557
1558  return TPResult::Ambiguous();
1559}
1560
1561/// '[' constant-expression[opt] ']'
1562///
1563Parser::TPResult Parser::TryParseBracketDeclarator() {
1564  ConsumeBracket();
1565  if (!SkipUntil(tok::r_square))
1566    return TPResult::Error();
1567
1568  return TPResult::Ambiguous();
1569}
1570