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