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