clang  5.0.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 /// 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 
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;
372  }
373 
374  bool update(TPResult IsDecl) {
375  switch (IsDecl) {
376  case TPResult::True:
378  return true;
379  case TPResult::False:
381  return true;
382  case TPResult::Ambiguous:
383  return false;
384  case TPResult::Error:
386  return true;
387  }
388  llvm_unreachable("unknown tentative parse result");
389  }
390 
391  ConditionOrInitStatement result() const {
393  "result called but not yet resolved");
394  if (CanBeExpression)
396  if (CanBeCondition)
398  if (CanBeInitStatement)
401  }
402 };
403 
404 /// \brief 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))
469  else if (State.CanBeInitStatement && Tok.is(tok::semi))
471  else
473 }
474 
475  /// \brief 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 /// \brief 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  // declarator:
878  // direct-declarator
879  // ptr-operator declarator
880  if (TryParsePtrOperatorSeq() == TPResult::Error)
881  return TPResult::Error;
882 
883  // direct-declarator:
884  // direct-abstract-declarator:
885  if (Tok.is(tok::ellipsis))
886  ConsumeToken();
887 
888  if ((Tok.isOneOf(tok::identifier, tok::kw_operator) ||
889  (Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) ||
890  NextToken().is(tok::kw_operator)))) &&
891  mayHaveIdentifier) {
892  // declarator-id
893  if (Tok.is(tok::annot_cxxscope))
894  ConsumeAnnotationToken();
895  else if (Tok.is(tok::identifier))
896  TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
897  if (Tok.is(tok::kw_operator)) {
898  if (TryParseOperatorId() == TPResult::Error)
899  return TPResult::Error;
900  } else
901  ConsumeToken();
902  } else if (Tok.is(tok::l_paren)) {
903  ConsumeParen();
904  if (mayBeAbstract &&
905  (Tok.is(tok::r_paren) || // 'int()' is a function.
906  // 'int(...)' is a function.
907  (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
908  isDeclarationSpecifier())) { // 'int(int)' is a function.
909  // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
910  // exception-specification[opt]
911  TPResult TPR = TryParseFunctionDeclarator();
912  if (TPR != TPResult::Ambiguous)
913  return TPR;
914  } else {
915  // '(' declarator ')'
916  // '(' attributes declarator ')'
917  // '(' abstract-declarator ')'
918  if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec, tok::kw___cdecl,
919  tok::kw___stdcall, tok::kw___fastcall, tok::kw___thiscall,
920  tok::kw___regcall, tok::kw___vectorcall))
921  return TPResult::True; // attributes indicate declaration
922  TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
923  if (TPR != TPResult::Ambiguous)
924  return TPR;
925  if (Tok.isNot(tok::r_paren))
926  return TPResult::False;
927  ConsumeParen();
928  }
929  } else if (!mayBeAbstract) {
930  return TPResult::False;
931  }
932 
933  while (1) {
934  TPResult TPR(TPResult::Ambiguous);
935 
936  if (Tok.is(tok::l_paren)) {
937  // Check whether we have a function declarator or a possible ctor-style
938  // initializer that follows the declarator. Note that ctor-style
939  // initializers are not possible in contexts where abstract declarators
940  // are allowed.
941  if (!mayBeAbstract && !isCXXFunctionDeclarator())
942  break;
943 
944  // direct-declarator '(' parameter-declaration-clause ')'
945  // cv-qualifier-seq[opt] exception-specification[opt]
946  ConsumeParen();
947  TPR = TryParseFunctionDeclarator();
948  } else if (Tok.is(tok::l_square)) {
949  // direct-declarator '[' constant-expression[opt] ']'
950  // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
951  TPR = TryParseBracketDeclarator();
952  } else {
953  break;
954  }
955 
956  if (TPR != TPResult::Ambiguous)
957  return TPR;
958  }
959 
960  return TPResult::Ambiguous;
961 }
962 
963 Parser::TPResult
964 Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
965  switch (Kind) {
966  // Obviously starts an expression.
967  case tok::numeric_constant:
968  case tok::char_constant:
969  case tok::wide_char_constant:
970  case tok::utf8_char_constant:
971  case tok::utf16_char_constant:
972  case tok::utf32_char_constant:
973  case tok::string_literal:
974  case tok::wide_string_literal:
975  case tok::utf8_string_literal:
976  case tok::utf16_string_literal:
977  case tok::utf32_string_literal:
978  case tok::l_square:
979  case tok::l_paren:
980  case tok::amp:
981  case tok::ampamp:
982  case tok::star:
983  case tok::plus:
984  case tok::plusplus:
985  case tok::minus:
986  case tok::minusminus:
987  case tok::tilde:
988  case tok::exclaim:
989  case tok::kw_sizeof:
990  case tok::kw___func__:
991  case tok::kw_const_cast:
992  case tok::kw_delete:
993  case tok::kw_dynamic_cast:
994  case tok::kw_false:
995  case tok::kw_new:
996  case tok::kw_operator:
997  case tok::kw_reinterpret_cast:
998  case tok::kw_static_cast:
999  case tok::kw_this:
1000  case tok::kw_throw:
1001  case tok::kw_true:
1002  case tok::kw_typeid:
1003  case tok::kw_alignof:
1004  case tok::kw_noexcept:
1005  case tok::kw_nullptr:
1006  case tok::kw__Alignof:
1007  case tok::kw___null:
1008  case tok::kw___alignof:
1009  case tok::kw___builtin_choose_expr:
1010  case tok::kw___builtin_offsetof:
1011  case tok::kw___builtin_va_arg:
1012  case tok::kw___imag:
1013  case tok::kw___real:
1014  case tok::kw___FUNCTION__:
1015  case tok::kw___FUNCDNAME__:
1016  case tok::kw___FUNCSIG__:
1017  case tok::kw_L__FUNCTION__:
1018  case tok::kw___PRETTY_FUNCTION__:
1019  case tok::kw___uuidof:
1020 #define TYPE_TRAIT(N,Spelling,K) \
1021  case tok::kw_##Spelling:
1022 #include "clang/Basic/TokenKinds.def"
1023  return TPResult::True;
1024 
1025  // Obviously starts a type-specifier-seq:
1026  case tok::kw_char:
1027  case tok::kw_const:
1028  case tok::kw_double:
1029  case tok::kw___float128:
1030  case tok::kw_enum:
1031  case tok::kw_half:
1032  case tok::kw_float:
1033  case tok::kw_int:
1034  case tok::kw_long:
1035  case tok::kw___int64:
1036  case tok::kw___int128:
1037  case tok::kw_restrict:
1038  case tok::kw_short:
1039  case tok::kw_signed:
1040  case tok::kw_struct:
1041  case tok::kw_union:
1042  case tok::kw_unsigned:
1043  case tok::kw_void:
1044  case tok::kw_volatile:
1045  case tok::kw__Bool:
1046  case tok::kw__Complex:
1047  case tok::kw_class:
1048  case tok::kw_typename:
1049  case tok::kw_wchar_t:
1050  case tok::kw_char16_t:
1051  case tok::kw_char32_t:
1052  case tok::kw__Decimal32:
1053  case tok::kw__Decimal64:
1054  case tok::kw__Decimal128:
1055  case tok::kw___interface:
1056  case tok::kw___thread:
1057  case tok::kw_thread_local:
1058  case tok::kw__Thread_local:
1059  case tok::kw_typeof:
1060  case tok::kw___underlying_type:
1061  case tok::kw___cdecl:
1062  case tok::kw___stdcall:
1063  case tok::kw___fastcall:
1064  case tok::kw___thiscall:
1065  case tok::kw___regcall:
1066  case tok::kw___vectorcall:
1067  case tok::kw___unaligned:
1068  case tok::kw___vector:
1069  case tok::kw___pixel:
1070  case tok::kw___bool:
1071  case tok::kw__Atomic:
1072 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1073 #include "clang/Basic/OpenCLImageTypes.def"
1074  case tok::kw___unknown_anytype:
1075  return TPResult::False;
1076 
1077  default:
1078  break;
1079  }
1080 
1081  return TPResult::Ambiguous;
1082 }
1083 
1084 bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
1085  return std::find(TentativelyDeclaredIdentifiers.begin(),
1086  TentativelyDeclaredIdentifiers.end(), II)
1087  != TentativelyDeclaredIdentifiers.end();
1088 }
1089 
1090 namespace {
1091 class TentativeParseCCC : public CorrectionCandidateCallback {
1092 public:
1093  TentativeParseCCC(const Token &Next) {
1094  WantRemainingKeywords = false;
1095  WantTypeSpecifiers = Next.isOneOf(tok::l_paren, tok::r_paren, tok::greater,
1096  tok::l_brace, tok::identifier);
1097  }
1098 
1099  bool ValidateCandidate(const TypoCorrection &Candidate) override {
1100  // Reject any candidate that only resolves to instance members since they
1101  // aren't viable as standalone identifiers instead of member references.
1102  if (Candidate.isResolved() && !Candidate.isKeyword() &&
1103  std::all_of(Candidate.begin(), Candidate.end(),
1104  [](NamedDecl *ND) { return ND->isCXXInstanceMember(); }))
1105  return false;
1106 
1108  }
1109 };
1110 }
1111 /// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
1112 /// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
1113 /// be either a decl-specifier or a function-style cast, and TPResult::Error
1114 /// if a parsing error was found and reported.
1115 ///
1116 /// If HasMissingTypename is provided, a name with a dependent scope specifier
1117 /// will be treated as ambiguous if the 'typename' keyword is missing. If this
1118 /// happens, *HasMissingTypename will be set to 'true'. This will also be used
1119 /// as an indicator that undeclared identifiers (which will trigger a later
1120 /// parse error) should be treated as types. Returns TPResult::Ambiguous in
1121 /// such cases.
1122 ///
1123 /// decl-specifier:
1124 /// storage-class-specifier
1125 /// type-specifier
1126 /// function-specifier
1127 /// 'friend'
1128 /// 'typedef'
1129 /// [C++11] 'constexpr'
1130 /// [GNU] attributes declaration-specifiers[opt]
1131 ///
1132 /// storage-class-specifier:
1133 /// 'register'
1134 /// 'static'
1135 /// 'extern'
1136 /// 'mutable'
1137 /// 'auto'
1138 /// [GNU] '__thread'
1139 /// [C++11] 'thread_local'
1140 /// [C11] '_Thread_local'
1141 ///
1142 /// function-specifier:
1143 /// 'inline'
1144 /// 'virtual'
1145 /// 'explicit'
1146 ///
1147 /// typedef-name:
1148 /// identifier
1149 ///
1150 /// type-specifier:
1151 /// simple-type-specifier
1152 /// class-specifier
1153 /// enum-specifier
1154 /// elaborated-type-specifier
1155 /// typename-specifier
1156 /// cv-qualifier
1157 ///
1158 /// simple-type-specifier:
1159 /// '::'[opt] nested-name-specifier[opt] type-name
1160 /// '::'[opt] nested-name-specifier 'template'
1161 /// simple-template-id [TODO]
1162 /// 'char'
1163 /// 'wchar_t'
1164 /// 'bool'
1165 /// 'short'
1166 /// 'int'
1167 /// 'long'
1168 /// 'signed'
1169 /// 'unsigned'
1170 /// 'float'
1171 /// 'double'
1172 /// 'void'
1173 /// [GNU] typeof-specifier
1174 /// [GNU] '_Complex'
1175 /// [C++11] 'auto'
1176 /// [GNU] '__auto_type'
1177 /// [C++11] 'decltype' ( expression )
1178 /// [C++1y] 'decltype' ( 'auto' )
1179 ///
1180 /// type-name:
1181 /// class-name
1182 /// enum-name
1183 /// typedef-name
1184 ///
1185 /// elaborated-type-specifier:
1186 /// class-key '::'[opt] nested-name-specifier[opt] identifier
1187 /// class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
1188 /// simple-template-id
1189 /// 'enum' '::'[opt] nested-name-specifier[opt] identifier
1190 ///
1191 /// enum-name:
1192 /// identifier
1193 ///
1194 /// enum-specifier:
1195 /// 'enum' identifier[opt] '{' enumerator-list[opt] '}'
1196 /// 'enum' identifier[opt] '{' enumerator-list ',' '}'
1197 ///
1198 /// class-specifier:
1199 /// class-head '{' member-specification[opt] '}'
1200 ///
1201 /// class-head:
1202 /// class-key identifier[opt] base-clause[opt]
1203 /// class-key nested-name-specifier identifier base-clause[opt]
1204 /// class-key nested-name-specifier[opt] simple-template-id
1205 /// base-clause[opt]
1206 ///
1207 /// class-key:
1208 /// 'class'
1209 /// 'struct'
1210 /// 'union'
1211 ///
1212 /// cv-qualifier:
1213 /// 'const'
1214 /// 'volatile'
1215 /// [GNU] restrict
1216 ///
1217 Parser::TPResult
1218 Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
1219  bool *HasMissingTypename) {
1220  switch (Tok.getKind()) {
1221  case tok::identifier: {
1222  // Check for need to substitute AltiVec __vector keyword
1223  // for "vector" identifier.
1224  if (TryAltiVecVectorToken())
1225  return TPResult::True;
1226 
1227  const Token &Next = NextToken();
1228  // In 'foo bar', 'foo' is always a type name outside of Objective-C.
1229  if (!getLangOpts().ObjC1 && Next.is(tok::identifier))
1230  return TPResult::True;
1231 
1232  if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
1233  // Determine whether this is a valid expression. If not, we will hit
1234  // a parse error one way or another. In that case, tell the caller that
1235  // this is ambiguous. Typo-correct to type and expression keywords and
1236  // to types and identifiers, in order to try to recover from errors.
1237  switch (TryAnnotateName(false /* no nested name specifier */,
1238  llvm::make_unique<TentativeParseCCC>(Next))) {
1239  case ANK_Error:
1240  return TPResult::Error;
1241  case ANK_TentativeDecl:
1242  return TPResult::False;
1243  case ANK_TemplateName:
1244  // A bare type template-name which can't be a template template
1245  // argument is an error, and was probably intended to be a type.
1246  return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1247  case ANK_Unresolved:
1248  return HasMissingTypename ? TPResult::Ambiguous : TPResult::False;
1249  case ANK_Success:
1250  break;
1251  }
1252  assert(Tok.isNot(tok::identifier) &&
1253  "TryAnnotateName succeeded without producing an annotation");
1254  } else {
1255  // This might possibly be a type with a dependent scope specifier and
1256  // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1257  // since it will annotate as a primary expression, and we want to use the
1258  // "missing 'typename'" logic.
1260  return TPResult::Error;
1261  // If annotation failed, assume it's a non-type.
1262  // FIXME: If this happens due to an undeclared identifier, treat it as
1263  // ambiguous.
1264  if (Tok.is(tok::identifier))
1265  return TPResult::False;
1266  }
1267 
1268  // We annotated this token as something. Recurse to handle whatever we got.
1269  return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1270  }
1271 
1272  case tok::kw_typename: // typename T::type
1273  // Annotate typenames and C++ scope specifiers. If we get one, just
1274  // recurse to handle whatever we get.
1276  return TPResult::Error;
1277  return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1278 
1279  case tok::coloncolon: { // ::foo::bar
1280  const Token &Next = NextToken();
1281  if (Next.isOneOf(tok::kw_new, // ::new
1282  tok::kw_delete)) // ::delete
1283  return TPResult::False;
1284  }
1285  // Fall through.
1286  case tok::kw___super:
1287  case tok::kw_decltype:
1288  // Annotate typenames and C++ scope specifiers. If we get one, just
1289  // recurse to handle whatever we get.
1291  return TPResult::Error;
1292  return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
1293 
1294  // decl-specifier:
1295  // storage-class-specifier
1296  // type-specifier
1297  // function-specifier
1298  // 'friend'
1299  // 'typedef'
1300  // 'constexpr'
1301  // 'concept'
1302  case tok::kw_friend:
1303  case tok::kw_typedef:
1304  case tok::kw_constexpr:
1305  case tok::kw_concept:
1306  // storage-class-specifier
1307  case tok::kw_register:
1308  case tok::kw_static:
1309  case tok::kw_extern:
1310  case tok::kw_mutable:
1311  case tok::kw_auto:
1312  case tok::kw___thread:
1313  case tok::kw_thread_local:
1314  case tok::kw__Thread_local:
1315  // function-specifier
1316  case tok::kw_inline:
1317  case tok::kw_virtual:
1318  case tok::kw_explicit:
1319 
1320  // Modules
1321  case tok::kw___module_private__:
1322 
1323  // Debugger support
1324  case tok::kw___unknown_anytype:
1325 
1326  // type-specifier:
1327  // simple-type-specifier
1328  // class-specifier
1329  // enum-specifier
1330  // elaborated-type-specifier
1331  // typename-specifier
1332  // cv-qualifier
1333 
1334  // class-specifier
1335  // elaborated-type-specifier
1336  case tok::kw_class:
1337  case tok::kw_struct:
1338  case tok::kw_union:
1339  case tok::kw___interface:
1340  // enum-specifier
1341  case tok::kw_enum:
1342  // cv-qualifier
1343  case tok::kw_const:
1344  case tok::kw_volatile:
1345 
1346  // GNU
1347  case tok::kw_restrict:
1348  case tok::kw__Complex:
1349  case tok::kw___attribute:
1350  case tok::kw___auto_type:
1351  return TPResult::True;
1352 
1353  // Microsoft
1354  case tok::kw___declspec:
1355  case tok::kw___cdecl:
1356  case tok::kw___stdcall:
1357  case tok::kw___fastcall:
1358  case tok::kw___thiscall:
1359  case tok::kw___regcall:
1360  case tok::kw___vectorcall:
1361  case tok::kw___w64:
1362  case tok::kw___sptr:
1363  case tok::kw___uptr:
1364  case tok::kw___ptr64:
1365  case tok::kw___ptr32:
1366  case tok::kw___forceinline:
1367  case tok::kw___unaligned:
1368  case tok::kw__Nonnull:
1369  case tok::kw__Nullable:
1370  case tok::kw__Null_unspecified:
1371  case tok::kw___kindof:
1372  return TPResult::True;
1373 
1374  // Borland
1375  case tok::kw___pascal:
1376  return TPResult::True;
1377 
1378  // AltiVec
1379  case tok::kw___vector:
1380  return TPResult::True;
1381 
1382  case tok::annot_template_id: {
1383  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1384  if (TemplateId->Kind != TNK_Type_template)
1385  return TPResult::False;
1386  CXXScopeSpec SS;
1387  AnnotateTemplateIdTokenAsType();
1388  assert(Tok.is(tok::annot_typename));
1389  goto case_typename;
1390  }
1391 
1392  case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1393  // We've already annotated a scope; try to annotate a type.
1395  return TPResult::Error;
1396  if (!Tok.is(tok::annot_typename)) {
1397  // If the next token is an identifier or a type qualifier, then this
1398  // can't possibly be a valid expression either.
1399  if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1400  CXXScopeSpec SS;
1402  Tok.getAnnotationRange(),
1403  SS);
1404  if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1405  RevertingTentativeParsingAction PA(*this);
1406  ConsumeAnnotationToken();
1407  ConsumeToken();
1408  bool isIdentifier = Tok.is(tok::identifier);
1409  TPResult TPR = TPResult::False;
1410  if (!isIdentifier)
1411  TPR = isCXXDeclarationSpecifier(BracedCastResult,
1412  HasMissingTypename);
1413 
1414  if (isIdentifier ||
1415  TPR == TPResult::True || TPR == TPResult::Error)
1416  return TPResult::Error;
1417 
1418  if (HasMissingTypename) {
1419  // We can't tell whether this is a missing 'typename' or a valid
1420  // expression.
1421  *HasMissingTypename = true;
1422  return TPResult::Ambiguous;
1423  }
1424 
1425  // FIXME: Fails to either revert or commit the tentative parse!
1426  } else {
1427  // Try to resolve the name. If it doesn't exist, assume it was
1428  // intended to name a type and keep disambiguating.
1429  switch (TryAnnotateName(false /* SS is not dependent */)) {
1430  case ANK_Error:
1431  return TPResult::Error;
1432  case ANK_TentativeDecl:
1433  return TPResult::False;
1434  case ANK_TemplateName:
1435  // A bare type template-name which can't be a template template
1436  // argument is an error, and was probably intended to be a type.
1437  return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1438  case ANK_Unresolved:
1439  return HasMissingTypename ? TPResult::Ambiguous
1440  : TPResult::False;
1441  case ANK_Success:
1442  // Annotated it, check again.
1443  assert(Tok.isNot(tok::annot_cxxscope) ||
1444  NextToken().isNot(tok::identifier));
1445  return isCXXDeclarationSpecifier(BracedCastResult,
1446  HasMissingTypename);
1447  }
1448  }
1449  }
1450  return TPResult::False;
1451  }
1452  // If that succeeded, fallthrough into the generic simple-type-id case.
1453  LLVM_FALLTHROUGH;
1454 
1455  // The ambiguity resides in a simple-type-specifier/typename-specifier
1456  // followed by a '('. The '(' could either be the start of:
1457  //
1458  // direct-declarator:
1459  // '(' declarator ')'
1460  //
1461  // direct-abstract-declarator:
1462  // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1463  // exception-specification[opt]
1464  // '(' abstract-declarator ')'
1465  //
1466  // or part of a function-style cast expression:
1467  //
1468  // simple-type-specifier '(' expression-list[opt] ')'
1469  //
1470 
1471  // simple-type-specifier:
1472 
1473  case tok::annot_typename:
1474  case_typename:
1475  // In Objective-C, we might have a protocol-qualified type.
1476  if (getLangOpts().ObjC1 && NextToken().is(tok::less)) {
1477  // Tentatively parse the protocol qualifiers.
1478  RevertingTentativeParsingAction PA(*this);
1479  ConsumeAnyToken(); // The type token
1480 
1481  TPResult TPR = TryParseProtocolQualifiers();
1482  bool isFollowedByParen = Tok.is(tok::l_paren);
1483  bool isFollowedByBrace = Tok.is(tok::l_brace);
1484 
1485  if (TPR == TPResult::Error)
1486  return TPResult::Error;
1487 
1488  if (isFollowedByParen)
1489  return TPResult::Ambiguous;
1490 
1491  if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1492  return BracedCastResult;
1493 
1494  return TPResult::True;
1495  }
1496  LLVM_FALLTHROUGH;
1497 
1498  case tok::kw_char:
1499  case tok::kw_wchar_t:
1500  case tok::kw_char16_t:
1501  case tok::kw_char32_t:
1502  case tok::kw_bool:
1503  case tok::kw_short:
1504  case tok::kw_int:
1505  case tok::kw_long:
1506  case tok::kw___int64:
1507  case tok::kw___int128:
1508  case tok::kw_signed:
1509  case tok::kw_unsigned:
1510  case tok::kw_half:
1511  case tok::kw_float:
1512  case tok::kw_double:
1513  case tok::kw___float128:
1514  case tok::kw_void:
1515  case tok::annot_decltype:
1516  if (NextToken().is(tok::l_paren))
1517  return TPResult::Ambiguous;
1518 
1519  // This is a function-style cast in all cases we disambiguate other than
1520  // one:
1521  // struct S {
1522  // enum E : int { a = 4 }; // enum
1523  // enum E : int { 4 }; // bit-field
1524  // };
1525  if (getLangOpts().CPlusPlus11 && NextToken().is(tok::l_brace))
1526  return BracedCastResult;
1527 
1528  if (isStartOfObjCClassMessageMissingOpenBracket())
1529  return TPResult::False;
1530 
1531  return TPResult::True;
1532 
1533  // GNU typeof support.
1534  case tok::kw_typeof: {
1535  if (NextToken().isNot(tok::l_paren))
1536  return TPResult::True;
1537 
1538  RevertingTentativeParsingAction PA(*this);
1539 
1540  TPResult TPR = TryParseTypeofSpecifier();
1541  bool isFollowedByParen = Tok.is(tok::l_paren);
1542  bool isFollowedByBrace = Tok.is(tok::l_brace);
1543 
1544  if (TPR == TPResult::Error)
1545  return TPResult::Error;
1546 
1547  if (isFollowedByParen)
1548  return TPResult::Ambiguous;
1549 
1550  if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1551  return BracedCastResult;
1552 
1553  return TPResult::True;
1554  }
1555 
1556  // C++0x type traits support
1557  case tok::kw___underlying_type:
1558  return TPResult::True;
1559 
1560  // C11 _Atomic
1561  case tok::kw__Atomic:
1562  return TPResult::True;
1563 
1564  default:
1565  return TPResult::False;
1566  }
1567 }
1568 
1569 bool Parser::isCXXDeclarationSpecifierAType() {
1570  switch (Tok.getKind()) {
1571  // typename-specifier
1572  case tok::annot_decltype:
1573  case tok::annot_template_id:
1574  case tok::annot_typename:
1575  case tok::kw_typeof:
1576  case tok::kw___underlying_type:
1577  return true;
1578 
1579  // elaborated-type-specifier
1580  case tok::kw_class:
1581  case tok::kw_struct:
1582  case tok::kw_union:
1583  case tok::kw___interface:
1584  case tok::kw_enum:
1585  return true;
1586 
1587  // simple-type-specifier
1588  case tok::kw_char:
1589  case tok::kw_wchar_t:
1590  case tok::kw_char16_t:
1591  case tok::kw_char32_t:
1592  case tok::kw_bool:
1593  case tok::kw_short:
1594  case tok::kw_int:
1595  case tok::kw_long:
1596  case tok::kw___int64:
1597  case tok::kw___int128:
1598  case tok::kw_signed:
1599  case tok::kw_unsigned:
1600  case tok::kw_half:
1601  case tok::kw_float:
1602  case tok::kw_double:
1603  case tok::kw___float128:
1604  case tok::kw_void:
1605  case tok::kw___unknown_anytype:
1606  case tok::kw___auto_type:
1607  return true;
1608 
1609  case tok::kw_auto:
1610  return getLangOpts().CPlusPlus11;
1611 
1612  case tok::kw__Atomic:
1613  // "_Atomic foo"
1614  return NextToken().is(tok::l_paren);
1615 
1616  default:
1617  return false;
1618  }
1619 }
1620 
1621 /// [GNU] typeof-specifier:
1622 /// 'typeof' '(' expressions ')'
1623 /// 'typeof' '(' type-name ')'
1624 ///
1625 Parser::TPResult Parser::TryParseTypeofSpecifier() {
1626  assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1627  ConsumeToken();
1628 
1629  assert(Tok.is(tok::l_paren) && "Expected '('");
1630  // Parse through the parens after 'typeof'.
1631  ConsumeParen();
1632  if (!SkipUntil(tok::r_paren, StopAtSemi))
1633  return TPResult::Error;
1634 
1635  return TPResult::Ambiguous;
1636 }
1637 
1638 /// [ObjC] protocol-qualifiers:
1639 //// '<' identifier-list '>'
1640 Parser::TPResult Parser::TryParseProtocolQualifiers() {
1641  assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1642  ConsumeToken();
1643  do {
1644  if (Tok.isNot(tok::identifier))
1645  return TPResult::Error;
1646  ConsumeToken();
1647 
1648  if (Tok.is(tok::comma)) {
1649  ConsumeToken();
1650  continue;
1651  }
1652 
1653  if (Tok.is(tok::greater)) {
1654  ConsumeToken();
1655  return TPResult::Ambiguous;
1656  }
1657  } while (false);
1658 
1659  return TPResult::Error;
1660 }
1661 
1662 /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1663 /// a constructor-style initializer, when parsing declaration statements.
1664 /// Returns true for function declarator and false for constructor-style
1665 /// initializer.
1666 /// If during the disambiguation process a parsing error is encountered,
1667 /// the function returns true to let the declaration parsing code handle it.
1668 ///
1669 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1670 /// exception-specification[opt]
1671 ///
1672 bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1673 
1674  // C++ 8.2p1:
1675  // The ambiguity arising from the similarity between a function-style cast and
1676  // a declaration mentioned in 6.8 can also occur in the context of a
1677  // declaration. In that context, the choice is between a function declaration
1678  // with a redundant set of parentheses around a parameter name and an object
1679  // declaration with a function-style cast as the initializer. Just as for the
1680  // ambiguities mentioned in 6.8, the resolution is to consider any construct
1681  // that could possibly be a declaration a declaration.
1682 
1683  RevertingTentativeParsingAction PA(*this);
1684 
1685  ConsumeParen();
1686  bool InvalidAsDeclaration = false;
1687  TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1688  if (TPR == TPResult::Ambiguous) {
1689  if (Tok.isNot(tok::r_paren))
1690  TPR = TPResult::False;
1691  else {
1692  const Token &Next = NextToken();
1693  if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
1694  tok::kw_throw, tok::kw_noexcept, tok::l_square,
1695  tok::l_brace, tok::kw_try, tok::equal, tok::arrow) ||
1696  isCXX11VirtSpecifier(Next))
1697  // The next token cannot appear after a constructor-style initializer,
1698  // and can appear next in a function definition. This must be a function
1699  // declarator.
1700  TPR = TPResult::True;
1701  else if (InvalidAsDeclaration)
1702  // Use the absence of 'typename' as a tie-breaker.
1703  TPR = TPResult::False;
1704  }
1705  }
1706 
1707  if (IsAmbiguous && TPR == TPResult::Ambiguous)
1708  *IsAmbiguous = true;
1709 
1710  // In case of an error, let the declaration parsing code handle it.
1711  return TPR != TPResult::False;
1712 }
1713 
1714 /// parameter-declaration-clause:
1715 /// parameter-declaration-list[opt] '...'[opt]
1716 /// parameter-declaration-list ',' '...'
1717 ///
1718 /// parameter-declaration-list:
1719 /// parameter-declaration
1720 /// parameter-declaration-list ',' parameter-declaration
1721 ///
1722 /// parameter-declaration:
1723 /// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1724 /// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1725 /// '=' assignment-expression
1726 /// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1727 /// attributes[opt]
1728 /// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1729 /// attributes[opt] '=' assignment-expression
1730 ///
1731 Parser::TPResult
1732 Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
1733  bool VersusTemplateArgument) {
1734 
1735  if (Tok.is(tok::r_paren))
1736  return TPResult::Ambiguous;
1737 
1738  // parameter-declaration-list[opt] '...'[opt]
1739  // parameter-declaration-list ',' '...'
1740  //
1741  // parameter-declaration-list:
1742  // parameter-declaration
1743  // parameter-declaration-list ',' parameter-declaration
1744  //
1745  while (1) {
1746  // '...'[opt]
1747  if (Tok.is(tok::ellipsis)) {
1748  ConsumeToken();
1749  if (Tok.is(tok::r_paren))
1750  return TPResult::True; // '...)' is a sign of a function declarator.
1751  else
1752  return TPResult::False;
1753  }
1754 
1755  // An attribute-specifier-seq here is a sign of a function declarator.
1756  if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1757  /*OuterMightBeMessageSend*/true))
1758  return TPResult::True;
1759 
1760  ParsedAttributes attrs(AttrFactory);
1761  MaybeParseMicrosoftAttributes(attrs);
1762 
1763  // decl-specifier-seq
1764  // A parameter-declaration's initializer must be preceded by an '=', so
1765  // decl-specifier-seq '{' is not a parameter in C++11.
1766  TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
1767  InvalidAsDeclaration);
1768 
1769  if (VersusTemplateArgument && TPR == TPResult::True) {
1770  // Consume the decl-specifier-seq. We have to look past it, since a
1771  // type-id might appear here in a template argument.
1772  bool SeenType = false;
1773  do {
1774  SeenType |= isCXXDeclarationSpecifierAType();
1775  if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1776  return TPResult::Error;
1777 
1778  // If we see a parameter name, this can't be a template argument.
1779  if (SeenType && Tok.is(tok::identifier))
1780  return TPResult::True;
1781 
1782  TPR = isCXXDeclarationSpecifier(TPResult::False,
1783  InvalidAsDeclaration);
1784  if (TPR == TPResult::Error)
1785  return TPR;
1786  } while (TPR != TPResult::False);
1787  } else if (TPR == TPResult::Ambiguous) {
1788  // Disambiguate what follows the decl-specifier.
1789  if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1790  return TPResult::Error;
1791  } else
1792  return TPR;
1793 
1794  // declarator
1795  // abstract-declarator[opt]
1796  TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1797  if (TPR != TPResult::Ambiguous)
1798  return TPR;
1799 
1800  // [GNU] attributes[opt]
1801  if (Tok.is(tok::kw___attribute))
1802  return TPResult::True;
1803 
1804  // If we're disambiguating a template argument in a default argument in
1805  // a class definition versus a parameter declaration, an '=' here
1806  // disambiguates the parse one way or the other.
1807  // If this is a parameter, it must have a default argument because
1808  // (a) the previous parameter did, and
1809  // (b) this must be the first declaration of the function, so we can't
1810  // inherit any default arguments from elsewhere.
1811  // If we see an ')', then we've reached the end of a
1812  // parameter-declaration-clause, and the last param is missing its default
1813  // argument.
1814  if (VersusTemplateArgument)
1815  return Tok.isOneOf(tok::equal, tok::r_paren) ? TPResult::True
1816  : TPResult::False;
1817 
1818  if (Tok.is(tok::equal)) {
1819  // '=' assignment-expression
1820  // Parse through assignment-expression.
1821  // FIXME: assignment-expression may contain an unparenthesized comma.
1822  if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
1823  return TPResult::Error;
1824  }
1825 
1826  if (Tok.is(tok::ellipsis)) {
1827  ConsumeToken();
1828  if (Tok.is(tok::r_paren))
1829  return TPResult::True; // '...)' is a sign of a function declarator.
1830  else
1831  return TPResult::False;
1832  }
1833 
1834  if (!TryConsumeToken(tok::comma))
1835  break;
1836  }
1837 
1838  return TPResult::Ambiguous;
1839 }
1840 
1841 /// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1842 /// parsing as a function declarator.
1843 /// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1844 /// return TPResult::Ambiguous, otherwise it will return either False() or
1845 /// Error().
1846 ///
1847 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1848 /// exception-specification[opt]
1849 ///
1850 /// exception-specification:
1851 /// 'throw' '(' type-id-list[opt] ')'
1852 ///
1853 Parser::TPResult Parser::TryParseFunctionDeclarator() {
1854 
1855  // The '(' is already parsed.
1856 
1857  TPResult TPR = TryParseParameterDeclarationClause();
1858  if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
1859  TPR = TPResult::False;
1860 
1861  if (TPR == TPResult::False || TPR == TPResult::Error)
1862  return TPR;
1863 
1864  // Parse through the parens.
1865  if (!SkipUntil(tok::r_paren, StopAtSemi))
1866  return TPResult::Error;
1867 
1868  // cv-qualifier-seq
1869  while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict))
1870  ConsumeToken();
1871 
1872  // ref-qualifier[opt]
1873  if (Tok.isOneOf(tok::amp, tok::ampamp))
1874  ConsumeToken();
1875 
1876  // exception-specification
1877  if (Tok.is(tok::kw_throw)) {
1878  ConsumeToken();
1879  if (Tok.isNot(tok::l_paren))
1880  return TPResult::Error;
1881 
1882  // Parse through the parens after 'throw'.
1883  ConsumeParen();
1884  if (!SkipUntil(tok::r_paren, StopAtSemi))
1885  return TPResult::Error;
1886  }
1887  if (Tok.is(tok::kw_noexcept)) {
1888  ConsumeToken();
1889  // Possibly an expression as well.
1890  if (Tok.is(tok::l_paren)) {
1891  // Find the matching rparen.
1892  ConsumeParen();
1893  if (!SkipUntil(tok::r_paren, StopAtSemi))
1894  return TPResult::Error;
1895  }
1896  }
1897 
1898  return TPResult::Ambiguous;
1899 }
1900 
1901 /// '[' constant-expression[opt] ']'
1902 ///
1903 Parser::TPResult Parser::TryParseBracketDeclarator() {
1904  ConsumeBracket();
1905  if (!SkipUntil(tok::r_square, StopAtSemi))
1906  return TPResult::Error;
1907 
1908  return TPResult::Ambiguous;
1909 }
Disambiguated as an expression (either kind).
Simple class containing the result of Sema::CorrectTypo.
const LangOptions & getLangOpts() const
Definition: Parser.h:267
bool TryAnnotateCXXScopeToken(bool EnteringContext=false)
TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and ...
Definition: Parser.cpp:1841
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)
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:934
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:602
Disambiguated as a simple-declaration init-statement.
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:320
One of these records is kept for each identifier that is lexed.
LineState State
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
tok::TokenKind getKind() const
Definition: Token.h:90
void * getAnnotationValue() const
Definition: Token.h:224
Disambiguated as the declaration form of condition.
ASTContext * Context
virtual bool ValidateCandidate(const TypoCorrection &candidate)
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
SourceRange getAnnotationRange() const
SourceRange of the group of tokens that this annotation token represents.
Definition: Token.h:158
bool hasUDSuffix() const
Return true if this token is a string or character literal which has a ud-suffix. ...
Definition: Token.h:291
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
Kind
Stop skipping at semicolon.
Definition: Parser.h:914
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
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:1620
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:95
bool isResolved() const
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
bool isKeyword() const
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h: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()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:312
decl_iterator end()
Represents a complete lambda introducer.
Definition: DeclSpec.h:2485
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
ParsedAttributes - A collection of parsed attributes.
Stop skipping at specified token, but don't skip the token itself.
Definition: Parser.h:916
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177