clang  3.7.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  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, tok::kw___unaligned))
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_enum:
950  case tok::kw_half:
951  case tok::kw_float:
952  case tok::kw_int:
953  case tok::kw_long:
954  case tok::kw___int64:
955  case tok::kw___int128:
956  case tok::kw_restrict:
957  case tok::kw_short:
958  case tok::kw_signed:
959  case tok::kw_struct:
960  case tok::kw_union:
961  case tok::kw_unsigned:
962  case tok::kw_void:
963  case tok::kw_volatile:
964  case tok::kw__Bool:
965  case tok::kw__Complex:
966  case tok::kw_class:
967  case tok::kw_typename:
968  case tok::kw_wchar_t:
969  case tok::kw_char16_t:
970  case tok::kw_char32_t:
971  case tok::kw__Decimal32:
972  case tok::kw__Decimal64:
973  case tok::kw__Decimal128:
974  case tok::kw___interface:
975  case tok::kw___thread:
976  case tok::kw_thread_local:
977  case tok::kw__Thread_local:
978  case tok::kw_typeof:
979  case tok::kw___underlying_type:
980  case tok::kw___cdecl:
981  case tok::kw___stdcall:
982  case tok::kw___fastcall:
983  case tok::kw___thiscall:
984  case tok::kw___vectorcall:
985  case tok::kw___unaligned:
986  case tok::kw___vector:
987  case tok::kw___pixel:
988  case tok::kw___bool:
989  case tok::kw__Atomic:
990  case tok::kw___unknown_anytype:
991  return TPResult::False;
992 
993  default:
994  break;
995  }
996 
997  return TPResult::Ambiguous;
998 }
999 
1000 bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
1001  return std::find(TentativelyDeclaredIdentifiers.begin(),
1002  TentativelyDeclaredIdentifiers.end(), II)
1003  != TentativelyDeclaredIdentifiers.end();
1004 }
1005 
1006 namespace {
1007 class TentativeParseCCC : public CorrectionCandidateCallback {
1008 public:
1009  TentativeParseCCC(const Token &Next) {
1010  WantRemainingKeywords = false;
1011  WantTypeSpecifiers = Next.isOneOf(tok::l_paren, tok::r_paren, tok::greater,
1012  tok::l_brace, tok::identifier);
1013  }
1014 
1015  bool ValidateCandidate(const TypoCorrection &Candidate) override {
1016  // Reject any candidate that only resolves to instance members since they
1017  // aren't viable as standalone identifiers instead of member references.
1018  if (Candidate.isResolved() && !Candidate.isKeyword() &&
1019  std::all_of(Candidate.begin(), Candidate.end(),
1020  [](NamedDecl *ND) { return ND->isCXXInstanceMember(); }))
1021  return false;
1022 
1024  }
1025 };
1026 }
1027 /// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
1028 /// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
1029 /// be either a decl-specifier or a function-style cast, and TPResult::Error
1030 /// if a parsing error was found and reported.
1031 ///
1032 /// If HasMissingTypename is provided, a name with a dependent scope specifier
1033 /// will be treated as ambiguous if the 'typename' keyword is missing. If this
1034 /// happens, *HasMissingTypename will be set to 'true'. This will also be used
1035 /// as an indicator that undeclared identifiers (which will trigger a later
1036 /// parse error) should be treated as types. Returns TPResult::Ambiguous in
1037 /// such cases.
1038 ///
1039 /// decl-specifier:
1040 /// storage-class-specifier
1041 /// type-specifier
1042 /// function-specifier
1043 /// 'friend'
1044 /// 'typedef'
1045 /// [C++11] 'constexpr'
1046 /// [GNU] attributes declaration-specifiers[opt]
1047 ///
1048 /// storage-class-specifier:
1049 /// 'register'
1050 /// 'static'
1051 /// 'extern'
1052 /// 'mutable'
1053 /// 'auto'
1054 /// [GNU] '__thread'
1055 /// [C++11] 'thread_local'
1056 /// [C11] '_Thread_local'
1057 ///
1058 /// function-specifier:
1059 /// 'inline'
1060 /// 'virtual'
1061 /// 'explicit'
1062 ///
1063 /// typedef-name:
1064 /// identifier
1065 ///
1066 /// type-specifier:
1067 /// simple-type-specifier
1068 /// class-specifier
1069 /// enum-specifier
1070 /// elaborated-type-specifier
1071 /// typename-specifier
1072 /// cv-qualifier
1073 ///
1074 /// simple-type-specifier:
1075 /// '::'[opt] nested-name-specifier[opt] type-name
1076 /// '::'[opt] nested-name-specifier 'template'
1077 /// simple-template-id [TODO]
1078 /// 'char'
1079 /// 'wchar_t'
1080 /// 'bool'
1081 /// 'short'
1082 /// 'int'
1083 /// 'long'
1084 /// 'signed'
1085 /// 'unsigned'
1086 /// 'float'
1087 /// 'double'
1088 /// 'void'
1089 /// [GNU] typeof-specifier
1090 /// [GNU] '_Complex'
1091 /// [C++11] 'auto'
1092 /// [C++11] 'decltype' ( expression )
1093 /// [C++1y] 'decltype' ( 'auto' )
1094 ///
1095 /// type-name:
1096 /// class-name
1097 /// enum-name
1098 /// typedef-name
1099 ///
1100 /// elaborated-type-specifier:
1101 /// class-key '::'[opt] nested-name-specifier[opt] identifier
1102 /// class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
1103 /// simple-template-id
1104 /// 'enum' '::'[opt] nested-name-specifier[opt] identifier
1105 ///
1106 /// enum-name:
1107 /// identifier
1108 ///
1109 /// enum-specifier:
1110 /// 'enum' identifier[opt] '{' enumerator-list[opt] '}'
1111 /// 'enum' identifier[opt] '{' enumerator-list ',' '}'
1112 ///
1113 /// class-specifier:
1114 /// class-head '{' member-specification[opt] '}'
1115 ///
1116 /// class-head:
1117 /// class-key identifier[opt] base-clause[opt]
1118 /// class-key nested-name-specifier identifier base-clause[opt]
1119 /// class-key nested-name-specifier[opt] simple-template-id
1120 /// base-clause[opt]
1121 ///
1122 /// class-key:
1123 /// 'class'
1124 /// 'struct'
1125 /// 'union'
1126 ///
1127 /// cv-qualifier:
1128 /// 'const'
1129 /// 'volatile'
1130 /// [GNU] restrict
1131 ///
1132 Parser::TPResult
1133 Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
1134  bool *HasMissingTypename) {
1135  switch (Tok.getKind()) {
1136  case tok::identifier: {
1137  // Check for need to substitute AltiVec __vector keyword
1138  // for "vector" identifier.
1139  if (TryAltiVecVectorToken())
1140  return TPResult::True;
1141 
1142  const Token &Next = NextToken();
1143  // In 'foo bar', 'foo' is always a type name outside of Objective-C.
1144  if (!getLangOpts().ObjC1 && Next.is(tok::identifier))
1145  return TPResult::True;
1146 
1147  if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
1148  // Determine whether this is a valid expression. If not, we will hit
1149  // a parse error one way or another. In that case, tell the caller that
1150  // this is ambiguous. Typo-correct to type and expression keywords and
1151  // to types and identifiers, in order to try to recover from errors.
1152  switch (TryAnnotateName(false /* no nested name specifier */,
1153  llvm::make_unique<TentativeParseCCC>(Next))) {
1154  case ANK_Error:
1155  return TPResult::Error;
1156  case ANK_TentativeDecl:
1157  return TPResult::False;
1158  case ANK_TemplateName:
1159  // A bare type template-name which can't be a template template
1160  // argument is an error, and was probably intended to be a type.
1161  return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1162  case ANK_Unresolved:
1163  return HasMissingTypename ? TPResult::Ambiguous : TPResult::False;
1164  case ANK_Success:
1165  break;
1166  }
1167  assert(Tok.isNot(tok::identifier) &&
1168  "TryAnnotateName succeeded without producing an annotation");
1169  } else {
1170  // This might possibly be a type with a dependent scope specifier and
1171  // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1172  // since it will annotate as a primary expression, and we want to use the
1173  // "missing 'typename'" logic.
1175  return TPResult::Error;
1176  // If annotation failed, assume it's a non-type.
1177  // FIXME: If this happens due to an undeclared identifier, treat it as
1178  // ambiguous.
1179  if (Tok.is(tok::identifier))
1180  return TPResult::False;
1181  }
1182 
1183  // We annotated this token as something. Recurse to handle whatever we got.
1184  return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1185  }
1186 
1187  case tok::kw_typename: // typename T::type
1188  // Annotate typenames and C++ scope specifiers. If we get one, just
1189  // recurse to handle whatever we get.
1191  return TPResult::Error;
1192  return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1193 
1194  case tok::coloncolon: { // ::foo::bar
1195  const Token &Next = NextToken();
1196  if (Next.isOneOf(tok::kw_new, // ::new
1197  tok::kw_delete)) // ::delete
1198  return TPResult::False;
1199  }
1200  // Fall through.
1201  case tok::kw___super:
1202  case tok::kw_decltype:
1203  // Annotate typenames and C++ scope specifiers. If we get one, just
1204  // recurse to handle whatever we get.
1206  return TPResult::Error;
1207  return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1208 
1209  // decl-specifier:
1210  // storage-class-specifier
1211  // type-specifier
1212  // function-specifier
1213  // 'friend'
1214  // 'typedef'
1215  // 'constexpr'
1216  // 'concept'
1217  case tok::kw_friend:
1218  case tok::kw_typedef:
1219  case tok::kw_constexpr:
1220  case tok::kw_concept:
1221  // storage-class-specifier
1222  case tok::kw_register:
1223  case tok::kw_static:
1224  case tok::kw_extern:
1225  case tok::kw_mutable:
1226  case tok::kw_auto:
1227  case tok::kw___thread:
1228  case tok::kw_thread_local:
1229  case tok::kw__Thread_local:
1230  // function-specifier
1231  case tok::kw_inline:
1232  case tok::kw_virtual:
1233  case tok::kw_explicit:
1234 
1235  // Modules
1236  case tok::kw___module_private__:
1237 
1238  // Debugger support
1239  case tok::kw___unknown_anytype:
1240 
1241  // type-specifier:
1242  // simple-type-specifier
1243  // class-specifier
1244  // enum-specifier
1245  // elaborated-type-specifier
1246  // typename-specifier
1247  // cv-qualifier
1248 
1249  // class-specifier
1250  // elaborated-type-specifier
1251  case tok::kw_class:
1252  case tok::kw_struct:
1253  case tok::kw_union:
1254  case tok::kw___interface:
1255  // enum-specifier
1256  case tok::kw_enum:
1257  // cv-qualifier
1258  case tok::kw_const:
1259  case tok::kw_volatile:
1260 
1261  // GNU
1262  case tok::kw_restrict:
1263  case tok::kw__Complex:
1264  case tok::kw___attribute:
1265  return TPResult::True;
1266 
1267  // Microsoft
1268  case tok::kw___declspec:
1269  case tok::kw___cdecl:
1270  case tok::kw___stdcall:
1271  case tok::kw___fastcall:
1272  case tok::kw___thiscall:
1273  case tok::kw___vectorcall:
1274  case tok::kw___w64:
1275  case tok::kw___sptr:
1276  case tok::kw___uptr:
1277  case tok::kw___ptr64:
1278  case tok::kw___ptr32:
1279  case tok::kw___forceinline:
1280  case tok::kw___unaligned:
1281  case tok::kw__Nonnull:
1282  case tok::kw__Nullable:
1283  case tok::kw__Null_unspecified:
1284  case tok::kw___kindof:
1285  return TPResult::True;
1286 
1287  // Borland
1288  case tok::kw___pascal:
1289  return TPResult::True;
1290 
1291  // AltiVec
1292  case tok::kw___vector:
1293  return TPResult::True;
1294 
1295  case tok::annot_template_id: {
1296  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1297  if (TemplateId->Kind != TNK_Type_template)
1298  return TPResult::False;
1299  CXXScopeSpec SS;
1300  AnnotateTemplateIdTokenAsType();
1301  assert(Tok.is(tok::annot_typename));
1302  goto case_typename;
1303  }
1304 
1305  case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1306  // We've already annotated a scope; try to annotate a type.
1308  return TPResult::Error;
1309  if (!Tok.is(tok::annot_typename)) {
1310  // If the next token is an identifier or a type qualifier, then this
1311  // can't possibly be a valid expression either.
1312  if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1313  CXXScopeSpec SS;
1315  Tok.getAnnotationRange(),
1316  SS);
1317  if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1318  TentativeParsingAction PA(*this);
1319  ConsumeToken();
1320  ConsumeToken();
1321  bool isIdentifier = Tok.is(tok::identifier);
1322  TPResult TPR = TPResult::False;
1323  if (!isIdentifier)
1324  TPR = isCXXDeclarationSpecifier(BracedCastResult,
1325  HasMissingTypename);
1326  PA.Revert();
1327 
1328  if (isIdentifier ||
1329  TPR == TPResult::True || TPR == TPResult::Error)
1330  return TPResult::Error;
1331 
1332  if (HasMissingTypename) {
1333  // We can't tell whether this is a missing 'typename' or a valid
1334  // expression.
1335  *HasMissingTypename = true;
1336  return TPResult::Ambiguous;
1337  }
1338  } else {
1339  // Try to resolve the name. If it doesn't exist, assume it was
1340  // intended to name a type and keep disambiguating.
1341  switch (TryAnnotateName(false /* SS is not dependent */)) {
1342  case ANK_Error:
1343  return TPResult::Error;
1344  case ANK_TentativeDecl:
1345  return TPResult::False;
1346  case ANK_TemplateName:
1347  // A bare type template-name which can't be a template template
1348  // argument is an error, and was probably intended to be a type.
1349  return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1350  case ANK_Unresolved:
1351  return HasMissingTypename ? TPResult::Ambiguous
1352  : TPResult::False;
1353  case ANK_Success:
1354  // Annotated it, check again.
1355  assert(Tok.isNot(tok::annot_cxxscope) ||
1356  NextToken().isNot(tok::identifier));
1357  return isCXXDeclarationSpecifier(BracedCastResult,
1358  HasMissingTypename);
1359  }
1360  }
1361  }
1362  return TPResult::False;
1363  }
1364  // If that succeeded, fallthrough into the generic simple-type-id case.
1365 
1366  // The ambiguity resides in a simple-type-specifier/typename-specifier
1367  // followed by a '('. The '(' could either be the start of:
1368  //
1369  // direct-declarator:
1370  // '(' declarator ')'
1371  //
1372  // direct-abstract-declarator:
1373  // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1374  // exception-specification[opt]
1375  // '(' abstract-declarator ')'
1376  //
1377  // or part of a function-style cast expression:
1378  //
1379  // simple-type-specifier '(' expression-list[opt] ')'
1380  //
1381 
1382  // simple-type-specifier:
1383 
1384  case tok::annot_typename:
1385  case_typename:
1386  // In Objective-C, we might have a protocol-qualified type.
1387  if (getLangOpts().ObjC1 && NextToken().is(tok::less)) {
1388  // Tentatively parse the protocol qualifiers.
1389  TentativeParsingAction PA(*this);
1390  ConsumeToken(); // The type token
1391 
1392  TPResult TPR = TryParseProtocolQualifiers();
1393  bool isFollowedByParen = Tok.is(tok::l_paren);
1394  bool isFollowedByBrace = Tok.is(tok::l_brace);
1395 
1396  PA.Revert();
1397 
1398  if (TPR == TPResult::Error)
1399  return TPResult::Error;
1400 
1401  if (isFollowedByParen)
1402  return TPResult::Ambiguous;
1403 
1404  if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1405  return BracedCastResult;
1406 
1407  return TPResult::True;
1408  }
1409 
1410  case tok::kw_char:
1411  case tok::kw_wchar_t:
1412  case tok::kw_char16_t:
1413  case tok::kw_char32_t:
1414  case tok::kw_bool:
1415  case tok::kw_short:
1416  case tok::kw_int:
1417  case tok::kw_long:
1418  case tok::kw___int64:
1419  case tok::kw___int128:
1420  case tok::kw_signed:
1421  case tok::kw_unsigned:
1422  case tok::kw_half:
1423  case tok::kw_float:
1424  case tok::kw_double:
1425  case tok::kw_void:
1426  case tok::annot_decltype:
1427  if (NextToken().is(tok::l_paren))
1428  return TPResult::Ambiguous;
1429 
1430  // This is a function-style cast in all cases we disambiguate other than
1431  // one:
1432  // struct S {
1433  // enum E : int { a = 4 }; // enum
1434  // enum E : int { 4 }; // bit-field
1435  // };
1436  if (getLangOpts().CPlusPlus11 && NextToken().is(tok::l_brace))
1437  return BracedCastResult;
1438 
1439  if (isStartOfObjCClassMessageMissingOpenBracket())
1440  return TPResult::False;
1441 
1442  return TPResult::True;
1443 
1444  // GNU typeof support.
1445  case tok::kw_typeof: {
1446  if (NextToken().isNot(tok::l_paren))
1447  return TPResult::True;
1448 
1449  TentativeParsingAction PA(*this);
1450 
1451  TPResult TPR = TryParseTypeofSpecifier();
1452  bool isFollowedByParen = Tok.is(tok::l_paren);
1453  bool isFollowedByBrace = Tok.is(tok::l_brace);
1454 
1455  PA.Revert();
1456 
1457  if (TPR == TPResult::Error)
1458  return TPResult::Error;
1459 
1460  if (isFollowedByParen)
1461  return TPResult::Ambiguous;
1462 
1463  if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1464  return BracedCastResult;
1465 
1466  return TPResult::True;
1467  }
1468 
1469  // C++0x type traits support
1470  case tok::kw___underlying_type:
1471  return TPResult::True;
1472 
1473  // C11 _Atomic
1474  case tok::kw__Atomic:
1475  return TPResult::True;
1476 
1477  default:
1478  return TPResult::False;
1479  }
1480 }
1481 
1482 bool Parser::isCXXDeclarationSpecifierAType() {
1483  switch (Tok.getKind()) {
1484  // typename-specifier
1485  case tok::annot_decltype:
1486  case tok::annot_template_id:
1487  case tok::annot_typename:
1488  case tok::kw_typeof:
1489  case tok::kw___underlying_type:
1490  return true;
1491 
1492  // elaborated-type-specifier
1493  case tok::kw_class:
1494  case tok::kw_struct:
1495  case tok::kw_union:
1496  case tok::kw___interface:
1497  case tok::kw_enum:
1498  return true;
1499 
1500  // simple-type-specifier
1501  case tok::kw_char:
1502  case tok::kw_wchar_t:
1503  case tok::kw_char16_t:
1504  case tok::kw_char32_t:
1505  case tok::kw_bool:
1506  case tok::kw_short:
1507  case tok::kw_int:
1508  case tok::kw_long:
1509  case tok::kw___int64:
1510  case tok::kw___int128:
1511  case tok::kw_signed:
1512  case tok::kw_unsigned:
1513  case tok::kw_half:
1514  case tok::kw_float:
1515  case tok::kw_double:
1516  case tok::kw_void:
1517  case tok::kw___unknown_anytype:
1518  return true;
1519 
1520  case tok::kw_auto:
1521  return getLangOpts().CPlusPlus11;
1522 
1523  case tok::kw__Atomic:
1524  // "_Atomic foo"
1525  return NextToken().is(tok::l_paren);
1526 
1527  default:
1528  return false;
1529  }
1530 }
1531 
1532 /// [GNU] typeof-specifier:
1533 /// 'typeof' '(' expressions ')'
1534 /// 'typeof' '(' type-name ')'
1535 ///
1536 Parser::TPResult Parser::TryParseTypeofSpecifier() {
1537  assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1538  ConsumeToken();
1539 
1540  assert(Tok.is(tok::l_paren) && "Expected '('");
1541  // Parse through the parens after 'typeof'.
1542  ConsumeParen();
1543  if (!SkipUntil(tok::r_paren, StopAtSemi))
1544  return TPResult::Error;
1545 
1546  return TPResult::Ambiguous;
1547 }
1548 
1549 /// [ObjC] protocol-qualifiers:
1550 //// '<' identifier-list '>'
1551 Parser::TPResult Parser::TryParseProtocolQualifiers() {
1552  assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1553  ConsumeToken();
1554  do {
1555  if (Tok.isNot(tok::identifier))
1556  return TPResult::Error;
1557  ConsumeToken();
1558 
1559  if (Tok.is(tok::comma)) {
1560  ConsumeToken();
1561  continue;
1562  }
1563 
1564  if (Tok.is(tok::greater)) {
1565  ConsumeToken();
1566  return TPResult::Ambiguous;
1567  }
1568  } while (false);
1569 
1570  return TPResult::Error;
1571 }
1572 
1573 /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1574 /// a constructor-style initializer, when parsing declaration statements.
1575 /// Returns true for function declarator and false for constructor-style
1576 /// initializer.
1577 /// If during the disambiguation process a parsing error is encountered,
1578 /// the function returns true to let the declaration parsing code handle it.
1579 ///
1580 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1581 /// exception-specification[opt]
1582 ///
1583 bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1584 
1585  // C++ 8.2p1:
1586  // The ambiguity arising from the similarity between a function-style cast and
1587  // a declaration mentioned in 6.8 can also occur in the context of a
1588  // declaration. In that context, the choice is between a function declaration
1589  // with a redundant set of parentheses around a parameter name and an object
1590  // declaration with a function-style cast as the initializer. Just as for the
1591  // ambiguities mentioned in 6.8, the resolution is to consider any construct
1592  // that could possibly be a declaration a declaration.
1593 
1594  TentativeParsingAction PA(*this);
1595 
1596  ConsumeParen();
1597  bool InvalidAsDeclaration = false;
1598  TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1599  if (TPR == TPResult::Ambiguous) {
1600  if (Tok.isNot(tok::r_paren))
1601  TPR = TPResult::False;
1602  else {
1603  const Token &Next = NextToken();
1604  if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
1605  tok::kw_throw, tok::kw_noexcept, tok::l_square,
1606  tok::l_brace, tok::kw_try, tok::equal, tok::arrow) ||
1607  isCXX11VirtSpecifier(Next))
1608  // The next token cannot appear after a constructor-style initializer,
1609  // and can appear next in a function definition. This must be a function
1610  // declarator.
1611  TPR = TPResult::True;
1612  else if (InvalidAsDeclaration)
1613  // Use the absence of 'typename' as a tie-breaker.
1614  TPR = TPResult::False;
1615  }
1616  }
1617 
1618  PA.Revert();
1619 
1620  if (IsAmbiguous && TPR == TPResult::Ambiguous)
1621  *IsAmbiguous = true;
1622 
1623  // In case of an error, let the declaration parsing code handle it.
1624  return TPR != TPResult::False;
1625 }
1626 
1627 /// parameter-declaration-clause:
1628 /// parameter-declaration-list[opt] '...'[opt]
1629 /// parameter-declaration-list ',' '...'
1630 ///
1631 /// parameter-declaration-list:
1632 /// parameter-declaration
1633 /// parameter-declaration-list ',' parameter-declaration
1634 ///
1635 /// parameter-declaration:
1636 /// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1637 /// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1638 /// '=' assignment-expression
1639 /// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1640 /// attributes[opt]
1641 /// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1642 /// attributes[opt] '=' assignment-expression
1643 ///
1644 Parser::TPResult
1645 Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
1646  bool VersusTemplateArgument) {
1647 
1648  if (Tok.is(tok::r_paren))
1649  return TPResult::Ambiguous;
1650 
1651  // parameter-declaration-list[opt] '...'[opt]
1652  // parameter-declaration-list ',' '...'
1653  //
1654  // parameter-declaration-list:
1655  // parameter-declaration
1656  // parameter-declaration-list ',' parameter-declaration
1657  //
1658  while (1) {
1659  // '...'[opt]
1660  if (Tok.is(tok::ellipsis)) {
1661  ConsumeToken();
1662  if (Tok.is(tok::r_paren))
1663  return TPResult::True; // '...)' is a sign of a function declarator.
1664  else
1665  return TPResult::False;
1666  }
1667 
1668  // An attribute-specifier-seq here is a sign of a function declarator.
1669  if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1670  /*OuterMightBeMessageSend*/true))
1671  return TPResult::True;
1672 
1673  ParsedAttributes attrs(AttrFactory);
1674  MaybeParseMicrosoftAttributes(attrs);
1675 
1676  // decl-specifier-seq
1677  // A parameter-declaration's initializer must be preceded by an '=', so
1678  // decl-specifier-seq '{' is not a parameter in C++11.
1679  TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
1680  InvalidAsDeclaration);
1681 
1682  if (VersusTemplateArgument && TPR == TPResult::True) {
1683  // Consume the decl-specifier-seq. We have to look past it, since a
1684  // type-id might appear here in a template argument.
1685  bool SeenType = false;
1686  do {
1687  SeenType |= isCXXDeclarationSpecifierAType();
1688  if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1689  return TPResult::Error;
1690 
1691  // If we see a parameter name, this can't be a template argument.
1692  if (SeenType && Tok.is(tok::identifier))
1693  return TPResult::True;
1694 
1695  TPR = isCXXDeclarationSpecifier(TPResult::False,
1696  InvalidAsDeclaration);
1697  if (TPR == TPResult::Error)
1698  return TPR;
1699  } while (TPR != TPResult::False);
1700  } else if (TPR == TPResult::Ambiguous) {
1701  // Disambiguate what follows the decl-specifier.
1702  if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1703  return TPResult::Error;
1704  } else
1705  return TPR;
1706 
1707  // declarator
1708  // abstract-declarator[opt]
1709  TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1710  if (TPR != TPResult::Ambiguous)
1711  return TPR;
1712 
1713  // [GNU] attributes[opt]
1714  if (Tok.is(tok::kw___attribute))
1715  return TPResult::True;
1716 
1717  // If we're disambiguating a template argument in a default argument in
1718  // a class definition versus a parameter declaration, an '=' here
1719  // disambiguates the parse one way or the other.
1720  // If this is a parameter, it must have a default argument because
1721  // (a) the previous parameter did, and
1722  // (b) this must be the first declaration of the function, so we can't
1723  // inherit any default arguments from elsewhere.
1724  // If we see an ')', then we've reached the end of a
1725  // parameter-declaration-clause, and the last param is missing its default
1726  // argument.
1727  if (VersusTemplateArgument)
1728  return Tok.isOneOf(tok::equal, tok::r_paren) ? TPResult::True
1729  : TPResult::False;
1730 
1731  if (Tok.is(tok::equal)) {
1732  // '=' assignment-expression
1733  // Parse through assignment-expression.
1734  // FIXME: assignment-expression may contain an unparenthesized comma.
1735  if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
1736  return TPResult::Error;
1737  }
1738 
1739  if (Tok.is(tok::ellipsis)) {
1740  ConsumeToken();
1741  if (Tok.is(tok::r_paren))
1742  return TPResult::True; // '...)' is a sign of a function declarator.
1743  else
1744  return TPResult::False;
1745  }
1746 
1747  if (!TryConsumeToken(tok::comma))
1748  break;
1749  }
1750 
1751  return TPResult::Ambiguous;
1752 }
1753 
1754 /// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1755 /// parsing as a function declarator.
1756 /// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1757 /// return TPResult::Ambiguous, otherwise it will return either False() or
1758 /// Error().
1759 ///
1760 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1761 /// exception-specification[opt]
1762 ///
1763 /// exception-specification:
1764 /// 'throw' '(' type-id-list[opt] ')'
1765 ///
1766 Parser::TPResult Parser::TryParseFunctionDeclarator() {
1767 
1768  // The '(' is already parsed.
1769 
1770  TPResult TPR = TryParseParameterDeclarationClause();
1771  if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
1772  TPR = TPResult::False;
1773 
1774  if (TPR == TPResult::False || TPR == TPResult::Error)
1775  return TPR;
1776 
1777  // Parse through the parens.
1778  if (!SkipUntil(tok::r_paren, StopAtSemi))
1779  return TPResult::Error;
1780 
1781  // cv-qualifier-seq
1782  while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict))
1783  ConsumeToken();
1784 
1785  // ref-qualifier[opt]
1786  if (Tok.isOneOf(tok::amp, tok::ampamp))
1787  ConsumeToken();
1788 
1789  // exception-specification
1790  if (Tok.is(tok::kw_throw)) {
1791  ConsumeToken();
1792  if (Tok.isNot(tok::l_paren))
1793  return TPResult::Error;
1794 
1795  // Parse through the parens after 'throw'.
1796  ConsumeParen();
1797  if (!SkipUntil(tok::r_paren, StopAtSemi))
1798  return TPResult::Error;
1799  }
1800  if (Tok.is(tok::kw_noexcept)) {
1801  ConsumeToken();
1802  // Possibly an expression as well.
1803  if (Tok.is(tok::l_paren)) {
1804  // Find the matching rparen.
1805  ConsumeParen();
1806  if (!SkipUntil(tok::r_paren, StopAtSemi))
1807  return TPResult::Error;
1808  }
1809  }
1810 
1811  return TPResult::Ambiguous;
1812 }
1813 
1814 /// '[' constant-expression[opt] ']'
1815 ///
1816 Parser::TPResult Parser::TryParseBracketDeclarator() {
1817  ConsumeBracket();
1818  if (!SkipUntil(tok::r_square, StopAtSemi))
1819  return TPResult::Error;
1820 
1821  return TPResult::Ambiguous;
1822 }
Simple class containing the result of Sema::CorrectTypo.
const LangOptions & getLangOpts() const
Definition: Parse/Parser.h:243
bool TryAnnotateCXXScopeToken(bool EnteringContext=false)
decl_iterator begin()
TemplateNameKind Kind
The kind of template that Template refers to.
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
Definition: Parse/Parser.h:861
Information about a template-id annotation token.
const Token & NextToken()
Definition: Parse/Parser.h:546
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parse/Parser.h:292
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
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:68
tok::TokenKind getKind() const
Definition: Token.h:90
void * getAnnotationValue() const
Definition: Token.h:224
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:158
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:96
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:81
Kind
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
bool is(tok::TokenKind K) const
Definition: Token.h:95
bool isResolved() const
bool isKeyword() const
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:97
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()
Definition: Parse/Parser.h:284
bool TryAnnotateTypeOrScopeToken(bool EnteringContext=false, bool NeedType=false)
decl_iterator end()
Represents a complete lambda introducer.
Definition: DeclSpec.h:2255
Stop skipping at specified token, but don't skip the token itself.
Definition: Parse/Parser.h:843
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177