Coverage Report

Created: 2022-01-18 06:27

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Parse/ParseTentative.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- ParseTentative.cpp - Ambiguity Resolution Parsing ----------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
//  This file implements the tentative parsing portions of the Parser
10
//  interfaces, for ambiguity resolution.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "clang/Parse/Parser.h"
15
#include "clang/Parse/ParseDiagnostic.h"
16
#include "clang/Sema/ParsedTemplate.h"
17
using namespace clang;
18
19
/// isCXXDeclarationStatement - C++-specialized function that disambiguates
20
/// between a declaration or an expression statement, when parsing function
21
/// bodies. Returns true for declaration, false for expression.
22
///
23
///         declaration-statement:
24
///           block-declaration
25
///
26
///         block-declaration:
27
///           simple-declaration
28
///           asm-definition
29
///           namespace-alias-definition
30
///           using-declaration
31
///           using-directive
32
/// [C++0x]   static_assert-declaration
33
///
34
///         asm-definition:
35
///           'asm' '(' string-literal ')' ';'
36
///
37
///         namespace-alias-definition:
38
///           'namespace' identifier = qualified-namespace-specifier ';'
39
///
40
///         using-declaration:
41
///           'using' typename[opt] '::'[opt] nested-name-specifier
42
///                 unqualified-id ';'
43
///           'using' '::' unqualified-id ;
44
///
45
///         using-directive:
46
///           'using' 'namespace' '::'[opt] nested-name-specifier[opt]
47
///                 namespace-name ';'
48
///
49
2.24M
bool Parser::isCXXDeclarationStatement() {
50
2.24M
  switch (Tok.getKind()) {
51
    // asm-definition
52
0
  case tok::kw_asm:
53
    // namespace-alias-definition
54
29
  case tok::kw_namespace:
55
    // using-declaration
56
    // using-directive
57
18.0k
  case tok::kw_using:
58
    // static_assert-declaration
59
43.6k
  case tok::kw_static_assert:
60
45.0k
  case tok::kw__Static_assert:
61
45.0k
    return true;
62
    // simple-declaration
63
2.19M
  default:
64
2.19M
    return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/false);
65
2.24M
  }
66
2.24M
}
67
68
/// isCXXSimpleDeclaration - C++-specialized function that disambiguates
69
/// between a simple-declaration or an expression-statement.
70
/// If during the disambiguation process a parsing error is encountered,
71
/// the function returns true to let the declaration parsing code handle it.
72
/// Returns false if the statement is disambiguated as expression.
73
///
74
/// simple-declaration:
75
///   decl-specifier-seq init-declarator-list[opt] ';'
76
///   decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
77
///                      brace-or-equal-initializer ';'    [C++17]
78
///
79
/// (if AllowForRangeDecl specified)
80
/// for ( for-range-declaration : for-range-initializer ) statement
81
///
82
/// for-range-declaration:
83
///    decl-specifier-seq declarator
84
///    decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
85
///
86
/// In any of the above cases there can be a preceding attribute-specifier-seq,
87
/// but the caller is expected to handle that.
88
2.33M
bool Parser::isCXXSimpleDeclaration(bool AllowForRangeDecl) {
89
  // C++ 6.8p1:
90
  // There is an ambiguity in the grammar involving expression-statements and
91
  // declarations: An expression-statement with a function-style explicit type
92
  // conversion (5.2.3) as its leftmost subexpression can be indistinguishable
93
  // from a declaration where the first declarator starts with a '('. In those
94
  // cases the statement is a declaration. [Note: To disambiguate, the whole
95
  // statement might have to be examined to determine if it is an
96
  // expression-statement or a declaration].
97
98
  // C++ 6.8p3:
99
  // The disambiguation is purely syntactic; that is, the meaning of the names
100
  // occurring in such a statement, beyond whether they are type-names or not,
101
  // is not generally used in or changed by the disambiguation. Class
102
  // templates are instantiated as necessary to determine if a qualified name
103
  // is a type-name. Disambiguation precedes parsing, and a statement
104
  // disambiguated as a declaration may be an ill-formed declaration.
105
106
  // We don't have to parse all of the decl-specifier-seq part. There's only
107
  // an ambiguity if the first decl-specifier is
108
  // simple-type-specifier/typename-specifier followed by a '(', which may
109
  // indicate a function-style cast expression.
110
  // isCXXDeclarationSpecifier will return TPResult::Ambiguous only in such
111
  // a case.
112
113
2.33M
  bool InvalidAsDeclaration = false;
114
2.33M
  TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
115
2.33M
                                           &InvalidAsDeclaration);
116
2.33M
  if (TPR != TPResult::Ambiguous)
117
2.28M
    return TPR != TPResult::False; // Returns true for TPResult::True or
118
                                   // TPResult::Error.
119
120
  // FIXME: TryParseSimpleDeclaration doesn't look past the first initializer,
121
  // and so gets some cases wrong. We can't carry on if we've already seen
122
  // something which makes this statement invalid as a declaration in this case,
123
  // since it can cause us to misparse valid code. Revisit this once
124
  // TryParseInitDeclaratorList is fixed.
125
51.6k
  if (InvalidAsDeclaration)
126
38.5k
    return false;
127
128
  // FIXME: Add statistics about the number of ambiguous statements encountered
129
  // and how they were resolved (number of declarations+number of expressions).
130
131
  // Ok, we have a simple-type-specifier/typename-specifier followed by a '(',
132
  // or an identifier which doesn't resolve as anything. We need tentative
133
  // parsing...
134
135
13.1k
  {
136
13.1k
    RevertingTentativeParsingAction PA(*this);
137
13.1k
    TPR = TryParseSimpleDeclaration(AllowForRangeDecl);
138
13.1k
  }
139
140
  // In case of an error, let the declaration parsing code handle it.
141
13.1k
  if (TPR == TPResult::Error)
142
9
    return true;
143
144
  // Declarations take precedence over expressions.
145
13.1k
  if (TPR == TPResult::Ambiguous)
146
321
    TPR = TPResult::True;
147
148
13.1k
  assert(TPR == TPResult::True || TPR == TPResult::False);
149
0
  return TPR == TPResult::True;
150
13.1k
}
151
152
/// Try to consume a token sequence that we've already identified as
153
/// (potentially) starting a decl-specifier.
154
84.3k
Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
155
84.3k
  switch (Tok.getKind()) {
156
0
  case tok::kw__Atomic:
157
0
    if (NextToken().isNot(tok::l_paren)) {
158
0
      ConsumeToken();
159
0
      break;
160
0
    }
161
0
    LLVM_FALLTHROUGH;
162
15
  case tok::kw_typeof:
163
15
  case tok::kw___attribute:
164
15
  case tok::kw___underlying_type: {
165
15
    ConsumeToken();
166
15
    if (Tok.isNot(tok::l_paren))
167
0
      return TPResult::Error;
168
15
    ConsumeParen();
169
15
    if (!SkipUntil(tok::r_paren))
170
0
      return TPResult::Error;
171
15
    break;
172
15
  }
173
174
15
  case tok::kw_class:
175
2
  case tok::kw_struct:
176
4
  case tok::kw_union:
177
4
  case tok::kw___interface:
178
5
  case tok::kw_enum:
179
    // elaborated-type-specifier:
180
    //     class-key attribute-specifier-seq[opt]
181
    //         nested-name-specifier[opt] identifier
182
    //     class-key nested-name-specifier[opt] template[opt] simple-template-id
183
    //     enum nested-name-specifier[opt] identifier
184
    //
185
    // FIXME: We don't support class-specifiers nor enum-specifiers here.
186
5
    ConsumeToken();
187
188
    // Skip attributes.
189
5
    if (!TrySkipAttributes())
190
0
      return TPResult::Error;
191
192
5
    if (TryAnnotateOptionalCXXScopeToken())
193
0
      return TPResult::Error;
194
5
    if (Tok.is(tok::annot_cxxscope))
195
1
      ConsumeAnnotationToken();
196
5
    if (Tok.is(tok::identifier))
197
3
      ConsumeToken();
198
2
    else if (Tok.is(tok::annot_template_id))
199
1
      ConsumeAnnotationToken();
200
1
    else
201
1
      return TPResult::Error;
202
4
    break;
203
204
507
  case tok::annot_cxxscope:
205
507
    ConsumeAnnotationToken();
206
507
    LLVM_FALLTHROUGH;
207
84.2k
  default:
208
84.2k
    ConsumeAnyToken();
209
210
84.2k
    if (getLangOpts().ObjC && 
Tok.is(tok::less)2.43k
)
211
9
      return TryParseProtocolQualifiers();
212
84.2k
    break;
213
84.3k
  }
214
215
84.2k
  return TPResult::Ambiguous;
216
84.3k
}
217
218
/// simple-declaration:
219
///   decl-specifier-seq init-declarator-list[opt] ';'
220
///
221
/// (if AllowForRangeDecl specified)
222
/// for ( for-range-declaration : for-range-initializer ) statement
223
/// for-range-declaration:
224
///    attribute-specifier-seqopt type-specifier-seq declarator
225
///
226
13.1k
Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
227
13.1k
  if (TryConsumeDeclarationSpecifier() == TPResult::Error)
228
9
    return TPResult::Error;
229
230
  // Two decl-specifiers in a row conclusively disambiguate this as being a
231
  // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
232
  // overwhelmingly common case that the next token is a '('.
233
13.1k
  if (Tok.isNot(tok::l_paren)) {
234
279
    TPResult TPR = isCXXDeclarationSpecifier();
235
279
    if (TPR == TPResult::Ambiguous)
236
0
      return TPResult::True;
237
279
    if (TPR == TPResult::True || 
TPR == TPResult::Error278
)
238
1
      return TPR;
239
278
    assert(TPR == TPResult::False);
240
278
  }
241
242
13.1k
  TPResult TPR = TryParseInitDeclaratorList();
243
13.1k
  if (TPR != TPResult::Ambiguous)
244
9.84k
    return TPR;
245
246
3.32k
  if (Tok.isNot(tok::semi) && 
(3.00k
!AllowForRangeDecl3.00k
||
Tok.isNot(tok::colon)8
))
247
3.00k
    return TPResult::False;
248
249
321
  return TPResult::Ambiguous;
250
3.32k
}
251
252
/// Tentatively parse an init-declarator-list in order to disambiguate it from
253
/// an expression.
254
///
255
///       init-declarator-list:
256
///         init-declarator
257
///         init-declarator-list ',' init-declarator
258
///
259
///       init-declarator:
260
///         declarator initializer[opt]
261
/// [GNU]   declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
262
///
263
///       initializer:
264
///         brace-or-equal-initializer
265
///         '(' expression-list ')'
266
///
267
///       brace-or-equal-initializer:
268
///         '=' initializer-clause
269
/// [C++11] braced-init-list
270
///
271
///       initializer-clause:
272
///         assignment-expression
273
///         braced-init-list
274
///
275
///       braced-init-list:
276
///         '{' initializer-list ','[opt] '}'
277
///         '{' '}'
278
///
279
13.1k
Parser::TPResult Parser::TryParseInitDeclaratorList() {
280
13.2k
  while (true) {
281
    // declarator
282
13.2k
    TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
283
13.2k
    if (TPR != TPResult::Ambiguous)
284
7.89k
      return TPR;
285
286
    // [GNU] simple-asm-expr[opt] attributes[opt]
287
5.31k
    if (Tok.isOneOf(tok::kw_asm, tok::kw___attribute))
288
8
      return TPResult::True;
289
290
    // initializer[opt]
291
5.31k
    if (Tok.is(tok::l_paren)) {
292
      // Parse through the parens.
293
11
      ConsumeParen();
294
11
      if (!SkipUntil(tok::r_paren, StopAtSemi))
295
0
        return TPResult::Error;
296
5.30k
    } else if (Tok.is(tok::l_brace)) {
297
      // A left-brace here is sufficient to disambiguate the parse; an
298
      // expression can never be followed directly by a braced-init-list.
299
4
      return TPResult::True;
300
5.29k
    } else if (Tok.is(tok::equal) || 
isTokIdentifier_in()3.34k
) {
301
      // MSVC and g++ won't examine the rest of declarators if '=' is
302
      // encountered; they just conclude that we have a declaration.
303
      // EDG parses the initializer completely, which is the proper behavior
304
      // for this case.
305
      //
306
      // At present, Clang follows MSVC and g++, since the parser does not have
307
      // the ability to parse an expression fully without recording the
308
      // results of that parse.
309
      // FIXME: Handle this case correctly.
310
      //
311
      // Also allow 'in' after an Objective-C declaration as in:
312
      // for (int (^b)(void) in array). Ideally this should be done in the
313
      // context of parsing for-init-statement of a foreach statement only. But,
314
      // in any other context 'in' is invalid after a declaration and parser
315
      // issues the error regardless of outcome of this decision.
316
      // FIXME: Change if above assumption does not hold.
317
1.95k
      return TPResult::True;
318
1.95k
    }
319
320
3.35k
    if (!TryConsumeToken(tok::comma))
321
3.34k
      break;
322
3.35k
  }
323
324
3.34k
  return TPResult::Ambiguous;
325
13.1k
}
326
327
struct Parser::ConditionDeclarationOrInitStatementState {
328
  Parser &P;
329
  bool CanBeExpression = true;
330
  bool CanBeCondition = true;
331
  bool CanBeInitStatement;
332
  bool CanBeForRangeDecl;
333
334
  ConditionDeclarationOrInitStatementState(Parser &P, bool CanBeInitStatement,
335
                                           bool CanBeForRangeDecl)
336
      : P(P), CanBeInitStatement(CanBeInitStatement),
337
707k
        CanBeForRangeDecl(CanBeForRangeDecl) {}
338
339
711k
  bool resolved() {
340
711k
    return CanBeExpression + CanBeCondition + CanBeInitStatement +
341
711k
               CanBeForRangeDecl < 2;
342
711k
  }
343
344
1.23k
  void markNotExpression() {
345
1.23k
    CanBeExpression = false;
346
347
1.23k
    if (!resolved()) {
348
      // FIXME: Unify the parsing codepaths for condition variables and
349
      // simple-declarations so that we don't need to eagerly figure out which
350
      // kind we have here. (Just parse init-declarators until we reach a
351
      // semicolon or right paren.)
352
707
      RevertingTentativeParsingAction PA(P);
353
707
      if (CanBeForRangeDecl) {
354
        // Skip until we hit a ')', ';', or a ':' with no matching '?'.
355
        // The final case is a for range declaration, the rest are not.
356
170
        unsigned QuestionColonDepth = 0;
357
178
        while (true) {
358
178
          P.SkipUntil({tok::r_paren, tok::semi, tok::question, tok::colon},
359
178
                      StopBeforeMatch);
360
178
          if (P.Tok.is(tok::question))
361
4
            ++QuestionColonDepth;
362
174
          else if (P.Tok.is(tok::colon)) {
363
66
            if (QuestionColonDepth)
364
4
              --QuestionColonDepth;
365
62
            else {
366
62
              CanBeCondition = CanBeInitStatement = false;
367
62
              return;
368
62
            }
369
108
          } else {
370
108
            CanBeForRangeDecl = false;
371
108
            break;
372
108
          }
373
8
          P.ConsumeToken();
374
8
        }
375
537
      } else {
376
        // Just skip until we hit a ')' or ';'.
377
537
        P.SkipUntil(tok::r_paren, tok::semi, StopBeforeMatch);
378
537
      }
379
645
      if (P.Tok.isNot(tok::r_paren))
380
204
        CanBeCondition = CanBeForRangeDecl = false;
381
645
      if (P.Tok.isNot(tok::semi))
382
443
        CanBeInitStatement = false;
383
645
    }
384
1.23k
  }
385
386
23
  bool markNotCondition() {
387
23
    CanBeCondition = false;
388
23
    return resolved();
389
23
  }
390
391
23
  bool markNotForRangeDecl() {
392
23
    CanBeForRangeDecl = false;
393
23
    return resolved();
394
23
  }
395
396
709k
  bool update(TPResult IsDecl) {
397
709k
    switch (IsDecl) {
398
1.22k
    case TPResult::True:
399
1.22k
      markNotExpression();
400
1.22k
      assert(resolved() && "can't continue after tentative parsing bails out");
401
0
      break;
402
706k
    case TPResult::False:
403
706k
      CanBeCondition = CanBeInitStatement = CanBeForRangeDecl = false;
404
706k
      break;
405
1.89k
    case TPResult::Ambiguous:
406
1.89k
      break;
407
0
    case TPResult::Error:
408
0
      CanBeExpression = CanBeCondition = CanBeInitStatement =
409
0
          CanBeForRangeDecl = false;
410
0
      break;
411
709k
    }
412
709k
    return resolved();
413
709k
  }
414
415
707k
  ConditionOrInitStatement result() const {
416
707k
    assert(CanBeExpression + CanBeCondition + CanBeInitStatement +
417
707k
                   CanBeForRangeDecl < 2 &&
418
707k
           "result called but not yet resolved");
419
707k
    if (CanBeExpression)
420
706k
      return ConditionOrInitStatement::Expression;
421
1.23k
    if (CanBeCondition)
422
973
      return ConditionOrInitStatement::ConditionDecl;
423
266
    if (CanBeInitStatement)
424
95
      return ConditionOrInitStatement::InitStmtDecl;
425
171
    if (CanBeForRangeDecl)
426
62
      return ConditionOrInitStatement::ForRangeDecl;
427
109
    return ConditionOrInitStatement::Error;
428
171
  }
429
};
430
431
172
bool Parser::isEnumBase(bool AllowSemi) {
432
172
  assert(Tok.is(tok::colon) && "should be looking at the ':'");
433
434
0
  RevertingTentativeParsingAction PA(*this);
435
  // ':'
436
172
  ConsumeToken();
437
438
  // type-specifier-seq
439
172
  bool InvalidAsDeclSpec = false;
440
  // FIXME: We could disallow non-type decl-specifiers here, but it makes no
441
  // difference: those specifiers are ill-formed regardless of the
442
  // interpretation.
443
172
  TPResult R = isCXXDeclarationSpecifier(/*BracedCastResult*/ TPResult::True,
444
172
                                         &InvalidAsDeclSpec);
445
172
  if (R == TPResult::Ambiguous) {
446
    // We either have a decl-specifier followed by '(' or an undeclared
447
    // identifier.
448
13
    if (TryConsumeDeclarationSpecifier() == TPResult::Error)
449
0
      return true;
450
451
    // If we get to the end of the enum-base, we hit either a '{' or a ';'.
452
    // Don't bother checking the enumerator-list.
453
13
    if (Tok.is(tok::l_brace) || 
(11
AllowSemi11
&&
Tok.is(tok::semi)11
))
454
2
      return true;
455
456
    // A second decl-specifier unambiguously indicatges an enum-base.
457
11
    R = isCXXDeclarationSpecifier(TPResult::True, &InvalidAsDeclSpec);
458
11
  }
459
460
170
  return R != TPResult::False;
461
172
}
462
463
/// Disambiguates between a declaration in a condition, a
464
/// simple-declaration in an init-statement, and an expression for
465
/// a condition of a if/switch statement.
466
///
467
///       condition:
468
///         expression
469
///         type-specifier-seq declarator '=' assignment-expression
470
/// [C++11] type-specifier-seq declarator '=' initializer-clause
471
/// [C++11] type-specifier-seq declarator braced-init-list
472
/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
473
///             '=' assignment-expression
474
///       simple-declaration:
475
///         decl-specifier-seq init-declarator-list[opt] ';'
476
///
477
/// Note that, unlike isCXXSimpleDeclaration, we must disambiguate all the way
478
/// to the ';' to disambiguate cases like 'int(x))' (an expression) from
479
/// 'int(x);' (a simple-declaration in an init-statement).
480
Parser::ConditionOrInitStatement
481
Parser::isCXXConditionDeclarationOrInitStatement(bool CanBeInitStatement,
482
707k
                                                 bool CanBeForRangeDecl) {
483
707k
  ConditionDeclarationOrInitStatementState State(*this, CanBeInitStatement,
484
707k
                                                 CanBeForRangeDecl);
485
486
707k
  if (CanBeInitStatement && 
Tok.is(tok::kw_using)479k
)
487
14
    return ConditionOrInitStatement::InitStmtDecl;
488
707k
  if (State.update(isCXXDeclarationSpecifier()))
489
706k
    return State.result();
490
491
  // It might be a declaration; we need tentative parsing.
492
929
  RevertingTentativeParsingAction PA(*this);
493
494
  // FIXME: A tag definition unambiguously tells us this is an init-statement.
495
929
  if (State.update(TryConsumeDeclarationSpecifier()))
496
0
    return State.result();
497
929
  assert(Tok.is(tok::l_paren) && "Expected '('");
498
499
935
  while (true) {
500
    // Consume a declarator.
501
935
    if (State.update(TryParseDeclarator(false/*mayBeAbstract*/)))
502
899
      return State.result();
503
504
    // Attributes, asm label, or an initializer imply this is not an expression.
505
    // FIXME: Disambiguate properly after an = instead of assuming that it's a
506
    // valid declaration.
507
36
    if (Tok.isOneOf(tok::equal, tok::kw_asm, tok::kw___attribute) ||
508
36
        
(27
getLangOpts().CPlusPlus1127
&&
Tok.is(tok::l_brace)26
)) {
509
11
      State.markNotExpression();
510
11
      return State.result();
511
11
    }
512
513
    // A colon here identifies a for-range declaration.
514
25
    if (State.CanBeForRangeDecl && 
Tok.is(tok::colon)3
)
515
2
      return ConditionOrInitStatement::ForRangeDecl;
516
517
    // At this point, it can't be a condition any more, because a condition
518
    // must have a brace-or-equal-initializer.
519
23
    if (State.markNotCondition())
520
0
      return State.result();
521
522
    // Likewise, it can't be a for-range declaration any more.
523
23
    if (State.markNotForRangeDecl())
524
1
      return State.result();
525
526
    // A parenthesized initializer could be part of an expression or a
527
    // simple-declaration.
528
22
    if (Tok.is(tok::l_paren)) {
529
1
      ConsumeParen();
530
1
      SkipUntil(tok::r_paren, StopAtSemi);
531
1
    }
532
533
22
    if (!TryConsumeToken(tok::comma))
534
16
      break;
535
22
  }
536
537
  // We reached the end. If it can now be some kind of decl, then it is.
538
16
  if (State.CanBeCondition && 
Tok.is(tok::r_paren)0
)
539
0
    return ConditionOrInitStatement::ConditionDecl;
540
16
  else if (State.CanBeInitStatement && Tok.is(tok::semi))
541
2
    return ConditionOrInitStatement::InitStmtDecl;
542
14
  else
543
14
    return ConditionOrInitStatement::Expression;
544
16
}
545
546
  /// Determine whether the next set of tokens contains a type-id.
547
  ///
548
  /// The context parameter states what context we're parsing right
549
  /// now, which affects how this routine copes with the token
550
  /// following the type-id. If the context is TypeIdInParens, we have
551
  /// already parsed the '(' and we will cease lookahead when we hit
552
  /// the corresponding ')'. If the context is
553
  /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
554
  /// before this template argument, and will cease lookahead when we
555
  /// hit a '>', '>>' (in C++0x), or ','; or, in C++0x, an ellipsis immediately
556
  /// preceding such. Returns true for a type-id and false for an expression.
557
  /// If during the disambiguation process a parsing error is encountered,
558
  /// the function returns true to let the declaration parsing code handle it.
559
  ///
560
  /// type-id:
561
  ///   type-specifier-seq abstract-declarator[opt]
562
  ///
563
5.96M
bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
564
565
5.96M
  isAmbiguous = false;
566
567
  // C++ 8.2p2:
568
  // The ambiguity arising from the similarity between a function-style cast and
569
  // a type-id can occur in different contexts. The ambiguity appears as a
570
  // choice between a function-style cast expression and a declaration of a
571
  // type. The resolution is that any construct that could possibly be a type-id
572
  // in its syntactic context shall be considered a type-id.
573
574
5.96M
  TPResult TPR = isCXXDeclarationSpecifier();
575
5.96M
  if (TPR != TPResult::Ambiguous)
576
5.90M
    return TPR != TPResult::False; // Returns true for TPResult::True or
577
                                     // TPResult::Error.
578
579
  // FIXME: Add statistics about the number of ambiguous statements encountered
580
  // and how they were resolved (number of declarations+number of expressions).
581
582
  // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
583
  // We need tentative parsing...
584
585
58.3k
  RevertingTentativeParsingAction PA(*this);
586
587
  // type-specifier-seq
588
58.3k
  TryConsumeDeclarationSpecifier();
589
58.3k
  assert(Tok.is(tok::l_paren) && "Expected '('");
590
591
  // declarator
592
0
  TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
593
594
  // In case of an error, let the declaration parsing code handle it.
595
58.3k
  if (TPR == TPResult::Error)
596
1
    TPR = TPResult::True;
597
598
58.3k
  if (TPR == TPResult::Ambiguous) {
599
    // We are supposed to be inside parens, so if after the abstract declarator
600
    // we encounter a ')' this is a type-id, otherwise it's an expression.
601
57.2k
    if (Context == TypeIdInParens && 
Tok.is(tok::r_paren)3.61k
) {
602
3.38k
      TPR = TPResult::True;
603
3.38k
      isAmbiguous = true;
604
605
    // We are supposed to be inside a template argument, so if after
606
    // the abstract declarator we encounter a '>', '>>' (in C++0x), or
607
    // ','; or, in C++0x, an ellipsis immediately preceding such, this
608
    // is a type-id. Otherwise, it's an expression.
609
53.8k
    } else if (Context == TypeIdAsTemplateArgument &&
610
53.8k
               
(53.6k
Tok.isOneOf(tok::greater, tok::comma)53.6k
||
611
53.6k
                
(29
getLangOpts().CPlusPlus1129
&&
612
29
                 (Tok.isOneOf(tok::greatergreater,
613
29
                              tok::greatergreatergreater) ||
614
29
                  
(19
Tok.is(tok::ellipsis)19
&&
615
19
                   NextToken().isOneOf(tok::greater, tok::greatergreater,
616
4
                                       tok::greatergreatergreater,
617
53.5k
                                       tok::comma)))))) {
618
53.5k
      TPR = TPResult::True;
619
53.5k
      isAmbiguous = true;
620
621
53.5k
    } else
622
248
      TPR = TPResult::False;
623
57.2k
  }
624
625
58.3k
  assert(TPR == TPResult::True || TPR == TPResult::False);
626
0
  return TPR == TPResult::True;
627
5.96M
}
628
629
/// Returns true if this is a C++11 attribute-specifier. Per
630
/// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
631
/// always introduce an attribute. In Objective-C++11, this rule does not
632
/// apply if either '[' begins a message-send.
633
///
634
/// If Disambiguate is true, we try harder to determine whether a '[[' starts
635
/// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
636
///
637
/// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
638
/// Obj-C message send or the start of an attribute. Otherwise, we assume it
639
/// is not an Obj-C message send.
640
///
641
/// C++11 [dcl.attr.grammar]:
642
///
643
///     attribute-specifier:
644
///         '[' '[' attribute-list ']' ']'
645
///         alignment-specifier
646
///
647
///     attribute-list:
648
///         attribute[opt]
649
///         attribute-list ',' attribute[opt]
650
///         attribute '...'
651
///         attribute-list ',' attribute '...'
652
///
653
///     attribute:
654
///         attribute-token attribute-argument-clause[opt]
655
///
656
///     attribute-token:
657
///         identifier
658
///         identifier '::' identifier
659
///
660
///     attribute-argument-clause:
661
///         '(' balanced-token-seq ')'
662
Parser::CXX11AttributeKind
663
Parser::isCXX11AttributeSpecifier(bool Disambiguate,
664
99.8M
                                  bool OuterMightBeMessageSend) {
665
99.8M
  if (Tok.is(tok::kw_alignas))
666
16.5k
    return CAK_AttributeSpecifier;
667
668
99.8M
  if (Tok.isNot(tok::l_square) || 
NextToken().isNot(tok::l_square)147k
)
669
99.7M
    return CAK_NotAttributeSpecifier;
670
671
  // No tentative parsing if we don't need to look for ']]' or a lambda.
672
16.4k
  if (!Disambiguate && 
!getLangOpts().ObjC16.4k
)
673
16.0k
    return CAK_AttributeSpecifier;
674
675
  // '[[using ns: ...]]' is an attribute.
676
417
  if (GetLookAheadToken(2).is(tok::kw_using))
677
0
    return CAK_AttributeSpecifier;
678
679
417
  RevertingTentativeParsingAction PA(*this);
680
681
  // Opening brackets were checked for above.
682
417
  ConsumeBracket();
683
684
417
  if (!getLangOpts().ObjC) {
685
8
    ConsumeBracket();
686
687
8
    bool IsAttribute = SkipUntil(tok::r_square);
688
8
    IsAttribute &= Tok.is(tok::r_square);
689
690
8
    return IsAttribute ? 
CAK_AttributeSpecifier4
:
CAK_InvalidAttributeSpecifier4
;
691
8
  }
692
693
  // In Obj-C++11, we need to distinguish four situations:
694
  //  1a) int x[[attr]];                     C++11 attribute.
695
  //  1b) [[attr]];                          C++11 statement attribute.
696
  //   2) int x[[obj](){ return 1; }()];     Lambda in array size/index.
697
  //  3a) int x[[obj get]];                  Message send in array size/index.
698
  //  3b) [[Class alloc] init];              Message send in message send.
699
  //   4) [[obj]{ return self; }() doStuff]; Lambda in message send.
700
  // (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
701
702
  // Check to see if this is a lambda-expression.
703
  // FIXME: If this disambiguation is too slow, fold the tentative lambda parse
704
  // into the tentative attribute parse below.
705
409
  {
706
409
    RevertingTentativeParsingAction LambdaTPA(*this);
707
409
    LambdaIntroducer Intro;
708
409
    LambdaIntroducerTentativeParse Tentative;
709
409
    if (ParseLambdaIntroducer(Intro, &Tentative)) {
710
      // We hit a hard error after deciding this was not an attribute.
711
      // FIXME: Don't parse and annotate expressions when disambiguating
712
      // against an attribute.
713
0
      return CAK_NotAttributeSpecifier;
714
0
    }
715
716
409
    switch (Tentative) {
717
32
    case LambdaIntroducerTentativeParse::MessageSend:
718
      // Case 3: The inner construct is definitely a message send, so the
719
      // outer construct is definitely not an attribute.
720
32
      return CAK_NotAttributeSpecifier;
721
722
283
    case LambdaIntroducerTentativeParse::Success:
723
284
    case LambdaIntroducerTentativeParse::Incomplete:
724
      // This is a lambda-introducer or attribute-specifier.
725
284
      if (Tok.is(tok::r_square))
726
        // Case 1: C++11 attribute.
727
277
        return CAK_AttributeSpecifier;
728
729
7
      if (OuterMightBeMessageSend)
730
        // Case 4: Lambda in message send.
731
5
        return CAK_NotAttributeSpecifier;
732
733
      // Case 2: Lambda in array size / index.
734
2
      return CAK_InvalidAttributeSpecifier;
735
736
93
    case LambdaIntroducerTentativeParse::Invalid:
737
      // No idea what this is; we couldn't parse it as a lambda-introducer.
738
      // Might still be an attribute-specifier or a message send.
739
93
      break;
740
409
    }
741
409
  }
742
743
93
  ConsumeBracket();
744
745
  // If we don't have a lambda-introducer, then we have an attribute or a
746
  // message-send.
747
93
  bool IsAttribute = true;
748
97
  while (Tok.isNot(tok::r_square)) {
749
97
    if (Tok.is(tok::comma)) {
750
      // Case 1: Stray commas can only occur in attributes.
751
1
      return CAK_AttributeSpecifier;
752
1
    }
753
754
    // Parse the attribute-token, if present.
755
    // C++11 [dcl.attr.grammar]:
756
    //   If a keyword or an alternative token that satisfies the syntactic
757
    //   requirements of an identifier is contained in an attribute-token,
758
    //   it is considered an identifier.
759
96
    SourceLocation Loc;
760
96
    if (!TryParseCXX11AttributeIdentifier(Loc)) {
761
10
      IsAttribute = false;
762
10
      break;
763
10
    }
764
86
    if (Tok.is(tok::coloncolon)) {
765
74
      ConsumeToken();
766
74
      if (!TryParseCXX11AttributeIdentifier(Loc)) {
767
0
        IsAttribute = false;
768
0
        break;
769
0
      }
770
74
    }
771
772
    // Parse the attribute-argument-clause, if present.
773
86
    if (Tok.is(tok::l_paren)) {
774
15
      ConsumeParen();
775
15
      if (!SkipUntil(tok::r_paren)) {
776
0
        IsAttribute = false;
777
0
        break;
778
0
      }
779
15
    }
780
781
86
    TryConsumeToken(tok::ellipsis);
782
783
86
    if (!TryConsumeToken(tok::comma))
784
82
      break;
785
86
  }
786
787
  // An attribute must end ']]'.
788
92
  if (IsAttribute) {
789
82
    if (Tok.is(tok::r_square)) {
790
75
      ConsumeBracket();
791
75
      IsAttribute = Tok.is(tok::r_square);
792
75
    } else {
793
7
      IsAttribute = false;
794
7
    }
795
82
  }
796
797
92
  if (IsAttribute)
798
    // Case 1: C++11 statement attribute.
799
75
    return CAK_AttributeSpecifier;
800
801
  // Case 3: Message send.
802
17
  return CAK_NotAttributeSpecifier;
803
92
}
804
805
60.8k
bool Parser::TrySkipAttributes() {
806
60.9k
  while (Tok.isOneOf(tok::l_square, tok::kw___attribute, tok::kw___declspec,
807
60.9k
                     tok::kw_alignas)) {
808
48
    if (Tok.is(tok::l_square)) {
809
8
      ConsumeBracket();
810
8
      if (Tok.isNot(tok::l_square))
811
1
        return false;
812
7
      ConsumeBracket();
813
7
      if (!SkipUntil(tok::r_square) || Tok.isNot(tok::r_square))
814
0
        return false;
815
      // Note that explicitly checking for `[[` and `]]` allows to fail as
816
      // expected in the case of the Objective-C message send syntax.
817
7
      ConsumeBracket();
818
40
    } else {
819
40
      ConsumeToken();
820
40
      if (Tok.isNot(tok::l_paren))
821
0
        return false;
822
40
      ConsumeParen();
823
40
      if (!SkipUntil(tok::r_paren))
824
0
        return false;
825
40
    }
826
48
  }
827
828
60.8k
  return true;
829
60.8k
}
830
831
137k
Parser::TPResult Parser::TryParsePtrOperatorSeq() {
832
198k
  while (true) {
833
198k
    if (TryAnnotateOptionalCXXScopeToken(true))
834
0
      return TPResult::Error;
835
836
198k
    if (Tok.isOneOf(tok::star, tok::amp, tok::caret, tok::ampamp) ||
837
198k
        
(158k
Tok.is(tok::annot_cxxscope)158k
&&
NextToken().is(tok::star)23.7k
)) {
838
      // ptr-operator
839
60.8k
      ConsumeAnyToken();
840
841
      // Skip attributes.
842
60.8k
      if (!TrySkipAttributes())
843
1
        return TPResult::Error;
844
845
63.5k
      
while (60.8k
Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict,
846
63.5k
                         tok::kw__Nonnull, tok::kw__Nullable,
847
63.5k
                         tok::kw__Nullable_result, tok::kw__Null_unspecified,
848
63.5k
                         tok::kw__Atomic))
849
2.62k
        ConsumeToken();
850
137k
    } else {
851
137k
      return TPResult::True;
852
137k
    }
853
198k
  }
854
137k
}
855
856
///         operator-function-id:
857
///           'operator' operator
858
///
859
///         operator: one of
860
///           new  delete  new[]  delete[]  +  -  *  /  %  ^  [...]
861
///
862
///         conversion-function-id:
863
///           'operator' conversion-type-id
864
///
865
///         conversion-type-id:
866
///           type-specifier-seq conversion-declarator[opt]
867
///
868
///         conversion-declarator:
869
///           ptr-operator conversion-declarator[opt]
870
///
871
///         literal-operator-id:
872
///           'operator' string-literal identifier
873
///           'operator' user-defined-string-literal
874
16
Parser::TPResult Parser::TryParseOperatorId() {
875
16
  assert(Tok.is(tok::kw_operator));
876
0
  ConsumeToken();
877
878
  // Maybe this is an operator-function-id.
879
16
  switch (Tok.getKind()) {
880
0
  case tok::kw_new: case tok::kw_delete:
881
0
    ConsumeToken();
882
0
    if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
883
0
      ConsumeBracket();
884
0
      ConsumeBracket();
885
0
    }
886
0
    return TPResult::True;
887
888
0
#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemOnly) \
889
312
  case tok::Token:
890
0
#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemOnly)
891
16
#include 
"clang/Basic/OperatorKinds.def"0
892
16
    ConsumeToken();
893
16
    return TPResult::True;
894
895
0
  case tok::l_square:
896
0
    if (NextToken().is(tok::r_square)) {
897
0
      ConsumeBracket();
898
0
      ConsumeBracket();
899
0
      return TPResult::True;
900
0
    }
901
0
    break;
902
903
0
  case tok::l_paren:
904
0
    if (NextToken().is(tok::r_paren)) {
905
0
      ConsumeParen();
906
0
      ConsumeParen();
907
0
      return TPResult::True;
908
0
    }
909
0
    break;
910
911
0
  default:
912
0
    break;
913
16
  }
914
915
  // Maybe this is a literal-operator-id.
916
0
  if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
917
0
    bool FoundUDSuffix = false;
918
0
    do {
919
0
      FoundUDSuffix |= Tok.hasUDSuffix();
920
0
      ConsumeStringToken();
921
0
    } while (isTokenStringLiteral());
922
923
0
    if (!FoundUDSuffix) {
924
0
      if (Tok.is(tok::identifier))
925
0
        ConsumeToken();
926
0
      else
927
0
        return TPResult::Error;
928
0
    }
929
0
    return TPResult::True;
930
0
  }
931
932
  // Maybe this is a conversion-function-id.
933
0
  bool AnyDeclSpecifiers = false;
934
0
  while (true) {
935
0
    TPResult TPR = isCXXDeclarationSpecifier();
936
0
    if (TPR == TPResult::Error)
937
0
      return TPR;
938
0
    if (TPR == TPResult::False) {
939
0
      if (!AnyDeclSpecifiers)
940
0
        return TPResult::Error;
941
0
      break;
942
0
    }
943
0
    if (TryConsumeDeclarationSpecifier() == TPResult::Error)
944
0
      return TPResult::Error;
945
0
    AnyDeclSpecifiers = true;
946
0
  }
947
0
  return TryParsePtrOperatorSeq();
948
0
}
949
950
///         declarator:
951
///           direct-declarator
952
///           ptr-operator declarator
953
///
954
///         direct-declarator:
955
///           declarator-id
956
///           direct-declarator '(' parameter-declaration-clause ')'
957
///                 cv-qualifier-seq[opt] exception-specification[opt]
958
///           direct-declarator '[' constant-expression[opt] ']'
959
///           '(' declarator ')'
960
/// [GNU]     '(' attributes declarator ')'
961
///
962
///         abstract-declarator:
963
///           ptr-operator abstract-declarator[opt]
964
///           direct-abstract-declarator
965
///
966
///         direct-abstract-declarator:
967
///           direct-abstract-declarator[opt]
968
///                 '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
969
///                 exception-specification[opt]
970
///           direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
971
///           '(' abstract-declarator ')'
972
/// [C++0x]   ...
973
///
974
///         ptr-operator:
975
///           '*' cv-qualifier-seq[opt]
976
///           '&'
977
/// [C++0x]   '&&'                                                        [TODO]
978
///           '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
979
///
980
///         cv-qualifier-seq:
981
///           cv-qualifier cv-qualifier-seq[opt]
982
///
983
///         cv-qualifier:
984
///           'const'
985
///           'volatile'
986
///
987
///         declarator-id:
988
///           '...'[opt] id-expression
989
///
990
///         id-expression:
991
///           unqualified-id
992
///           qualified-id                                                [TODO]
993
///
994
///         unqualified-id:
995
///           identifier
996
///           operator-function-id
997
///           conversion-function-id
998
///           literal-operator-id
999
///           '~' class-name                                              [TODO]
1000
///           '~' decltype-specifier                                      [TODO]
1001
///           template-id                                                 [TODO]
1002
///
1003
Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
1004
                                            bool mayHaveIdentifier,
1005
137k
                                            bool mayHaveDirectInit) {
1006
  // declarator:
1007
  //   direct-declarator
1008
  //   ptr-operator declarator
1009
137k
  if (TryParsePtrOperatorSeq() == TPResult::Error)
1010
1
    return TPResult::Error;
1011
1012
  // direct-declarator:
1013
  // direct-abstract-declarator:
1014
137k
  if (Tok.is(tok::ellipsis))
1015
18
    ConsumeToken();
1016
1017
137k
  if ((Tok.isOneOf(tok::identifier, tok::kw_operator) ||
1018
137k
       
(122k
Tok.is(tok::annot_cxxscope)122k
&&
(3.14k
NextToken().is(tok::identifier)3.14k
||
1019
3.14k
                                        
NextToken().is(tok::kw_operator)418
))) &&
1020
137k
      
mayHaveIdentifier17.9k
) {
1021
    // declarator-id
1022
17.8k
    if (Tok.is(tok::annot_cxxscope)) {
1023
2.70k
      CXXScopeSpec SS;
1024
2.70k
      Actions.RestoreNestedNameSpecifierAnnotation(
1025
2.70k
          Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
1026
2.70k
      if (SS.isInvalid())
1027
1
        return TPResult::Error;
1028
2.70k
      ConsumeAnnotationToken();
1029
15.1k
    } else if (Tok.is(tok::identifier)) {
1030
15.1k
      TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
1031
15.1k
    }
1032
17.8k
    if (Tok.is(tok::kw_operator)) {
1033
16
      if (TryParseOperatorId() == TPResult::Error)
1034
0
        return TPResult::Error;
1035
16
    } else
1036
17.8k
      ConsumeToken();
1037
119k
  } else if (Tok.is(tok::l_paren)) {
1038
84.0k
    ConsumeParen();
1039
84.0k
    if (mayBeAbstract &&
1040
84.0k
        
(70.1k
Tok.is(tok::r_paren)70.1k
|| // 'int()' is a function.
1041
         // 'int(...)' is a function.
1042
70.1k
         
(67.8k
Tok.is(tok::ellipsis)67.8k
&&
NextToken().is(tok::r_paren)5
) ||
1043
70.1k
         
isDeclarationSpecifier()67.8k
)) { // 'int(int)' is a function.
1044
      // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1045
      //        exception-specification[opt]
1046
30.7k
      TPResult TPR = TryParseFunctionDeclarator();
1047
30.7k
      if (TPR != TPResult::Ambiguous)
1048
1
        return TPR;
1049
53.2k
    } else {
1050
      // '(' declarator ')'
1051
      // '(' attributes declarator ')'
1052
      // '(' abstract-declarator ')'
1053
53.2k
      if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec, tok::kw___cdecl,
1054
53.2k
                      tok::kw___stdcall, tok::kw___fastcall, tok::kw___thiscall,
1055
53.2k
                      tok::kw___regcall, tok::kw___vectorcall))
1056
3
        return TPResult::True; // attributes indicate declaration
1057
53.2k
      TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
1058
53.2k
      if (TPR != TPResult::Ambiguous)
1059
4.42k
        return TPR;
1060
48.8k
      if (Tok.isNot(tok::r_paren))
1061
5.68k
        return TPResult::False;
1062
43.1k
      ConsumeParen();
1063
43.1k
    }
1064
84.0k
  } else 
if (35.7k
!mayBeAbstract35.7k
) {
1065
4.63k
    return TPResult::False;
1066
4.63k
  }
1067
1068
122k
  if (mayHaveDirectInit)
1069
59
    return TPResult::Ambiguous;
1070
1071
162k
  
while (122k
true) {
1072
162k
    TPResult TPR(TPResult::Ambiguous);
1073
1074
162k
    if (Tok.is(tok::l_paren)) {
1075
      // Check whether we have a function declarator or a possible ctor-style
1076
      // initializer that follows the declarator. Note that ctor-style
1077
      // initializers are not possible in contexts where abstract declarators
1078
      // are allowed.
1079
36.4k
      if (!mayBeAbstract && 
!isCXXFunctionDeclarator()4.26k
)
1080
2.68k
        break;
1081
1082
      // direct-declarator '(' parameter-declaration-clause ')'
1083
      //        cv-qualifier-seq[opt] exception-specification[opt]
1084
33.7k
      ConsumeParen();
1085
33.7k
      TPR = TryParseFunctionDeclarator();
1086
126k
    } else if (Tok.is(tok::l_square)) {
1087
      // direct-declarator '[' constant-expression[opt] ']'
1088
      // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
1089
6.24k
      TPR = TryParseBracketDeclarator();
1090
120k
    } else if (Tok.is(tok::kw_requires)) {
1091
      // declarator requires-clause
1092
      // A requires clause indicates a function declaration.
1093
3
      TPR = TPResult::True;
1094
120k
    } else {
1095
120k
      break;
1096
120k
    }
1097
1098
39.9k
    if (TPR != TPResult::Ambiguous)
1099
7
      return TPR;
1100
39.9k
  }
1101
1102
122k
  return TPResult::Ambiguous;
1103
122k
}
1104
1105
14.6M
bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
1106
14.6M
  return llvm::is_contained(TentativelyDeclaredIdentifiers, II);
1107
14.6M
}
1108
1109
namespace {
1110
class TentativeParseCCC final : public CorrectionCandidateCallback {
1111
public:
1112
12.2M
  TentativeParseCCC(const Token &Next) {
1113
12.2M
    WantRemainingKeywords = false;
1114
12.2M
    WantTypeSpecifiers =
1115
12.2M
        Next.isOneOf(tok::l_paren, tok::r_paren, tok::greater, tok::l_brace,
1116
12.2M
                     tok::identifier, tok::comma);
1117
12.2M
  }
1118
1119
180
  bool ValidateCandidate(const TypoCorrection &Candidate) override {
1120
    // Reject any candidate that only resolves to instance members since they
1121
    // aren't viable as standalone identifiers instead of member references.
1122
180
    if (Candidate.isResolved() && !Candidate.isKeyword() &&
1123
180
        llvm::all_of(Candidate,
1124
157
                     [](NamedDecl *ND) { return ND->isCXXInstanceMember(); }))
1125
4
      return false;
1126
1127
176
    return CorrectionCandidateCallback::ValidateCandidate(Candidate);
1128
180
  }
1129
1130
209
  std::unique_ptr<CorrectionCandidateCallback> clone() override {
1131
209
    return std::make_unique<TentativeParseCCC>(*this);
1132
209
  }
1133
};
1134
}
1135
/// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
1136
/// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
1137
/// be either a decl-specifier or a function-style cast, and TPResult::Error
1138
/// if a parsing error was found and reported.
1139
///
1140
/// If InvalidAsDeclSpec is not null, some cases that would be ill-formed as
1141
/// declaration specifiers but possibly valid as some other kind of construct
1142
/// return TPResult::Ambiguous instead of TPResult::False. When this happens,
1143
/// the intent is to keep trying to disambiguate, on the basis that we might
1144
/// find a better reason to treat this construct as a declaration later on.
1145
/// When this happens and the name could possibly be valid in some other
1146
/// syntactic context, *InvalidAsDeclSpec is set to 'true'. The current cases
1147
/// that trigger this are:
1148
///
1149
///   * When parsing X::Y (with no 'typename') where X is dependent
1150
///   * When parsing X<Y> where X is undeclared
1151
///
1152
///         decl-specifier:
1153
///           storage-class-specifier
1154
///           type-specifier
1155
///           function-specifier
1156
///           'friend'
1157
///           'typedef'
1158
/// [C++11]   'constexpr'
1159
/// [C++20]   'consteval'
1160
/// [GNU]     attributes declaration-specifiers[opt]
1161
///
1162
///         storage-class-specifier:
1163
///           'register'
1164
///           'static'
1165
///           'extern'
1166
///           'mutable'
1167
///           'auto'
1168
/// [GNU]     '__thread'
1169
/// [C++11]   'thread_local'
1170
/// [C11]     '_Thread_local'
1171
///
1172
///         function-specifier:
1173
///           'inline'
1174
///           'virtual'
1175
///           'explicit'
1176
///
1177
///         typedef-name:
1178
///           identifier
1179
///
1180
///         type-specifier:
1181
///           simple-type-specifier
1182
///           class-specifier
1183
///           enum-specifier
1184
///           elaborated-type-specifier
1185
///           typename-specifier
1186
///           cv-qualifier
1187
///
1188
///         simple-type-specifier:
1189
///           '::'[opt] nested-name-specifier[opt] type-name
1190
///           '::'[opt] nested-name-specifier 'template'
1191
///                 simple-template-id                              [TODO]
1192
///           'char'
1193
///           'wchar_t'
1194
///           'bool'
1195
///           'short'
1196
///           'int'
1197
///           'long'
1198
///           'signed'
1199
///           'unsigned'
1200
///           'float'
1201
///           'double'
1202
///           'void'
1203
/// [GNU]     typeof-specifier
1204
/// [GNU]     '_Complex'
1205
/// [C++11]   'auto'
1206
/// [GNU]     '__auto_type'
1207
/// [C++11]   'decltype' ( expression )
1208
/// [C++1y]   'decltype' ( 'auto' )
1209
///
1210
///         type-name:
1211
///           class-name
1212
///           enum-name
1213
///           typedef-name
1214
///
1215
///         elaborated-type-specifier:
1216
///           class-key '::'[opt] nested-name-specifier[opt] identifier
1217
///           class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
1218
///               simple-template-id
1219
///           'enum' '::'[opt] nested-name-specifier[opt] identifier
1220
///
1221
///         enum-name:
1222
///           identifier
1223
///
1224
///         enum-specifier:
1225
///           'enum' identifier[opt] '{' enumerator-list[opt] '}'
1226
///           'enum' identifier[opt] '{' enumerator-list ',' '}'
1227
///
1228
///         class-specifier:
1229
///           class-head '{' member-specification[opt] '}'
1230
///
1231
///         class-head:
1232
///           class-key identifier[opt] base-clause[opt]
1233
///           class-key nested-name-specifier identifier base-clause[opt]
1234
///           class-key nested-name-specifier[opt] simple-template-id
1235
///               base-clause[opt]
1236
///
1237
///         class-key:
1238
///           'class'
1239
///           'struct'
1240
///           'union'
1241
///
1242
///         cv-qualifier:
1243
///           'const'
1244
///           'volatile'
1245
/// [GNU]     restrict
1246
///
1247
Parser::TPResult
1248
Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
1249
31.7M
                                  bool *InvalidAsDeclSpec) {
1250
31.7M
  auto IsPlaceholderSpecifier = [&] (TemplateIdAnnotation *TemplateId,
1251
31.7M
                                     int Lookahead) {
1252
    // We have a placeholder-constraint (we check for 'auto' or 'decltype' to
1253
    // distinguish 'C<int>;' from 'C<int> auto c = 1;')
1254
40.0k
    return TemplateId->Kind == TNK_Concept_template &&
1255
40.0k
        GetLookAheadToken(Lookahead + 1).isOneOf(tok::kw_auto, tok::kw_decltype,
1256
            // If we have an identifier here, the user probably forgot the
1257
            // 'auto' in the placeholder constraint, e.g. 'C<int> x = 2;'
1258
            // This will be diagnosed nicely later, so disambiguate as a
1259
            // declaration.
1260
69
            tok::identifier);
1261
40.0k
  };
1262
31.7M
  switch (Tok.getKind()) {
1263
13.7M
  case tok::identifier: {
1264
    // Check for need to substitute AltiVec __vector keyword
1265
    // for "vector" identifier.
1266
13.7M
    if (TryAltiVecVectorToken())
1267
44.9k
      return TPResult::True;
1268
1269
13.6M
    const Token &Next = NextToken();
1270
    // In 'foo bar', 'foo' is always a type name outside of Objective-C.
1271
13.6M
    if (!getLangOpts().ObjC && 
Next.is(tok::identifier)13.1M
)
1272
514k
      return TPResult::True;
1273
1274
13.1M
    if (Next.isNot(tok::coloncolon) && 
Next.isNot(tok::less)12.8M
) {
1275
      // Determine whether this is a valid expression. If not, we will hit
1276
      // a parse error one way or another. In that case, tell the caller that
1277
      // this is ambiguous. Typo-correct to type and expression keywords and
1278
      // to types and identifiers, in order to try to recover from errors.
1279
12.2M
      TentativeParseCCC CCC(Next);
1280
12.2M
      switch (TryAnnotateName(&CCC)) {
1281
104
      case ANK_Error:
1282
104
        return TPResult::Error;
1283
25
      case ANK_TentativeDecl:
1284
25
        return TPResult::False;
1285
9.53k
      case ANK_TemplateName:
1286
        // In C++17, this could be a type template for class template argument
1287
        // deduction. Try to form a type annotation for it. If we're in a
1288
        // template template argument, we'll undo this when checking the
1289
        // validity of the argument.
1290
9.53k
        if (getLangOpts().CPlusPlus17) {
1291
419
          if (TryAnnotateTypeOrScopeToken())
1292
0
            return TPResult::Error;
1293
419
          if (Tok.isNot(tok::identifier))
1294
419
            break;
1295
419
        }
1296
1297
        // A bare type template-name which can't be a template template
1298
        // argument is an error, and was probably intended to be a type.
1299
9.11k
        return GreaterThanIsOperator ? 
TPResult::True6
:
TPResult::False9.10k
;
1300
405
      case ANK_Unresolved:
1301
405
        return InvalidAsDeclSpec ? 
TPResult::Ambiguous274
:
TPResult::False131
;
1302
12.2M
      case ANK_Success:
1303
12.2M
        break;
1304
12.2M
      }
1305
12.2M
      assert(Tok.isNot(tok::identifier) &&
1306
12.2M
             "TryAnnotateName succeeded without producing an annotation");
1307
12.2M
    } else {
1308
      // This might possibly be a type with a dependent scope specifier and
1309
      // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1310
      // since it will annotate as a primary expression, and we want to use the
1311
      // "missing 'typename'" logic.
1312
891k
      if (TryAnnotateTypeOrScopeToken())
1313
29
        return TPResult::Error;
1314
      // If annotation failed, assume it's a non-type.
1315
      // FIXME: If this happens due to an undeclared identifier, treat it as
1316
      // ambiguous.
1317
891k
      if (Tok.is(tok::identifier))
1318
153k
        return TPResult::False;
1319
891k
    }
1320
1321
    // We annotated this token as something. Recurse to handle whatever we got.
1322
12.9M
    return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1323
13.1M
  }
1324
1325
154k
  case tok::kw_typename:  // typename T::type
1326
    // Annotate typenames and C++ scope specifiers.  If we get one, just
1327
    // recurse to handle whatever we get.
1328
154k
    if (TryAnnotateTypeOrScopeToken())
1329
12
      return TPResult::Error;
1330
154k
    return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1331
1332
18.3k
  case tok::coloncolon: {    // ::foo::bar
1333
18.3k
    const Token &Next = NextToken();
1334
18.3k
    if (Next.isOneOf(tok::kw_new,       // ::new
1335
18.3k
                     tok::kw_delete))   // ::delete
1336
16.5k
      return TPResult::False;
1337
18.3k
    
LLVM_FALLTHROUGH1.80k
;
1338
1.80k
  }
1339
1.82k
  case tok::kw___super:
1340
13.8k
  case tok::kw_decltype:
1341
    // Annotate typenames and C++ scope specifiers.  If we get one, just
1342
    // recurse to handle whatever we get.
1343
13.8k
    if (TryAnnotateTypeOrScopeToken())
1344
2
      return TPResult::Error;
1345
13.8k
    return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1346
1347
    // decl-specifier:
1348
    //   storage-class-specifier
1349
    //   type-specifier
1350
    //   function-specifier
1351
    //   'friend'
1352
    //   'typedef'
1353
    //   'constexpr'
1354
4
  case tok::kw_friend:
1355
119k
  case tok::kw_typedef:
1356
120k
  case tok::kw_constexpr:
1357
120k
  case tok::kw_consteval:
1358
120k
  case tok::kw_constinit:
1359
    // storage-class-specifier
1360
120k
  case tok::kw_register:
1361
128k
  case tok::kw_static:
1362
129k
  case tok::kw_extern:
1363
129k
  case tok::kw_mutable:
1364
139k
  case tok::kw_auto:
1365
139k
  case tok::kw___thread:
1366
139k
  case tok::kw_thread_local:
1367
139k
  case tok::kw__Thread_local:
1368
    // function-specifier
1369
139k
  case tok::kw_inline:
1370
139k
  case tok::kw_virtual:
1371
139k
  case tok::kw_explicit:
1372
1373
    // Modules
1374
139k
  case tok::kw___module_private__:
1375
1376
    // Debugger support
1377
139k
  case tok::kw___unknown_anytype:
1378
1379
    // type-specifier:
1380
    //   simple-type-specifier
1381
    //   class-specifier
1382
    //   enum-specifier
1383
    //   elaborated-type-specifier
1384
    //   typename-specifier
1385
    //   cv-qualifier
1386
1387
    // class-specifier
1388
    // elaborated-type-specifier
1389
140k
  case tok::kw_class:
1390
159k
  case tok::kw_struct:
1391
164k
  case tok::kw_union:
1392
164k
  case tok::kw___interface:
1393
    // enum-specifier
1394
171k
  case tok::kw_enum:
1395
    // cv-qualifier
1396
562k
  case tok::kw_const:
1397
592k
  case tok::kw_volatile:
1398
592k
    return TPResult::True;
1399
1400
    // OpenCL address space qualifiers
1401
15
  case tok::kw_private:
1402
15
    if (!getLangOpts().OpenCL)
1403
1
      return TPResult::False;
1404
15
    
LLVM_FALLTHROUGH14
;14
1405
98
  case tok::kw___private:
1406
470
  case tok::kw___local:
1407
994
  case tok::kw___global:
1408
1.17k
  case tok::kw___constant:
1409
1.27k
  case tok::kw___generic:
1410
    // OpenCL access qualifiers
1411
1.75k
  case tok::kw___read_only:
1412
2.02k
  case tok::kw___write_only:
1413
2.44k
  case tok::kw___read_write:
1414
    // OpenCL pipe
1415
2.45k
  case tok::kw_pipe:
1416
1417
    // GNU
1418
2.46k
  case tok::kw_restrict:
1419
2.55k
  case tok::kw__Complex:
1420
3.07k
  case tok::kw___attribute:
1421
3.08k
  case tok::kw___auto_type:
1422
3.08k
    return TPResult::True;
1423
1424
    // Microsoft
1425
85
  case tok::kw___declspec:
1426
87
  case tok::kw___cdecl:
1427
92
  case tok::kw___stdcall:
1428
94
  case tok::kw___fastcall:
1429
94
  case tok::kw___thiscall:
1430
94
  case tok::kw___regcall:
1431
94
  case tok::kw___vectorcall:
1432
94
  case tok::kw___w64:
1433
94
  case tok::kw___sptr:
1434
94
  case tok::kw___uptr:
1435
94
  case tok::kw___ptr64:
1436
94
  case tok::kw___ptr32:
1437
94
  case tok::kw___forceinline:
1438
132
  case tok::kw___unaligned:
1439
173
  case tok::kw__Nonnull:
1440
426
  case tok::kw__Nullable:
1441
426
  case tok::kw__Nullable_result:
1442
427
  case tok::kw__Null_unspecified:
1443
433
  case tok::kw___kindof:
1444
433
    return TPResult::True;
1445
1446
    // Borland
1447
4
  case tok::kw___pascal:
1448
4
    return TPResult::True;
1449
1450
    // AltiVec
1451
73
  case tok::kw___vector:
1452
73
    return TPResult::True;
1453
1454
10.3k
  case tok::annot_template_id: {
1455
10.3k
    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1456
    // If lookup for the template-name found nothing, don't assume we have a
1457
    // definitive disambiguation result yet.
1458
10.3k
    if ((TemplateId->hasInvalidName() ||
1459
10.3k
         TemplateId->Kind == TNK_Undeclared_template) &&
1460
10.3k
        
InvalidAsDeclSpec50
) {
1461
      // 'template-id(' can be a valid expression but not a valid decl spec if
1462
      // the template-name is not declared, but we don't consider this to be a
1463
      // definitive disambiguation. In any other context, it's an error either
1464
      // way.
1465
37
      *InvalidAsDeclSpec = NextToken().is(tok::l_paren);
1466
37
      return TPResult::Ambiguous;
1467
37
    }
1468
10.3k
    if (TemplateId->hasInvalidName())
1469
0
      return TPResult::Error;
1470
10.3k
    if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/0))
1471
56
      return TPResult::True;
1472
10.3k
    if (TemplateId->Kind != TNK_Type_template)
1473
10.2k
      return TPResult::False;
1474
3
    CXXScopeSpec SS;
1475
3
    AnnotateTemplateIdTokenAsType(SS);
1476
3
    assert(Tok.is(tok::annot_typename));
1477
0
    goto case_typename;
1478
10.3k
  }
1479
1480
410k
  case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1481
    // We've already annotated a scope; try to annotate a type.
1482
410k
    if (TryAnnotateTypeOrScopeToken())
1483
0
      return TPResult::Error;
1484
410k
    if (!Tok.is(tok::annot_typename)) {
1485
410k
      if (Tok.is(tok::annot_cxxscope) &&
1486
410k
          NextToken().is(tok::annot_template_id)) {
1487
29.7k
        TemplateIdAnnotation *TemplateId =
1488
29.7k
            takeTemplateIdAnnotation(NextToken());
1489
29.7k
        if (TemplateId->hasInvalidName()) {
1490
6
          if (InvalidAsDeclSpec) {
1491
1
            *InvalidAsDeclSpec = NextToken().is(tok::l_paren);
1492
1
            return TPResult::Ambiguous;
1493
1
          }
1494
5
          return TPResult::Error;
1495
6
        }
1496
29.7k
        if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/1))
1497
4
          return TPResult::True;
1498
29.7k
      }
1499
      // If the next token is an identifier or a type qualifier, then this
1500
      // can't possibly be a valid expression either.
1501
410k
      if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1502
366k
        CXXScopeSpec SS;
1503
366k
        Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1504
366k
                                                     Tok.getAnnotationRange(),
1505
366k
                                                     SS);
1506
366k
        if (SS.getScopeRep() && 
SS.getScopeRep()->isDependent()366k
) {
1507
280k
          RevertingTentativeParsingAction PA(*this);
1508
280k
          ConsumeAnnotationToken();
1509
280k
          ConsumeToken();
1510
280k
          bool isIdentifier = Tok.is(tok::identifier);
1511
280k
          TPResult TPR = TPResult::False;
1512
280k
          if (!isIdentifier)
1513
280k
            TPR = isCXXDeclarationSpecifier(BracedCastResult,
1514
280k
                                            InvalidAsDeclSpec);
1515
1516
280k
          if (isIdentifier ||
1517
280k
              
TPR == TPResult::True280k
||
TPR == TPResult::Error280k
)
1518
21
            return TPResult::Error;
1519
1520
280k
          if (InvalidAsDeclSpec) {
1521
            // We can't tell whether this is a missing 'typename' or a valid
1522
            // expression.
1523
38.8k
            *InvalidAsDeclSpec = true;
1524
38.8k
            return TPResult::Ambiguous;
1525
241k
          } else {
1526
            // In MS mode, if InvalidAsDeclSpec is not provided, and the tokens
1527
            // are or the form *) or &) *> or &> &&>, this can't be an expression.
1528
            // The typename must be missing.
1529
241k
            if (getLangOpts().MSVCCompat) {
1530
41
              if (((Tok.is(tok::amp) || 
Tok.is(tok::star)37
) &&
1531
41
                   
(6
NextToken().is(tok::r_paren)6
||
1532
6
                    
NextToken().is(tok::greater)5
)) ||
1533
41
                  
(39
Tok.is(tok::ampamp)39
&&
NextToken().is(tok::greater)0
))
1534
2
                return TPResult::True;
1535
41
            }
1536
241k
          }
1537
280k
        } else {
1538
          // Try to resolve the name. If it doesn't exist, assume it was
1539
          // intended to name a type and keep disambiguating.
1540
85.9k
          switch (TryAnnotateName()) {
1541
4
          case ANK_Error:
1542
4
            return TPResult::Error;
1543
0
          case ANK_TentativeDecl:
1544
0
            return TPResult::False;
1545
47
          case ANK_TemplateName:
1546
            // In C++17, this could be a type template for class template
1547
            // argument deduction.
1548
47
            if (getLangOpts().CPlusPlus17) {
1549
0
              if (TryAnnotateTypeOrScopeToken())
1550
0
                return TPResult::Error;
1551
0
              if (Tok.isNot(tok::identifier))
1552
0
                break;
1553
0
            }
1554
1555
            // A bare type template-name which can't be a template template
1556
            // argument is an error, and was probably intended to be a type.
1557
            // In C++17, this could be class template argument deduction.
1558
47
            return (getLangOpts().CPlusPlus17 || GreaterThanIsOperator)
1559
47
                       ? 
TPResult::True9
1560
47
                       : 
TPResult::False38
;
1561
235
          case ANK_Unresolved:
1562
235
            return InvalidAsDeclSpec ? 
TPResult::Ambiguous158
:
TPResult::False77
;
1563
85.6k
          case ANK_Success:
1564
85.6k
            break;
1565
85.9k
          }
1566
1567
          // Annotated it, check again.
1568
85.6k
          assert(Tok.isNot(tok::annot_cxxscope) ||
1569
85.6k
                 NextToken().isNot(tok::identifier));
1570
0
          return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1571
85.9k
        }
1572
366k
      }
1573
285k
      return TPResult::False;
1574
410k
    }
1575
    // If that succeeded, fallthrough into the generic simple-type-id case.
1576
410k
    
LLVM_FALLTHROUGH14
;14
1577
1578
    // The ambiguity resides in a simple-type-specifier/typename-specifier
1579
    // followed by a '('. The '(' could either be the start of:
1580
    //
1581
    //   direct-declarator:
1582
    //     '(' declarator ')'
1583
    //
1584
    //   direct-abstract-declarator:
1585
    //     '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1586
    //              exception-specification[opt]
1587
    //     '(' abstract-declarator ')'
1588
    //
1589
    // or part of a function-style cast expression:
1590
    //
1591
    //     simple-type-specifier '(' expression-list[opt] ')'
1592
    //
1593
1594
    // simple-type-specifier:
1595
1596
12.1M
  case tok::annot_typename:
1597
12.1M
  case_typename:
1598
    // In Objective-C, we might have a protocol-qualified type.
1599
12.1M
    if (getLangOpts().ObjC && 
NextToken().is(tok::less)362k
) {
1600
      // Tentatively parse the protocol qualifiers.
1601
0
      RevertingTentativeParsingAction PA(*this);
1602
0
      ConsumeAnyToken(); // The type token
1603
1604
0
      TPResult TPR = TryParseProtocolQualifiers();
1605
0
      bool isFollowedByParen = Tok.is(tok::l_paren);
1606
0
      bool isFollowedByBrace = Tok.is(tok::l_brace);
1607
1608
0
      if (TPR == TPResult::Error)
1609
0
        return TPResult::Error;
1610
1611
0
      if (isFollowedByParen)
1612
0
        return TPResult::Ambiguous;
1613
1614
0
      if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1615
0
        return BracedCastResult;
1616
1617
0
      return TPResult::True;
1618
0
    }
1619
12.1M
    LLVM_FALLTHROUGH;
1620
1621
12.2M
  case tok::kw_char:
1622
12.3M
  case tok::kw_wchar_t:
1623
12.3M
  case tok::kw_char8_t:
1624
12.3M
  case tok::kw_char16_t:
1625
12.3M
  case tok::kw_char32_t:
1626
12.4M
  case tok::kw_bool:
1627
12.4M
  case tok::kw_short:
1628
12.7M
  case tok::kw_int:
1629
12.8M
  case tok::kw_long:
1630
12.8M
  case tok::kw___int64:
1631
12.8M
  case tok::kw___int128:
1632
12.8M
  case tok::kw_signed:
1633
12.9M
  case tok::kw_unsigned:
1634
12.9M
  case tok::kw_half:
1635
13.0M
  case tok::kw_float:
1636
13.1M
  case tok::kw_double:
1637
13.1M
  case tok::kw___bf16:
1638
13.1M
  case tok::kw__Float16:
1639
13.1M
  case tok::kw___float128:
1640
13.1M
  case tok::kw___ibm128:
1641
13.3M
  case tok::kw_void:
1642
13.3M
  case tok::annot_decltype:
1643
160M
#define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1644
160M
#include 
"clang/Basic/OpenCLImageTypes.def"13.3M
1645
160M
    if (
NextToken().is(tok::l_paren)13.3M
)
1646
84.9k
      return TPResult::Ambiguous;
1647
1648
    // This is a function-style cast in all cases we disambiguate other than
1649
    // one:
1650
    //   struct S {
1651
    //     enum E : int { a = 4 }; // enum
1652
    //     enum E : int { 4 };     // bit-field
1653
    //   };
1654
13.3M
    if (getLangOpts().CPlusPlus11 && 
NextToken().is(tok::l_brace)13.2M
)
1655
1.07k
      return BracedCastResult;
1656
1657
13.3M
    if (isStartOfObjCClassMessageMissingOpenBracket())
1658
3
      return TPResult::False;
1659
1660
13.3M
    return TPResult::True;
1661
1662
  // GNU typeof support.
1663
730
  case tok::kw_typeof: {
1664
730
    if (NextToken().isNot(tok::l_paren))
1665
3
      return TPResult::True;
1666
1667
727
    RevertingTentativeParsingAction PA(*this);
1668
1669
727
    TPResult TPR = TryParseTypeofSpecifier();
1670
727
    bool isFollowedByParen = Tok.is(tok::l_paren);
1671
727
    bool isFollowedByBrace = Tok.is(tok::l_brace);
1672
1673
727
    if (TPR == TPResult::Error)
1674
0
      return TPResult::Error;
1675
1676
727
    if (isFollowedByParen)
1677
15
      return TPResult::Ambiguous;
1678
1679
712
    if (getLangOpts().CPlusPlus11 && 
isFollowedByBrace676
)
1680
0
      return BracedCastResult;
1681
1682
712
    return TPResult::True;
1683
712
  }
1684
1685
  // C++0x type traits support
1686
7
  case tok::kw___underlying_type:
1687
7
    return TPResult::True;
1688
1689
  // C11 _Atomic
1690
33
  case tok::kw__Atomic:
1691
33
    return TPResult::True;
1692
1693
199
  case tok::kw__BitInt:
1694
199
  case tok::kw__ExtInt: {
1695
199
    if (NextToken().isNot(tok::l_paren))
1696
0
      return TPResult::Error;
1697
199
    RevertingTentativeParsingAction PA(*this);
1698
199
    ConsumeToken();
1699
199
    ConsumeParen();
1700
1701
199
    if (!SkipUntil(tok::r_paren, StopAtSemi))
1702
0
      return TPResult::Error;
1703
1704
199
    if (Tok.is(tok::l_paren))
1705
0
      return TPResult::Ambiguous;
1706
1707
199
    if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
1708
0
      return BracedCastResult;
1709
1710
199
    return TPResult::True;
1711
199
  }
1712
3.46M
  default:
1713
3.46M
    return TPResult::False;
1714
31.7M
  }
1715
31.7M
}
1716
1717
11.8k
bool Parser::isCXXDeclarationSpecifierAType() {
1718
11.8k
  switch (Tok.getKind()) {
1719
    // typename-specifier
1720
0
  case tok::annot_decltype:
1721
6
  case tok::annot_template_id:
1722
7.60k
  case tok::annot_typename:
1723
7.60k
  case tok::kw_typeof:
1724
7.60k
  case tok::kw___underlying_type:
1725
7.60k
    return true;
1726
1727
    // elaborated-type-specifier
1728
0
  case tok::kw_class:
1729
2
  case tok::kw_struct:
1730
4
  case tok::kw_union:
1731
4
  case tok::kw___interface:
1732
5
  case tok::kw_enum:
1733
5
    return true;
1734
1735
    // simple-type-specifier
1736
37
  case tok::kw_char:
1737
37
  case tok::kw_wchar_t:
1738
37
  case tok::kw_char8_t:
1739
37
  case tok::kw_char16_t:
1740
37
  case tok::kw_char32_t:
1741
45
  case tok::kw_bool:
1742
49
  case tok::kw_short:
1743
485
  case tok::kw_int:
1744
485
  case tok::kw__ExtInt:
1745
485
  case tok::kw__BitInt:
1746
485
  case tok::kw_long:
1747
485
  case tok::kw___int64:
1748
485
  case tok::kw___int128:
1749
485
  case tok::kw_signed:
1750
490
  case tok::kw_unsigned:
1751
492
  case tok::kw_half:
1752
498
  case tok::kw_float:
1753
507
  case tok::kw_double:
1754
507
  case tok::kw___bf16:
1755
507
  case tok::kw__Float16:
1756
507
  case tok::kw___float128:
1757
507
  case tok::kw___ibm128:
1758
3.79k
  case tok::kw_void:
1759
3.79k
  case tok::kw___unknown_anytype:
1760
3.79k
  case tok::kw___auto_type:
1761
45.5k
#define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1762
3.79k
#include "clang/Basic/OpenCLImageTypes.def"
1763
3.79k
    return true;
1764
1765
0
  case tok::kw_auto:
1766
0
    return getLangOpts().CPlusPlus11;
1767
1768
0
  case tok::kw__Atomic:
1769
    // "_Atomic foo"
1770
0
    return NextToken().is(tok::l_paren);
1771
1772
406
  default:
1773
406
    return false;
1774
11.8k
  }
1775
11.8k
}
1776
1777
/// [GNU] typeof-specifier:
1778
///         'typeof' '(' expressions ')'
1779
///         'typeof' '(' type-name ')'
1780
///
1781
727
Parser::TPResult Parser::TryParseTypeofSpecifier() {
1782
727
  assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1783
0
  ConsumeToken();
1784
1785
727
  assert(Tok.is(tok::l_paren) && "Expected '('");
1786
  // Parse through the parens after 'typeof'.
1787
0
  ConsumeParen();
1788
727
  if (!SkipUntil(tok::r_paren, StopAtSemi))
1789
0
    return TPResult::Error;
1790
1791
727
  return TPResult::Ambiguous;
1792
727
}
1793
1794
/// [ObjC] protocol-qualifiers:
1795
////         '<' identifier-list '>'
1796
9
Parser::TPResult Parser::TryParseProtocolQualifiers() {
1797
9
  assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1798
0
  ConsumeToken();
1799
9
  do {
1800
9
    if (Tok.isNot(tok::identifier))
1801
3
      return TPResult::Error;
1802
6
    ConsumeToken();
1803
1804
6
    if (Tok.is(tok::comma)) {
1805
0
      ConsumeToken();
1806
0
      continue;
1807
0
    }
1808
1809
6
    if (Tok.is(tok::greater)) {
1810
0
      ConsumeToken();
1811
0
      return TPResult::Ambiguous;
1812
0
    }
1813
6
  } while (false);
1814
1815
6
  return TPResult::Error;
1816
9
}
1817
1818
/// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1819
/// a constructor-style initializer, when parsing declaration statements.
1820
/// Returns true for function declarator and false for constructor-style
1821
/// initializer.
1822
/// If during the disambiguation process a parsing error is encountered,
1823
/// the function returns true to let the declaration parsing code handle it.
1824
///
1825
/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1826
///         exception-specification[opt]
1827
///
1828
9.28M
bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1829
1830
  // C++ 8.2p1:
1831
  // The ambiguity arising from the similarity between a function-style cast and
1832
  // a declaration mentioned in 6.8 can also occur in the context of a
1833
  // declaration. In that context, the choice is between a function declaration
1834
  // with a redundant set of parentheses around a parameter name and an object
1835
  // declaration with a function-style cast as the initializer. Just as for the
1836
  // ambiguities mentioned in 6.8, the resolution is to consider any construct
1837
  // that could possibly be a declaration a declaration.
1838
1839
9.28M
  RevertingTentativeParsingAction PA(*this);
1840
1841
9.28M
  ConsumeParen();
1842
9.28M
  bool InvalidAsDeclaration = false;
1843
9.28M
  TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1844
9.28M
  if (TPR == TPResult::Ambiguous) {
1845
156k
    if (Tok.isNot(tok::r_paren))
1846
5
      TPR = TPResult::False;
1847
156k
    else {
1848
156k
      const Token &Next = NextToken();
1849
156k
      if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
1850
156k
                       tok::kw_throw, tok::kw_noexcept, tok::l_square,
1851
156k
                       tok::l_brace, tok::kw_try, tok::equal, tok::arrow) ||
1852
156k
          
isCXX11VirtSpecifier(Next)65.1k
)
1853
        // The next token cannot appear after a constructor-style initializer,
1854
        // and can appear next in a function definition. This must be a function
1855
        // declarator.
1856
91.5k
        TPR = TPResult::True;
1857
65.1k
      else if (InvalidAsDeclaration)
1858
        // Use the absence of 'typename' as a tie-breaker.
1859
53
        TPR = TPResult::False;
1860
156k
    }
1861
156k
  }
1862
1863
9.28M
  if (IsAmbiguous && 
TPR == TPResult::Ambiguous9.27M
)
1864
64.9k
    *IsAmbiguous = true;
1865
1866
  // In case of an error, let the declaration parsing code handle it.
1867
9.28M
  return TPR != TPResult::False;
1868
9.28M
}
1869
1870
/// parameter-declaration-clause:
1871
///   parameter-declaration-list[opt] '...'[opt]
1872
///   parameter-declaration-list ',' '...'
1873
///
1874
/// parameter-declaration-list:
1875
///   parameter-declaration
1876
///   parameter-declaration-list ',' parameter-declaration
1877
///
1878
/// parameter-declaration:
1879
///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1880
///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1881
///     '=' assignment-expression
1882
///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1883
///     attributes[opt]
1884
///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1885
///     attributes[opt] '=' assignment-expression
1886
///
1887
Parser::TPResult
1888
Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
1889
9.34M
                                           bool VersusTemplateArgument) {
1890
1891
9.34M
  if (Tok.is(tok::r_paren))
1892
155k
    return TPResult::Ambiguous;
1893
1894
  //   parameter-declaration-list[opt] '...'[opt]
1895
  //   parameter-declaration-list ',' '...'
1896
  //
1897
  // parameter-declaration-list:
1898
  //   parameter-declaration
1899
  //   parameter-declaration-list ',' parameter-declaration
1900
  //
1901
9.19M
  
while (9.18M
true) {
1902
    // '...'[opt]
1903
9.19M
    if (Tok.is(tok::ellipsis)) {
1904
1.84k
      ConsumeToken();
1905
1.84k
      if (Tok.is(tok::r_paren))
1906
1.84k
        return TPResult::True; // '...)' is a sign of a function declarator.
1907
0
      else
1908
0
        return TPResult::False;
1909
1.84k
    }
1910
1911
    // An attribute-specifier-seq here is a sign of a function declarator.
1912
9.18M
    if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1913
9.18M
                                  /*OuterMightBeMessageSend*/true))
1914
9
      return TPResult::True;
1915
1916
9.18M
    ParsedAttributes attrs(AttrFactory);
1917
9.18M
    MaybeParseMicrosoftAttributes(attrs);
1918
1919
    // decl-specifier-seq
1920
    // A parameter-declaration's initializer must be preceded by an '=', so
1921
    // decl-specifier-seq '{' is not a parameter in C++11.
1922
9.18M
    TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
1923
9.18M
                                             InvalidAsDeclaration);
1924
    // A declaration-specifier (not followed by '(' or '{') means this can't be
1925
    // an expression, but it could still be a template argument.
1926
9.18M
    if (TPR != TPResult::Ambiguous &&
1927
9.18M
        
!(9.17M
VersusTemplateArgument9.17M
&&
TPR == TPResult::True38
))
1928
9.17M
      return TPR;
1929
1930
11.8k
    bool SeenType = false;
1931
11.8k
    do {
1932
11.8k
      SeenType |= isCXXDeclarationSpecifierAType();
1933
11.8k
      if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1934
1
        return TPResult::Error;
1935
1936
      // If we see a parameter name, this can't be a template argument.
1937
11.8k
      if (SeenType && 
Tok.is(tok::identifier)11.4k
)
1938
11
        return TPResult::True;
1939
1940
11.8k
      TPR = isCXXDeclarationSpecifier(TPResult::False,
1941
11.8k
                                      InvalidAsDeclaration);
1942
11.8k
      if (TPR == TPResult::Error)
1943
0
        return TPR;
1944
1945
      // Two declaration-specifiers means this can't be an expression.
1946
11.8k
      if (TPR == TPResult::True && 
!VersusTemplateArgument5
)
1947
5
        return TPR;
1948
11.8k
    } while (
TPR != TPResult::False11.7k
);
1949
1950
    // declarator
1951
    // abstract-declarator[opt]
1952
11.7k
    TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1953
11.7k
    if (TPR != TPResult::Ambiguous)
1954
328
      return TPR;
1955
1956
    // [GNU] attributes[opt]
1957
11.4k
    if (Tok.is(tok::kw___attribute))
1958
1
      return TPResult::True;
1959
1960
    // If we're disambiguating a template argument in a default argument in
1961
    // a class definition versus a parameter declaration, an '=' here
1962
    // disambiguates the parse one way or the other.
1963
    // If this is a parameter, it must have a default argument because
1964
    //   (a) the previous parameter did, and
1965
    //   (b) this must be the first declaration of the function, so we can't
1966
    //       inherit any default arguments from elsewhere.
1967
    // FIXME: If we reach a ')' without consuming any '>'s, then this must
1968
    // also be a function parameter (that's missing its default argument).
1969
11.4k
    if (VersusTemplateArgument)
1970
30
      return Tok.is(tok::equal) ? 
TPResult::True3
:
TPResult::False27
;
1971
1972
11.4k
    if (Tok.is(tok::equal)) {
1973
      // '=' assignment-expression
1974
      // Parse through assignment-expression.
1975
9
      if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
1976
0
        return TPResult::Error;
1977
9
    }
1978
1979
11.4k
    if (Tok.is(tok::ellipsis)) {
1980
2
      ConsumeToken();
1981
2
      if (Tok.is(tok::r_paren))
1982
1
        return TPResult::True; // '...)' is a sign of a function declarator.
1983
1
      else
1984
1
        return TPResult::False;
1985
2
    }
1986
1987
11.4k
    if (!TryConsumeToken(tok::comma))
1988
9.34k
      break;
1989
11.4k
  }
1990
1991
9.34k
  return TPResult::Ambiguous;
1992
9.18M
}
1993
1994
/// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1995
/// parsing as a function declarator.
1996
/// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1997
/// return TPResult::Ambiguous, otherwise it will return either False() or
1998
/// Error().
1999
///
2000
/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
2001
///         exception-specification[opt]
2002
///
2003
/// exception-specification:
2004
///   'throw' '(' type-id-list[opt] ')'
2005
///
2006
64.4k
Parser::TPResult Parser::TryParseFunctionDeclarator() {
2007
  // The '(' is already parsed.
2008
2009
64.4k
  TPResult TPR = TryParseParameterDeclarationClause();
2010
64.4k
  if (TPR == TPResult::Ambiguous && 
Tok.isNot(tok::r_paren)8.30k
)
2011
0
    TPR = TPResult::False;
2012
2013
64.4k
  if (TPR == TPResult::False || 
TPR == TPResult::Error64.4k
)
2014
1
    return TPR;
2015
2016
  // Parse through the parens.
2017
64.4k
  if (!SkipUntil(tok::r_paren, StopAtSemi))
2018
1
    return TPResult::Error;
2019
2020
  // cv-qualifier-seq
2021
82.8k
  
while (64.4k
Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw___unaligned,
2022
82.8k
                     tok::kw_restrict))
2023
18.3k
    ConsumeToken();
2024
2025
  // ref-qualifier[opt]
2026
64.4k
  if (Tok.isOneOf(tok::amp, tok::ampamp))
2027
7.70k
    ConsumeToken();
2028
2029
  // exception-specification
2030
64.4k
  if (Tok.is(tok::kw_throw)) {
2031
75
    ConsumeToken();
2032
75
    if (Tok.isNot(tok::l_paren))
2033
0
      return TPResult::Error;
2034
2035
    // Parse through the parens after 'throw'.
2036
75
    ConsumeParen();
2037
75
    if (!SkipUntil(tok::r_paren, StopAtSemi))
2038
0
      return TPResult::Error;
2039
75
  }
2040
64.4k
  if (Tok.is(tok::kw_noexcept)) {
2041
131
    ConsumeToken();
2042
    // Possibly an expression as well.
2043
131
    if (Tok.is(tok::l_paren)) {
2044
      // Find the matching rparen.
2045
27
      ConsumeParen();
2046
27
      if (!SkipUntil(tok::r_paren, StopAtSemi))
2047
0
        return TPResult::Error;
2048
27
    }
2049
131
  }
2050
2051
64.4k
  return TPResult::Ambiguous;
2052
64.4k
}
2053
2054
/// '[' constant-expression[opt] ']'
2055
///
2056
6.24k
Parser::TPResult Parser::TryParseBracketDeclarator() {
2057
6.24k
  ConsumeBracket();
2058
2059
  // A constant-expression cannot begin with a '{', but the
2060
  // expr-or-braced-init-list of a postfix-expression can.
2061
6.24k
  if (Tok.is(tok::l_brace))
2062
2
    return TPResult::False;
2063
2064
6.24k
  if (!SkipUntil(tok::r_square, tok::comma, StopAtSemi | StopBeforeMatch))
2065
0
    return TPResult::Error;
2066
2067
  // If we hit a comma before the ']', this is not a constant-expression,
2068
  // but might still be the expr-or-braced-init-list of a postfix-expression.
2069
6.24k
  if (Tok.isNot(tok::r_square))
2070
1
    return TPResult::False;
2071
2072
6.24k
  ConsumeBracket();
2073
6.24k
  return TPResult::Ambiguous;
2074
6.24k
}
2075
2076
/// Determine whether we might be looking at the '<' template-argument-list '>'
2077
/// of a template-id or simple-template-id, rather than a less-than comparison.
2078
/// This will often fail and produce an ambiguity, but should never be wrong
2079
/// if it returns True or False.
2080
5.28k
Parser::TPResult Parser::isTemplateArgumentList(unsigned TokensToSkip) {
2081
5.28k
  if (!TokensToSkip) {
2082
2.43k
    if (Tok.isNot(tok::less))
2083
0
      return TPResult::False;
2084
2.43k
    if (NextToken().is(tok::greater))
2085
0
      return TPResult::True;
2086
2.43k
  }
2087
2088
5.28k
  RevertingTentativeParsingAction PA(*this);
2089
2090
8.14k
  while (TokensToSkip) {
2091
2.85k
    ConsumeAnyToken();
2092
2.85k
    --TokensToSkip;
2093
2.85k
  }
2094
2095
5.28k
  if (!TryConsumeToken(tok::less))
2096
0
    return TPResult::False;
2097
2098
  // We can't do much to tell an expression apart from a template-argument,
2099
  // but one good distinguishing factor is that a "decl-specifier" not
2100
  // followed by '(' or '{' can't appear in an expression.
2101
5.28k
  bool InvalidAsTemplateArgumentList = false;
2102
5.28k
  if (isCXXDeclarationSpecifier(TPResult::False,
2103
5.28k
                                       &InvalidAsTemplateArgumentList) ==
2104
5.28k
             TPResult::True)
2105
287
    return TPResult::True;
2106
4.99k
  if (InvalidAsTemplateArgumentList)
2107
14
    return TPResult::False;
2108
2109
  // FIXME: In many contexts, X<thing1, Type> can only be a
2110
  // template-argument-list. But that's not true in general:
2111
  //
2112
  // using b = int;
2113
  // void f() {
2114
  //   int a = A<B, b, c = C>D; // OK, declares b, not a template-id.
2115
  //
2116
  // X<Y<0, int> // ', int>' might be end of X's template argument list
2117
  //
2118
  // We might be able to disambiguate a few more cases if we're careful.
2119
2120
  // A template-argument-list must be terminated by a '>'.
2121
4.98k
  if (SkipUntil({tok::greater, tok::greatergreater, tok::greatergreatergreater},
2122
4.98k
                StopAtSemi | StopBeforeMatch))
2123
146
    return TPResult::Ambiguous;
2124
4.83k
  return TPResult::False;
2125
4.98k
}
2126
2127
/// Determine whether we might be looking at the '(' of a C++20 explicit(bool)
2128
/// in an earlier language mode.
2129
44
Parser::TPResult Parser::isExplicitBool() {
2130
44
  assert(Tok.is(tok::l_paren) && "expected to be looking at a '(' token");
2131
2132
0
  RevertingTentativeParsingAction PA(*this);
2133
44
  ConsumeParen();
2134
2135
  // We can only have 'explicit' on a constructor, conversion function, or
2136
  // deduction guide. The declarator of a deduction guide cannot be
2137
  // parenthesized, so we know this isn't a deduction guide. So the only
2138
  // thing we need to check for is some number of parens followed by either
2139
  // the current class name or 'operator'.
2140
46
  while (Tok.is(tok::l_paren))
2141
2
    ConsumeParen();
2142
2143
44
  if (TryAnnotateOptionalCXXScopeToken())
2144
0
    return TPResult::Error;
2145
2146
  // Class-scope constructor and conversion function names can't really be
2147
  // qualified, but we get better diagnostics if we assume they can be.
2148
44
  CXXScopeSpec SS;
2149
44
  if (Tok.is(tok::annot_cxxscope)) {
2150
6
    Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
2151
6
                                                 Tok.getAnnotationRange(),
2152
6
                                                 SS);
2153
6
    ConsumeAnnotationToken();
2154
6
  }
2155
2156
  // 'explicit(operator' might be explicit(bool) or the declaration of a
2157
  // conversion function, but it's probably a conversion function.
2158
44
  if (Tok.is(tok::kw_operator))
2159
3
    return TPResult::Ambiguous;
2160
2161
  // If this can't be a constructor name, it can only be explicit(bool).
2162
41
  if (Tok.isNot(tok::identifier) && 
Tok.isNot(tok::annot_template_id)15
)
2163
15
    return TPResult::True;
2164
26
  if (!Actions.isCurrentClassName(Tok.is(tok::identifier)
2165
26
                                      ? *Tok.getIdentifierInfo()
2166
26
                                      : 
*takeTemplateIdAnnotation(Tok)->Name0
,
2167
26
                                  getCurScope(), &SS))
2168
23
    return TPResult::True;
2169
  // Formally, we must have a right-paren after the constructor name to match
2170
  // the grammar for a constructor. But clang permits a parenthesized
2171
  // constructor declarator, so also allow a constructor declarator to follow
2172
  // with no ')' token after the constructor name.
2173
3
  if (!NextToken().is(tok::r_paren) &&
2174
3
      !isConstructorDeclarator(/*Unqualified=*/SS.isEmpty(),
2175
1
                               /*DeductionGuide=*/false))
2176
0
    return TPResult::True;
2177
2178
  // Might be explicit(bool) or a parenthesized constructor name.
2179
3
  return TPResult::Ambiguous;
2180
3
}