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