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