Coverage Report

Created: 2021-09-21 08:58

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Parse/ParseExprCXX.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- ParseExprCXX.cpp - C++ Expression 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 Expression parsing implementation for C++.
10
//
11
//===----------------------------------------------------------------------===//
12
#include "clang/AST/ASTContext.h"
13
#include "clang/AST/Decl.h"
14
#include "clang/AST/DeclTemplate.h"
15
#include "clang/AST/ExprCXX.h"
16
#include "clang/Basic/PrettyStackTrace.h"
17
#include "clang/Lex/LiteralSupport.h"
18
#include "clang/Parse/ParseDiagnostic.h"
19
#include "clang/Parse/Parser.h"
20
#include "clang/Parse/RAIIObjectsForParser.h"
21
#include "clang/Sema/DeclSpec.h"
22
#include "clang/Sema/ParsedTemplate.h"
23
#include "clang/Sema/Scope.h"
24
#include "llvm/Support/ErrorHandling.h"
25
#include <numeric>
26
27
using namespace clang;
28
29
11
static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
30
11
  switch (Kind) {
31
    // template name
32
6
    case tok::unknown:             return 0;
33
    // casts
34
0
    case tok::kw_addrspace_cast:   return 1;
35
1
    case tok::kw_const_cast:       return 2;
36
1
    case tok::kw_dynamic_cast:     return 3;
37
1
    case tok::kw_reinterpret_cast: return 4;
38
2
    case tok::kw_static_cast:      return 5;
39
0
    default:
40
0
      llvm_unreachable("Unknown type for digraph error message.");
41
11
  }
42
11
}
43
44
// Are the two tokens adjacent in the same source file?
45
1.60k
bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
46
1.60k
  SourceManager &SM = PP.getSourceManager();
47
1.60k
  SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
48
1.60k
  SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
49
1.60k
  return FirstEnd == SM.getSpellingLoc(Second.getLocation());
50
1.60k
}
51
52
// Suggest fixit for "<::" after a cast.
53
static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
54
11
                       Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
55
  // Pull '<:' and ':' off token stream.
56
11
  if (!AtDigraph)
57
6
    PP.Lex(DigraphToken);
58
11
  PP.Lex(ColonToken);
59
60
11
  SourceRange Range;
61
11
  Range.setBegin(DigraphToken.getLocation());
62
11
  Range.setEnd(ColonToken.getLocation());
63
11
  P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
64
11
      << SelectDigraphErrorMessage(Kind)
65
11
      << FixItHint::CreateReplacement(Range, "< ::");
66
67
  // Update token information to reflect their change in token type.
68
11
  ColonToken.setKind(tok::coloncolon);
69
11
  ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
70
11
  ColonToken.setLength(2);
71
11
  DigraphToken.setKind(tok::less);
72
11
  DigraphToken.setLength(1);
73
74
  // Push new tokens back to token stream.
75
11
  PP.EnterToken(ColonToken, /*IsReinject*/ true);
76
11
  if (!AtDigraph)
77
6
    PP.EnterToken(DigraphToken, /*IsReinject*/ true);
78
11
}
79
80
// Check for '<::' which should be '< ::' instead of '[:' when following
81
// a template name.
82
void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
83
                                        bool EnteringContext,
84
66.1M
                                        IdentifierInfo &II, CXXScopeSpec &SS) {
85
66.1M
  if (!Next.is(tok::l_square) || 
Next.getLength() != 2199k
)
86
66.1M
    return;
87
88
20
  Token SecondToken = GetLookAheadToken(2);
89
20
  if (!SecondToken.is(tok::colon) || 
!areTokensAdjacent(Next, SecondToken)18
)
90
14
    return;
91
92
6
  TemplateTy Template;
93
6
  UnqualifiedId TemplateName;
94
6
  TemplateName.setIdentifier(&II, Tok.getLocation());
95
6
  bool MemberOfUnknownSpecialization;
96
6
  if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
97
6
                              TemplateName, ObjectType, EnteringContext,
98
6
                              Template, MemberOfUnknownSpecialization))
99
0
    return;
100
101
6
  FixDigraph(*this, PP, Next, SecondToken, tok::unknown,
102
6
             /*AtDigraph*/false);
103
6
}
104
105
/// Parse global scope or nested-name-specifier if present.
106
///
107
/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
108
/// may be preceded by '::'). Note that this routine will not parse ::new or
109
/// ::delete; it will just leave them in the token stream.
110
///
111
///       '::'[opt] nested-name-specifier
112
///       '::'
113
///
114
///       nested-name-specifier:
115
///         type-name '::'
116
///         namespace-name '::'
117
///         nested-name-specifier identifier '::'
118
///         nested-name-specifier 'template'[opt] simple-template-id '::'
119
///
120
///
121
/// \param SS the scope specifier that will be set to the parsed
122
/// nested-name-specifier (or empty)
123
///
124
/// \param ObjectType if this nested-name-specifier is being parsed following
125
/// the "." or "->" of a member access expression, this parameter provides the
126
/// type of the object whose members are being accessed.
127
///
128
/// \param ObjectHadErrors if this unqualified-id occurs within a member access
129
/// expression, indicates whether the original subexpressions had any errors.
130
/// When true, diagnostics for missing 'template' keyword will be supressed.
131
///
132
/// \param EnteringContext whether we will be entering into the context of
133
/// the nested-name-specifier after parsing it.
134
///
135
/// \param MayBePseudoDestructor When non-NULL, points to a flag that
136
/// indicates whether this nested-name-specifier may be part of a
137
/// pseudo-destructor name. In this case, the flag will be set false
138
/// if we don't actually end up parsing a destructor name. Moreover,
139
/// if we do end up determining that we are parsing a destructor name,
140
/// the last component of the nested-name-specifier is not parsed as
141
/// part of the scope specifier.
142
///
143
/// \param IsTypename If \c true, this nested-name-specifier is known to be
144
/// part of a type name. This is used to improve error recovery.
145
///
146
/// \param LastII When non-NULL, points to an IdentifierInfo* that will be
147
/// filled in with the leading identifier in the last component of the
148
/// nested-name-specifier, if any.
149
///
150
/// \param OnlyNamespace If true, only considers namespaces in lookup.
151
///
152
///
153
/// \returns true if there was an error parsing a scope specifier
154
bool Parser::ParseOptionalCXXScopeSpecifier(
155
    CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
156
    bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename,
157
93.1M
    IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) {
158
93.1M
  assert(getLangOpts().CPlusPlus &&
159
93.1M
         "Call sites of this function should be guarded by checking for C++");
160
161
93.1M
  if (Tok.is(tok::annot_cxxscope)) {
162
2.81M
    assert(!LastII && "want last identifier but have already annotated scope");
163
0
    assert(!MayBePseudoDestructor && "unexpected annot_cxxscope");
164
0
    Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
165
2.81M
                                                 Tok.getAnnotationRange(),
166
2.81M
                                                 SS);
167
2.81M
    ConsumeAnnotationToken();
168
2.81M
    return false;
169
2.81M
  }
170
171
  // Has to happen before any "return false"s in this function.
172
90.3M
  bool CheckForDestructor = false;
173
90.3M
  if (MayBePseudoDestructor && 
*MayBePseudoDestructor1.11M
) {
174
826k
    CheckForDestructor = true;
175
826k
    *MayBePseudoDestructor = false;
176
826k
  }
177
178
90.3M
  if (LastII)
179
211k
    *LastII = nullptr;
180
181
90.3M
  bool HasScopeSpecifier = false;
182
183
90.3M
  if (Tok.is(tok::coloncolon)) {
184
    // ::new and ::delete aren't nested-name-specifiers.
185
155k
    tok::TokenKind NextKind = NextToken().getKind();
186
155k
    if (NextKind == tok::kw_new || 
NextKind == tok::kw_delete137k
)
187
17.5k
      return false;
188
189
137k
    if (NextKind == tok::l_brace) {
190
      // It is invalid to have :: {, consume the scope qualifier and pretend
191
      // like we never saw it.
192
1
      Diag(ConsumeToken(), diag::err_expected) << tok::identifier;
193
137k
    } else {
194
      // '::' - Global scope qualifier.
195
137k
      if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS))
196
0
        return true;
197
198
137k
      HasScopeSpecifier = true;
199
137k
    }
200
137k
  }
201
202
90.3M
  if (Tok.is(tok::kw___super)) {
203
44
    SourceLocation SuperLoc = ConsumeToken();
204
44
    if (!Tok.is(tok::coloncolon)) {
205
2
      Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super);
206
2
      return true;
207
2
    }
208
209
42
    return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS);
210
44
  }
211
212
90.3M
  if (!HasScopeSpecifier &&
213
90.3M
      
Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)90.1M
) {
214
39.1k
    DeclSpec DS(AttrFactory);
215
39.1k
    SourceLocation DeclLoc = Tok.getLocation();
216
39.1k
    SourceLocation EndLoc  = ParseDecltypeSpecifier(DS);
217
218
39.1k
    SourceLocation CCLoc;
219
    // Work around a standard defect: 'decltype(auto)::' is not a
220
    // nested-name-specifier.
221
39.1k
    if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto ||
222
39.1k
        
!TryConsumeToken(tok::coloncolon, CCLoc)38.6k
) {
223
38.9k
      AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
224
38.9k
      return false;
225
38.9k
    }
226
227
106
    if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
228
15
      SS.SetInvalid(SourceRange(DeclLoc, CCLoc));
229
230
106
    HasScopeSpecifier = true;
231
106
  }
232
233
  // Preferred type might change when parsing qualifiers, we need the original.
234
90.2M
  auto SavedType = PreferredType;
235
95.5M
  while (true) {
236
95.5M
    if (HasScopeSpecifier) {
237
2.81M
      if (Tok.is(tok::code_completion)) {
238
59
        cutOffParsing();
239
        // Code completion for a nested-name-specifier, where the code
240
        // completion token follows the '::'.
241
59
        Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext,
242
59
                                        InUsingDeclaration, ObjectType.get(),
243
59
                                        SavedType.get(SS.getBeginLoc()));
244
        // Include code completion token into the range of the scope otherwise
245
        // when we try to annotate the scope tokens the dangling code completion
246
        // token will cause assertion in
247
        // Preprocessor::AnnotatePreviousCachedTokens.
248
59
        SS.setEndLoc(Tok.getLocation());
249
59
        return true;
250
59
      }
251
252
      // C++ [basic.lookup.classref]p5:
253
      //   If the qualified-id has the form
254
      //
255
      //       ::class-name-or-namespace-name::...
256
      //
257
      //   the class-name-or-namespace-name is looked up in global scope as a
258
      //   class-name or namespace-name.
259
      //
260
      // To implement this, we clear out the object type as soon as we've
261
      // seen a leading '::' or part of a nested-name-specifier.
262
2.81M
      ObjectType = nullptr;
263
2.81M
    }
264
265
    // nested-name-specifier:
266
    //   nested-name-specifier 'template'[opt] simple-template-id '::'
267
268
    // Parse the optional 'template' keyword, then make sure we have
269
    // 'identifier <' after it.
270
95.5M
    if (Tok.is(tok::kw_template)) {
271
      // If we don't have a scope specifier or an object type, this isn't a
272
      // nested-name-specifier, since they aren't allowed to start with
273
      // 'template'.
274
23.4k
      if (!HasScopeSpecifier && 
!ObjectType7.60k
)
275
70
        break;
276
277
23.4k
      TentativeParsingAction TPA(*this);
278
23.4k
      SourceLocation TemplateKWLoc = ConsumeToken();
279
280
23.4k
      UnqualifiedId TemplateName;
281
23.4k
      if (Tok.is(tok::identifier)) {
282
        // Consume the identifier.
283
23.3k
        TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
284
23.3k
        ConsumeToken();
285
23.3k
      } else 
if (73
Tok.is(tok::kw_operator)73
) {
286
        // We don't need to actually parse the unqualified-id in this case,
287
        // because a simple-template-id cannot start with 'operator', but
288
        // go ahead and parse it anyway for consistency with the case where
289
        // we already annotated the template-id.
290
64
        if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
291
64
                                       TemplateName)) {
292
3
          TPA.Commit();
293
3
          break;
294
3
        }
295
296
61
        if (TemplateName.getKind() != UnqualifiedIdKind::IK_OperatorFunctionId &&
297
61
            
TemplateName.getKind() != UnqualifiedIdKind::IK_LiteralOperatorId1
) {
298
0
          Diag(TemplateName.getSourceRange().getBegin(),
299
0
               diag::err_id_after_template_in_nested_name_spec)
300
0
            << TemplateName.getSourceRange();
301
0
          TPA.Commit();
302
0
          break;
303
0
        }
304
61
      } else {
305
9
        TPA.Revert();
306
9
        break;
307
9
      }
308
309
      // If the next token is not '<', we have a qualified-id that refers
310
      // to a template name, such as T::template apply, but is not a
311
      // template-id.
312
23.3k
      if (Tok.isNot(tok::less)) {
313
572
        TPA.Revert();
314
572
        break;
315
572
      }
316
317
      // Commit to parsing the template-id.
318
22.8k
      TPA.Commit();
319
22.8k
      TemplateTy Template;
320
22.8k
      TemplateNameKind TNK = Actions.ActOnTemplateName(
321
22.8k
          getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
322
22.8k
          EnteringContext, Template, /*AllowInjectedClassName*/ true);
323
22.8k
      if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
324
22.8k
                                  TemplateName, false))
325
0
        return true;
326
327
22.8k
      continue;
328
22.8k
    }
329
330
95.5M
    if (Tok.is(tok::annot_template_id) && 
NextToken().is(tok::coloncolon)2.89M
) {
331
      // We have
332
      //
333
      //   template-id '::'
334
      //
335
      // So we need to check whether the template-id is a simple-template-id of
336
      // the right kind (it should name a type or be dependent), and then
337
      // convert it into a type within the nested-name-specifier.
338
1.09M
      TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
339
1.09M
      if (CheckForDestructor && 
GetLookAheadToken(2).is(tok::tilde)75
) {
340
30
        *MayBePseudoDestructor = true;
341
30
        return false;
342
30
      }
343
344
1.09M
      if (LastII)
345
226
        *LastII = TemplateId->Name;
346
347
      // Consume the template-id token.
348
1.09M
      ConsumeAnnotationToken();
349
350
1.09M
      assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
351
0
      SourceLocation CCLoc = ConsumeToken();
352
353
1.09M
      HasScopeSpecifier = true;
354
355
1.09M
      ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
356
1.09M
                                         TemplateId->NumArgs);
357
358
1.09M
      if (TemplateId->isInvalid() ||
359
1.09M
          Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
360
1.09M
                                              SS,
361
1.09M
                                              TemplateId->TemplateKWLoc,
362
1.09M
                                              TemplateId->Template,
363
1.09M
                                              TemplateId->TemplateNameLoc,
364
1.09M
                                              TemplateId->LAngleLoc,
365
1.09M
                                              TemplateArgsPtr,
366
1.09M
                                              TemplateId->RAngleLoc,
367
1.09M
                                              CCLoc,
368
1.09M
                                              EnteringContext)) {
369
339
        SourceLocation StartLoc
370
339
          = SS.getBeginLoc().isValid()? 
SS.getBeginLoc()25
371
339
                                      : 
TemplateId->TemplateNameLoc314
;
372
339
        SS.SetInvalid(SourceRange(StartLoc, CCLoc));
373
339
      }
374
375
1.09M
      continue;
376
1.09M
    }
377
378
    // The rest of the nested-name-specifier possibilities start with
379
    // tok::identifier.
380
94.4M
    if (Tok.isNot(tok::identifier))
381
26.8M
      break;
382
383
67.5M
    IdentifierInfo &II = *Tok.getIdentifierInfo();
384
385
    // nested-name-specifier:
386
    //   type-name '::'
387
    //   namespace-name '::'
388
    //   nested-name-specifier identifier '::'
389
67.5M
    Token Next = NextToken();
390
67.5M
    Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(),
391
67.5M
                                    ObjectType);
392
393
    // If we get foo:bar, this is almost certainly a typo for foo::bar.  Recover
394
    // and emit a fixit hint for it.
395
67.5M
    if (Next.is(tok::colon) && 
!ColonIsSacred184k
) {
396
1.19k
      if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo,
397
1.19k
                                            EnteringContext) &&
398
          // If the token after the colon isn't an identifier, it's still an
399
          // error, but they probably meant something else strange so don't
400
          // recover like this.
401
1.19k
          
PP.LookAhead(1).is(tok::identifier)160
) {
402
160
        Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
403
160
          << FixItHint::CreateReplacement(Next.getLocation(), "::");
404
        // Recover as if the user wrote '::'.
405
160
        Next.setKind(tok::coloncolon);
406
160
      }
407
1.19k
    }
408
409
67.5M
    if (Next.is(tok::coloncolon) && 
GetLookAheadToken(2).is(tok::l_brace)1.39M
) {
410
      // It is invalid to have :: {, consume the scope qualifier and pretend
411
      // like we never saw it.
412
4
      Token Identifier = Tok; // Stash away the identifier.
413
4
      ConsumeToken();         // Eat the identifier, current token is now '::'.
414
4
      Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected)
415
4
          << tok::identifier;
416
4
      UnconsumeToken(Identifier); // Stick the identifier back.
417
4
      Next = NextToken();         // Point Next at the '{' token.
418
4
    }
419
420
67.5M
    if (Next.is(tok::coloncolon)) {
421
1.39M
      if (CheckForDestructor && 
GetLookAheadToken(2).is(tok::tilde)394
) {
422
175
        *MayBePseudoDestructor = true;
423
175
        return false;
424
175
      }
425
426
1.39M
      if (ColonIsSacred) {
427
101k
        const Token &Next2 = GetLookAheadToken(2);
428
101k
        if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
429
101k
            Next2.is(tok::kw_public) || 
Next2.is(tok::kw_virtual)101k
) {
430
1
          Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
431
1
              << Next2.getName()
432
1
              << FixItHint::CreateReplacement(Next.getLocation(), ":");
433
1
          Token ColonColon;
434
1
          PP.Lex(ColonColon);
435
1
          ColonColon.setKind(tok::colon);
436
1
          PP.EnterToken(ColonColon, /*IsReinject*/ true);
437
1
          break;
438
1
        }
439
101k
      }
440
441
1.39M
      if (LastII)
442
16.8k
        *LastII = &II;
443
444
      // We have an identifier followed by a '::'. Lookup this name
445
      // as the name in a nested-name-specifier.
446
1.39M
      Token Identifier = Tok;
447
1.39M
      SourceLocation IdLoc = ConsumeToken();
448
1.39M
      assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
449
1.39M
             "NextToken() not working properly!");
450
0
      Token ColonColon = Tok;
451
1.39M
      SourceLocation CCLoc = ConsumeToken();
452
453
1.39M
      bool IsCorrectedToColon = false;
454
1.39M
      bool *CorrectionFlagPtr = ColonIsSacred ? 
&IsCorrectedToColon101k
:
nullptr1.29M
;
455
1.39M
      if (Actions.ActOnCXXNestedNameSpecifier(
456
1.39M
              getCurScope(), IdInfo, EnteringContext, SS, false,
457
1.39M
              CorrectionFlagPtr, OnlyNamespace)) {
458
        // Identifier is not recognized as a nested name, but we can have
459
        // mistyped '::' instead of ':'.
460
275
        if (CorrectionFlagPtr && 
IsCorrectedToColon49
) {
461
9
          ColonColon.setKind(tok::colon);
462
9
          PP.EnterToken(Tok, /*IsReinject*/ true);
463
9
          PP.EnterToken(ColonColon, /*IsReinject*/ true);
464
9
          Tok = Identifier;
465
9
          break;
466
9
        }
467
266
        SS.SetInvalid(SourceRange(IdLoc, CCLoc));
468
266
      }
469
1.39M
      HasScopeSpecifier = true;
470
1.39M
      continue;
471
1.39M
    }
472
473
66.1M
    CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
474
475
    // nested-name-specifier:
476
    //   type-name '<'
477
66.1M
    if (Next.is(tok::less)) {
478
479
3.12M
      TemplateTy Template;
480
3.12M
      UnqualifiedId TemplateName;
481
3.12M
      TemplateName.setIdentifier(&II, Tok.getLocation());
482
3.12M
      bool MemberOfUnknownSpecialization;
483
3.12M
      if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
484
3.12M
                                              /*hasTemplateKeyword=*/false,
485
3.12M
                                                        TemplateName,
486
3.12M
                                                        ObjectType,
487
3.12M
                                                        EnteringContext,
488
3.12M
                                                        Template,
489
3.12M
                                              MemberOfUnknownSpecialization)) {
490
        // If lookup didn't find anything, we treat the name as a template-name
491
        // anyway. C++20 requires this, and in prior language modes it improves
492
        // error recovery. But before we commit to this, check that we actually
493
        // have something that looks like a template-argument-list next.
494
2.76M
        if (!IsTypename && 
TNK == TNK_Undeclared_template2.31M
&&
495
2.76M
            
isTemplateArgumentList(1) == TPResult::False339
)
496
22
          break;
497
498
        // We have found a template name, so annotate this token
499
        // with a template-id annotation. We do not permit the
500
        // template-id to be translated into a type annotation,
501
        // because some clients (e.g., the parsing of class template
502
        // specializations) still want to see the original template-id
503
        // token, and it might not be a type at all (e.g. a concept name in a
504
        // type-constraint).
505
2.76M
        ConsumeToken();
506
2.76M
        if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
507
2.76M
                                    TemplateName, false))
508
25
          return true;
509
2.76M
        continue;
510
2.76M
      }
511
512
364k
      if (MemberOfUnknownSpecialization && 
(2.54k
ObjectType2.54k
||
SS.isSet()77
) &&
513
364k
          
(2.54k
IsTypename2.54k
||
isTemplateArgumentList(1) == TPResult::True2.52k
)) {
514
        // If we had errors before, ObjectType can be dependent even without any
515
        // templates. Do not report missing template keyword in that case.
516
81
        if (!ObjectHadErrors) {
517
          // We have something like t::getAs<T>, where getAs is a
518
          // member of an unknown specialization. However, this will only
519
          // parse correctly as a template, so suggest the keyword 'template'
520
          // before 'getAs' and treat this as a dependent template name.
521
73
          unsigned DiagID = diag::err_missing_dependent_template_keyword;
522
73
          if (getLangOpts().MicrosoftExt)
523
4
            DiagID = diag::warn_missing_dependent_template_keyword;
524
525
73
          Diag(Tok.getLocation(), DiagID)
526
73
              << II.getName()
527
73
              << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
528
73
        }
529
530
81
        SourceLocation TemplateNameLoc = ConsumeToken();
531
532
81
        TemplateNameKind TNK = Actions.ActOnTemplateName(
533
81
            getCurScope(), SS, TemplateNameLoc, TemplateName, ObjectType,
534
81
            EnteringContext, Template, /*AllowInjectedClassName*/ true);
535
81
        if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
536
81
                                    TemplateName, false))
537
0
          return true;
538
539
81
        continue;
540
81
      }
541
364k
    }
542
543
    // We don't have any tokens that form the beginning of a
544
    // nested-name-specifier, so we're done.
545
63.4M
    break;
546
66.1M
  }
547
548
  // Even if we didn't see any pieces of a nested-name-specifier, we
549
  // still check whether there is a tilde in this position, which
550
  // indicates a potential pseudo-destructor.
551
90.2M
  if (CheckForDestructor && 
!HasScopeSpecifier826k
&&
Tok.is(tok::tilde)826k
)
552
7.49k
    *MayBePseudoDestructor = true;
553
554
90.2M
  return false;
555
90.2M
}
556
557
ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS,
558
                                           bool isAddressOfOperand,
559
3.04M
                                           Token &Replacement) {
560
3.04M
  ExprResult E;
561
562
  // We may have already annotated this id-expression.
563
3.04M
  switch (Tok.getKind()) {
564
1.92M
  case tok::annot_non_type: {
565
1.92M
    NamedDecl *ND = getNonTypeAnnotation(Tok);
566
1.92M
    SourceLocation Loc = ConsumeAnnotationToken();
567
1.92M
    E = Actions.ActOnNameClassifiedAsNonType(getCurScope(), SS, ND, Loc, Tok);
568
1.92M
    break;
569
0
  }
570
571
2.15k
  case tok::annot_non_type_dependent: {
572
2.15k
    IdentifierInfo *II = getIdentifierAnnotation(Tok);
573
2.15k
    SourceLocation Loc = ConsumeAnnotationToken();
574
575
    // This is only the direct operand of an & operator if it is not
576
    // followed by a postfix-expression suffix.
577
2.15k
    if (isAddressOfOperand && 
isPostfixExpressionSuffixStart()0
)
578
0
      isAddressOfOperand = false;
579
580
2.15k
    E = Actions.ActOnNameClassifiedAsDependentNonType(SS, II, Loc,
581
2.15k
                                                      isAddressOfOperand);
582
2.15k
    break;
583
0
  }
584
585
613
  case tok::annot_non_type_undeclared: {
586
613
    assert(SS.isEmpty() &&
587
613
           "undeclared non-type annotation should be unqualified");
588
0
    IdentifierInfo *II = getIdentifierAnnotation(Tok);
589
613
    SourceLocation Loc = ConsumeAnnotationToken();
590
613
    E = Actions.ActOnNameClassifiedAsUndeclaredNonType(II, Loc);
591
613
    break;
592
0
  }
593
594
1.11M
  default:
595
1.11M
    SourceLocation TemplateKWLoc;
596
1.11M
    UnqualifiedId Name;
597
1.11M
    if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
598
1.11M
                           /*ObjectHadErrors=*/false,
599
1.11M
                           /*EnteringContext=*/false,
600
1.11M
                           /*AllowDestructorName=*/false,
601
1.11M
                           /*AllowConstructorName=*/false,
602
1.11M
                           /*AllowDeductionGuide=*/false, &TemplateKWLoc, Name))
603
137
      return ExprError();
604
605
    // This is only the direct operand of an & operator if it is not
606
    // followed by a postfix-expression suffix.
607
1.11M
    if (isAddressOfOperand && 
isPostfixExpressionSuffixStart()5.01k
)
608
141
      isAddressOfOperand = false;
609
610
1.11M
    E = Actions.ActOnIdExpression(
611
1.11M
        getCurScope(), SS, TemplateKWLoc, Name, Tok.is(tok::l_paren),
612
1.11M
        isAddressOfOperand, /*CCC=*/nullptr, /*IsInlineAsmIdentifier=*/false,
613
1.11M
        &Replacement);
614
1.11M
    break;
615
3.04M
  }
616
617
3.04M
  if (!E.isInvalid() && 
!E.isUnset()3.04M
&&
Tok.is(tok::less)3.04M
)
618
149
    checkPotentialAngleBracket(E);
619
3.04M
  return E;
620
3.04M
}
621
622
/// ParseCXXIdExpression - Handle id-expression.
623
///
624
///       id-expression:
625
///         unqualified-id
626
///         qualified-id
627
///
628
///       qualified-id:
629
///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
630
///         '::' identifier
631
///         '::' operator-function-id
632
///         '::' template-id
633
///
634
/// NOTE: The standard specifies that, for qualified-id, the parser does not
635
/// expect:
636
///
637
///   '::' conversion-function-id
638
///   '::' '~' class-name
639
///
640
/// This may cause a slight inconsistency on diagnostics:
641
///
642
/// class C {};
643
/// namespace A {}
644
/// void f() {
645
///   :: A :: ~ C(); // Some Sema error about using destructor with a
646
///                  // namespace.
647
///   :: ~ C(); // Some Parser error like 'unexpected ~'.
648
/// }
649
///
650
/// We simplify the parser a bit and make it work like:
651
///
652
///       qualified-id:
653
///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
654
///         '::' unqualified-id
655
///
656
/// That way Sema can handle and report similar errors for namespaces and the
657
/// global scope.
658
///
659
/// The isAddressOfOperand parameter indicates that this id-expression is a
660
/// direct operand of the address-of operator. This is, besides member contexts,
661
/// the only place where a qualified-id naming a non-static class member may
662
/// appear.
663
///
664
1.13M
ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
665
  // qualified-id:
666
  //   '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
667
  //   '::' unqualified-id
668
  //
669
1.13M
  CXXScopeSpec SS;
670
1.13M
  ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
671
1.13M
                                 /*ObjectHadErrors=*/false,
672
1.13M
                                 /*EnteringContext=*/false);
673
674
1.13M
  Token Replacement;
675
1.13M
  ExprResult Result =
676
1.13M
      tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
677
1.13M
  if (Result.isUnset()) {
678
    // If the ExprResult is valid but null, then typo correction suggested a
679
    // keyword replacement that needs to be reparsed.
680
4
    UnconsumeToken(Replacement);
681
4
    Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
682
4
  }
683
1.13M
  assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "
684
1.13M
                              "for a previous keyword suggestion");
685
0
  return Result;
686
1.13M
}
687
688
/// ParseLambdaExpression - Parse a C++11 lambda expression.
689
///
690
///       lambda-expression:
691
///         lambda-introducer lambda-declarator compound-statement
692
///         lambda-introducer '<' template-parameter-list '>'
693
///             requires-clause[opt] lambda-declarator compound-statement
694
///
695
///       lambda-introducer:
696
///         '[' lambda-capture[opt] ']'
697
///
698
///       lambda-capture:
699
///         capture-default
700
///         capture-list
701
///         capture-default ',' capture-list
702
///
703
///       capture-default:
704
///         '&'
705
///         '='
706
///
707
///       capture-list:
708
///         capture
709
///         capture-list ',' capture
710
///
711
///       capture:
712
///         simple-capture
713
///         init-capture     [C++1y]
714
///
715
///       simple-capture:
716
///         identifier
717
///         '&' identifier
718
///         'this'
719
///
720
///       init-capture:      [C++1y]
721
///         identifier initializer
722
///         '&' identifier initializer
723
///
724
///       lambda-declarator:
725
///         lambda-specifiers     [C++2b]
726
///         '(' parameter-declaration-clause ')' lambda-specifiers
727
///             requires-clause[opt]
728
///
729
///       lambda-specifiers:
730
///         decl-specifier-seq[opt] noexcept-specifier[opt]
731
///             attribute-specifier-seq[opt] trailing-return-type[opt]
732
///
733
7.91k
ExprResult Parser::ParseLambdaExpression() {
734
  // Parse lambda-introducer.
735
7.91k
  LambdaIntroducer Intro;
736
7.91k
  if (ParseLambdaIntroducer(Intro)) {
737
59
    SkipUntil(tok::r_square, StopAtSemi);
738
59
    SkipUntil(tok::l_brace, StopAtSemi);
739
59
    SkipUntil(tok::r_brace, StopAtSemi);
740
59
    return ExprError();
741
59
  }
742
743
7.85k
  return ParseLambdaExpressionAfterIntroducer(Intro);
744
7.91k
}
745
746
/// Use lookahead and potentially tentative parsing to determine if we are
747
/// looking at a C++11 lambda expression, and parse it if we are.
748
///
749
/// If we are not looking at a lambda expression, returns ExprError().
750
2.96k
ExprResult Parser::TryParseLambdaExpression() {
751
2.96k
  assert(getLangOpts().CPlusPlus11
752
2.96k
         && Tok.is(tok::l_square)
753
2.96k
         && "Not at the start of a possible lambda expression.");
754
755
0
  const Token Next = NextToken();
756
2.96k
  if (Next.is(tok::eof)) // Nothing else to lookup here...
757
1
    return ExprEmpty();
758
759
2.96k
  const Token After = GetLookAheadToken(2);
760
  // If lookahead indicates this is a lambda...
761
2.96k
  if (Next.is(tok::r_square) ||     // []
762
2.96k
      
Next.is(tok::equal)2.88k
|| // [=
763
2.96k
      
(2.84k
Next.is(tok::amp)2.84k
&& // [&] or [&,
764
2.84k
       
After.isOneOf(tok::r_square, tok::comma)41
) ||
765
2.96k
      
(2.81k
Next.is(tok::identifier)2.81k
&& // [identifier]
766
2.81k
       
After.is(tok::r_square)2.02k
) ||
767
2.96k
      
Next.is(tok::ellipsis)2.79k
) { // [...
768
175
    return ParseLambdaExpression();
769
175
  }
770
771
  // If lookahead indicates an ObjC message send...
772
  // [identifier identifier
773
2.79k
  if (Next.is(tok::identifier) && 
After.is(tok::identifier)2.00k
)
774
1.85k
    return ExprEmpty();
775
776
  // Here, we're stuck: lambda introducers and Objective-C message sends are
777
  // unambiguous, but it requires arbitrary lookhead.  [a,b,c,d,e,f,g] is a
778
  // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send.  Instead of
779
  // writing two routines to parse a lambda introducer, just try to parse
780
  // a lambda introducer first, and fall back if that fails.
781
938
  LambdaIntroducer Intro;
782
938
  {
783
938
    TentativeParsingAction TPA(*this);
784
938
    LambdaIntroducerTentativeParse Tentative;
785
938
    if (ParseLambdaIntroducer(Intro, &Tentative)) {
786
0
      TPA.Commit();
787
0
      return ExprError();
788
0
    }
789
790
938
    switch (Tentative) {
791
20
    case LambdaIntroducerTentativeParse::Success:
792
20
      TPA.Commit();
793
20
      break;
794
795
16
    case LambdaIntroducerTentativeParse::Incomplete:
796
      // Didn't fully parse the lambda-introducer, try again with a
797
      // non-tentative parse.
798
16
      TPA.Revert();
799
16
      Intro = LambdaIntroducer();
800
16
      if (ParseLambdaIntroducer(Intro))
801
0
        return ExprError();
802
16
      break;
803
804
57
    case LambdaIntroducerTentativeParse::MessageSend:
805
902
    case LambdaIntroducerTentativeParse::Invalid:
806
      // Not a lambda-introducer, might be a message send.
807
902
      TPA.Revert();
808
902
      return ExprEmpty();
809
938
    }
810
938
  }
811
812
36
  return ParseLambdaExpressionAfterIntroducer(Intro);
813
938
}
814
815
/// Parse a lambda introducer.
816
/// \param Intro A LambdaIntroducer filled in with information about the
817
///        contents of the lambda-introducer.
818
/// \param Tentative If non-null, we are disambiguating between a
819
///        lambda-introducer and some other construct. In this mode, we do not
820
///        produce any diagnostics or take any other irreversible action unless
821
///        we're sure that this is a lambda-expression.
822
/// \return \c true if parsing (or disambiguation) failed with a diagnostic and
823
///         the caller should bail out / recover.
824
bool Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
825
9.34k
                                   LambdaIntroducerTentativeParse *Tentative) {
826
9.34k
  if (Tentative)
827
1.41k
    *Tentative = LambdaIntroducerTentativeParse::Success;
828
829
9.34k
  assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
830
0
  BalancedDelimiterTracker T(*this, tok::l_square);
831
9.34k
  T.consumeOpen();
832
833
9.34k
  Intro.Range.setBegin(T.getOpenLocation());
834
835
9.34k
  bool First = true;
836
837
  // Produce a diagnostic if we're not tentatively parsing; otherwise track
838
  // that our parse has failed.
839
9.34k
  auto Invalid = [&](llvm::function_ref<void()> Action) {
840
1.00k
    if (Tentative) {
841
943
      *Tentative = LambdaIntroducerTentativeParse::Invalid;
842
943
      return false;
843
943
    }
844
59
    Action();
845
59
    return true;
846
1.00k
  };
847
848
  // Perform some irreversible action if this is a non-tentative parse;
849
  // otherwise note that our actions were incomplete.
850
9.34k
  auto NonTentativeAction = [&](llvm::function_ref<void()> Action) {
851
476
    if (Tentative)
852
15
      *Tentative = LambdaIntroducerTentativeParse::Incomplete;
853
461
    else
854
461
      Action();
855
476
  };
856
857
  // Parse capture-default.
858
9.34k
  if (Tok.is(tok::amp) &&
859
9.34k
      
(2.09k
NextToken().is(tok::comma)2.09k
||
NextToken().is(tok::r_square)2.01k
)) {
860
1.86k
    Intro.Default = LCD_ByRef;
861
1.86k
    Intro.DefaultLoc = ConsumeToken();
862
1.86k
    First = false;
863
1.86k
    if (!Tok.getIdentifierInfo()) {
864
      // This can only be a lambda; no need for tentative parsing any more.
865
      // '[[and]]' can still be an attribute, though.
866
1.86k
      Tentative = nullptr;
867
1.86k
    }
868
7.47k
  } else if (Tok.is(tok::equal)) {
869
867
    Intro.Default = LCD_ByCopy;
870
867
    Intro.DefaultLoc = ConsumeToken();
871
867
    First = false;
872
867
    Tentative = nullptr;
873
867
  }
874
875
11.4k
  while (Tok.isNot(tok::r_square)) {
876
3.24k
    if (!First) {
877
567
      if (Tok.isNot(tok::comma)) {
878
        // Provide a completion for a lambda introducer here. Except
879
        // in Objective-C, where this is Almost Surely meant to be a message
880
        // send. In that case, fail here and let the ObjC message
881
        // expression parser perform the completion.
882
168
        if (Tok.is(tok::code_completion) &&
883
168
            
!(7
getLangOpts().ObjC7
&&
Tentative7
)) {
884
1
          cutOffParsing();
885
1
          Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
886
1
                                               /*AfterAmpersand=*/false);
887
1
          break;
888
1
        }
889
890
167
        return Invalid([&] {
891
13
          Diag(Tok.getLocation(), diag::err_expected_comma_or_rsquare);
892
13
        });
893
168
      }
894
399
      ConsumeToken();
895
399
    }
896
897
3.07k
    if (Tok.is(tok::code_completion)) {
898
8
      cutOffParsing();
899
      // If we're in Objective-C++ and we have a bare '[', then this is more
900
      // likely to be a message receiver.
901
8
      if (getLangOpts().ObjC && 
Tentative5
&&
First5
)
902
3
        Actions.CodeCompleteObjCMessageReceiver(getCurScope());
903
5
      else
904
5
        Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
905
5
                                             /*AfterAmpersand=*/false);
906
8
      break;
907
8
    }
908
909
3.06k
    First = false;
910
911
    // Parse capture.
912
3.06k
    LambdaCaptureKind Kind = LCK_ByCopy;
913
3.06k
    LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
914
3.06k
    SourceLocation Loc;
915
3.06k
    IdentifierInfo *Id = nullptr;
916
3.06k
    SourceLocation EllipsisLocs[4];
917
3.06k
    ExprResult Init;
918
3.06k
    SourceLocation LocStart = Tok.getLocation();
919
920
3.06k
    if (Tok.is(tok::star)) {
921
128
      Loc = ConsumeToken();
922
128
      if (Tok.is(tok::kw_this)) {
923
124
        ConsumeToken();
924
124
        Kind = LCK_StarThis;
925
124
      } else {
926
4
        return Invalid([&] {
927
0
          Diag(Tok.getLocation(), diag::err_expected_star_this_capture);
928
0
        });
929
4
      }
930
2.94k
    } else if (Tok.is(tok::kw_this)) {
931
250
      Kind = LCK_This;
932
250
      Loc = ConsumeToken();
933
2.69k
    } else if (Tok.isOneOf(tok::amp, tok::equal) &&
934
2.69k
               
NextToken().isOneOf(tok::comma, tok::r_square)323
&&
935
2.69k
               
Intro.Default == LCD_None11
) {
936
      // We have a lone "&" or "=" which is either a misplaced capture-default
937
      // or the start of a capture (in the "&" case) with the rest of the
938
      // capture missing. Both are an error but a misplaced capture-default
939
      // is more likely if we don't already have a capture default.
940
7
      return Invalid(
941
7
          [&] { Diag(Tok.getLocation(), diag::err_capture_default_first); });
942
2.68k
    } else {
943
2.68k
      TryConsumeToken(tok::ellipsis, EllipsisLocs[0]);
944
945
2.68k
      if (Tok.is(tok::amp)) {
946
323
        Kind = LCK_ByRef;
947
323
        ConsumeToken();
948
949
323
        if (Tok.is(tok::code_completion)) {
950
0
          cutOffParsing();
951
0
          Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
952
0
                                               /*AfterAmpersand=*/true);
953
0
          break;
954
0
        }
955
323
      }
956
957
2.68k
      TryConsumeToken(tok::ellipsis, EllipsisLocs[1]);
958
959
2.68k
      if (Tok.is(tok::identifier)) {
960
1.85k
        Id = Tok.getIdentifierInfo();
961
1.85k
        Loc = ConsumeToken();
962
1.85k
      } else 
if (824
Tok.is(tok::kw_this)824
) {
963
7
        return Invalid([&] {
964
          // FIXME: Suggest a fixit here.
965
6
          Diag(Tok.getLocation(), diag::err_this_captured_by_reference);
966
6
        });
967
817
      } else {
968
817
        return Invalid([&] {
969
33
          Diag(Tok.getLocation(), diag::err_expected_capture);
970
33
        });
971
817
      }
972
973
1.85k
      TryConsumeToken(tok::ellipsis, EllipsisLocs[2]);
974
975
1.85k
      if (Tok.is(tok::l_paren)) {
976
176
        BalancedDelimiterTracker Parens(*this, tok::l_paren);
977
176
        Parens.consumeOpen();
978
979
176
        InitKind = LambdaCaptureInitKind::DirectInit;
980
981
176
        ExprVector Exprs;
982
176
        CommaLocsTy Commas;
983
176
        if (Tentative) {
984
61
          Parens.skipToEnd();
985
61
          *Tentative = LambdaIntroducerTentativeParse::Incomplete;
986
115
        } else if (ParseExpressionList(Exprs, Commas)) {
987
1
          Parens.skipToEnd();
988
1
          Init = ExprError();
989
114
        } else {
990
114
          Parens.consumeClose();
991
114
          Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
992
114
                                            Parens.getCloseLocation(),
993
114
                                            Exprs);
994
114
        }
995
1.68k
      } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
996
        // Each lambda init-capture forms its own full expression, which clears
997
        // Actions.MaybeODRUseExprs. So create an expression evaluation context
998
        // to save the necessary state, and restore it later.
999
333
        EnterExpressionEvaluationContext EC(
1000
333
            Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1001
1002
333
        if (TryConsumeToken(tok::equal))
1003
310
          InitKind = LambdaCaptureInitKind::CopyInit;
1004
23
        else
1005
23
          InitKind = LambdaCaptureInitKind::ListInit;
1006
1007
333
        if (!Tentative) {
1008
310
          Init = ParseInitializer();
1009
310
        } else 
if (23
Tok.is(tok::l_brace)23
) {
1010
5
          BalancedDelimiterTracker Braces(*this, tok::l_brace);
1011
5
          Braces.consumeOpen();
1012
5
          Braces.skipToEnd();
1013
5
          *Tentative = LambdaIntroducerTentativeParse::Incomplete;
1014
18
        } else {
1015
          // We're disambiguating this:
1016
          //
1017
          //   [..., x = expr
1018
          //
1019
          // We need to find the end of the following expression in order to
1020
          // determine whether this is an Obj-C message send's receiver, a
1021
          // C99 designator, or a lambda init-capture.
1022
          //
1023
          // Parse the expression to find where it ends, and annotate it back
1024
          // onto the tokens. We would have parsed this expression the same way
1025
          // in either case: both the RHS of an init-capture and the RHS of an
1026
          // assignment expression are parsed as an initializer-clause, and in
1027
          // neither case can anything be added to the scope between the '[' and
1028
          // here.
1029
          //
1030
          // FIXME: This is horrible. Adding a mechanism to skip an expression
1031
          // would be much cleaner.
1032
          // FIXME: If there is a ',' before the next ']' or ':', we can skip to
1033
          // that instead. (And if we see a ':' with no matching '?', we can
1034
          // classify this as an Obj-C message send.)
1035
18
          SourceLocation StartLoc = Tok.getLocation();
1036
18
          InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
1037
18
          Init = ParseInitializer();
1038
18
          if (!Init.isInvalid())
1039
16
            Init = Actions.CorrectDelayedTyposInExpr(Init.get());
1040
1041
18
          if (Tok.getLocation() != StartLoc) {
1042
            // Back out the lexing of the token after the initializer.
1043
16
            PP.RevertCachedTokens(1);
1044
1045
            // Replace the consumed tokens with an appropriate annotation.
1046
16
            Tok.setLocation(StartLoc);
1047
16
            Tok.setKind(tok::annot_primary_expr);
1048
16
            setExprAnnotation(Tok, Init);
1049
16
            Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation());
1050
16
            PP.AnnotateCachedTokens(Tok);
1051
1052
            // Consume the annotated initializer.
1053
16
            ConsumeAnnotationToken();
1054
16
          }
1055
18
        }
1056
333
      }
1057
1058
1.85k
      TryConsumeToken(tok::ellipsis, EllipsisLocs[3]);
1059
1.85k
    }
1060
1061
    // Check if this is a message send before we act on a possible init-capture.
1062
2.23k
    if (Tentative && 
Tok.is(tok::identifier)654
&&
1063
2.23k
        
NextToken().isOneOf(tok::colon, tok::r_square)101
) {
1064
      // This can only be a message send. We're done with disambiguation.
1065
101
      *Tentative = LambdaIntroducerTentativeParse::MessageSend;
1066
101
      return false;
1067
101
    }
1068
1069
    // Ensure that any ellipsis was in the right place.
1070
2.13k
    SourceLocation EllipsisLoc;
1071
2.13k
    if (std::any_of(std::begin(EllipsisLocs), std::end(EllipsisLocs),
1072
8.27k
                    [](SourceLocation Loc) { return Loc.isValid(); })) {
1073
      // The '...' should appear before the identifier in an init-capture, and
1074
      // after the identifier otherwise.
1075
160
      bool InitCapture = InitKind != LambdaCaptureInitKind::NoInit;
1076
160
      SourceLocation *ExpectedEllipsisLoc =
1077
160
          !InitCapture      ? 
&EllipsisLocs[2]93
:
1078
160
          
Kind == LCK_ByRef67
?
&EllipsisLocs[1]12
:
1079
67
                              
&EllipsisLocs[0]55
;
1080
160
      EllipsisLoc = *ExpectedEllipsisLoc;
1081
1082
160
      unsigned DiagID = 0;
1083
160
      if (EllipsisLoc.isInvalid()) {
1084
44
        DiagID = diag::err_lambda_capture_misplaced_ellipsis;
1085
176
        for (SourceLocation Loc : EllipsisLocs) {
1086
176
          if (Loc.isValid())
1087
44
            EllipsisLoc = Loc;
1088
176
        }
1089
116
      } else {
1090
116
        unsigned NumEllipses = std::accumulate(
1091
116
            std::begin(EllipsisLocs), std::end(EllipsisLocs), 0,
1092
464
            [](int N, SourceLocation Loc) { return N + Loc.isValid(); });
1093
116
        if (NumEllipses > 1)
1094
0
          DiagID = diag::err_lambda_capture_multiple_ellipses;
1095
116
      }
1096
160
      if (DiagID) {
1097
44
        NonTentativeAction([&] {
1098
          // Point the diagnostic at the first misplaced ellipsis.
1099
43
          SourceLocation DiagLoc;
1100
106
          for (SourceLocation &Loc : EllipsisLocs) {
1101
106
            if (&Loc != ExpectedEllipsisLoc && 
Loc.isValid()83
) {
1102
43
              DiagLoc = Loc;
1103
43
              break;
1104
43
            }
1105
106
          }
1106
43
          assert(DiagLoc.isValid() && "no location for diagnostic");
1107
1108
          // Issue the diagnostic and produce fixits showing where the ellipsis
1109
          // should have been written.
1110
0
          auto &&D = Diag(DiagLoc, DiagID);
1111
43
          if (DiagID == diag::err_lambda_capture_misplaced_ellipsis) {
1112
43
            SourceLocation ExpectedLoc =
1113
43
                InitCapture ? 
Loc28
1114
43
                            : Lexer::getLocForEndOfToken(
1115
15
                                  Loc, 0, PP.getSourceManager(), getLangOpts());
1116
43
            D << InitCapture << FixItHint::CreateInsertion(ExpectedLoc, "...");
1117
43
          }
1118
172
          for (SourceLocation &Loc : EllipsisLocs) {
1119
172
            if (&Loc != ExpectedEllipsisLoc && 
Loc.isValid()129
)
1120
43
              D << FixItHint::CreateRemoval(Loc);
1121
172
          }
1122
43
        });
1123
44
      }
1124
160
    }
1125
1126
    // Process the init-capture initializers now rather than delaying until we
1127
    // form the lambda-expression so that they can be handled in the context
1128
    // enclosing the lambda-expression, rather than in the context of the
1129
    // lambda-expression itself.
1130
2.13k
    ParsedType InitCaptureType;
1131
2.13k
    if (Init.isUsable())
1132
434
      Init = Actions.CorrectDelayedTyposInExpr(Init.get());
1133
2.13k
    if (Init.isUsable()) {
1134
432
      NonTentativeAction([&] {
1135
        // Get the pointer and store it in an lvalue, so we can use it as an
1136
        // out argument.
1137
418
        Expr *InitExpr = Init.get();
1138
        // This performs any lvalue-to-rvalue conversions if necessary, which
1139
        // can affect what gets captured in the containing decl-context.
1140
418
        InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
1141
418
            Loc, Kind == LCK_ByRef, EllipsisLoc, Id, InitKind, InitExpr);
1142
418
        Init = InitExpr;
1143
418
      });
1144
432
    }
1145
1146
2.13k
    SourceLocation LocEnd = PrevTokLocation;
1147
1148
2.13k
    Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
1149
2.13k
                     InitCaptureType, SourceRange(LocStart, LocEnd));
1150
2.13k
  }
1151
1152
8.24k
  T.consumeClose();
1153
8.24k
  Intro.Range.setEnd(T.getCloseLocation());
1154
8.24k
  return false;
1155
9.34k
}
1156
1157
static void tryConsumeLambdaSpecifierToken(Parser &P,
1158
                                           SourceLocation &MutableLoc,
1159
                                           SourceLocation &ConstexprLoc,
1160
                                           SourceLocation &ConstevalLoc,
1161
6.18k
                                           SourceLocation &DeclEndLoc) {
1162
6.18k
  assert(MutableLoc.isInvalid());
1163
0
  assert(ConstexprLoc.isInvalid());
1164
  // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
1165
  // to the final of those locations. Emit an error if we have multiple
1166
  // copies of those keywords and recover.
1167
1168
6.53k
  while (true) {
1169
6.53k
    switch (P.getCurToken().getKind()) {
1170
209
    case tok::kw_mutable: {
1171
209
      if (MutableLoc.isValid()) {
1172
17
        P.Diag(P.getCurToken().getLocation(),
1173
17
               diag::err_lambda_decl_specifier_repeated)
1174
17
            << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1175
17
      }
1176
209
      MutableLoc = P.ConsumeToken();
1177
209
      DeclEndLoc = MutableLoc;
1178
209
      break /*switch*/;
1179
0
    }
1180
136
    case tok::kw_constexpr:
1181
136
      if (ConstexprLoc.isValid()) {
1182
13
        P.Diag(P.getCurToken().getLocation(),
1183
13
               diag::err_lambda_decl_specifier_repeated)
1184
13
            << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1185
13
      }
1186
136
      ConstexprLoc = P.ConsumeToken();
1187
136
      DeclEndLoc = ConstexprLoc;
1188
136
      break /*switch*/;
1189
5
    case tok::kw_consteval:
1190
5
      if (ConstevalLoc.isValid()) {
1191
0
        P.Diag(P.getCurToken().getLocation(),
1192
0
               diag::err_lambda_decl_specifier_repeated)
1193
0
            << 2 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1194
0
      }
1195
5
      ConstevalLoc = P.ConsumeToken();
1196
5
      DeclEndLoc = ConstevalLoc;
1197
5
      break /*switch*/;
1198
6.18k
    default:
1199
6.18k
      return;
1200
6.53k
    }
1201
6.53k
  }
1202
6.18k
}
1203
1204
static void
1205
addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
1206
6.18k
                                  DeclSpec &DS) {
1207
6.18k
  if (ConstexprLoc.isValid()) {
1208
123
    P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17
1209
123
                             ? 
diag::ext_constexpr_on_lambda_cxx178
1210
123
                             : 
diag::warn_cxx14_compat_constexpr_on_lambda115
);
1211
123
    const char *PrevSpec = nullptr;
1212
123
    unsigned DiagID = 0;
1213
123
    DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, ConstexprLoc, PrevSpec,
1214
123
                        DiagID);
1215
123
    assert(PrevSpec == nullptr && DiagID == 0 &&
1216
123
           "Constexpr cannot have been set previously!");
1217
123
  }
1218
6.18k
}
1219
1220
static void addConstevalToLambdaDeclSpecifier(Parser &P,
1221
                                              SourceLocation ConstevalLoc,
1222
6.18k
                                              DeclSpec &DS) {
1223
6.18k
  if (ConstevalLoc.isValid()) {
1224
5
    P.Diag(ConstevalLoc, diag::warn_cxx20_compat_consteval);
1225
5
    const char *PrevSpec = nullptr;
1226
5
    unsigned DiagID = 0;
1227
5
    DS.SetConstexprSpec(ConstexprSpecKind::Consteval, ConstevalLoc, PrevSpec,
1228
5
                        DiagID);
1229
5
    if (DiagID != 0)
1230
0
      P.Diag(ConstevalLoc, DiagID) << PrevSpec;
1231
5
  }
1232
6.18k
}
1233
1234
/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1235
/// expression.
1236
ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1237
7.89k
                     LambdaIntroducer &Intro) {
1238
7.89k
  SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1239
7.89k
  Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1240
1241
7.89k
  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1242
7.89k
                                "lambda expression parsing");
1243
1244
1245
1246
  // FIXME: Call into Actions to add any init-capture declarations to the
1247
  // scope while parsing the lambda-declarator and compound-statement.
1248
1249
  // Parse lambda-declarator[opt].
1250
7.89k
  DeclSpec DS(AttrFactory);
1251
7.89k
  Declarator D(DS, DeclaratorContext::LambdaExpr);
1252
7.89k
  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1253
7.89k
  Actions.PushLambdaScope();
1254
1255
7.89k
  ParsedAttributes Attr(AttrFactory);
1256
7.89k
  if (getLangOpts().CUDA) {
1257
    // In CUDA code, GNU attributes are allowed to appear immediately after the
1258
    // "[...]", even if there is no "(...)" before the lambda body.
1259
228
    MaybeParseGNUAttributes(D);
1260
228
  }
1261
1262
  // Helper to emit a warning if we see a CUDA host/device/global attribute
1263
  // after '(...)'. nvcc doesn't accept this.
1264
7.89k
  auto WarnIfHasCUDATargetAttr = [&] {
1265
7.89k
    if (getLangOpts().CUDA)
1266
228
      for (const ParsedAttr &A : Attr)
1267
26
        if (A.getKind() == ParsedAttr::AT_CUDADevice ||
1268
26
            
A.getKind() == ParsedAttr::AT_CUDAHost10
||
1269
26
            
A.getKind() == ParsedAttr::AT_CUDAGlobal0
)
1270
26
          Diag(A.getLoc(), diag::warn_cuda_attr_lambda_position)
1271
26
              << A.getAttrName()->getName();
1272
7.89k
  };
1273
1274
7.89k
  MultiParseScope TemplateParamScope(*this);
1275
7.89k
  if (Tok.is(tok::less)) {
1276
166
    Diag(Tok, getLangOpts().CPlusPlus20
1277
166
                  ? 
diag::warn_cxx17_compat_lambda_template_parameter_list139
1278
166
                  : 
diag::ext_lambda_template_parameter_list27
);
1279
1280
166
    SmallVector<NamedDecl*, 4> TemplateParams;
1281
166
    SourceLocation LAngleLoc, RAngleLoc;
1282
166
    if (ParseTemplateParameters(TemplateParamScope,
1283
166
                                CurTemplateDepthTracker.getDepth(),
1284
166
                                TemplateParams, LAngleLoc, RAngleLoc)) {
1285
0
      Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1286
0
      return ExprError();
1287
0
    }
1288
1289
166
    if (TemplateParams.empty()) {
1290
2
      Diag(RAngleLoc,
1291
2
           diag::err_lambda_template_parameter_list_empty);
1292
164
    } else {
1293
164
      ExprResult RequiresClause;
1294
164
      if (TryConsumeToken(tok::kw_requires)) {
1295
21
        RequiresClause =
1296
21
            Actions.ActOnRequiresClause(ParseConstraintLogicalOrExpression(
1297
21
                /*IsTrailingRequiresClause=*/false));
1298
21
        if (RequiresClause.isInvalid())
1299
0
          SkipUntil({tok::l_brace, tok::l_paren}, StopAtSemi | StopBeforeMatch);
1300
21
      }
1301
1302
164
      Actions.ActOnLambdaExplicitTemplateParameterList(
1303
164
          LAngleLoc, TemplateParams, RAngleLoc, RequiresClause);
1304
164
      ++CurTemplateDepthTracker;
1305
164
    }
1306
166
  }
1307
1308
  // Implement WG21 P2173, which allows attributes immediately before the
1309
  // lambda declarator and applies them to the corresponding function operator
1310
  // or operator template declaration. We accept this as a conforming extension
1311
  // in all language modes that support lambdas.
1312
7.89k
  if (isCXX11AttributeSpecifier()) {
1313
11
    Diag(Tok, getLangOpts().CPlusPlus2b
1314
11
                  ? 
diag::warn_cxx20_compat_decl_attrs_on_lambda4
1315
11
                  : 
diag::ext_decl_attrs_on_lambda7
);
1316
11
    MaybeParseCXX11Attributes(D);
1317
11
  }
1318
1319
7.89k
  TypeResult TrailingReturnType;
1320
7.89k
  SourceLocation TrailingReturnTypeLoc;
1321
1322
7.89k
  auto ParseLambdaSpecifiers =
1323
7.89k
      [&](SourceLocation LParenLoc, SourceLocation RParenLoc,
1324
7.89k
          MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo,
1325
7.89k
          SourceLocation EllipsisLoc) {
1326
6.18k
        SourceLocation DeclEndLoc = RParenLoc;
1327
1328
        // GNU-style attributes must be parsed before the mutable specifier to
1329
        // be compatible with GCC. MSVC-style attributes must be parsed before
1330
        // the mutable specifier to be compatible with MSVC.
1331
6.18k
        MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr);
1332
1333
        // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update
1334
        // the DeclEndLoc.
1335
6.18k
        SourceLocation MutableLoc;
1336
6.18k
        SourceLocation ConstexprLoc;
1337
6.18k
        SourceLocation ConstevalLoc;
1338
6.18k
        tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
1339
6.18k
                                       ConstevalLoc, DeclEndLoc);
1340
1341
6.18k
        addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
1342
6.18k
        addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
1343
        // Parse exception-specification[opt].
1344
6.18k
        ExceptionSpecificationType ESpecType = EST_None;
1345
6.18k
        SourceRange ESpecRange;
1346
6.18k
        SmallVector<ParsedType, 2> DynamicExceptions;
1347
6.18k
        SmallVector<SourceRange, 2> DynamicExceptionRanges;
1348
6.18k
        ExprResult NoexceptExpr;
1349
6.18k
        CachedTokens *ExceptionSpecTokens;
1350
6.18k
        ESpecType = tryParseExceptionSpecification(
1351
6.18k
            /*Delayed=*/false, ESpecRange, DynamicExceptions,
1352
6.18k
            DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens);
1353
1354
6.18k
        if (ESpecType != EST_None)
1355
60
          DeclEndLoc = ESpecRange.getEnd();
1356
1357
        // Parse attribute-specifier[opt].
1358
6.18k
        MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1359
1360
        // Parse OpenCL addr space attribute.
1361
6.18k
        if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local,
1362
6.18k
                        tok::kw___constant, tok::kw___generic)) {
1363
22
          ParseOpenCLQualifiers(DS.getAttributes());
1364
22
          ConsumeToken();
1365
22
        }
1366
1367
6.18k
        SourceLocation FunLocalRangeEnd = DeclEndLoc;
1368
1369
        // Parse trailing-return-type[opt].
1370
6.18k
        if (Tok.is(tok::arrow)) {
1371
907
          FunLocalRangeEnd = Tok.getLocation();
1372
907
          SourceRange Range;
1373
907
          TrailingReturnType = ParseTrailingReturnType(
1374
907
              Range, /*MayBeFollowedByDirectInit*/ false);
1375
907
          TrailingReturnTypeLoc = Range.getBegin();
1376
907
          if (Range.getEnd().isValid())
1377
677
            DeclEndLoc = Range.getEnd();
1378
907
        }
1379
1380
6.18k
        SourceLocation NoLoc;
1381
6.18k
        D.AddTypeInfo(
1382
6.18k
            DeclaratorChunk::getFunction(
1383
6.18k
                /*HasProto=*/true,
1384
6.18k
                /*IsAmbiguous=*/false, LParenLoc, ParamInfo.data(),
1385
6.18k
                ParamInfo.size(), EllipsisLoc, RParenLoc,
1386
6.18k
                /*RefQualifierIsLvalueRef=*/true,
1387
6.18k
                /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType, ESpecRange,
1388
6.18k
                DynamicExceptions.data(), DynamicExceptionRanges.data(),
1389
6.18k
                DynamicExceptions.size(),
1390
6.18k
                NoexceptExpr.isUsable() ? 
NoexceptExpr.get()11
:
nullptr6.17k
,
1391
6.18k
                /*ExceptionSpecTokens*/ nullptr,
1392
6.18k
                /*DeclsInPrototype=*/None, LParenLoc, FunLocalRangeEnd, D,
1393
6.18k
                TrailingReturnType, TrailingReturnTypeLoc, &DS),
1394
6.18k
            std::move(Attr), DeclEndLoc);
1395
6.18k
      };
1396
1397
7.89k
  if (Tok.is(tok::l_paren)) {
1398
6.13k
    ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
1399
6.13k
                                        Scope::FunctionDeclarationScope |
1400
6.13k
                                        Scope::DeclScope);
1401
1402
6.13k
    BalancedDelimiterTracker T(*this, tok::l_paren);
1403
6.13k
    T.consumeOpen();
1404
6.13k
    SourceLocation LParenLoc = T.getOpenLocation();
1405
1406
    // Parse parameter-declaration-clause.
1407
6.13k
    SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
1408
6.13k
    SourceLocation EllipsisLoc;
1409
1410
6.13k
    if (Tok.isNot(tok::r_paren)) {
1411
3.58k
      Actions.RecordParsingTemplateParameterDepth(
1412
3.58k
          CurTemplateDepthTracker.getOriginalDepth());
1413
1414
3.58k
      ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo,
1415
3.58k
                                      EllipsisLoc);
1416
      // For a generic lambda, each 'auto' within the parameter declaration
1417
      // clause creates a template type parameter, so increment the depth.
1418
      // If we've parsed any explicit template parameters, then the depth will
1419
      // have already been incremented. So we make sure that at most a single
1420
      // depth level is added.
1421
3.58k
      if (Actions.getCurGenericLambda())
1422
2.07k
        CurTemplateDepthTracker.setAddedDepth(1);
1423
3.58k
    }
1424
1425
6.13k
    T.consumeClose();
1426
1427
    // Parse lambda-specifiers.
1428
6.13k
    ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(),
1429
6.13k
                          ParamInfo, EllipsisLoc);
1430
1431
    // Parse requires-clause[opt].
1432
6.13k
    if (Tok.is(tok::kw_requires))
1433
14
      ParseTrailingRequiresClause(D);
1434
6.13k
  } else 
if (1.76k
Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1435
1.76k
                         tok::kw_constexpr, tok::kw_consteval,
1436
1.76k
                         tok::kw___private, tok::kw___global, tok::kw___local,
1437
1.76k
                         tok::kw___constant, tok::kw___generic,
1438
1.76k
                         tok::kw_requires, tok::kw_noexcept) ||
1439
1.76k
             
(1.70k
Tok.is(tok::l_square)1.70k
&&
NextToken().is(tok::l_square)0
)) {
1440
57
    if (!getLangOpts().CPlusPlus2b)
1441
      // It's common to forget that one needs '()' before 'mutable', an
1442
      // attribute specifier, the result type, or the requires clause. Deal with
1443
      // this.
1444
27
      Diag(Tok, diag::ext_lambda_missing_parens)
1445
27
          << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
1446
1447
57
    SourceLocation NoLoc;
1448
    // Parse lambda-specifiers.
1449
57
    std::vector<DeclaratorChunk::ParamInfo> EmptyParamInfo;
1450
57
    ParseLambdaSpecifiers(/*LParenLoc=*/NoLoc, /*RParenLoc=*/NoLoc,
1451
57
                          EmptyParamInfo, /*EllipsisLoc=*/NoLoc);
1452
57
  }
1453
1454
7.89k
  WarnIfHasCUDATargetAttr();
1455
1456
  // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1457
  // it.
1458
7.89k
  unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
1459
7.89k
                        Scope::CompoundStmtScope;
1460
7.89k
  ParseScope BodyScope(this, ScopeFlags);
1461
1462
7.89k
  Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
1463
1464
  // Parse compound-statement.
1465
7.89k
  if (!Tok.is(tok::l_brace)) {
1466
181
    Diag(Tok, diag::err_expected_lambda_body);
1467
181
    Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1468
181
    return ExprError();
1469
181
  }
1470
1471
7.71k
  StmtResult Stmt(ParseCompoundStatementBody());
1472
7.71k
  BodyScope.Exit();
1473
7.71k
  TemplateParamScope.Exit();
1474
1475
7.71k
  if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
1476
7.70k
    return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
1477
1478
6
  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1479
6
  return ExprError();
1480
7.71k
}
1481
1482
/// ParseCXXCasts - This handles the various ways to cast expressions to another
1483
/// type.
1484
///
1485
///       postfix-expression: [C++ 5.2p1]
1486
///         'dynamic_cast' '<' type-name '>' '(' expression ')'
1487
///         'static_cast' '<' type-name '>' '(' expression ')'
1488
///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
1489
///         'const_cast' '<' type-name '>' '(' expression ')'
1490
///
1491
/// C++ for OpenCL s2.3.1 adds:
1492
///         'addrspace_cast' '<' type-name '>' '(' expression ')'
1493
149k
ExprResult Parser::ParseCXXCasts() {
1494
149k
  tok::TokenKind Kind = Tok.getKind();
1495
149k
  const char *CastName = nullptr; // For error messages
1496
1497
149k
  switch (Kind) {
1498
0
  default: llvm_unreachable("Unknown C++ cast!");
1499
16
  case tok::kw_addrspace_cast:   CastName = "addrspace_cast";   break;
1500
4.90k
  case tok::kw_const_cast:       CastName = "const_cast";       break;
1501
1.27k
  case tok::kw_dynamic_cast:     CastName = "dynamic_cast";     break;
1502
8.05k
  case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1503
135k
  case tok::kw_static_cast:      CastName = "static_cast";      break;
1504
149k
  }
1505
1506
149k
  SourceLocation OpLoc = ConsumeToken();
1507
149k
  SourceLocation LAngleBracketLoc = Tok.getLocation();
1508
1509
  // Check for "<::" which is parsed as "[:".  If found, fix token stream,
1510
  // diagnose error, suggest fix, and recover parsing.
1511
149k
  if (Tok.is(tok::l_square) && 
Tok.getLength() == 217
) {
1512
17
    Token Next = NextToken();
1513
17
    if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1514
5
      FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1515
17
  }
1516
1517
149k
  if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1518
15
    return ExprError();
1519
1520
  // Parse the common declaration-specifiers piece.
1521
149k
  DeclSpec DS(AttrFactory);
1522
149k
  ParseSpecifierQualifierList(DS);
1523
1524
  // Parse the abstract-declarator, if present.
1525
149k
  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
1526
149k
  ParseDeclarator(DeclaratorInfo);
1527
1528
149k
  SourceLocation RAngleBracketLoc = Tok.getLocation();
1529
1530
149k
  if (ExpectAndConsume(tok::greater))
1531
0
    return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1532
1533
149k
  BalancedDelimiterTracker T(*this, tok::l_paren);
1534
1535
149k
  if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
1536
0
    return ExprError();
1537
1538
149k
  ExprResult Result = ParseExpression();
1539
1540
  // Match the ')'.
1541
149k
  T.consumeClose();
1542
1543
149k
  if (!Result.isInvalid() && 
!DeclaratorInfo.isInvalidType()149k
)
1544
149k
    Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
1545
149k
                                       LAngleBracketLoc, DeclaratorInfo,
1546
149k
                                       RAngleBracketLoc,
1547
149k
                                       T.getOpenLocation(), Result.get(),
1548
149k
                                       T.getCloseLocation());
1549
1550
149k
  return Result;
1551
149k
}
1552
1553
/// ParseCXXTypeid - This handles the C++ typeid expression.
1554
///
1555
///       postfix-expression: [C++ 5.2p1]
1556
///         'typeid' '(' expression ')'
1557
///         'typeid' '(' type-id ')'
1558
///
1559
5.56k
ExprResult Parser::ParseCXXTypeid() {
1560
5.56k
  assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
1561
1562
0
  SourceLocation OpLoc = ConsumeToken();
1563
5.56k
  SourceLocation LParenLoc, RParenLoc;
1564
5.56k
  BalancedDelimiterTracker T(*this, tok::l_paren);
1565
1566
  // typeid expressions are always parenthesized.
1567
5.56k
  if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
1568
1
    return ExprError();
1569
5.56k
  LParenLoc = T.getOpenLocation();
1570
1571
5.56k
  ExprResult Result;
1572
1573
  // C++0x [expr.typeid]p3:
1574
  //   When typeid is applied to an expression other than an lvalue of a
1575
  //   polymorphic class type [...] The expression is an unevaluated
1576
  //   operand (Clause 5).
1577
  //
1578
  // Note that we can't tell whether the expression is an lvalue of a
1579
  // polymorphic class type until after we've parsed the expression; we
1580
  // speculatively assume the subexpression is unevaluated, and fix it up
1581
  // later.
1582
  //
1583
  // We enter the unevaluated context before trying to determine whether we
1584
  // have a type-id, because the tentative parse logic will try to resolve
1585
  // names, and must treat them as unevaluated.
1586
5.56k
  EnterExpressionEvaluationContext Unevaluated(
1587
5.56k
      Actions, Sema::ExpressionEvaluationContext::Unevaluated,
1588
5.56k
      Sema::ReuseLambdaContextDecl);
1589
1590
5.56k
  if (isTypeIdInParens()) {
1591
5.26k
    TypeResult Ty = ParseTypeName();
1592
1593
    // Match the ')'.
1594
5.26k
    T.consumeClose();
1595
5.26k
    RParenLoc = T.getCloseLocation();
1596
5.26k
    if (Ty.isInvalid() || 
RParenLoc.isInvalid()5.25k
)
1597
8
      return ExprError();
1598
1599
5.25k
    Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1600
5.25k
                                    Ty.get().getAsOpaquePtr(), RParenLoc);
1601
5.25k
  } else {
1602
297
    Result = ParseExpression();
1603
1604
    // Match the ')'.
1605
297
    if (Result.isInvalid())
1606
6
      SkipUntil(tok::r_paren, StopAtSemi);
1607
291
    else {
1608
291
      T.consumeClose();
1609
291
      RParenLoc = T.getCloseLocation();
1610
291
      if (RParenLoc.isInvalid())
1611
0
        return ExprError();
1612
1613
291
      Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1614
291
                                      Result.get(), RParenLoc);
1615
291
    }
1616
297
  }
1617
1618
5.55k
  return Result;
1619
5.56k
}
1620
1621
/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1622
///
1623
///         '__uuidof' '(' expression ')'
1624
///         '__uuidof' '(' type-id ')'
1625
///
1626
178
ExprResult Parser::ParseCXXUuidof() {
1627
178
  assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1628
1629
0
  SourceLocation OpLoc = ConsumeToken();
1630
178
  BalancedDelimiterTracker T(*this, tok::l_paren);
1631
1632
  // __uuidof expressions are always parenthesized.
1633
178
  if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1634
0
    return ExprError();
1635
1636
178
  ExprResult Result;
1637
1638
178
  if (isTypeIdInParens()) {
1639
147
    TypeResult Ty = ParseTypeName();
1640
1641
    // Match the ')'.
1642
147
    T.consumeClose();
1643
1644
147
    if (Ty.isInvalid())
1645
0
      return ExprError();
1646
1647
147
    Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1648
147
                                    Ty.get().getAsOpaquePtr(),
1649
147
                                    T.getCloseLocation());
1650
147
  } else {
1651
31
    EnterExpressionEvaluationContext Unevaluated(
1652
31
        Actions, Sema::ExpressionEvaluationContext::Unevaluated);
1653
31
    Result = ParseExpression();
1654
1655
    // Match the ')'.
1656
31
    if (Result.isInvalid())
1657
0
      SkipUntil(tok::r_paren, StopAtSemi);
1658
31
    else {
1659
31
      T.consumeClose();
1660
1661
31
      Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1662
31
                                      /*isType=*/false,
1663
31
                                      Result.get(), T.getCloseLocation());
1664
31
    }
1665
31
  }
1666
1667
178
  return Result;
1668
178
}
1669
1670
/// Parse a C++ pseudo-destructor expression after the base,
1671
/// . or -> operator, and nested-name-specifier have already been
1672
/// parsed. We're handling this fragment of the grammar:
1673
///
1674
///       postfix-expression: [C++2a expr.post]
1675
///         postfix-expression . template[opt] id-expression
1676
///         postfix-expression -> template[opt] id-expression
1677
///
1678
///       id-expression:
1679
///         qualified-id
1680
///         unqualified-id
1681
///
1682
///       qualified-id:
1683
///         nested-name-specifier template[opt] unqualified-id
1684
///
1685
///       nested-name-specifier:
1686
///         type-name ::
1687
///         decltype-specifier ::    FIXME: not implemented, but probably only
1688
///                                         allowed in C++ grammar by accident
1689
///         nested-name-specifier identifier ::
1690
///         nested-name-specifier template[opt] simple-template-id ::
1691
///         [...]
1692
///
1693
///       unqualified-id:
1694
///         ~ type-name
1695
///         ~ decltype-specifier
1696
///         [...]
1697
///
1698
/// ... where the all but the last component of the nested-name-specifier
1699
/// has already been parsed, and the base expression is not of a non-dependent
1700
/// class type.
1701
ExprResult
1702
Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1703
                                 tok::TokenKind OpKind,
1704
                                 CXXScopeSpec &SS,
1705
7.70k
                                 ParsedType ObjectType) {
1706
  // If the last component of the (optional) nested-name-specifier is
1707
  // template[opt] simple-template-id, it has already been annotated.
1708
7.70k
  UnqualifiedId FirstTypeName;
1709
7.70k
  SourceLocation CCLoc;
1710
7.70k
  if (Tok.is(tok::identifier)) {
1711
175
    FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1712
175
    ConsumeToken();
1713
175
    assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1714
0
    CCLoc = ConsumeToken();
1715
7.52k
  } else if (Tok.is(tok::annot_template_id)) {
1716
30
    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1717
    // FIXME: Carry on and build an AST representation for tooling.
1718
30
    if (TemplateId->isInvalid())
1719
0
      return ExprError();
1720
30
    FirstTypeName.setTemplateId(TemplateId);
1721
30
    ConsumeAnnotationToken();
1722
30
    assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1723
0
    CCLoc = ConsumeToken();
1724
7.49k
  } else {
1725
7.49k
    assert(SS.isEmpty() && "missing last component of nested name specifier");
1726
0
    FirstTypeName.setIdentifier(nullptr, SourceLocation());
1727
7.49k
  }
1728
1729
  // Parse the tilde.
1730
7.70k
  assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1731
0
  SourceLocation TildeLoc = ConsumeToken();
1732
1733
7.70k
  if (Tok.is(tok::kw_decltype) && 
!FirstTypeName.isValid()23
) {
1734
20
    DeclSpec DS(AttrFactory);
1735
20
    ParseDecltypeSpecifier(DS);
1736
20
    if (DS.getTypeSpecType() == TST_error)
1737
0
      return ExprError();
1738
20
    return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1739
20
                                             TildeLoc, DS);
1740
20
  }
1741
1742
7.68k
  if (!Tok.is(tok::identifier)) {
1743
3
    Diag(Tok, diag::err_destructor_tilde_identifier);
1744
3
    return ExprError();
1745
3
  }
1746
1747
  // Parse the second type.
1748
7.67k
  UnqualifiedId SecondTypeName;
1749
7.67k
  IdentifierInfo *Name = Tok.getIdentifierInfo();
1750
7.67k
  SourceLocation NameLoc = ConsumeToken();
1751
7.67k
  SecondTypeName.setIdentifier(Name, NameLoc);
1752
1753
  // If there is a '<', the second type name is a template-id. Parse
1754
  // it as such.
1755
  //
1756
  // FIXME: This is not a context in which a '<' is assumed to start a template
1757
  // argument list. This affects examples such as
1758
  //   void f(auto *p) { p->~X<int>(); }
1759
  // ... but there's no ambiguity, and nowhere to write 'template' in such an
1760
  // example, so we accept it anyway.
1761
7.67k
  if (Tok.is(tok::less) &&
1762
7.67k
      ParseUnqualifiedIdTemplateId(
1763
480
          SS, ObjectType, Base && Base->containsErrors(), SourceLocation(),
1764
480
          Name, NameLoc, false, SecondTypeName,
1765
480
          /*AssumeTemplateId=*/true))
1766
5
    return ExprError();
1767
1768
7.67k
  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1769
7.67k
                                           SS, FirstTypeName, CCLoc, TildeLoc,
1770
7.67k
                                           SecondTypeName);
1771
7.67k
}
1772
1773
/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1774
///
1775
///       boolean-literal: [C++ 2.13.5]
1776
///         'true'
1777
///         'false'
1778
282k
ExprResult Parser::ParseCXXBoolLiteral() {
1779
282k
  tok::TokenKind Kind = Tok.getKind();
1780
282k
  return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1781
282k
}
1782
1783
/// ParseThrowExpression - This handles the C++ throw expression.
1784
///
1785
///       throw-expression: [C++ 15]
1786
///         'throw' assignment-expression[opt]
1787
14.3k
ExprResult Parser::ParseThrowExpression() {
1788
14.3k
  assert(Tok.is(tok::kw_throw) && "Not throw!");
1789
0
  SourceLocation ThrowLoc = ConsumeToken();           // Eat the throw token.
1790
1791
  // If the current token isn't the start of an assignment-expression,
1792
  // then the expression is not present.  This handles things like:
1793
  //   "C ? throw : (void)42", which is crazy but legal.
1794
14.3k
  switch (Tok.getKind()) {  // FIXME: move this predicate somewhere common.
1795
6.88k
  case tok::semi:
1796
6.88k
  case tok::r_paren:
1797
6.88k
  case tok::r_square:
1798
6.88k
  case tok::r_brace:
1799
6.89k
  case tok::colon:
1800
6.90k
  case tok::comma:
1801
6.90k
    return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
1802
1803
7.47k
  default:
1804
7.47k
    ExprResult Expr(ParseAssignmentExpression());
1805
7.47k
    if (Expr.isInvalid()) 
return Expr0
;
1806
7.47k
    return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
1807
14.3k
  }
1808
14.3k
}
1809
1810
/// Parse the C++ Coroutines co_yield expression.
1811
///
1812
///       co_yield-expression:
1813
///         'co_yield' assignment-expression[opt]
1814
174
ExprResult Parser::ParseCoyieldExpression() {
1815
174
  assert(Tok.is(tok::kw_co_yield) && "Not co_yield!");
1816
1817
0
  SourceLocation Loc = ConsumeToken();
1818
174
  ExprResult Expr = Tok.is(tok::l_brace) ? 
ParseBraceInitializer()12
1819
174
                                         : 
ParseAssignmentExpression()162
;
1820
174
  if (!Expr.isInvalid())
1821
174
    Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
1822
174
  return Expr;
1823
174
}
1824
1825
/// ParseCXXThis - This handles the C++ 'this' pointer.
1826
///
1827
/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1828
/// a non-lvalue expression whose value is the address of the object for which
1829
/// the function is called.
1830
208k
ExprResult Parser::ParseCXXThis() {
1831
208k
  assert(Tok.is(tok::kw_this) && "Not 'this'!");
1832
0
  SourceLocation ThisLoc = ConsumeToken();
1833
208k
  return Actions.ActOnCXXThis(ThisLoc);
1834
208k
}
1835
1836
/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1837
/// Can be interpreted either as function-style casting ("int(x)")
1838
/// or class type construction ("ClassType(x,y,z)")
1839
/// or creation of a value-initialized type ("int()").
1840
/// See [C++ 5.2.3].
1841
///
1842
///       postfix-expression: [C++ 5.2p1]
1843
///         simple-type-specifier '(' expression-list[opt] ')'
1844
/// [C++0x] simple-type-specifier braced-init-list
1845
///         typename-specifier '(' expression-list[opt] ')'
1846
/// [C++0x] typename-specifier braced-init-list
1847
///
1848
/// In C++1z onwards, the type specifier can also be a template-name.
1849
ExprResult
1850
326k
Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1851
326k
  Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCast);
1852
326k
  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
1853
1854
326k
  assert((Tok.is(tok::l_paren) ||
1855
326k
          (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
1856
326k
         && "Expected '(' or '{'!");
1857
1858
326k
  if (Tok.is(tok::l_brace)) {
1859
6.55k
    PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
1860
6.55k
    ExprResult Init = ParseBraceInitializer();
1861
6.55k
    if (Init.isInvalid())
1862
2
      return Init;
1863
6.55k
    Expr *InitList = Init.get();
1864
6.55k
    return Actions.ActOnCXXTypeConstructExpr(
1865
6.55k
        TypeRep, InitList->getBeginLoc(), MultiExprArg(&InitList, 1),
1866
6.55k
        InitList->getEndLoc(), /*ListInitialization=*/true);
1867
320k
  } else {
1868
320k
    BalancedDelimiterTracker T(*this, tok::l_paren);
1869
320k
    T.consumeOpen();
1870
1871
320k
    PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
1872
1873
320k
    ExprVector Exprs;
1874
320k
    CommaLocsTy CommaLocs;
1875
1876
320k
    auto RunSignatureHelp = [&]() {
1877
15
      QualType PreferredType;
1878
15
      if (TypeRep)
1879
14
        PreferredType = Actions.ProduceConstructorSignatureHelp(
1880
14
            getCurScope(), TypeRep.get()->getCanonicalTypeInternal(),
1881
14
            DS.getEndLoc(), Exprs, T.getOpenLocation());
1882
15
      CalledSignatureHelp = true;
1883
15
      return PreferredType;
1884
15
    };
1885
1886
320k
    if (Tok.isNot(tok::r_paren)) {
1887
202k
      if (
ParseExpressionList(Exprs, CommaLocs, [&] 169k
{
1888
202k
            PreferredType.enterFunctionArgument(Tok.getLocation(),
1889
202k
                                                RunSignatureHelp);
1890
202k
          })) {
1891
63
        if (PP.isCodeCompletionReached() && 
!CalledSignatureHelp15
)
1892
2
          RunSignatureHelp();
1893
63
        SkipUntil(tok::r_paren, StopAtSemi);
1894
63
        return ExprError();
1895
63
      }
1896
169k
    }
1897
1898
    // Match the ')'.
1899
320k
    T.consumeClose();
1900
1901
    // TypeRep could be null, if it references an invalid typedef.
1902
320k
    if (!TypeRep)
1903
81
      return ExprError();
1904
1905
320k
    assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1906
320k
           "Unexpected number of commas!");
1907
0
    return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1908
320k
                                             Exprs, T.getCloseLocation(),
1909
320k
                                             /*ListInitialization=*/false);
1910
320k
  }
1911
326k
}
1912
1913
/// ParseCXXCondition - if/switch/while condition expression.
1914
///
1915
///       condition:
1916
///         expression
1917
///         type-specifier-seq declarator '=' assignment-expression
1918
/// [C++11] type-specifier-seq declarator '=' initializer-clause
1919
/// [C++11] type-specifier-seq declarator braced-init-list
1920
/// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
1921
///             brace-or-equal-initializer
1922
/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1923
///             '=' assignment-expression
1924
///
1925
/// In C++1z, a condition may in some contexts be preceded by an
1926
/// optional init-statement. This function will parse that too.
1927
///
1928
/// \param InitStmt If non-null, an init-statement is permitted, and if present
1929
/// will be parsed and stored here.
1930
///
1931
/// \param Loc The location of the start of the statement that requires this
1932
/// condition, e.g., the "for" in a for loop.
1933
///
1934
/// \param FRI If non-null, a for range declaration is permitted, and if
1935
/// present will be parsed and stored here, and a null result will be returned.
1936
///
1937
/// \param EnterForConditionScope If true, enter a continue/break scope at the
1938
/// appropriate moment for a 'for' loop.
1939
///
1940
/// \returns The parsed condition.
1941
Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
1942
                                                SourceLocation Loc,
1943
                                                Sema::ConditionKind CK,
1944
                                                ForRangeInfo *FRI,
1945
704k
                                                bool EnterForConditionScope) {
1946
  // Helper to ensure we always enter a continue/break scope if requested.
1947
704k
  struct ForConditionScopeRAII {
1948
704k
    Scope *S;
1949
704k
    void enter(bool IsConditionVariable) {
1950
704k
      if (S) {
1951
184k
        S->AddFlags(Scope::BreakScope | Scope::ContinueScope);
1952
184k
        S->setIsConditionVarScope(IsConditionVariable);
1953
184k
      }
1954
704k
    }
1955
704k
    ~ForConditionScopeRAII() {
1956
704k
      if (S)
1957
184k
        S->setIsConditionVarScope(false);
1958
704k
    }
1959
704k
  } ForConditionScope{EnterForConditionScope ? 
getCurScope()184k
:
nullptr519k
};
1960
1961
704k
  ParenBraceBracketBalancer BalancerRAIIObj(*this);
1962
704k
  PreferredType.enterCondition(Actions, Tok.getLocation());
1963
1964
704k
  if (Tok.is(tok::code_completion)) {
1965
6
    cutOffParsing();
1966
6
    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
1967
6
    return Sema::ConditionError();
1968
6
  }
1969
1970
704k
  ParsedAttributesWithRange attrs(AttrFactory);
1971
704k
  MaybeParseCXX11Attributes(attrs);
1972
1973
704k
  const auto WarnOnInit = [this, &CK] {
1974
164
    Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
1975
164
                                ? 
diag::warn_cxx14_compat_init_statement154
1976
164
                                : 
diag::ext_init_statement10
)
1977
164
        << (CK == Sema::ConditionKind::Switch);
1978
164
  };
1979
1980
  // Determine what kind of thing we have.
1981
704k
  switch (isCXXConditionDeclarationOrInitStatement(InitStmt, FRI)) {
1982
703k
  case ConditionOrInitStatement::Expression: {
1983
    // If this is a for loop, we're entering its condition.
1984
703k
    ForConditionScope.enter(/*IsConditionVariable=*/false);
1985
1986
703k
    ProhibitAttributes(attrs);
1987
1988
    // We can have an empty expression here.
1989
    //   if (; true);
1990
703k
    if (InitStmt && 
Tok.is(tok::semi)476k
) {
1991
42
      WarnOnInit();
1992
42
      SourceLocation SemiLoc = Tok.getLocation();
1993
42
      if (!Tok.hasLeadingEmptyMacro() && 
!SemiLoc.isMacroID()32
) {
1994
12
        Diag(SemiLoc, diag::warn_empty_init_statement)
1995
12
            << (CK == Sema::ConditionKind::Switch)
1996
12
            << FixItHint::CreateRemoval(SemiLoc);
1997
12
      }
1998
42
      ConsumeToken();
1999
42
      *InitStmt = Actions.ActOnNullStmt(SemiLoc);
2000
42
      return ParseCXXCondition(nullptr, Loc, CK);
2001
42
    }
2002
2003
    // Parse the expression.
2004
703k
    ExprResult Expr = ParseExpression(); // expression
2005
703k
    if (Expr.isInvalid())
2006
87
      return Sema::ConditionError();
2007
2008
703k
    if (InitStmt && 
Tok.is(tok::semi)476k
) {
2009
26
      WarnOnInit();
2010
26
      *InitStmt = Actions.ActOnExprStmt(Expr.get());
2011
26
      ConsumeToken();
2012
26
      return ParseCXXCondition(nullptr, Loc, CK);
2013
26
    }
2014
2015
703k
    return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK);
2016
703k
  }
2017
2018
96
  case ConditionOrInitStatement::InitStmtDecl: {
2019
96
    WarnOnInit();
2020
96
    SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
2021
96
    DeclGroupPtrTy DG = ParseSimpleDeclaration(
2022
96
        DeclaratorContext::SelectionInit, DeclEnd, attrs, /*RequireSemi=*/true);
2023
96
    *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
2024
96
    return ParseCXXCondition(nullptr, Loc, CK);
2025
703k
  }
2026
2027
64
  case ConditionOrInitStatement::ForRangeDecl: {
2028
    // This is 'for (init-stmt; for-range-decl : range-expr)'.
2029
    // We're not actually in a for loop yet, so 'break' and 'continue' aren't
2030
    // permitted here.
2031
64
    assert(FRI && "should not parse a for range declaration here");
2032
0
    SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
2033
64
    DeclGroupPtrTy DG = ParseSimpleDeclaration(DeclaratorContext::ForInit,
2034
64
                                               DeclEnd, attrs, false, FRI);
2035
64
    FRI->LoopVar = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
2036
64
    assert((FRI->ColonLoc.isValid() || !DG) &&
2037
64
           "cannot find for range declaration");
2038
0
    return Sema::ConditionResult();
2039
703k
  }
2040
2041
968
  case ConditionOrInitStatement::ConditionDecl:
2042
1.07k
  case ConditionOrInitStatement::Error:
2043
1.07k
    break;
2044
704k
  }
2045
2046
  // If this is a for loop, we're entering its condition.
2047
1.07k
  ForConditionScope.enter(/*IsConditionVariable=*/true);
2048
2049
  // type-specifier-seq
2050
1.07k
  DeclSpec DS(AttrFactory);
2051
1.07k
  DS.takeAttributesFrom(attrs);
2052
1.07k
  ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition);
2053
2054
  // declarator
2055
1.07k
  Declarator DeclaratorInfo(DS, DeclaratorContext::Condition);
2056
1.07k
  ParseDeclarator(DeclaratorInfo);
2057
2058
  // simple-asm-expr[opt]
2059
1.07k
  if (Tok.is(tok::kw_asm)) {
2060
0
    SourceLocation Loc;
2061
0
    ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc));
2062
0
    if (AsmLabel.isInvalid()) {
2063
0
      SkipUntil(tok::semi, StopAtSemi);
2064
0
      return Sema::ConditionError();
2065
0
    }
2066
0
    DeclaratorInfo.setAsmLabel(AsmLabel.get());
2067
0
    DeclaratorInfo.SetRangeEnd(Loc);
2068
0
  }
2069
2070
  // If attributes are present, parse them.
2071
1.07k
  MaybeParseGNUAttributes(DeclaratorInfo);
2072
2073
  // Type-check the declaration itself.
2074
1.07k
  DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
2075
1.07k
                                                        DeclaratorInfo);
2076
1.07k
  if (Dcl.isInvalid())
2077
11
    return Sema::ConditionError();
2078
1.06k
  Decl *DeclOut = Dcl.get();
2079
2080
  // '=' assignment-expression
2081
  // If a '==' or '+=' is found, suggest a fixit to '='.
2082
1.06k
  bool CopyInitialization = isTokenEqualOrEqualTypo();
2083
1.06k
  if (CopyInitialization)
2084
1.04k
    ConsumeToken();
2085
2086
1.06k
  ExprResult InitExpr = ExprError();
2087
1.06k
  if (getLangOpts().CPlusPlus11 && 
Tok.is(tok::l_brace)975
) {
2088
12
    Diag(Tok.getLocation(),
2089
12
         diag::warn_cxx98_compat_generalized_initializer_lists);
2090
12
    InitExpr = ParseBraceInitializer();
2091
1.05k
  } else if (CopyInitialization) {
2092
1.03k
    PreferredType.enterVariableInit(Tok.getLocation(), DeclOut);
2093
1.03k
    InitExpr = ParseAssignmentExpression();
2094
1.03k
  } else 
if (19
Tok.is(tok::l_paren)19
) {
2095
    // This was probably an attempt to initialize the variable.
2096
2
    SourceLocation LParen = ConsumeParen(), RParen = LParen;
2097
2
    if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
2098
2
      RParen = ConsumeParen();
2099
2
    Diag(DeclOut->getLocation(),
2100
2
         diag::err_expected_init_in_condition_lparen)
2101
2
      << SourceRange(LParen, RParen);
2102
17
  } else {
2103
17
    Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
2104
17
  }
2105
2106
1.06k
  if (!InitExpr.isInvalid())
2107
1.04k
    Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
2108
26
  else
2109
26
    Actions.ActOnInitializerError(DeclOut);
2110
2111
1.06k
  Actions.FinalizeDeclaration(DeclOut);
2112
1.06k
  return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
2113
1.07k
}
2114
2115
/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
2116
/// This should only be called when the current token is known to be part of
2117
/// simple-type-specifier.
2118
///
2119
///       simple-type-specifier:
2120
///         '::'[opt] nested-name-specifier[opt] type-name
2121
///         '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
2122
///         char
2123
///         wchar_t
2124
///         bool
2125
///         short
2126
///         int
2127
///         long
2128
///         signed
2129
///         unsigned
2130
///         float
2131
///         double
2132
///         void
2133
/// [GNU]   typeof-specifier
2134
/// [C++0x] auto               [TODO]
2135
///
2136
///       type-name:
2137
///         class-name
2138
///         enum-name
2139
///         typedef-name
2140
///
2141
328k
void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
2142
328k
  DS.SetRangeStart(Tok.getLocation());
2143
328k
  const char *PrevSpec;
2144
328k
  unsigned DiagID;
2145
328k
  SourceLocation Loc = Tok.getLocation();
2146
328k
  const clang::PrintingPolicy &Policy =
2147
328k
      Actions.getASTContext().getPrintingPolicy();
2148
2149
328k
  switch (Tok.getKind()) {
2150
0
  case tok::identifier:   // foo::bar
2151
0
  case tok::coloncolon:   // ::foo::bar
2152
0
    llvm_unreachable("Annotation token should already be formed!");
2153
0
  default:
2154
0
    llvm_unreachable("Not a simple-type-specifier token!");
2155
2156
  // type-name
2157
321k
  case tok::annot_typename: {
2158
321k
    DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
2159
321k
                       getTypeAnnotation(Tok), Policy);
2160
321k
    DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2161
321k
    ConsumeAnnotationToken();
2162
2163
321k
    DS.Finish(Actions, Policy);
2164
321k
    return;
2165
0
  }
2166
2167
0
  case tok::kw__ExtInt: {
2168
0
    ExprResult ER = ParseExtIntegerArgument();
2169
0
    if (ER.isInvalid())
2170
0
      DS.SetTypeSpecError();
2171
0
    else
2172
0
      DS.SetExtIntType(Loc, ER.get(), PrevSpec, DiagID, Policy);
2173
2174
    // Do this here because we have already consumed the close paren.
2175
0
    DS.SetRangeEnd(PrevTokLocation);
2176
0
    DS.Finish(Actions, Policy);
2177
0
    return;
2178
0
  }
2179
2180
  // builtin types
2181
70
  case tok::kw_short:
2182
70
    DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec, DiagID,
2183
70
                        Policy);
2184
70
    break;
2185
10
  case tok::kw_long:
2186
10
    DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec, DiagID,
2187
10
                        Policy);
2188
10
    break;
2189
2
  case tok::kw___int64:
2190
2
    DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc, PrevSpec, DiagID,
2191
2
                        Policy);
2192
2
    break;
2193
0
  case tok::kw_signed:
2194
0
    DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
2195
0
    break;
2196
140
  case tok::kw_unsigned:
2197
140
    DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec, DiagID);
2198
140
    break;
2199
1.34k
  case tok::kw_void:
2200
1.34k
    DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
2201
1.34k
    break;
2202
277
  case tok::kw_char:
2203
277
    DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
2204
277
    break;
2205
656
  case tok::kw_int:
2206
656
    DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
2207
656
    break;
2208
11
  case tok::kw___int128:
2209
11
    DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
2210
11
    break;
2211
0
  case tok::kw___bf16:
2212
0
    DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec, DiagID, Policy);
2213
0
    break;
2214
0
  case tok::kw_half:
2215
0
    DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
2216
0
    break;
2217
148
  case tok::kw_float:
2218
148
    DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
2219
148
    break;
2220
9
  case tok::kw_double:
2221
9
    DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
2222
9
    break;
2223
0
  case tok::kw__Float16:
2224
0
    DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
2225
0
    break;
2226
0
  case tok::kw___float128:
2227
0
    DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
2228
0
    break;
2229
0
  case tok::kw___ibm128:
2230
0
    DS.SetTypeSpecType(DeclSpec::TST_ibm128, Loc, PrevSpec, DiagID, Policy);
2231
0
    break;
2232
6
  case tok::kw_wchar_t:
2233
6
    DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
2234
6
    break;
2235
2
  case tok::kw_char8_t:
2236
2
    DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec, DiagID, Policy);
2237
2
    break;
2238
1
  case tok::kw_char16_t:
2239
1
    DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
2240
1
    break;
2241
0
  case tok::kw_char32_t:
2242
0
    DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
2243
0
    break;
2244
3.69k
  case tok::kw_bool:
2245
3.69k
    DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
2246
3.69k
    break;
2247
0
#define GENERIC_IMAGE_TYPE(ImgType, Id)                                        \
2248
0
  case tok::kw_##ImgType##_t:                                                  \
2249
0
    DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, DiagID,     \
2250
0
                       Policy);                                                \
2251
0
    break;
2252
3.69k
#include "clang/Basic/OpenCLImageTypes.def"
2253
2254
197
  case tok::annot_decltype:
2255
197
  case tok::kw_decltype:
2256
197
    DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
2257
197
    return DS.Finish(Actions, Policy);
2258
2259
  // GNU typeof support.
2260
16
  case tok::kw_typeof:
2261
16
    ParseTypeofSpecifier(DS);
2262
16
    DS.Finish(Actions, Policy);
2263
16
    return;
2264
328k
  }
2265
6.37k
  ConsumeAnyToken();
2266
6.37k
  DS.SetRangeEnd(PrevTokLocation);
2267
6.37k
  DS.Finish(Actions, Policy);
2268
6.37k
}
2269
2270
/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
2271
/// [dcl.name]), which is a non-empty sequence of type-specifiers,
2272
/// e.g., "const short int". Note that the DeclSpec is *not* finished
2273
/// by parsing the type-specifier-seq, because these sequences are
2274
/// typically followed by some form of declarator. Returns true and
2275
/// emits diagnostics if this is not a type-specifier-seq, false
2276
/// otherwise.
2277
///
2278
///   type-specifier-seq: [C++ 8.1]
2279
///     type-specifier type-specifier-seq[opt]
2280
///
2281
40.0k
bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
2282
40.0k
  ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_type_specifier);
2283
40.0k
  DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
2284
40.0k
  return false;
2285
40.0k
}
2286
2287
/// Finish parsing a C++ unqualified-id that is a template-id of
2288
/// some form.
2289
///
2290
/// This routine is invoked when a '<' is encountered after an identifier or
2291
/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
2292
/// whether the unqualified-id is actually a template-id. This routine will
2293
/// then parse the template arguments and form the appropriate template-id to
2294
/// return to the caller.
2295
///
2296
/// \param SS the nested-name-specifier that precedes this template-id, if
2297
/// we're actually parsing a qualified-id.
2298
///
2299
/// \param ObjectType if this unqualified-id occurs within a member access
2300
/// expression, the type of the base object whose member is being accessed.
2301
///
2302
/// \param ObjectHadErrors this unqualified-id occurs within a member access
2303
/// expression, indicates whether the original subexpressions had any errors.
2304
///
2305
/// \param Name for constructor and destructor names, this is the actual
2306
/// identifier that may be a template-name.
2307
///
2308
/// \param NameLoc the location of the class-name in a constructor or
2309
/// destructor.
2310
///
2311
/// \param EnteringContext whether we're entering the scope of the
2312
/// nested-name-specifier.
2313
///
2314
/// \param Id as input, describes the template-name or operator-function-id
2315
/// that precedes the '<'. If template arguments were parsed successfully,
2316
/// will be updated with the template-id.
2317
///
2318
/// \param AssumeTemplateId When true, this routine will assume that the name
2319
/// refers to a template without performing name lookup to verify.
2320
///
2321
/// \returns true if a parse error occurred, false otherwise.
2322
bool Parser::ParseUnqualifiedIdTemplateId(
2323
    CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
2324
    SourceLocation TemplateKWLoc, IdentifierInfo *Name, SourceLocation NameLoc,
2325
5.82k
    bool EnteringContext, UnqualifiedId &Id, bool AssumeTemplateId) {
2326
5.82k
  assert(Tok.is(tok::less) && "Expected '<' to finish parsing a template-id");
2327
2328
0
  TemplateTy Template;
2329
5.82k
  TemplateNameKind TNK = TNK_Non_template;
2330
5.82k
  switch (Id.getKind()) {
2331
3.74k
  case UnqualifiedIdKind::IK_Identifier:
2332
5.75k
  case UnqualifiedIdKind::IK_OperatorFunctionId:
2333
5.75k
  case UnqualifiedIdKind::IK_LiteralOperatorId:
2334
5.75k
    if (AssumeTemplateId) {
2335
      // We defer the injected-class-name checks until we've found whether
2336
      // this template-id is used to form a nested-name-specifier or not.
2337
482
      TNK = Actions.ActOnTemplateName(getCurScope(), SS, TemplateKWLoc, Id,
2338
482
                                      ObjectType, EnteringContext, Template,
2339
482
                                      /*AllowInjectedClassName*/ true);
2340
5.27k
    } else {
2341
5.27k
      bool MemberOfUnknownSpecialization;
2342
5.27k
      TNK = Actions.isTemplateName(getCurScope(), SS,
2343
5.27k
                                   TemplateKWLoc.isValid(), Id,
2344
5.27k
                                   ObjectType, EnteringContext, Template,
2345
5.27k
                                   MemberOfUnknownSpecialization);
2346
      // If lookup found nothing but we're assuming that this is a template
2347
      // name, double-check that makes sense syntactically before committing
2348
      // to it.
2349
5.27k
      if (TNK == TNK_Undeclared_template &&
2350
5.27k
          
isTemplateArgumentList(0) == TPResult::False6
)
2351
0
        return false;
2352
2353
5.27k
      if (TNK == TNK_Non_template && 
MemberOfUnknownSpecialization3.25k
&&
2354
5.27k
          
ObjectType2.46k
&&
isTemplateArgumentList(0) == TPResult::True2.43k
) {
2355
        // If we had errors before, ObjectType can be dependent even without any
2356
        // templates, do not report missing template keyword in that case.
2357
1
        if (!ObjectHadErrors) {
2358
          // We have something like t->getAs<T>(), where getAs is a
2359
          // member of an unknown specialization. However, this will only
2360
          // parse correctly as a template, so suggest the keyword 'template'
2361
          // before 'getAs' and treat this as a dependent template name.
2362
1
          std::string Name;
2363
1
          if (Id.getKind() == UnqualifiedIdKind::IK_Identifier)
2364
0
            Name = std::string(Id.Identifier->getName());
2365
1
          else {
2366
1
            Name = "operator ";
2367
1
            if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId)
2368
1
              Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
2369
0
            else
2370
0
              Name += Id.Identifier->getName();
2371
1
          }
2372
1
          Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
2373
1
              << Name
2374
1
              << FixItHint::CreateInsertion(Id.StartLocation, "template ");
2375
1
        }
2376
1
        TNK = Actions.ActOnTemplateName(
2377
1
            getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2378
1
            Template, /*AllowInjectedClassName*/ true);
2379
5.27k
      } else if (TNK == TNK_Non_template) {
2380
3.25k
        return false;
2381
3.25k
      }
2382
5.27k
    }
2383
2.50k
    break;
2384
2385
2.50k
  case UnqualifiedIdKind::IK_ConstructorName: {
2386
0
    UnqualifiedId TemplateName;
2387
0
    bool MemberOfUnknownSpecialization;
2388
0
    TemplateName.setIdentifier(Name, NameLoc);
2389
0
    TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2390
0
                                 TemplateName, ObjectType,
2391
0
                                 EnteringContext, Template,
2392
0
                                 MemberOfUnknownSpecialization);
2393
0
    if (TNK == TNK_Non_template)
2394
0
      return false;
2395
0
    break;
2396
0
  }
2397
2398
65
  case UnqualifiedIdKind::IK_DestructorName: {
2399
65
    UnqualifiedId TemplateName;
2400
65
    bool MemberOfUnknownSpecialization;
2401
65
    TemplateName.setIdentifier(Name, NameLoc);
2402
65
    if (ObjectType) {
2403
50
      TNK = Actions.ActOnTemplateName(
2404
50
          getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2405
50
          EnteringContext, Template, /*AllowInjectedClassName*/ true);
2406
50
    } else {
2407
15
      TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2408
15
                                   TemplateName, ObjectType,
2409
15
                                   EnteringContext, Template,
2410
15
                                   MemberOfUnknownSpecialization);
2411
2412
15
      if (TNK == TNK_Non_template && 
!Id.DestructorName.get()6
) {
2413
6
        Diag(NameLoc, diag::err_destructor_template_id)
2414
6
          << Name << SS.getRange();
2415
        // Carry on to parse the template arguments before bailing out.
2416
6
      }
2417
15
    }
2418
65
    break;
2419
0
  }
2420
2421
0
  default:
2422
0
    return false;
2423
5.82k
  }
2424
2425
  // Parse the enclosed template argument list.
2426
2.56k
  SourceLocation LAngleLoc, RAngleLoc;
2427
2.56k
  TemplateArgList TemplateArgs;
2428
2.56k
  if (ParseTemplateIdAfterTemplateName(true, LAngleLoc, TemplateArgs,
2429
2.56k
                                       RAngleLoc))
2430
8
    return true;
2431
2432
  // If this is a non-template, we already issued a diagnostic.
2433
2.55k
  if (TNK == TNK_Non_template)
2434
16
    return true;
2435
2436
2.54k
  if (Id.getKind() == UnqualifiedIdKind::IK_Identifier ||
2437
2.54k
      
Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId2.05k
||
2438
2.54k
      
Id.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId57
) {
2439
    // Form a parsed representation of the template-id to be stored in the
2440
    // UnqualifiedId.
2441
2442
    // FIXME: Store name for literal operator too.
2443
2.48k
    IdentifierInfo *TemplateII =
2444
2.48k
        Id.getKind() == UnqualifiedIdKind::IK_Identifier ? 
Id.Identifier485
2445
2.48k
                                                         : 
nullptr2.00k
;
2446
2.48k
    OverloadedOperatorKind OpKind =
2447
2.48k
        Id.getKind() == UnqualifiedIdKind::IK_Identifier
2448
2.48k
            ? 
OO_None485
2449
2.48k
            : 
Id.OperatorFunctionId.Operator2.00k
;
2450
2451
2.48k
    TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create(
2452
2.48k
        TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
2453
2.48k
        LAngleLoc, RAngleLoc, TemplateArgs, /*ArgsInvalid*/false, TemplateIds);
2454
2455
2.48k
    Id.setTemplateId(TemplateId);
2456
2.48k
    return false;
2457
2.48k
  }
2458
2459
  // Bundle the template arguments together.
2460
54
  ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
2461
2462
  // Constructor and destructor names.
2463
54
  TypeResult Type = Actions.ActOnTemplateIdType(
2464
54
      getCurScope(), SS, TemplateKWLoc, Template, Name, NameLoc, LAngleLoc,
2465
54
      TemplateArgsPtr, RAngleLoc, /*IsCtorOrDtorName=*/true);
2466
54
  if (Type.isInvalid())
2467
0
    return true;
2468
2469
54
  if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
2470
0
    Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2471
54
  else
2472
54
    Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2473
2474
54
  return false;
2475
54
}
2476
2477
/// Parse an operator-function-id or conversion-function-id as part
2478
/// of a C++ unqualified-id.
2479
///
2480
/// This routine is responsible only for parsing the operator-function-id or
2481
/// conversion-function-id; it does not handle template arguments in any way.
2482
///
2483
/// \code
2484
///       operator-function-id: [C++ 13.5]
2485
///         'operator' operator
2486
///
2487
///       operator: one of
2488
///            new   delete  new[]   delete[]
2489
///            +     -    *  /    %  ^    &   |   ~
2490
///            !     =    <  >    += -=   *=  /=  %=
2491
///            ^=    &=   |= <<   >> >>= <<=  ==  !=
2492
///            <=    >=   && ||   ++ --   ,   ->* ->
2493
///            ()    []   <=>
2494
///
2495
///       conversion-function-id: [C++ 12.3.2]
2496
///         operator conversion-type-id
2497
///
2498
///       conversion-type-id:
2499
///         type-specifier-seq conversion-declarator[opt]
2500
///
2501
///       conversion-declarator:
2502
///         ptr-operator conversion-declarator[opt]
2503
/// \endcode
2504
///
2505
/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2506
/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2507
///
2508
/// \param EnteringContext whether we are entering the scope of the
2509
/// nested-name-specifier.
2510
///
2511
/// \param ObjectType if this unqualified-id occurs within a member access
2512
/// expression, the type of the base object whose member is being accessed.
2513
///
2514
/// \param Result on a successful parse, contains the parsed unqualified-id.
2515
///
2516
/// \returns true if parsing fails, false otherwise.
2517
bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2518
                                        ParsedType ObjectType,
2519
347k
                                        UnqualifiedId &Result) {
2520
347k
  assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
2521
2522
  // Consume the 'operator' keyword.
2523
0
  SourceLocation KeywordLoc = ConsumeToken();
2524
2525
  // Determine what kind of operator name we have.
2526
347k
  unsigned SymbolIdx = 0;
2527
347k
  SourceLocation SymbolLocations[3];
2528
347k
  OverloadedOperatorKind Op = OO_None;
2529
347k
  switch (Tok.getKind()) {
2530
8.33k
    case tok::kw_new:
2531
16.6k
    case tok::kw_delete: {
2532
16.6k
      bool isNew = Tok.getKind() == tok::kw_new;
2533
      // Consume the 'new' or 'delete'.
2534
16.6k
      SymbolLocations[SymbolIdx++] = ConsumeToken();
2535
      // Check for array new/delete.
2536
16.6k
      if (Tok.is(tok::l_square) &&
2537
16.6k
          
(6.49k
!getLangOpts().CPlusPlus116.49k
||
NextToken().isNot(tok::l_square)6.41k
)) {
2538
        // Consume the '[' and ']'.
2539
6.48k
        BalancedDelimiterTracker T(*this, tok::l_square);
2540
6.48k
        T.consumeOpen();
2541
6.48k
        T.consumeClose();
2542
6.48k
        if (T.getCloseLocation().isInvalid())
2543
0
          return true;
2544
2545
6.48k
        SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2546
6.48k
        SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2547
6.48k
        Op = isNew? 
OO_Array_New3.25k
:
OO_Array_Delete3.23k
;
2548
10.2k
      } else {
2549
10.2k
        Op = isNew? 
OO_New5.08k
:
OO_Delete5.12k
;
2550
10.2k
      }
2551
16.6k
      break;
2552
16.6k
    }
2553
2554
16.6k
#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2555
249k
    case tok::Token:                                                     \
2556
249k
      SymbolLocations[SymbolIdx++] = ConsumeToken();                     \
2557
249k
      Op = OO_##Name;                                                    \
2558
249k
      break;
2559
16.6k
#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2560
16.6k
#include "clang/Basic/OperatorKinds.def"
2561
2562
60.3k
    case tok::l_paren: {
2563
      // Consume the '(' and ')'.
2564
60.3k
      BalancedDelimiterTracker T(*this, tok::l_paren);
2565
60.3k
      T.consumeOpen();
2566
60.3k
      T.consumeClose();
2567
60.3k
      if (T.getCloseLocation().isInvalid())
2568
0
        return true;
2569
2570
60.3k
      SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2571
60.3k
      SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2572
60.3k
      Op = OO_Call;
2573
60.3k
      break;
2574
60.3k
    }
2575
2576
6.87k
    case tok::l_square: {
2577
      // Consume the '[' and ']'.
2578
6.87k
      BalancedDelimiterTracker T(*this, tok::l_square);
2579
6.87k
      T.consumeOpen();
2580
6.87k
      T.consumeClose();
2581
6.87k
      if (T.getCloseLocation().isInvalid())
2582
0
        return true;
2583
2584
6.87k
      SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2585
6.87k
      SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2586
6.87k
      Op = OO_Subscript;
2587
6.87k
      break;
2588
6.87k
    }
2589
2590
1
    case tok::code_completion: {
2591
      // Don't try to parse any further.
2592
1
      cutOffParsing();
2593
      // Code completion for the operator name.
2594
1
      Actions.CodeCompleteOperatorName(getCurScope());
2595
1
      return true;
2596
6.87k
    }
2597
2598
14.0k
    default:
2599
14.0k
      break;
2600
347k
  }
2601
2602
347k
  if (Op != OO_None) {
2603
    // We have parsed an operator-function-id.
2604
333k
    Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2605
333k
    return false;
2606
333k
  }
2607
2608
  // Parse a literal-operator-id.
2609
  //
2610
  //   literal-operator-id: C++11 [over.literal]
2611
  //     operator string-literal identifier
2612
  //     operator user-defined-string-literal
2613
2614
14.0k
  if (getLangOpts().CPlusPlus11 && 
isTokenStringLiteral()13.6k
) {
2615
807
    Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
2616
2617
807
    SourceLocation DiagLoc;
2618
807
    unsigned DiagId = 0;
2619
2620
    // We're past translation phase 6, so perform string literal concatenation
2621
    // before checking for "".
2622
807
    SmallVector<Token, 4> Toks;
2623
807
    SmallVector<SourceLocation, 4> TokLocs;
2624
1.64k
    while (isTokenStringLiteral()) {
2625
842
      if (!Tok.is(tok::string_literal) && 
!DiagId7
) {
2626
        // C++11 [over.literal]p1:
2627
        //   The string-literal or user-defined-string-literal in a
2628
        //   literal-operator-id shall have no encoding-prefix [...].
2629
7
        DiagLoc = Tok.getLocation();
2630
7
        DiagId = diag::err_literal_operator_string_prefix;
2631
7
      }
2632
842
      Toks.push_back(Tok);
2633
842
      TokLocs.push_back(ConsumeStringToken());
2634
842
    }
2635
2636
807
    StringLiteralParser Literal(Toks, PP);
2637
807
    if (Literal.hadError)
2638
4
      return true;
2639
2640
    // Grab the literal operator's suffix, which will be either the next token
2641
    // or a ud-suffix from the string literal.
2642
803
    bool IsUDSuffix = !Literal.getUDSuffix().empty();
2643
803
    IdentifierInfo *II = nullptr;
2644
803
    SourceLocation SuffixLoc;
2645
803
    if (IsUDSuffix) {
2646
342
      II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2647
342
      SuffixLoc =
2648
342
        Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
2649
342
                                       Literal.getUDSuffixOffset(),
2650
342
                                       PP.getSourceManager(), getLangOpts());
2651
461
    } else if (Tok.is(tok::identifier)) {
2652
459
      II = Tok.getIdentifierInfo();
2653
459
      SuffixLoc = ConsumeToken();
2654
459
      TokLocs.push_back(SuffixLoc);
2655
459
    } else {
2656
2
      Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
2657
2
      return true;
2658
2
    }
2659
2660
    // The string literal must be empty.
2661
801
    if (!Literal.GetString().empty() || 
Literal.Pascal793
) {
2662
      // C++11 [over.literal]p1:
2663
      //   The string-literal or user-defined-string-literal in a
2664
      //   literal-operator-id shall [...] contain no characters
2665
      //   other than the implicit terminating '\0'.
2666
8
      DiagLoc = TokLocs.front();
2667
8
      DiagId = diag::err_literal_operator_string_not_empty;
2668
8
    }
2669
2670
801
    if (DiagId) {
2671
      // This isn't a valid literal-operator-id, but we think we know
2672
      // what the user meant. Tell them what they should have written.
2673
12
      SmallString<32> Str;
2674
12
      Str += "\"\"";
2675
12
      Str += II->getName();
2676
12
      Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2677
12
          SourceRange(TokLocs.front(), TokLocs.back()), Str);
2678
12
    }
2679
2680
801
    Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
2681
2682
801
    return Actions.checkLiteralOperatorId(SS, Result, IsUDSuffix);
2683
803
  }
2684
2685
  // Parse a conversion-function-id.
2686
  //
2687
  //   conversion-function-id: [C++ 12.3.2]
2688
  //     operator conversion-type-id
2689
  //
2690
  //   conversion-type-id:
2691
  //     type-specifier-seq conversion-declarator[opt]
2692
  //
2693
  //   conversion-declarator:
2694
  //     ptr-operator conversion-declarator[opt]
2695
2696
  // Parse the type-specifier-seq.
2697
13.2k
  DeclSpec DS(AttrFactory);
2698
13.2k
  if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
2699
0
    return true;
2700
2701
  // Parse the conversion-declarator, which is merely a sequence of
2702
  // ptr-operators.
2703
13.2k
  Declarator D(DS, DeclaratorContext::ConversionId);
2704
13.2k
  ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2705
2706
  // Finish up the type.
2707
13.2k
  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
2708
13.2k
  if (Ty.isInvalid())
2709
42
    return true;
2710
2711
  // Note that this is a conversion-function-id.
2712
13.2k
  Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2713
13.2k
                                 D.getSourceRange().getEnd());
2714
13.2k
  return false;
2715
13.2k
}
2716
2717
/// Parse a C++ unqualified-id (or a C identifier), which describes the
2718
/// name of an entity.
2719
///
2720
/// \code
2721
///       unqualified-id: [C++ expr.prim.general]
2722
///         identifier
2723
///         operator-function-id
2724
///         conversion-function-id
2725
/// [C++0x] literal-operator-id [TODO]
2726
///         ~ class-name
2727
///         template-id
2728
///
2729
/// \endcode
2730
///
2731
/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2732
/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2733
///
2734
/// \param ObjectType if this unqualified-id occurs within a member access
2735
/// expression, the type of the base object whose member is being accessed.
2736
///
2737
/// \param ObjectHadErrors if this unqualified-id occurs within a member access
2738
/// expression, indicates whether the original subexpressions had any errors.
2739
/// When true, diagnostics for missing 'template' keyword will be supressed.
2740
///
2741
/// \param EnteringContext whether we are entering the scope of the
2742
/// nested-name-specifier.
2743
///
2744
/// \param AllowDestructorName whether we allow parsing of a destructor name.
2745
///
2746
/// \param AllowConstructorName whether we allow parsing a constructor name.
2747
///
2748
/// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2749
///
2750
/// \param Result on a successful parse, contains the parsed unqualified-id.
2751
///
2752
/// \returns true if parsing fails, false otherwise.
2753
bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType,
2754
                                bool ObjectHadErrors, bool EnteringContext,
2755
                                bool AllowDestructorName,
2756
                                bool AllowConstructorName,
2757
                                bool AllowDeductionGuide,
2758
                                SourceLocation *TemplateKWLoc,
2759
20.0M
                                UnqualifiedId &Result) {
2760
20.0M
  if (TemplateKWLoc)
2761
2.34M
    *TemplateKWLoc = SourceLocation();
2762
2763
  // Handle 'A::template B'. This is for template-ids which have not
2764
  // already been annotated by ParseOptionalCXXScopeSpecifier().
2765
20.0M
  bool TemplateSpecified = false;
2766
20.0M
  if (Tok.is(tok::kw_template)) {
2767
98
    if (TemplateKWLoc && 
(94
ObjectType94
||
SS.isSet()63
)) {
2768
94
      TemplateSpecified = true;
2769
94
      *TemplateKWLoc = ConsumeToken();
2770
94
    } else {
2771
4
      SourceLocation TemplateLoc = ConsumeToken();
2772
4
      Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
2773
4
        << FixItHint::CreateRemoval(TemplateLoc);
2774
4
    }
2775
98
  }
2776
2777
  // unqualified-id:
2778
  //   identifier
2779
  //   template-id (when it hasn't already been annotated)
2780
20.0M
  if (Tok.is(tok::identifier)) {
2781
    // Consume the identifier.
2782
19.3M
    IdentifierInfo *Id = Tok.getIdentifierInfo();
2783
19.3M
    SourceLocation IdLoc = ConsumeToken();
2784
2785
19.3M
    if (!getLangOpts().CPlusPlus) {
2786
      // If we're not in C++, only identifiers matter. Record the
2787
      // identifier and return.
2788
121k
      Result.setIdentifier(Id, IdLoc);
2789
121k
      return false;
2790
121k
    }
2791
2792
19.2M
    ParsedTemplateTy TemplateName;
2793
19.2M
    if (AllowConstructorName &&
2794
19.2M
        
Actions.isCurrentClassName(*Id, getCurScope(), &SS)443k
) {
2795
      // We have parsed a constructor name.
2796
277k
      ParsedType Ty = Actions.getConstructorName(*Id, IdLoc, getCurScope(), SS,
2797
277k
                                                 EnteringContext);
2798
277k
      if (!Ty)
2799
2
        return true;
2800
277k
      Result.setConstructorName(Ty, IdLoc, IdLoc);
2801
18.9M
    } else if (getLangOpts().CPlusPlus17 &&
2802
18.9M
               
AllowDeductionGuide376k
&&
SS.isEmpty()456
&&
2803
18.9M
               Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
2804
450
                                            &TemplateName)) {
2805
      // We have parsed a template-name naming a deduction guide.
2806
441
      Result.setDeductionGuideName(TemplateName, IdLoc);
2807
18.9M
    } else {
2808
      // We have parsed an identifier.
2809
18.9M
      Result.setIdentifier(Id, IdLoc);
2810
18.9M
    }
2811
2812
    // If the next token is a '<', we may have a template.
2813
19.2M
    TemplateTy Template;
2814
19.2M
    if (Tok.is(tok::less))
2815
3.26k
      return ParseUnqualifiedIdTemplateId(
2816
3.26k
          SS, ObjectType, ObjectHadErrors,
2817
3.26k
          TemplateKWLoc ? 
*TemplateKWLoc3.25k
:
SourceLocation()3
, Id, IdLoc,
2818
3.26k
          EnteringContext, Result, TemplateSpecified);
2819
19.2M
    else if (TemplateSpecified &&
2820
19.2M
             Actions.ActOnTemplateName(
2821
86
                 getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
2822
86
                 EnteringContext, Template,
2823
86
                 /*AllowInjectedClassName*/ true) == TNK_Non_template)
2824
12
      return true;
2825
2826
19.2M
    return false;
2827
19.2M
  }
2828
2829
  // unqualified-id:
2830
  //   template-id (already parsed and annotated)
2831
626k
  if (Tok.is(tok::annot_template_id)) {
2832
232k
    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2833
2834
    // FIXME: Consider passing invalid template-ids on to callers; they may
2835
    // be able to recover better than we can.
2836
232k
    if (TemplateId->isInvalid()) {
2837
89
      ConsumeAnnotationToken();
2838
89
      return true;
2839
89
    }
2840
2841
    // If the template-name names the current class, then this is a constructor
2842
232k
    if (AllowConstructorName && 
TemplateId->Name91
&&
2843
232k
        
Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)91
) {
2844
51
      if (SS.isSet()) {
2845
        // C++ [class.qual]p2 specifies that a qualified template-name
2846
        // is taken as the constructor name where a constructor can be
2847
        // declared. Thus, the template arguments are extraneous, so
2848
        // complain about them and remove them entirely.
2849
18
        Diag(TemplateId->TemplateNameLoc,
2850
18
             diag::err_out_of_line_constructor_template_id)
2851
18
          << TemplateId->Name
2852
18
          << FixItHint::CreateRemoval(
2853
18
                    SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2854
18
        ParsedType Ty = Actions.getConstructorName(
2855
18
            *TemplateId->Name, TemplateId->TemplateNameLoc, getCurScope(), SS,
2856
18
            EnteringContext);
2857
18
        if (!Ty)
2858
0
          return true;
2859
18
        Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2860
18
                                  TemplateId->RAngleLoc);
2861
18
        ConsumeAnnotationToken();
2862
18
        return false;
2863
18
      }
2864
2865
33
      Result.setConstructorTemplateId(TemplateId);
2866
33
      ConsumeAnnotationToken();
2867
33
      return false;
2868
51
    }
2869
2870
    // We have already parsed a template-id; consume the annotation token as
2871
    // our unqualified-id.
2872
232k
    Result.setTemplateId(TemplateId);
2873
232k
    SourceLocation TemplateLoc = TemplateId->TemplateKWLoc;
2874
232k
    if (TemplateLoc.isValid()) {
2875
13.1k
      if (TemplateKWLoc && 
(13.0k
ObjectType13.0k
||
SS.isSet()5.63k
))
2876
13.0k
        *TemplateKWLoc = TemplateLoc;
2877
11
      else
2878
11
        Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
2879
11
            << FixItHint::CreateRemoval(TemplateLoc);
2880
13.1k
    }
2881
232k
    ConsumeAnnotationToken();
2882
232k
    return false;
2883
232k
  }
2884
2885
  // unqualified-id:
2886
  //   operator-function-id
2887
  //   conversion-function-id
2888
393k
  if (Tok.is(tok::kw_operator)) {
2889
347k
    if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2890
52
      return true;
2891
2892
    // If we have an operator-function-id or a literal-operator-id and the next
2893
    // token is a '<', we may have a
2894
    //
2895
    //   template-id:
2896
    //     operator-function-id < template-argument-list[opt] >
2897
347k
    TemplateTy Template;
2898
347k
    if ((Result.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
2899
347k
         
Result.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId14.0k
) &&
2900
347k
        
Tok.is(tok::less)334k
)
2901
2.01k
      return ParseUnqualifiedIdTemplateId(
2902
2.01k
          SS, ObjectType, ObjectHadErrors,
2903
2.01k
          TemplateKWLoc ? 
*TemplateKWLoc172
:
SourceLocation()1.84k
, nullptr,
2904
2.01k
          SourceLocation(), EnteringContext, Result, TemplateSpecified);
2905
345k
    else if (TemplateSpecified &&
2906
345k
             Actions.ActOnTemplateName(
2907
0
                 getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
2908
0
                 EnteringContext, Template,
2909
0
                 /*AllowInjectedClassName*/ true) == TNK_Non_template)
2910
0
      return true;
2911
2912
345k
    return false;
2913
347k
  }
2914
2915
46.1k
  if (getLangOpts().CPlusPlus &&
2916
46.1k
      
(45.9k
AllowDestructorName45.9k
||
SS.isSet()3.10k
) &&
Tok.is(tok::tilde)42.9k
) {
2917
    // C++ [expr.unary.op]p10:
2918
    //   There is an ambiguity in the unary-expression ~X(), where X is a
2919
    //   class-name. The ambiguity is resolved in favor of treating ~ as a
2920
    //    unary complement rather than treating ~X as referring to a destructor.
2921
2922
    // Parse the '~'.
2923
42.7k
    SourceLocation TildeLoc = ConsumeToken();
2924
2925
42.7k
    if (TemplateSpecified) {
2926
      // C++ [temp.names]p3:
2927
      //   A name prefixed by the keyword template shall be a template-id [...]
2928
      //
2929
      // A template-id cannot begin with a '~' token. This would never work
2930
      // anyway: x.~A<int>() would specify that the destructor is a template,
2931
      // not that 'A' is a template.
2932
      //
2933
      // FIXME: Suggest replacing the attempted destructor name with a correct
2934
      // destructor name and recover. (This is not trivial if this would become
2935
      // a pseudo-destructor name).
2936
6
      Diag(*TemplateKWLoc, diag::err_unexpected_template_in_destructor_name)
2937
6
        << Tok.getLocation();
2938
6
      return true;
2939
6
    }
2940
2941
42.7k
    if (SS.isEmpty() && 
Tok.is(tok::kw_decltype)37.8k
) {
2942
26
      DeclSpec DS(AttrFactory);
2943
26
      SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2944
26
      if (ParsedType Type =
2945
26
              Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
2946
14
        Result.setDestructorName(TildeLoc, Type, EndLoc);
2947
14
        return false;
2948
14
      }
2949
12
      return true;
2950
26
    }
2951
2952
    // Parse the class-name.
2953
42.6k
    if (Tok.isNot(tok::identifier)) {
2954
13
      Diag(Tok, diag::err_destructor_tilde_identifier);
2955
13
      return true;
2956
13
    }
2957
2958
    // If the user wrote ~T::T, correct it to T::~T.
2959
42.6k
    DeclaratorScopeObj DeclScopeObj(*this, SS);
2960
42.6k
    if (NextToken().is(tok::coloncolon)) {
2961
      // Don't let ParseOptionalCXXScopeSpecifier() "correct"
2962
      // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
2963
      // it will confuse this recovery logic.
2964
41
      ColonProtectionRAIIObject ColonRAII(*this, false);
2965
2966
41
      if (SS.isSet()) {
2967
3
        AnnotateScopeToken(SS, /*NewAnnotation*/true);
2968
3
        SS.clear();
2969
3
      }
2970
41
      if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, ObjectHadErrors,
2971
41
                                         EnteringContext))
2972
0
        return true;
2973
41
      if (SS.isNotEmpty())
2974
38
        ObjectType = nullptr;
2975
41
      if (Tok.isNot(tok::identifier) || 
NextToken().is(tok::coloncolon)38
||
2976
41
          
!SS.isSet()35
) {
2977
15
        Diag(TildeLoc, diag::err_destructor_tilde_scope);
2978
15
        return true;
2979
15
      }
2980
2981
      // Recover as if the tilde had been written before the identifier.
2982
26
      Diag(TildeLoc, diag::err_destructor_tilde_scope)
2983
26
        << FixItHint::CreateRemoval(TildeLoc)
2984
26
        << FixItHint::CreateInsertion(Tok.getLocation(), "~");
2985
2986
      // Temporarily enter the scope for the rest of this function.
2987
26
      if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
2988
26
        DeclScopeObj.EnterDeclaratorScope();
2989
26
    }
2990
2991
    // Parse the class-name (or template-name in a simple-template-id).
2992
42.6k
    IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2993
42.6k
    SourceLocation ClassNameLoc = ConsumeToken();
2994
2995
42.6k
    if (Tok.is(tok::less)) {
2996
65
      Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
2997
65
      return ParseUnqualifiedIdTemplateId(
2998
65
          SS, ObjectType, ObjectHadErrors,
2999
65
          TemplateKWLoc ? 
*TemplateKWLoc57
:
SourceLocation()8
, ClassName,
3000
65
          ClassNameLoc, EnteringContext, Result, TemplateSpecified);
3001
65
    }
3002
3003
    // Note that this is a destructor name.
3004
42.5k
    ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
3005
42.5k
                                              ClassNameLoc, getCurScope(),
3006
42.5k
                                              SS, ObjectType,
3007
42.5k
                                              EnteringContext);
3008
42.5k
    if (!Ty)
3009
54
      return true;
3010
3011
42.5k
    Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
3012
42.5k
    return false;
3013
42.5k
  }
3014
3015
3.38k
  Diag(Tok, diag::err_expected_unqualified_id)
3016
3.38k
    << getLangOpts().CPlusPlus;
3017
3.38k
  return true;
3018
46.1k
}
3019
3020
/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
3021
/// memory in a typesafe manner and call constructors.
3022
///
3023
/// This method is called to parse the new expression after the optional :: has
3024
/// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
3025
/// is its location.  Otherwise, "Start" is the location of the 'new' token.
3026
///
3027
///        new-expression:
3028
///                   '::'[opt] 'new' new-placement[opt] new-type-id
3029
///                                     new-initializer[opt]
3030
///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3031
///                                     new-initializer[opt]
3032
///
3033
///        new-placement:
3034
///                   '(' expression-list ')'
3035
///
3036
///        new-type-id:
3037
///                   type-specifier-seq new-declarator[opt]
3038
/// [GNU]             attributes type-specifier-seq new-declarator[opt]
3039
///
3040
///        new-declarator:
3041
///                   ptr-operator new-declarator[opt]
3042
///                   direct-new-declarator
3043
///
3044
///        new-initializer:
3045
///                   '(' expression-list[opt] ')'
3046
/// [C++0x]           braced-init-list
3047
///
3048
ExprResult
3049
26.0k
Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
3050
26.0k
  assert(Tok.is(tok::kw_new) && "expected 'new' token");
3051
0
  ConsumeToken();   // Consume 'new'
3052
3053
  // A '(' now can be a new-placement or the '(' wrapping the type-id in the
3054
  // second form of new-expression. It can't be a new-type-id.
3055
3056
26.0k
  ExprVector PlacementArgs;
3057
26.0k
  SourceLocation PlacementLParen, PlacementRParen;
3058
3059
26.0k
  SourceRange TypeIdParens;
3060
26.0k
  DeclSpec DS(AttrFactory);
3061
26.0k
  Declarator DeclaratorInfo(DS, DeclaratorContext::CXXNew);
3062
26.0k
  if (Tok.is(tok::l_paren)) {
3063
    // If it turns out to be a placement, we change the type location.
3064
19.3k
    BalancedDelimiterTracker T(*this, tok::l_paren);
3065
19.3k
    T.consumeOpen();
3066
19.3k
    PlacementLParen = T.getOpenLocation();
3067
19.3k
    if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
3068
8
      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3069
8
      return ExprError();
3070
8
    }
3071
3072
19.3k
    T.consumeClose();
3073
19.3k
    PlacementRParen = T.getCloseLocation();
3074
19.3k
    if (PlacementRParen.isInvalid()) {
3075
0
      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3076
0
      return ExprError();
3077
0
    }
3078
3079
19.3k
    if (PlacementArgs.empty()) {
3080
      // Reset the placement locations. There was no placement.
3081
39
      TypeIdParens = T.getRange();
3082
39
      PlacementLParen = PlacementRParen = SourceLocation();
3083
19.3k
    } else {
3084
      // We still need the type.
3085
19.3k
      if (Tok.is(tok::l_paren)) {
3086
9
        BalancedDelimiterTracker T(*this, tok::l_paren);
3087
9
        T.consumeOpen();
3088
9
        MaybeParseGNUAttributes(DeclaratorInfo);
3089
9
        ParseSpecifierQualifierList(DS);
3090
9
        DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3091
9
        ParseDeclarator(DeclaratorInfo);
3092
9
        T.consumeClose();
3093
9
        TypeIdParens = T.getRange();
3094
19.3k
      } else {
3095
19.3k
        MaybeParseGNUAttributes(DeclaratorInfo);
3096
19.3k
        if (ParseCXXTypeSpecifierSeq(DS))
3097
0
          DeclaratorInfo.setInvalidType(true);
3098
19.3k
        else {
3099
19.3k
          DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3100
19.3k
          ParseDeclaratorInternal(DeclaratorInfo,
3101
19.3k
                                  &Parser::ParseDirectNewDeclarator);
3102
19.3k
        }
3103
19.3k
      }
3104
19.3k
    }
3105
19.3k
  } else {
3106
    // A new-type-id is a simplified type-id, where essentially the
3107
    // direct-declarator is replaced by a direct-new-declarator.
3108
6.62k
    MaybeParseGNUAttributes(DeclaratorInfo);
3109
6.62k
    if (ParseCXXTypeSpecifierSeq(DS))
3110
0
      DeclaratorInfo.setInvalidType(true);
3111
6.62k
    else {
3112
6.62k
      DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3113
6.62k
      ParseDeclaratorInternal(DeclaratorInfo,
3114
6.62k
                              &Parser::ParseDirectNewDeclarator);
3115
6.62k
    }
3116
6.62k
  }
3117
25.9k
  if (DeclaratorInfo.isInvalidType()) {
3118
28
    SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3119
28
    return ExprError();
3120
28
  }
3121
3122
25.9k
  ExprResult Initializer;
3123
3124
25.9k
  if (Tok.is(tok::l_paren)) {
3125
22.8k
    SourceLocation ConstructorLParen, ConstructorRParen;
3126
22.8k
    ExprVector ConstructorArgs;
3127
22.8k
    BalancedDelimiterTracker T(*this, tok::l_paren);
3128
22.8k
    T.consumeOpen();
3129
22.8k
    ConstructorLParen = T.getOpenLocation();
3130
22.8k
    if (Tok.isNot(tok::r_paren)) {
3131
22.1k
      CommaLocsTy CommaLocs;
3132
22.1k
      auto RunSignatureHelp = [&]() {
3133
3
        ParsedType TypeRep =
3134
3
            Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
3135
3
        QualType PreferredType;
3136
        // ActOnTypeName might adjust DeclaratorInfo and return a null type even
3137
        // the passing DeclaratorInfo is valid, e.g. running SignatureHelp on
3138
        // `new decltype(invalid) (^)`.
3139
3
        if (TypeRep)
3140
1
          PreferredType = Actions.ProduceConstructorSignatureHelp(
3141
1
              getCurScope(), TypeRep.get()->getCanonicalTypeInternal(),
3142
1
              DeclaratorInfo.getEndLoc(), ConstructorArgs, ConstructorLParen);
3143
3
        CalledSignatureHelp = true;
3144
3
        return PreferredType;
3145
3
      };
3146
34.2k
      if (
ParseExpressionList(ConstructorArgs, CommaLocs, [&] 22.1k
{
3147
34.2k
            PreferredType.enterFunctionArgument(Tok.getLocation(),
3148
34.2k
                                                RunSignatureHelp);
3149
34.2k
          })) {
3150
3
        if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
3151
0
          RunSignatureHelp();
3152
3
        SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3153
3
        return ExprError();
3154
3
      }
3155
22.1k
    }
3156
22.8k
    T.consumeClose();
3157
22.8k
    ConstructorRParen = T.getCloseLocation();
3158
22.8k
    if (ConstructorRParen.isInvalid()) {
3159
0
      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3160
0
      return ExprError();
3161
0
    }
3162
22.8k
    Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
3163
22.8k
                                             ConstructorRParen,
3164
22.8k
                                             ConstructorArgs);
3165
22.8k
  } else 
if (3.12k
Tok.is(tok::l_brace)3.12k
&&
getLangOpts().CPlusPlus11165
) {
3166
163
    Diag(Tok.getLocation(),
3167
163
         diag::warn_cxx98_compat_generalized_initializer_lists);
3168
163
    Initializer = ParseBraceInitializer();
3169
163
  }
3170
25.9k
  if (Initializer.isInvalid())
3171
0
    return Initializer;
3172
3173
25.9k
  return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
3174
25.9k
                             PlacementArgs, PlacementRParen,
3175
25.9k
                             TypeIdParens, DeclaratorInfo, Initializer.get());
3176
25.9k
}
3177
3178
/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
3179
/// passed to ParseDeclaratorInternal.
3180
///
3181
///        direct-new-declarator:
3182
///                   '[' expression[opt] ']'
3183
///                   direct-new-declarator '[' constant-expression ']'
3184
///
3185
25.9k
void Parser::ParseDirectNewDeclarator(Declarator &D) {
3186
  // Parse the array dimensions.
3187
25.9k
  bool First = true;
3188
27.2k
  while (Tok.is(tok::l_square)) {
3189
    // An array-size expression can't start with a lambda.
3190
1.26k
    if (CheckProhibitedCXX11Attribute())
3191
0
      continue;
3192
3193
1.26k
    BalancedDelimiterTracker T(*this, tok::l_square);
3194
1.26k
    T.consumeOpen();
3195
3196
1.26k
    ExprResult Size =
3197
1.26k
        First ? 
(1.20k
Tok.is(tok::r_square)1.20k
?
ExprResult()28
:
ParseExpression()1.18k
)
3198
1.26k
              : 
ParseConstantExpression()57
;
3199
1.26k
    if (Size.isInvalid()) {
3200
      // Recover
3201
0
      SkipUntil(tok::r_square, StopAtSemi);
3202
0
      return;
3203
0
    }
3204
1.26k
    First = false;
3205
3206
1.26k
    T.consumeClose();
3207
3208
    // Attributes here appertain to the array type. C++11 [expr.new]p5.
3209
1.26k
    ParsedAttributes Attrs(AttrFactory);
3210
1.26k
    MaybeParseCXX11Attributes(Attrs);
3211
3212
1.26k
    D.AddTypeInfo(DeclaratorChunk::getArray(0,
3213
1.26k
                                            /*isStatic=*/false, /*isStar=*/false,
3214
1.26k
                                            Size.get(), T.getOpenLocation(),
3215
1.26k
                                            T.getCloseLocation()),
3216
1.26k
                  std::move(Attrs), T.getCloseLocation());
3217
3218
1.26k
    if (T.getCloseLocation().isInvalid())
3219
0
      return;
3220
1.26k
  }
3221
25.9k
}
3222
3223
/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
3224
/// This ambiguity appears in the syntax of the C++ new operator.
3225
///
3226
///        new-expression:
3227
///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3228
///                                     new-initializer[opt]
3229
///
3230
///        new-placement:
3231
///                   '(' expression-list ')'
3232
///
3233
bool Parser::ParseExpressionListOrTypeId(
3234
                                   SmallVectorImpl<Expr*> &PlacementArgs,
3235
19.3k
                                         Declarator &D) {
3236
  // The '(' was already consumed.
3237
19.3k
  if (isTypeIdInParens()) {
3238
39
    ParseSpecifierQualifierList(D.getMutableDeclSpec());
3239
39
    D.SetSourceRange(D.getDeclSpec().getSourceRange());
3240
39
    ParseDeclarator(D);
3241
39
    return D.isInvalidType();
3242
39
  }
3243
3244
  // It's not a type, it has to be an expression list.
3245
  // Discard the comma locations - ActOnCXXNew has enough parameters.
3246
19.3k
  CommaLocsTy CommaLocs;
3247
19.3k
  return ParseExpressionList(PlacementArgs, CommaLocs);
3248
19.3k
}
3249
3250
/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
3251
/// to free memory allocated by new.
3252
///
3253
/// This method is called to parse the 'delete' expression after the optional
3254
/// '::' has been already parsed.  If the '::' was present, "UseGlobal" is true
3255
/// and "Start" is its location.  Otherwise, "Start" is the location of the
3256
/// 'delete' token.
3257
///
3258
///        delete-expression:
3259
///                   '::'[opt] 'delete' cast-expression
3260
///                   '::'[opt] 'delete' '[' ']' cast-expression
3261
ExprResult
3262
4.85k
Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
3263
4.85k
  assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
3264
0
  ConsumeToken(); // Consume 'delete'
3265
3266
  // Array delete?
3267
4.85k
  bool ArrayDelete = false;
3268
4.85k
  if (Tok.is(tok::l_square) && 
NextToken().is(tok::r_square)1.69k
) {
3269
    // C++11 [expr.delete]p1:
3270
    //   Whenever the delete keyword is followed by empty square brackets, it
3271
    //   shall be interpreted as [array delete].
3272
    //   [Footnote: A lambda expression with a lambda-introducer that consists
3273
    //              of empty square brackets can follow the delete keyword if
3274
    //              the lambda expression is enclosed in parentheses.]
3275
3276
1.68k
    const Token Next = GetLookAheadToken(2);
3277
3278
    // Basic lookahead to check if we have a lambda expression.
3279
1.68k
    if (Next.isOneOf(tok::l_brace, tok::less) ||
3280
1.68k
        
(1.67k
Next.is(tok::l_paren)1.67k
&&
3281
1.67k
         
(25
GetLookAheadToken(3).is(tok::r_paren)25
||
3282
25
          
(20
GetLookAheadToken(3).is(tok::identifier)20
&&
3283
20
           
GetLookAheadToken(4).is(tok::identifier)6
)))) {
3284
16
      TentativeParsingAction TPA(*this);
3285
16
      SourceLocation LSquareLoc = Tok.getLocation();
3286
16
      SourceLocation RSquareLoc = NextToken().getLocation();
3287
3288
      // SkipUntil can't skip pairs of </*...*/>; don't emit a FixIt in this
3289
      // case.
3290
16
      SkipUntil({tok::l_brace, tok::less}, StopBeforeMatch);
3291
16
      SourceLocation RBraceLoc;
3292
16
      bool EmitFixIt = false;
3293
16
      if (Tok.is(tok::l_brace)) {
3294
14
        ConsumeBrace();
3295
14
        SkipUntil(tok::r_brace, StopBeforeMatch);
3296
14
        RBraceLoc = Tok.getLocation();
3297
14
        EmitFixIt = true;
3298
14
      }
3299
3300
16
      TPA.Revert();
3301
3302
16
      if (EmitFixIt)
3303
14
        Diag(Start, diag::err_lambda_after_delete)
3304
14
            << SourceRange(Start, RSquareLoc)
3305
14
            << FixItHint::CreateInsertion(LSquareLoc, "(")
3306
14
            << FixItHint::CreateInsertion(
3307
14
                   Lexer::getLocForEndOfToken(
3308
14
                       RBraceLoc, 0, Actions.getSourceManager(), getLangOpts()),
3309
14
                   ")");
3310
2
      else
3311
2
        Diag(Start, diag::err_lambda_after_delete)
3312
2
            << SourceRange(Start, RSquareLoc);
3313
3314
      // Warn that the non-capturing lambda isn't surrounded by parentheses
3315
      // to disambiguate it from 'delete[]'.
3316
16
      ExprResult Lambda = ParseLambdaExpression();
3317
16
      if (Lambda.isInvalid())
3318
0
        return ExprError();
3319
3320
      // Evaluate any postfix expressions used on the lambda.
3321
16
      Lambda = ParsePostfixExpressionSuffix(Lambda);
3322
16
      if (Lambda.isInvalid())
3323
0
        return ExprError();
3324
16
      return Actions.ActOnCXXDelete(Start, UseGlobal, /*ArrayForm=*/false,
3325
16
                                    Lambda.get());
3326
16
    }
3327
3328
1.66k
    ArrayDelete = true;
3329
1.66k
    BalancedDelimiterTracker T(*this, tok::l_square);
3330
3331
1.66k
    T.consumeOpen();
3332
1.66k
    T.consumeClose();
3333
1.66k
    if (T.getCloseLocation().isInvalid())
3334
0
      return ExprError();
3335
1.66k
  }
3336
3337
4.84k
  ExprResult Operand(ParseCastExpression(AnyCastExpr));
3338
4.84k
  if (Operand.isInvalid())
3339
5
    return Operand;
3340
3341
4.83k
  return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
3342
4.84k
}
3343
3344
/// ParseRequiresExpression - Parse a C++2a requires-expression.
3345
/// C++2a [expr.prim.req]p1
3346
///     A requires-expression provides a concise way to express requirements on
3347
///     template arguments. A requirement is one that can be checked by name
3348
///     lookup (6.4) or by checking properties of types and expressions.
3349
///
3350
///     requires-expression:
3351
///         'requires' requirement-parameter-list[opt] requirement-body
3352
///
3353
///     requirement-parameter-list:
3354
///         '(' parameter-declaration-clause[opt] ')'
3355
///
3356
///     requirement-body:
3357
///         '{' requirement-seq '}'
3358
///
3359
///     requirement-seq:
3360
///         requirement
3361
///         requirement-seq requirement
3362
///
3363
///     requirement:
3364
///         simple-requirement
3365
///         type-requirement
3366
///         compound-requirement
3367
///         nested-requirement
3368
240
ExprResult Parser::ParseRequiresExpression() {
3369
240
  assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword");
3370
0
  SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires'
3371
3372
240
  llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls;
3373
240
  if (Tok.is(tok::l_paren)) {
3374
    // requirement parameter list is present.
3375
100
    ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope |
3376
100
                                    Scope::DeclScope);
3377
100
    BalancedDelimiterTracker Parens(*this, tok::l_paren);
3378
100
    Parens.consumeOpen();
3379
100
    if (!Tok.is(tok::r_paren)) {
3380
97
      ParsedAttributes FirstArgAttrs(getAttrFactory());
3381
97
      SourceLocation EllipsisLoc;
3382
97
      llvm::SmallVector<DeclaratorChunk::ParamInfo, 2> LocalParameters;
3383
97
      ParseParameterDeclarationClause(DeclaratorContext::RequiresExpr,
3384
97
                                      FirstArgAttrs, LocalParameters,
3385
97
                                      EllipsisLoc);
3386
97
      if (EllipsisLoc.isValid())
3387
1
        Diag(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis);
3388
97
      for (auto &ParamInfo : LocalParameters)
3389
112
        LocalParameterDecls.push_back(cast<ParmVarDecl>(ParamInfo.Param));
3390
97
    }
3391
100
    Parens.consumeClose();
3392
100
  }
3393
3394
240
  BalancedDelimiterTracker Braces(*this, tok::l_brace);
3395
240
  if (Braces.expectAndConsume())
3396
0
    return ExprError();
3397
3398
  // Start of requirement list
3399
240
  llvm::SmallVector<concepts::Requirement *, 2> Requirements;
3400
3401
  // C++2a [expr.prim.req]p2
3402
  //   Expressions appearing within a requirement-body are unevaluated operands.
3403
240
  EnterExpressionEvaluationContext Ctx(
3404
240
      Actions, Sema::ExpressionEvaluationContext::Unevaluated);
3405
3406
240
  ParseScope BodyScope(this, Scope::DeclScope);
3407
240
  RequiresExprBodyDecl *Body = Actions.ActOnStartRequiresExpr(
3408
240
      RequiresKWLoc, LocalParameterDecls, getCurScope());
3409
3410
240
  if (Tok.is(tok::r_brace)) {
3411
    // Grammar does not allow an empty body.
3412
    // requirement-body:
3413
    //   { requirement-seq }
3414
    // requirement-seq:
3415
    //   requirement
3416
    //   requirement-seq requirement
3417
1
    Diag(Tok, diag::err_empty_requires_expr);
3418
    // Continue anyway and produce a requires expr with no requirements.
3419
239
  } else {
3420
551
    while (!Tok.is(tok::r_brace)) {
3421
317
      switch (Tok.getKind()) {
3422
68
      case tok::l_brace: {
3423
        // Compound requirement
3424
        // C++ [expr.prim.req.compound]
3425
        //     compound-requirement:
3426
        //         '{' expression '}' 'noexcept'[opt]
3427
        //             return-type-requirement[opt] ';'
3428
        //     return-type-requirement:
3429
        //         trailing-return-type
3430
        //         '->' cv-qualifier-seq[opt] constrained-parameter
3431
        //             cv-qualifier-seq[opt] abstract-declarator[opt]
3432
68
        BalancedDelimiterTracker ExprBraces(*this, tok::l_brace);
3433
68
        ExprBraces.consumeOpen();
3434
68
        ExprResult Expression =
3435
68
            Actions.CorrectDelayedTyposInExpr(ParseExpression());
3436
68
        if (!Expression.isUsable()) {
3437
1
          ExprBraces.skipToEnd();
3438
1
          SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3439
1
          break;
3440
1
        }
3441
67
        if (ExprBraces.consumeClose())
3442
0
          ExprBraces.skipToEnd();
3443
3444
67
        concepts::Requirement *Req = nullptr;
3445
67
        SourceLocation NoexceptLoc;
3446
67
        TryConsumeToken(tok::kw_noexcept, NoexceptLoc);
3447
67
        if (Tok.is(tok::semi)) {
3448
21
          Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc);
3449
21
          if (Req)
3450
21
            Requirements.push_back(Req);
3451
21
          break;
3452
21
        }
3453
46
        if (!TryConsumeToken(tok::arrow))
3454
          // User probably forgot the arrow, remind them and try to continue.
3455
2
          Diag(Tok, diag::err_requires_expr_missing_arrow)
3456
2
              << FixItHint::CreateInsertion(Tok.getLocation(), "->");
3457
        // Try to parse a 'type-constraint'
3458
46
        if (TryAnnotateTypeConstraint()) {
3459
0
          SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3460
0
          break;
3461
0
        }
3462
46
        if (!isTypeConstraintAnnotation()) {
3463
1
          Diag(Tok, diag::err_requires_expr_expected_type_constraint);
3464
1
          SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3465
1
          break;
3466
1
        }
3467
45
        CXXScopeSpec SS;
3468
45
        if (Tok.is(tok::annot_cxxscope)) {
3469
1
          Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
3470
1
                                                       Tok.getAnnotationRange(),
3471
1
                                                       SS);
3472
1
          ConsumeAnnotationToken();
3473
1
        }
3474
3475
45
        Req = Actions.ActOnCompoundRequirement(
3476
45
            Expression.get(), NoexceptLoc, SS, takeTemplateIdAnnotation(Tok),
3477
45
            TemplateParameterDepth);
3478
45
        ConsumeAnnotationToken();
3479
45
        if (Req)
3480
45
          Requirements.push_back(Req);
3481
45
        break;
3482
46
      }
3483
249
      default: {
3484
249
        bool PossibleRequiresExprInSimpleRequirement = false;
3485
249
        if (Tok.is(tok::kw_requires)) {
3486
80
          auto IsNestedRequirement = [&] {
3487
80
            RevertingTentativeParsingAction TPA(*this);
3488
80
            ConsumeToken(); // 'requires'
3489
80
            if (Tok.is(tok::l_brace))
3490
              // This is a requires expression
3491
              // requires (T t) {
3492
              //   requires { t++; };
3493
              //   ...      ^
3494
              // }
3495
1
              return false;
3496
79
            if (Tok.is(tok::l_paren)) {
3497
              // This might be the parameter list of a requires expression
3498
4
              ConsumeParen();
3499
4
              auto Res = TryParseParameterDeclarationClause();
3500
4
              if (Res != TPResult::False) {
3501
                // Skip to the closing parenthesis
3502
                // FIXME: Don't traverse these tokens twice (here and in
3503
                //  TryParseParameterDeclarationClause).
3504
3
                unsigned Depth = 1;
3505
8
                while (Depth != 0) {
3506
5
                  if (Tok.is(tok::l_paren))
3507
0
                    Depth++;
3508
5
                  else if (Tok.is(tok::r_paren))
3509
3
                    Depth--;
3510
5
                  ConsumeAnyToken();
3511
5
                }
3512
                // requires (T t) {
3513
                //   requires () ?
3514
                //   ...         ^
3515
                //   - OR -
3516
                //   requires (int x) ?
3517
                //   ...              ^
3518
                // }
3519
3
                if (Tok.is(tok::l_brace))
3520
                  // requires (...) {
3521
                  //                ^ - a requires expression as a
3522
                  //                    simple-requirement.
3523
2
                  return false;
3524
3
              }
3525
4
            }
3526
77
            return true;
3527
79
          };
3528
80
          if (IsNestedRequirement()) {
3529
77
            ConsumeToken();
3530
            // Nested requirement
3531
            // C++ [expr.prim.req.nested]
3532
            //     nested-requirement:
3533
            //         'requires' constraint-expression ';'
3534
77
            ExprResult ConstraintExpr =
3535
77
                Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression());
3536
77
            if (ConstraintExpr.isInvalid() || 
!ConstraintExpr.isUsable()76
) {
3537
1
              SkipUntil(tok::semi, tok::r_brace,
3538
1
                        SkipUntilFlags::StopBeforeMatch);
3539
1
              break;
3540
1
            }
3541
76
            if (auto *Req =
3542
76
                    Actions.ActOnNestedRequirement(ConstraintExpr.get()))
3543
75
              Requirements.push_back(Req);
3544
1
            else {
3545
1
              SkipUntil(tok::semi, tok::r_brace,
3546
1
                        SkipUntilFlags::StopBeforeMatch);
3547
1
              break;
3548
1
            }
3549
75
            break;
3550
76
          } else
3551
3
            PossibleRequiresExprInSimpleRequirement = true;
3552
169
        } else if (Tok.is(tok::kw_typename)) {
3553
          // This might be 'typename T::value_type;' (a type requirement) or
3554
          // 'typename T::value_type{};' (a simple requirement).
3555
84
          TentativeParsingAction TPA(*this);
3556
3557
          // We need to consume the typename to allow 'requires { typename a; }'
3558
84
          SourceLocation TypenameKWLoc = ConsumeToken();
3559
84
          if (TryAnnotateCXXScopeToken()) {
3560
0
            TPA.Commit();
3561
0
            SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3562
0
            break;
3563
0
          }
3564
84
          CXXScopeSpec SS;
3565
84
          if (Tok.is(tok::annot_cxxscope)) {
3566
58
            Actions.RestoreNestedNameSpecifierAnnotation(
3567
58
                Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
3568
58
            ConsumeAnnotationToken();
3569
58
          }
3570
3571
84
          if (Tok.isOneOf(tok::identifier, tok::annot_template_id) &&
3572
84
              
!NextToken().isOneOf(tok::l_brace, tok::l_paren)81
) {
3573
79
            TPA.Commit();
3574
79
            SourceLocation NameLoc = Tok.getLocation();
3575
79
            IdentifierInfo *II = nullptr;
3576
79
            TemplateIdAnnotation *TemplateId = nullptr;
3577
79
            if (Tok.is(tok::identifier)) {
3578
51
              II = Tok.getIdentifierInfo();
3579
51
              ConsumeToken();
3580
51
            } else {
3581
28
              TemplateId = takeTemplateIdAnnotation(Tok);
3582
28
              ConsumeAnnotationToken();
3583
28
              if (TemplateId->isInvalid())
3584
0
                break;
3585
28
            }
3586
3587
79
            if (auto *Req = Actions.ActOnTypeRequirement(TypenameKWLoc, SS,
3588
79
                                                         NameLoc, II,
3589
79
                                                         TemplateId)) {
3590
64
              Requirements.push_back(Req);
3591
64
            }
3592
79
            break;
3593
79
          }
3594
5
          TPA.Revert();
3595
5
        }
3596
        // Simple requirement
3597
        // C++ [expr.prim.req.simple]
3598
        //     simple-requirement:
3599
        //         expression ';'
3600
93
        SourceLocation StartLoc = Tok.getLocation();
3601
93
        ExprResult Expression =
3602
93
            Actions.CorrectDelayedTyposInExpr(ParseExpression());
3603
93
        if (!Expression.isUsable()) {
3604
7
          SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3605
7
          break;
3606
7
        }
3607
86
        if (!Expression.isInvalid() && PossibleRequiresExprInSimpleRequirement)
3608
3
          Diag(StartLoc, diag::err_requires_expr_in_simple_requirement)
3609
3
              << FixItHint::CreateInsertion(StartLoc, "requires");
3610
86
        if (auto *Req = Actions.ActOnSimpleRequirement(Expression.get()))
3611
86
          Requirements.push_back(Req);
3612
0
        else {
3613
0
          SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3614
0
          break;
3615
0
        }
3616
        // User may have tried to put some compound requirement stuff here
3617
86
        if (Tok.is(tok::kw_noexcept)) {
3618
1
          Diag(Tok, diag::err_requires_expr_simple_requirement_noexcept)
3619
1
              << FixItHint::CreateInsertion(StartLoc, "{")
3620
1
              << FixItHint::CreateInsertion(Tok.getLocation(), "}");
3621
1
          SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3622
1
          break;
3623
1
        }
3624
85
        break;
3625
86
      }
3626
317
      }
3627
317
      if (ExpectAndConsumeSemi(diag::err_expected_semi_requirement)) {
3628
5
        SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3629
5
        TryConsumeToken(tok::semi);
3630
5
        break;
3631
5
      }
3632
317
    }
3633
239
    if (Requirements.empty()) {
3634
      // Don't emit an empty requires expr here to avoid confusing the user with
3635
      // other diagnostics quoting an empty requires expression they never
3636
      // wrote.
3637
24
      Braces.consumeClose();
3638
24
      Actions.ActOnFinishRequiresExpr();
3639
24
      return ExprError();
3640
24
    }
3641
239
  }
3642
216
  Braces.consumeClose();
3643
216
  Actions.ActOnFinishRequiresExpr();
3644
216
  return Actions.ActOnRequiresExpr(RequiresKWLoc, Body, LocalParameterDecls,
3645
216
                                   Requirements, Braces.getCloseLocation());
3646
240
}
3647
3648
27.5k
static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
3649
27.5k
  switch (kind) {
3650
0
  default: llvm_unreachable("Not a known type trait");
3651
20.2k
#define TYPE_TRAIT_1(Spelling, Name, Key) \
3652
20.2k
case tok::kw_ ## Spelling: return UTT_ ## Name;
3653
5.39k
#define TYPE_TRAIT_2(Spelling, Name, Key) \
3654
5.39k
case tok::kw_ ## Spelling: return BTT_ ## Name;
3655
0
#include "clang/Basic/TokenKinds.def"
3656
0
#define TYPE_TRAIT_N(Spelling, Name, Key) \
3657
1.86k
  case tok::kw_ ## Spelling: return TT_ ## Name;
3658
27.5k
#include 
"clang/Basic/TokenKinds.def"27
3659
27.5k
  }
3660
27.5k
}
3661
3662
492
static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
3663
492
  switch (kind) {
3664
0
  default:
3665
0
    llvm_unreachable("Not a known array type trait");
3666
0
#define ARRAY_TYPE_TRAIT(Spelling, Name, Key)                                  \
3667
492
  case tok::kw_##Spelling:                                                     \
3668
492
    return ATT_##Name;
3669
492
#include 
"clang/Basic/TokenKinds.def"0
3670
492
  }
3671
492
}
3672
3673
439
static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
3674
439
  switch (kind) {
3675
0
  default:
3676
0
    llvm_unreachable("Not a known unary expression trait.");
3677
0
#define EXPRESSION_TRAIT(Spelling, Name, Key)                                  \
3678
439
  case tok::kw_##Spelling:                                                     \
3679
439
    return ET_##Name;
3680
439
#include 
"clang/Basic/TokenKinds.def"0
3681
439
  }
3682
439
}
3683
3684
27.5k
static unsigned TypeTraitArity(tok::TokenKind kind) {
3685
27.5k
  switch (kind) {
3686
0
    default: llvm_unreachable("Not a known type trait");
3687
27.5k
#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
3688
27.5k
#include 
"clang/Basic/TokenKinds.def"0
3689
27.5k
  }
3690
27.5k
}
3691
3692
/// Parse the built-in type-trait pseudo-functions that allow
3693
/// implementation of the TR1/C++11 type traits templates.
3694
///
3695
///       primary-expression:
3696
///          unary-type-trait '(' type-id ')'
3697
///          binary-type-trait '(' type-id ',' type-id ')'
3698
///          type-trait '(' type-id-seq ')'
3699
///
3700
///       type-id-seq:
3701
///          type-id ...[opt] type-id-seq[opt]
3702
///
3703
27.5k
ExprResult Parser::ParseTypeTrait() {
3704
27.5k
  tok::TokenKind Kind = Tok.getKind();
3705
27.5k
  unsigned Arity = TypeTraitArity(Kind);
3706
3707
27.5k
  SourceLocation Loc = ConsumeToken();
3708
3709
27.5k
  BalancedDelimiterTracker Parens(*this, tok::l_paren);
3710
27.5k
  if (Parens.expectAndConsume())
3711
0
    return ExprError();
3712
3713
27.5k
  SmallVector<ParsedType, 2> Args;
3714
132k
  do {
3715
    // Parse the next type.
3716
132k
    TypeResult Ty = ParseTypeName();
3717
132k
    if (Ty.isInvalid()) {
3718
7
      Parens.skipToEnd();
3719
7
      return ExprError();
3720
7
    }
3721
3722
    // Parse the ellipsis, if present.
3723
132k
    if (Tok.is(tok::ellipsis)) {
3724
1.40k
      Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
3725
1.40k
      if (Ty.isInvalid()) {
3726
0
        Parens.skipToEnd();
3727
0
        return ExprError();
3728
0
      }
3729
1.40k
    }
3730
3731
    // Add this type to the list of arguments.
3732
132k
    Args.push_back(Ty.get());
3733
132k
  } while (TryConsumeToken(tok::comma));
3734
3735
27.5k
  if (Parens.consumeClose())
3736
0
    return ExprError();
3737
3738
27.5k
  SourceLocation EndLoc = Parens.getCloseLocation();
3739
3740
27.5k
  if (Arity && 
Args.size() != Arity25.6k
) {
3741
0
    Diag(EndLoc, diag::err_type_trait_arity)
3742
0
      << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
3743
0
    return ExprError();
3744
0
  }
3745
3746
27.5k
  if (!Arity && 
Args.empty()1.86k
) {
3747
0
    Diag(EndLoc, diag::err_type_trait_arity)
3748
0
      << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
3749
0
    return ExprError();
3750
0
  }
3751
3752
27.5k
  return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
3753
27.5k
}
3754
3755
/// ParseArrayTypeTrait - Parse the built-in array type-trait
3756
/// pseudo-functions.
3757
///
3758
///       primary-expression:
3759
/// [Embarcadero]     '__array_rank' '(' type-id ')'
3760
/// [Embarcadero]     '__array_extent' '(' type-id ',' expression ')'
3761
///
3762
492
ExprResult Parser::ParseArrayTypeTrait() {
3763
492
  ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
3764
492
  SourceLocation Loc = ConsumeToken();
3765
3766
492
  BalancedDelimiterTracker T(*this, tok::l_paren);
3767
492
  if (T.expectAndConsume())
3768
0
    return ExprError();
3769
3770
492
  TypeResult Ty = ParseTypeName();
3771
492
  if (Ty.isInvalid()) {
3772
0
    SkipUntil(tok::comma, StopAtSemi);
3773
0
    SkipUntil(tok::r_paren, StopAtSemi);
3774
0
    return ExprError();
3775
0
  }
3776
3777
492
  switch (ATT) {
3778
10
  case ATT_ArrayRank: {
3779
10
    T.consumeClose();
3780
10
    return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
3781
10
                                       T.getCloseLocation());
3782
0
  }
3783
482
  case ATT_ArrayExtent: {
3784
482
    if (ExpectAndConsume(tok::comma)) {
3785
0
      SkipUntil(tok::r_paren, StopAtSemi);
3786
0
      return ExprError();
3787
0
    }
3788
3789
482
    ExprResult DimExpr = ParseExpression();
3790
482
    T.consumeClose();
3791
3792
482
    return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
3793
482
                                       T.getCloseLocation());
3794
482
  }
3795
492
  }
3796
0
  llvm_unreachable("Invalid ArrayTypeTrait!");
3797
0
}
3798
3799
/// ParseExpressionTrait - Parse built-in expression-trait
3800
/// pseudo-functions like __is_lvalue_expr( xxx ).
3801
///
3802
///       primary-expression:
3803
/// [Embarcadero]     expression-trait '(' expression ')'
3804
///
3805
439
ExprResult Parser::ParseExpressionTrait() {
3806
439
  ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
3807
439
  SourceLocation Loc = ConsumeToken();
3808
3809
439
  BalancedDelimiterTracker T(*this, tok::l_paren);
3810
439
  if (T.expectAndConsume())
3811
0
    return ExprError();
3812
3813
439
  ExprResult Expr = ParseExpression();
3814
3815
439
  T.consumeClose();
3816
3817
439
  return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
3818
439
                                      T.getCloseLocation());
3819
439
}
3820
3821
3822
/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3823
/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3824
/// based on the context past the parens.
3825
ExprResult
3826
Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3827
                                         ParsedType &CastTy,
3828
                                         BalancedDelimiterTracker &Tracker,
3829
1.62k
                                         ColonProtectionRAIIObject &ColonProt) {
3830
1.62k
  assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
3831
0
  assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
3832
0
  assert(isTypeIdInParens() && "Not a type-id!");
3833
3834
0
  ExprResult Result(true);
3835
1.62k
  CastTy = nullptr;
3836
3837
  // We need to disambiguate a very ugly part of the C++ syntax:
3838
  //
3839
  // (T())x;  - type-id
3840
  // (T())*x; - type-id
3841
  // (T())/x; - expression
3842
  // (T());   - expression
3843
  //
3844
  // The bad news is that we cannot use the specialized tentative parser, since
3845
  // it can only verify that the thing inside the parens can be parsed as
3846
  // type-id, it is not useful for determining the context past the parens.
3847
  //
3848
  // The good news is that the parser can disambiguate this part without
3849
  // making any unnecessary Action calls.
3850
  //
3851
  // It uses a scheme similar to parsing inline methods. The parenthesized
3852
  // tokens are cached, the context that follows is determined (possibly by
3853
  // parsing a cast-expression), and then we re-introduce the cached tokens
3854
  // into the token stream and parse them appropriately.
3855
3856
1.62k
  ParenParseOption ParseAs;
3857
1.62k
  CachedTokens Toks;
3858
3859
  // Store the tokens of the parentheses. We will parse them after we determine
3860
  // the context that follows them.
3861
1.62k
  if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3862
    // We didn't find the ')' we expected.
3863
0
    Tracker.consumeClose();
3864
0
    return ExprError();
3865
0
  }
3866
3867
1.62k
  if (Tok.is(tok::l_brace)) {
3868
2
    ParseAs = CompoundLiteral;
3869
1.62k
  } else {
3870
1.62k
    bool NotCastExpr;
3871
1.62k
    if (Tok.is(tok::l_paren) && 
NextToken().is(tok::r_paren)142
) {
3872
1
      NotCastExpr = true;
3873
1.61k
    } else {
3874
      // Try parsing the cast-expression that may follow.
3875
      // If it is not a cast-expression, NotCastExpr will be true and no token
3876
      // will be consumed.
3877
1.61k
      ColonProt.restore();
3878
1.61k
      Result = ParseCastExpression(AnyCastExpr,
3879
1.61k
                                   false/*isAddressofOperand*/,
3880
1.61k
                                   NotCastExpr,
3881
                                   // type-id has priority.
3882
1.61k
                                   IsTypeCast);
3883
1.61k
    }
3884
3885
    // If we parsed a cast-expression, it's really a type-id, otherwise it's
3886
    // an expression.
3887
1.62k
    ParseAs = NotCastExpr ? 
SimpleExpr642
:
CastExpr978
;
3888
1.62k
  }
3889
3890
  // Create a fake EOF to mark end of Toks buffer.
3891
1.62k
  Token AttrEnd;
3892
1.62k
  AttrEnd.startToken();
3893
1.62k
  AttrEnd.setKind(tok::eof);
3894
1.62k
  AttrEnd.setLocation(Tok.getLocation());
3895
1.62k
  AttrEnd.setEofData(Toks.data());
3896
1.62k
  Toks.push_back(AttrEnd);
3897
3898
  // The current token should go after the cached tokens.
3899
1.62k
  Toks.push_back(Tok);
3900
  // Re-enter the stored parenthesized tokens into the token stream, so we may
3901
  // parse them now.
3902
1.62k
  PP.EnterTokenStream(Toks, /*DisableMacroExpansion*/ true,
3903
1.62k
                      /*IsReinject*/ true);
3904
  // Drop the current token and bring the first cached one. It's the same token
3905
  // as when we entered this function.
3906
1.62k
  ConsumeAnyToken();
3907
3908
1.62k
  if (ParseAs >= CompoundLiteral) {
3909
    // Parse the type declarator.
3910
980
    DeclSpec DS(AttrFactory);
3911
980
    Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
3912
980
    {
3913
980
      ColonProtectionRAIIObject InnerColonProtection(*this);
3914
980
      ParseSpecifierQualifierList(DS);
3915
980
      ParseDeclarator(DeclaratorInfo);
3916
980
    }
3917
3918
    // Match the ')'.
3919
980
    Tracker.consumeClose();
3920
980
    ColonProt.restore();
3921
3922
    // Consume EOF marker for Toks buffer.
3923
980
    assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3924
0
    ConsumeAnyToken();
3925
3926
980
    if (ParseAs == CompoundLiteral) {
3927
2
      ExprType = CompoundLiteral;
3928
2
      if (DeclaratorInfo.isInvalidType())
3929
0
        return ExprError();
3930
3931
2
      TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
3932
2
      return ParseCompoundLiteralExpression(Ty.get(),
3933
2
                                            Tracker.getOpenLocation(),
3934
2
                                            Tracker.getCloseLocation());
3935
2
    }
3936
3937
    // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
3938
978
    assert(ParseAs == CastExpr);
3939
3940
978
    if (DeclaratorInfo.isInvalidType())
3941
0
      return ExprError();
3942
3943
    // Result is what ParseCastExpression returned earlier.
3944
978
    if (!Result.isInvalid())
3945
970
      Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
3946
970
                                    DeclaratorInfo, CastTy,
3947
970
                                    Tracker.getCloseLocation(), Result.get());
3948
978
    return Result;
3949
978
  }
3950
3951
  // Not a compound literal, and not followed by a cast-expression.
3952
642
  assert(ParseAs == SimpleExpr);
3953
3954
0
  ExprType = SimpleExpr;
3955
642
  Result = ParseExpression();
3956
642
  if (!Result.isInvalid() && 
Tok.is(tok::r_paren)641
)
3957
641
    Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
3958
641
                                    Tok.getLocation(), Result.get());
3959
3960
  // Match the ')'.
3961
642
  if (Result.isInvalid()) {
3962
4
    while (Tok.isNot(tok::eof))
3963
3
      ConsumeAnyToken();
3964
1
    assert(Tok.getEofData() == AttrEnd.getEofData());
3965
0
    ConsumeAnyToken();
3966
1
    return ExprError();
3967
1
  }
3968
3969
641
  Tracker.consumeClose();
3970
  // Consume EOF marker for Toks buffer.
3971
641
  assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3972
0
  ConsumeAnyToken();
3973
641
  return Result;
3974
642
}
3975
3976
/// Parse a __builtin_bit_cast(T, E).
3977
639
ExprResult Parser::ParseBuiltinBitCast() {
3978
639
  SourceLocation KWLoc = ConsumeToken();
3979
3980
639
  BalancedDelimiterTracker T(*this, tok::l_paren);
3981
639
  if (T.expectAndConsume(diag::err_expected_lparen_after, "__builtin_bit_cast"))
3982
0
    return ExprError();
3983
3984
  // Parse the common declaration-specifiers piece.
3985
639
  DeclSpec DS(AttrFactory);
3986
639
  ParseSpecifierQualifierList(DS);
3987
3988
  // Parse the abstract-declarator, if present.
3989
639
  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
3990
639
  ParseDeclarator(DeclaratorInfo);
3991
3992
639
  if (ExpectAndConsume(tok::comma)) {
3993
0
    Diag(Tok.getLocation(), diag::err_expected) << tok::comma;
3994
0
    SkipUntil(tok::r_paren, StopAtSemi);
3995
0
    return ExprError();
3996
0
  }
3997
3998
639
  ExprResult Operand = ParseExpression();
3999
4000
639
  if (T.consumeClose())
4001
0
    return ExprError();
4002
4003
639
  if (Operand.isInvalid() || DeclaratorInfo.isInvalidType())
4004
0
    return ExprError();
4005
4006
639
  return Actions.ActOnBuiltinBitCastExpr(KWLoc, DeclaratorInfo, Operand,
4007
639
                                         T.getCloseLocation());
4008
639
}