/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp

Bug Summary

File:	clang/lib/Parse/ParseExprCXX.cpp
Warning:	line 2054, column 5 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ParseExprCXX.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/build-llvm/tools/clang/lib/Parse -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/build-llvm/tools/clang/lib/Parse -I /build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse -I /build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include -I /build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/build-llvm/tools/clang/lib/Parse -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-03-15-022507-3198-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp

/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp

→

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/Parse/Parser.h"
13#include "clang/AST/ASTContext.h"
14#include "clang/AST/Decl.h"
15#include "clang/AST/DeclTemplate.h"
16#include "clang/AST/ExprCXX.h"
17#include "clang/Basic/PrettyStackTrace.h"
18#include "clang/Lex/LiteralSupport.h"
19#include "clang/Parse/ParseDiagnostic.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>

27using namespace clang;

29static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
switch (Kind) {
  // template name
  case tok::unknown:             return 0;
  // casts
  case tok::kw_addrspace_cast:   return 1;
  case tok::kw_const_cast:       return 2;
  case tok::kw_dynamic_cast:     return 3;
  case tok::kw_reinterpret_cast: return 4;
  case tok::kw_static_cast:      return 5;
  default:
    llvm_unreachable("Unknown type for digraph error message.")::llvm::llvm_unreachable_internal("Unknown type for digraph error message."
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 40);
}
42}

44// Are the two tokens adjacent in the same source file?
45bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
SourceManager &SM = PP.getSourceManager();
SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
return FirstEnd == SM.getSpellingLoc(Second.getLocation());
50}

52// Suggest fixit for "<::" after a cast.
53static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
                     Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
// Pull '<:' and ':' off token stream.
if (!AtDigraph)
  PP.Lex(DigraphToken);
PP.Lex(ColonToken);

SourceRange Range;
Range.setBegin(DigraphToken.getLocation());
Range.setEnd(ColonToken.getLocation());
P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
    << SelectDigraphErrorMessage(Kind)
    << FixItHint::CreateReplacement(Range, "< ::");

// Update token information to reflect their change in token type.
ColonToken.setKind(tok::coloncolon);
ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
ColonToken.setLength(2);
DigraphToken.setKind(tok::less);
DigraphToken.setLength(1);

// Push new tokens back to token stream.
PP.EnterToken(ColonToken, /*IsReinject*/ true);
if (!AtDigraph)
  PP.EnterToken(DigraphToken, /*IsReinject*/ true);
78}

80// Check for '<::' which should be '< ::' instead of '[:' when following
81// a template name.
82void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
                                      bool EnteringContext,
                                      IdentifierInfo &II, CXXScopeSpec &SS) {
if (!Next.is(tok::l_square) || Next.getLength() != 2)
  return;

Token SecondToken = GetLookAheadToken(2);
if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
  return;

TemplateTy Template;
UnqualifiedId TemplateName;
TemplateName.setIdentifier(&II, Tok.getLocation());
bool MemberOfUnknownSpecialization;
if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
                            TemplateName, ObjectType, EnteringContext,
                            Template, MemberOfUnknownSpecialization))
  return;

FixDigraph(*this, PP, Next, SecondToken, tok::unknown,
           /*AtDigraph*/false);
103}

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
154bool Parser::ParseOptionalCXXScopeSpecifier(
  CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
  bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename,
  IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) {
assert(getLangOpts().CPlusPlus &&((getLangOpts().CPlusPlus && "Call sites of this function should be guarded by checking for C++"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Call sites of this function should be guarded by checking for C++\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 159, __PRETTY_FUNCTION__))
       "Call sites of this function should be guarded by checking for C++")((getLangOpts().CPlusPlus && "Call sites of this function should be guarded by checking for C++"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Call sites of this function should be guarded by checking for C++\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 159, __PRETTY_FUNCTION__));

if (Tok.is(tok::annot_cxxscope)) {
  assert(!LastII && "want last identifier but have already annotated scope")((!LastII && "want last identifier but have already annotated scope"
) ? static_cast<void> (0) : __assert_fail ("!LastII && \"want last identifier but have already annotated scope\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 162, __PRETTY_FUNCTION__));
  assert(!MayBePseudoDestructor && "unexpected annot_cxxscope")((!MayBePseudoDestructor && "unexpected annot_cxxscope"
) ? static_cast<void> (0) : __assert_fail ("!MayBePseudoDestructor && \"unexpected annot_cxxscope\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 163, __PRETTY_FUNCTION__));
  Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
                                               Tok.getAnnotationRange(),
                                               SS);
  ConsumeAnnotationToken();
  return false;
}

// Has to happen before any "return false"s in this function.
bool CheckForDestructor = false;
if (MayBePseudoDestructor && *MayBePseudoDestructor) {
  CheckForDestructor = true;
  *MayBePseudoDestructor = false;
}

if (LastII)
  *LastII = nullptr;

bool HasScopeSpecifier = false;

if (Tok.is(tok::coloncolon)) {
  // ::new and ::delete aren't nested-name-specifiers.
  tok::TokenKind NextKind = NextToken().getKind();
  if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
    return false;

  if (NextKind == tok::l_brace) {
    // It is invalid to have :: {, consume the scope qualifier and pretend
    // like we never saw it.
    Diag(ConsumeToken(), diag::err_expected) << tok::identifier;
  } else {
    // '::' - Global scope qualifier.
    if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS))
      return true;

    HasScopeSpecifier = true;
  }
}

if (Tok.is(tok::kw___super)) {
  SourceLocation SuperLoc = ConsumeToken();
  if (!Tok.is(tok::coloncolon)) {
    Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super);
    return true;
  }

  return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS);
}

if (!HasScopeSpecifier &&
    Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {
  DeclSpec DS(AttrFactory);
  SourceLocation DeclLoc = Tok.getLocation();
  SourceLocation EndLoc  = ParseDecltypeSpecifier(DS);

  SourceLocation CCLoc;
  // Work around a standard defect: 'decltype(auto)::' is not a
  // nested-name-specifier.
  if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto ||
      !TryConsumeToken(tok::coloncolon, CCLoc)) {
    AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
    return false;
  }

  if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
    SS.SetInvalid(SourceRange(DeclLoc, CCLoc));

  HasScopeSpecifier = true;
}

// Preferred type might change when parsing qualifiers, we need the original.
auto SavedType = PreferredType;
while (true) {
  if (HasScopeSpecifier) {
    if (Tok.is(tok::code_completion)) {
      // Code completion for a nested-name-specifier, where the code
      // completion token follows the '::'.
      Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext,
                                      InUsingDeclaration, ObjectType.get(),
                                      SavedType.get(SS.getBeginLoc()));
      // Include code completion token into the range of the scope otherwise
      // when we try to annotate the scope tokens the dangling code completion
      // token will cause assertion in
      // Preprocessor::AnnotatePreviousCachedTokens.
      SS.setEndLoc(Tok.getLocation());
      cutOffParsing();
      return true;
    }

    // C++ [basic.lookup.classref]p5:
    //   If the qualified-id has the form
    //
    //       ::class-name-or-namespace-name::...
    //
    //   the class-name-or-namespace-name is looked up in global scope as a
    //   class-name or namespace-name.
    //
    // To implement this, we clear out the object type as soon as we've
    // seen a leading '::' or part of a nested-name-specifier.
    ObjectType = nullptr;
  }

  // nested-name-specifier:
  //   nested-name-specifier 'template'[opt] simple-template-id '::'

  // Parse the optional 'template' keyword, then make sure we have
  // 'identifier <' after it.
  if (Tok.is(tok::kw_template)) {
    // If we don't have a scope specifier or an object type, this isn't a
    // nested-name-specifier, since they aren't allowed to start with
    // 'template'.
    if (!HasScopeSpecifier && !ObjectType)
      break;

    TentativeParsingAction TPA(*this);
    SourceLocation TemplateKWLoc = ConsumeToken();

    UnqualifiedId TemplateName;
    if (Tok.is(tok::identifier)) {
      // Consume the identifier.
      TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
      ConsumeToken();
    } else if (Tok.is(tok::kw_operator)) {
      // We don't need to actually parse the unqualified-id in this case,
      // because a simple-template-id cannot start with 'operator', but
      // go ahead and parse it anyway for consistency with the case where
      // we already annotated the template-id.
      if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
                                     TemplateName)) {
        TPA.Commit();
        break;
      }

      if (TemplateName.getKind() != UnqualifiedIdKind::IK_OperatorFunctionId &&
          TemplateName.getKind() != UnqualifiedIdKind::IK_LiteralOperatorId) {
        Diag(TemplateName.getSourceRange().getBegin(),
             diag::err_id_after_template_in_nested_name_spec)
          << TemplateName.getSourceRange();
        TPA.Commit();
        break;
      }
    } else {
      TPA.Revert();
      break;
    }

    // If the next token is not '<', we have a qualified-id that refers
    // to a template name, such as T::template apply, but is not a
    // template-id.
    if (Tok.isNot(tok::less)) {
      TPA.Revert();
      break;
    }

    // Commit to parsing the template-id.
    TPA.Commit();
    TemplateTy Template;
    TemplateNameKind TNK = Actions.ActOnTemplateName(
        getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
        EnteringContext, Template, /*AllowInjectedClassName*/ true);
    if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
                                TemplateName, false))
      return true;

    continue;
  }

  if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
    // We have
    //
    //   template-id '::'
    //
    // So we need to check whether the template-id is a simple-template-id of
    // the right kind (it should name a type or be dependent), and then
    // convert it into a type within the nested-name-specifier.
    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
    if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
      *MayBePseudoDestructor = true;
      return false;
    }

    if (LastII)
      *LastII = TemplateId->Name;

    // Consume the template-id token.
    ConsumeAnnotationToken();

    assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!")((Tok.is(tok::coloncolon) && "NextToken() not working properly!"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::coloncolon) && \"NextToken() not working properly!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 350, __PRETTY_FUNCTION__));
    SourceLocation CCLoc = ConsumeToken();

    HasScopeSpecifier = true;

    ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
                                       TemplateId->NumArgs);

    if (TemplateId->isInvalid() ||
        Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
                                            SS,
                                            TemplateId->TemplateKWLoc,
                                            TemplateId->Template,
                                            TemplateId->TemplateNameLoc,
                                            TemplateId->LAngleLoc,
                                            TemplateArgsPtr,
                                            TemplateId->RAngleLoc,
                                            CCLoc,
                                            EnteringContext)) {
      SourceLocation StartLoc
        = SS.getBeginLoc().isValid()? SS.getBeginLoc()
                                    : TemplateId->TemplateNameLoc;
      SS.SetInvalid(SourceRange(StartLoc, CCLoc));
    }

    continue;
  }

  // The rest of the nested-name-specifier possibilities start with
  // tok::identifier.
  if (Tok.isNot(tok::identifier))
    break;

  IdentifierInfo &II = *Tok.getIdentifierInfo();

  // nested-name-specifier:
  //   type-name '::'
  //   namespace-name '::'
  //   nested-name-specifier identifier '::'
  Token Next = NextToken();
  Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(),
                                  ObjectType);

  // If we get foo:bar, this is almost certainly a typo for foo::bar.  Recover
  // and emit a fixit hint for it.
  if (Next.is(tok::colon) && !ColonIsSacred) {
    if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo,
                                          EnteringContext) &&
        // If the token after the colon isn't an identifier, it's still an
        // error, but they probably meant something else strange so don't
        // recover like this.
        PP.LookAhead(1).is(tok::identifier)) {
      Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
        << FixItHint::CreateReplacement(Next.getLocation(), "::");
      // Recover as if the user wrote '::'.
      Next.setKind(tok::coloncolon);
    }
  }

  if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) {
    // It is invalid to have :: {, consume the scope qualifier and pretend
    // like we never saw it.
    Token Identifier = Tok; // Stash away the identifier.
    ConsumeToken();         // Eat the identifier, current token is now '::'.
    Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected)
        << tok::identifier;
    UnconsumeToken(Identifier); // Stick the identifier back.
    Next = NextToken();         // Point Next at the '{' token.
  }

  if (Next.is(tok::coloncolon)) {
    if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
      *MayBePseudoDestructor = true;
      return false;
    }

    if (ColonIsSacred) {
      const Token &Next2 = GetLookAheadToken(2);
      if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
          Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {
        Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
            << Next2.getName()
            << FixItHint::CreateReplacement(Next.getLocation(), ":");
        Token ColonColon;
        PP.Lex(ColonColon);
        ColonColon.setKind(tok::colon);
        PP.EnterToken(ColonColon, /*IsReinject*/ true);
        break;
      }
    }

    if (LastII)
      *LastII = &II;

    // We have an identifier followed by a '::'. Lookup this name
    // as the name in a nested-name-specifier.
    Token Identifier = Tok;
    SourceLocation IdLoc = ConsumeToken();
    assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&((Tok.isOneOf(tok::coloncolon, tok::colon) && "NextToken() not working properly!"
) ? static_cast<void> (0) : __assert_fail ("Tok.isOneOf(tok::coloncolon, tok::colon) && \"NextToken() not working properly!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 449, __PRETTY_FUNCTION__))
           "NextToken() not working properly!")((Tok.isOneOf(tok::coloncolon, tok::colon) && "NextToken() not working properly!"
) ? static_cast<void> (0) : __assert_fail ("Tok.isOneOf(tok::coloncolon, tok::colon) && \"NextToken() not working properly!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 449, __PRETTY_FUNCTION__));
    Token ColonColon = Tok;
    SourceLocation CCLoc = ConsumeToken();

    bool IsCorrectedToColon = false;
    bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
    if (Actions.ActOnCXXNestedNameSpecifier(
            getCurScope(), IdInfo, EnteringContext, SS, false,
            CorrectionFlagPtr, OnlyNamespace)) {
      // Identifier is not recognized as a nested name, but we can have
      // mistyped '::' instead of ':'.
      if (CorrectionFlagPtr && IsCorrectedToColon) {
        ColonColon.setKind(tok::colon);
        PP.EnterToken(Tok, /*IsReinject*/ true);
        PP.EnterToken(ColonColon, /*IsReinject*/ true);
        Tok = Identifier;
        break;
      }
      SS.SetInvalid(SourceRange(IdLoc, CCLoc));
    }
    HasScopeSpecifier = true;
    continue;
  }

  CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);

  // nested-name-specifier:
  //   type-name '<'
  if (Next.is(tok::less)) {

    TemplateTy Template;
    UnqualifiedId TemplateName;
    TemplateName.setIdentifier(&II, Tok.getLocation());
    bool MemberOfUnknownSpecialization;
    if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
                                            /*hasTemplateKeyword=*/false,
                                                      TemplateName,
                                                      ObjectType,
                                                      EnteringContext,
                                                      Template,
                                            MemberOfUnknownSpecialization)) {
      // If lookup didn't find anything, we treat the name as a template-name
      // anyway. C++20 requires this, and in prior language modes it improves
      // error recovery. But before we commit to this, check that we actually
      // have something that looks like a template-argument-list next.
      if (!IsTypename && TNK == TNK_Undeclared_template &&
          isTemplateArgumentList(1) == TPResult::False)
        break;

      // We have found a template name, so annotate this token
      // with a template-id annotation. We do not permit the
      // template-id to be translated into a type annotation,
      // because some clients (e.g., the parsing of class template
      // specializations) still want to see the original template-id
      // token, and it might not be a type at all (e.g. a concept name in a
      // type-constraint).
      ConsumeToken();
      if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
                                  TemplateName, false))
        return true;
      continue;
    }

    if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
        (IsTypename || isTemplateArgumentList(1) == TPResult::True)) {
      // If we had errors before, ObjectType can be dependent even without any
      // templates. Do not report missing template keyword in that case.
      if (!ObjectHadErrors) {
        // We have something like t::getAs<T>, where getAs is a
        // member of an unknown specialization. However, this will only
        // parse correctly as a template, so suggest the keyword 'template'
        // before 'getAs' and treat this as a dependent template name.
        unsigned DiagID = diag::err_missing_dependent_template_keyword;
        if (getLangOpts().MicrosoftExt)
          DiagID = diag::warn_missing_dependent_template_keyword;

        Diag(Tok.getLocation(), DiagID)
            << II.getName()
            << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
      }

      SourceLocation TemplateNameLoc = ConsumeToken();

      TemplateNameKind TNK = Actions.ActOnTemplateName(
          getCurScope(), SS, TemplateNameLoc, TemplateName, ObjectType,
          EnteringContext, Template, /*AllowInjectedClassName*/ true);
      if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
                                  TemplateName, false))
        return true;

      continue;
    }
  }

  // We don't have any tokens that form the beginning of a
  // nested-name-specifier, so we're done.
  break;
}

// Even if we didn't see any pieces of a nested-name-specifier, we
// still check whether there is a tilde in this position, which
// indicates a potential pseudo-destructor.
if (CheckForDestructor && !HasScopeSpecifier && Tok.is(tok::tilde))
  *MayBePseudoDestructor = true;

return false;
555}

557ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS,
                                         bool isAddressOfOperand,
                                         Token &Replacement) {
ExprResult E;

// We may have already annotated this id-expression.
switch (Tok.getKind()) {
case tok::annot_non_type: {
  NamedDecl *ND = getNonTypeAnnotation(Tok);
  SourceLocation Loc = ConsumeAnnotationToken();
  E = Actions.ActOnNameClassifiedAsNonType(getCurScope(), SS, ND, Loc, Tok);
  break;
}

case tok::annot_non_type_dependent: {
  IdentifierInfo *II = getIdentifierAnnotation(Tok);
  SourceLocation Loc = ConsumeAnnotationToken();

  // This is only the direct operand of an & operator if it is not
  // followed by a postfix-expression suffix.
  if (isAddressOfOperand && isPostfixExpressionSuffixStart())
    isAddressOfOperand = false;

  E = Actions.ActOnNameClassifiedAsDependentNonType(SS, II, Loc,
                                                    isAddressOfOperand);
  break;
}

case tok::annot_non_type_undeclared: {
  assert(SS.isEmpty() &&((SS.isEmpty() && "undeclared non-type annotation should be unqualified"
) ? static_cast<void> (0) : __assert_fail ("SS.isEmpty() && \"undeclared non-type annotation should be unqualified\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 587, __PRETTY_FUNCTION__))
         "undeclared non-type annotation should be unqualified")((SS.isEmpty() && "undeclared non-type annotation should be unqualified"
) ? static_cast<void> (0) : __assert_fail ("SS.isEmpty() && \"undeclared non-type annotation should be unqualified\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 587, __PRETTY_FUNCTION__));
  IdentifierInfo *II = getIdentifierAnnotation(Tok);
  SourceLocation Loc = ConsumeAnnotationToken();
  E = Actions.ActOnNameClassifiedAsUndeclaredNonType(II, Loc);
  break;
}

default:
  SourceLocation TemplateKWLoc;
  UnqualifiedId Name;
  if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
                         /*ObjectHadErrors=*/false,
                         /*EnteringContext=*/false,
                         /*AllowDestructorName=*/false,
                         /*AllowConstructorName=*/false,
                         /*AllowDeductionGuide=*/false, &TemplateKWLoc, Name))
    return ExprError();

  // This is only the direct operand of an & operator if it is not
  // followed by a postfix-expression suffix.
  if (isAddressOfOperand && isPostfixExpressionSuffixStart())
    isAddressOfOperand = false;

  E = Actions.ActOnIdExpression(
      getCurScope(), SS, TemplateKWLoc, Name, Tok.is(tok::l_paren),
      isAddressOfOperand, /*CCC=*/nullptr, /*IsInlineAsmIdentifier=*/false,
      &Replacement);
  break;
}

if (!E.isInvalid() && !E.isUnset() && Tok.is(tok::less))
  checkPotentialAngleBracket(E);
return E;
620}

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///
664ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
// qualified-id:
//   '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
//   '::' unqualified-id
//
CXXScopeSpec SS;
ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
                               /*ObjectHadErrors=*/false,
                               /*EnteringContext=*/false);

Token Replacement;
ExprResult Result =
    tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
if (Result.isUnset()) {
  // If the ExprResult is valid but null, then typo correction suggested a
  // keyword replacement that needs to be reparsed.
  UnconsumeToken(Replacement);
  Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
}
assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "((!Result.isUnset() && "Typo correction suggested a keyword replacement "
 "for a previous keyword suggestion") ? static_cast<void>
 (0) : __assert_fail ("!Result.isUnset() && \"Typo correction suggested a keyword replacement \" \"for a previous keyword suggestion\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 684, __PRETTY_FUNCTION__))
                            "for a previous keyword suggestion")((!Result.isUnset() && "Typo correction suggested a keyword replacement "
 "for a previous keyword suggestion") ? static_cast<void>
 (0) : __assert_fail ("!Result.isUnset() && \"Typo correction suggested a keyword replacement \" \"for a previous keyword suggestion\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 684, __PRETTY_FUNCTION__));
return Result;
686}

688/// ParseLambdaExpression - Parse a C++11 lambda expression.
689///
690///       lambda-expression:
691///         lambda-introducer lambda-declarator[opt] compound-statement
692///         lambda-introducer '<' template-parameter-list '>'
693///             lambda-declarator[opt] 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///         '(' parameter-declaration-clause ')' attribute-specifier[opt]
726///           'mutable'[opt] exception-specification[opt]
727///           trailing-return-type[opt]
728///
729ExprResult Parser::ParseLambdaExpression() {
// Parse lambda-introducer.
LambdaIntroducer Intro;
if (ParseLambdaIntroducer(Intro)) {
  SkipUntil(tok::r_square, StopAtSemi);
  SkipUntil(tok::l_brace, StopAtSemi);
  SkipUntil(tok::r_brace, StopAtSemi);
  return ExprError();
}

return ParseLambdaExpressionAfterIntroducer(Intro);
740}

742/// Use lookahead and potentially tentative parsing to determine if we are
743/// looking at a C++11 lambda expression, and parse it if we are.
744///
745/// If we are not looking at a lambda expression, returns ExprError().
746ExprResult Parser::TryParseLambdaExpression() {
assert(getLangOpts().CPlusPlus11((getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) &&
 "Not at the start of a possible lambda expression.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 749, __PRETTY_FUNCTION__))
       && Tok.is(tok::l_square)((getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) &&
 "Not at the start of a possible lambda expression.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 749, __PRETTY_FUNCTION__))
       && "Not at the start of a possible lambda expression.")((getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) &&
 "Not at the start of a possible lambda expression.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 749, __PRETTY_FUNCTION__));

const Token Next = NextToken();
if (Next.is(tok::eof)) // Nothing else to lookup here...
  return ExprEmpty();

const Token After = GetLookAheadToken(2);
// If lookahead indicates this is a lambda...
if (Next.is(tok::r_square) ||     // []
    Next.is(tok::equal) ||        // [=
    (Next.is(tok::amp) &&         // [&] or [&,
     After.isOneOf(tok::r_square, tok::comma)) ||
    (Next.is(tok::identifier) &&  // [identifier]
     After.is(tok::r_square)) ||
    Next.is(tok::ellipsis)) {     // [...
  return ParseLambdaExpression();
}

// If lookahead indicates an ObjC message send...
// [identifier identifier
if (Next.is(tok::identifier) && After.is(tok::identifier))
  return ExprEmpty();

// Here, we're stuck: lambda introducers and Objective-C message sends are
// unambiguous, but it requires arbitrary lookhead.  [a,b,c,d,e,f,g] is a
// lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send.  Instead of
// writing two routines to parse a lambda introducer, just try to parse
// a lambda introducer first, and fall back if that fails.
LambdaIntroducer Intro;
{
  TentativeParsingAction TPA(*this);
  LambdaIntroducerTentativeParse Tentative;
  if (ParseLambdaIntroducer(Intro, &Tentative)) {
    TPA.Commit();
    return ExprError();
  }

  switch (Tentative) {
  case LambdaIntroducerTentativeParse::Success:
    TPA.Commit();
    break;

  case LambdaIntroducerTentativeParse::Incomplete:
    // Didn't fully parse the lambda-introducer, try again with a
    // non-tentative parse.
    TPA.Revert();
    Intro = LambdaIntroducer();
    if (ParseLambdaIntroducer(Intro))
      return ExprError();
    break;

  case LambdaIntroducerTentativeParse::MessageSend:
  case LambdaIntroducerTentativeParse::Invalid:
    // Not a lambda-introducer, might be a message send.
    TPA.Revert();
    return ExprEmpty();
  }
}

return ParseLambdaExpressionAfterIntroducer(Intro);
809}

811/// Parse a lambda introducer.
812/// \param Intro A LambdaIntroducer filled in with information about the
813///        contents of the lambda-introducer.
814/// \param Tentative If non-null, we are disambiguating between a
815///        lambda-introducer and some other construct. In this mode, we do not
816///        produce any diagnostics or take any other irreversible action unless
817///        we're sure that this is a lambda-expression.
818/// \return \c true if parsing (or disambiguation) failed with a diagnostic and
819///         the caller should bail out / recover.
820bool Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
                                 LambdaIntroducerTentativeParse *Tentative) {
if (Tentative)
  *Tentative = LambdaIntroducerTentativeParse::Success;

assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.")((Tok.is(tok::l_square) && "Lambda expressions begin with '['."
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::l_square) && \"Lambda expressions begin with '['.\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 825, __PRETTY_FUNCTION__));
BalancedDelimiterTracker T(*this, tok::l_square);
T.consumeOpen();

Intro.Range.setBegin(T.getOpenLocation());

bool First = true;

// Produce a diagnostic if we're not tentatively parsing; otherwise track
// that our parse has failed.
auto Invalid = [&](llvm::function_ref<void()> Action) {
  if (Tentative) {
    *Tentative = LambdaIntroducerTentativeParse::Invalid;
    return false;
  }
  Action();
  return true;
};

// Perform some irreversible action if this is a non-tentative parse;
// otherwise note that our actions were incomplete.
auto NonTentativeAction = [&](llvm::function_ref<void()> Action) {
  if (Tentative)
    *Tentative = LambdaIntroducerTentativeParse::Incomplete;
  else
    Action();
};

// Parse capture-default.
if (Tok.is(tok::amp) &&
    (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
  Intro.Default = LCD_ByRef;
  Intro.DefaultLoc = ConsumeToken();
  First = false;
  if (!Tok.getIdentifierInfo()) {
    // This can only be a lambda; no need for tentative parsing any more.
    // '[[and]]' can still be an attribute, though.
    Tentative = nullptr;
  }
} else if (Tok.is(tok::equal)) {
  Intro.Default = LCD_ByCopy;
  Intro.DefaultLoc = ConsumeToken();
  First = false;
  Tentative = nullptr;
}

while (Tok.isNot(tok::r_square)) {
  if (!First) {
    if (Tok.isNot(tok::comma)) {
      // Provide a completion for a lambda introducer here. Except
      // in Objective-C, where this is Almost Surely meant to be a message
      // send. In that case, fail here and let the ObjC message
      // expression parser perform the completion.
      if (Tok.is(tok::code_completion) &&
          !(getLangOpts().ObjC && Tentative)) {
        Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
                                             /*AfterAmpersand=*/false);
        cutOffParsing();
        break;
      }

      return Invalid([&] {
        Diag(Tok.getLocation(), diag::err_expected_comma_or_rsquare);
      });
    }
    ConsumeToken();
  }

  if (Tok.is(tok::code_completion)) {
    // If we're in Objective-C++ and we have a bare '[', then this is more
    // likely to be a message receiver.
    if (getLangOpts().ObjC && Tentative && First)
      Actions.CodeCompleteObjCMessageReceiver(getCurScope());
    else
      Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
                                           /*AfterAmpersand=*/false);
    cutOffParsing();
    break;
  }

  First = false;

  // Parse capture.
  LambdaCaptureKind Kind = LCK_ByCopy;
  LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
  SourceLocation Loc;
  IdentifierInfo *Id = nullptr;
  SourceLocation EllipsisLocs[4];
  ExprResult Init;
  SourceLocation LocStart = Tok.getLocation();

  if (Tok.is(tok::star)) {
    Loc = ConsumeToken();
    if (Tok.is(tok::kw_this)) {
      ConsumeToken();
      Kind = LCK_StarThis;
    } else {
      return Invalid([&] {
        Diag(Tok.getLocation(), diag::err_expected_star_this_capture);
      });
    }
  } else if (Tok.is(tok::kw_this)) {
    Kind = LCK_This;
    Loc = ConsumeToken();
  } else if (Tok.isOneOf(tok::amp, tok::equal) &&
             NextToken().isOneOf(tok::comma, tok::r_square) &&
             Intro.Default == LCD_None) {
    // We have a lone "&" or "=" which is either a misplaced capture-default
    // or the start of a capture (in the "&" case) with the rest of the
    // capture missing. Both are an error but a misplaced capture-default
    // is more likely if we don't already have a capture default.
    return Invalid(
        [&] { Diag(Tok.getLocation(), diag::err_capture_default_first); });
  } else {
    TryConsumeToken(tok::ellipsis, EllipsisLocs[0]);

    if (Tok.is(tok::amp)) {
      Kind = LCK_ByRef;
      ConsumeToken();

      if (Tok.is(tok::code_completion)) {
        Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
                                             /*AfterAmpersand=*/true);
        cutOffParsing();
        break;
      }
    }

    TryConsumeToken(tok::ellipsis, EllipsisLocs[1]);

    if (Tok.is(tok::identifier)) {
      Id = Tok.getIdentifierInfo();
      Loc = ConsumeToken();
    } else if (Tok.is(tok::kw_this)) {
      return Invalid([&] {
        // FIXME: Suggest a fixit here.
        Diag(Tok.getLocation(), diag::err_this_captured_by_reference);
      });
    } else {
      return Invalid([&] {
        Diag(Tok.getLocation(), diag::err_expected_capture);
      });
    }

    TryConsumeToken(tok::ellipsis, EllipsisLocs[2]);

    if (Tok.is(tok::l_paren)) {
      BalancedDelimiterTracker Parens(*this, tok::l_paren);
      Parens.consumeOpen();

      InitKind = LambdaCaptureInitKind::DirectInit;

      ExprVector Exprs;
      CommaLocsTy Commas;
      if (Tentative) {
        Parens.skipToEnd();
        *Tentative = LambdaIntroducerTentativeParse::Incomplete;
      } else if (ParseExpressionList(Exprs, Commas)) {
        Parens.skipToEnd();
        Init = ExprError();
      } else {
        Parens.consumeClose();
        Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
                                          Parens.getCloseLocation(),
                                          Exprs);
      }
    } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
      // Each lambda init-capture forms its own full expression, which clears
      // Actions.MaybeODRUseExprs. So create an expression evaluation context
      // to save the necessary state, and restore it later.
      EnterExpressionEvaluationContext EC(
          Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

      if (TryConsumeToken(tok::equal))
        InitKind = LambdaCaptureInitKind::CopyInit;
      else
        InitKind = LambdaCaptureInitKind::ListInit;

      if (!Tentative) {
        Init = ParseInitializer();
      } else if (Tok.is(tok::l_brace)) {
        BalancedDelimiterTracker Braces(*this, tok::l_brace);
        Braces.consumeOpen();
        Braces.skipToEnd();
        *Tentative = LambdaIntroducerTentativeParse::Incomplete;
      } else {
        // We're disambiguating this:
        //
        //   [..., x = expr
        //
        // We need to find the end of the following expression in order to
        // determine whether this is an Obj-C message send's receiver, a
        // C99 designator, or a lambda init-capture.
        //
        // Parse the expression to find where it ends, and annotate it back
        // onto the tokens. We would have parsed this expression the same way
        // in either case: both the RHS of an init-capture and the RHS of an
        // assignment expression are parsed as an initializer-clause, and in
        // neither case can anything be added to the scope between the '[' and
        // here.
        //
        // FIXME: This is horrible. Adding a mechanism to skip an expression
        // would be much cleaner.
        // FIXME: If there is a ',' before the next ']' or ':', we can skip to
        // that instead. (And if we see a ':' with no matching '?', we can
        // classify this as an Obj-C message send.)
        SourceLocation StartLoc = Tok.getLocation();
        InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
        Init = ParseInitializer();
        if (!Init.isInvalid())
          Init = Actions.CorrectDelayedTyposInExpr(Init.get());

        if (Tok.getLocation() != StartLoc) {
          // Back out the lexing of the token after the initializer.
          PP.RevertCachedTokens(1);

          // Replace the consumed tokens with an appropriate annotation.
          Tok.setLocation(StartLoc);
          Tok.setKind(tok::annot_primary_expr);
          setExprAnnotation(Tok, Init);
          Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation());
          PP.AnnotateCachedTokens(Tok);

          // Consume the annotated initializer.
          ConsumeAnnotationToken();
        }
      }
    }

    TryConsumeToken(tok::ellipsis, EllipsisLocs[3]);
  }

  // Check if this is a message send before we act on a possible init-capture.
  if (Tentative && Tok.is(tok::identifier) &&
      NextToken().isOneOf(tok::colon, tok::r_square)) {
    // This can only be a message send. We're done with disambiguation.
    *Tentative = LambdaIntroducerTentativeParse::MessageSend;
    return false;
  }

  // Ensure that any ellipsis was in the right place.
  SourceLocation EllipsisLoc;
  if (std::any_of(std::begin(EllipsisLocs), std::end(EllipsisLocs),
                  [](SourceLocation Loc) { return Loc.isValid(); })) {
    // The '...' should appear before the identifier in an init-capture, and
    // after the identifier otherwise.
    bool InitCapture = InitKind != LambdaCaptureInitKind::NoInit;
    SourceLocation *ExpectedEllipsisLoc =
        !InitCapture      ? &EllipsisLocs[2] :
        Kind == LCK_ByRef ? &EllipsisLocs[1] :
                            &EllipsisLocs[0];
    EllipsisLoc = *ExpectedEllipsisLoc;

    unsigned DiagID = 0;
    if (EllipsisLoc.isInvalid()) {
      DiagID = diag::err_lambda_capture_misplaced_ellipsis;
      for (SourceLocation Loc : EllipsisLocs) {
        if (Loc.isValid())
          EllipsisLoc = Loc;
      }
    } else {
      unsigned NumEllipses = std::accumulate(
          std::begin(EllipsisLocs), std::end(EllipsisLocs), 0,
          [](int N, SourceLocation Loc) { return N + Loc.isValid(); });
      if (NumEllipses > 1)
        DiagID = diag::err_lambda_capture_multiple_ellipses;
    }
    if (DiagID) {
      NonTentativeAction([&] {
        // Point the diagnostic at the first misplaced ellipsis.
        SourceLocation DiagLoc;
        for (SourceLocation &Loc : EllipsisLocs) {
          if (&Loc != ExpectedEllipsisLoc && Loc.isValid()) {
            DiagLoc = Loc;
            break;
          }
        }
        assert(DiagLoc.isValid() && "no location for diagnostic")((DiagLoc.isValid() && "no location for diagnostic") ?
 static_cast<void> (0) : __assert_fail ("DiagLoc.isValid() && \"no location for diagnostic\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1102, __PRETTY_FUNCTION__));

        // Issue the diagnostic and produce fixits showing where the ellipsis
        // should have been written.
        auto &&D = Diag(DiagLoc, DiagID);
        if (DiagID == diag::err_lambda_capture_misplaced_ellipsis) {
          SourceLocation ExpectedLoc =
              InitCapture ? Loc
                          : Lexer::getLocForEndOfToken(
                                Loc, 0, PP.getSourceManager(), getLangOpts());
          D << InitCapture << FixItHint::CreateInsertion(ExpectedLoc, "...");
        }
        for (SourceLocation &Loc : EllipsisLocs) {
          if (&Loc != ExpectedEllipsisLoc && Loc.isValid())
            D << FixItHint::CreateRemoval(Loc);
        }
      });
    }
  }

  // Process the init-capture initializers now rather than delaying until we
  // form the lambda-expression so that they can be handled in the context
  // enclosing the lambda-expression, rather than in the context of the
  // lambda-expression itself.
  ParsedType InitCaptureType;
  if (Init.isUsable())
    Init = Actions.CorrectDelayedTyposInExpr(Init.get());
  if (Init.isUsable()) {
    NonTentativeAction([&] {
      // Get the pointer and store it in an lvalue, so we can use it as an
      // out argument.
      Expr *InitExpr = Init.get();
      // This performs any lvalue-to-rvalue conversions if necessary, which
      // can affect what gets captured in the containing decl-context.
      InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
          Loc, Kind == LCK_ByRef, EllipsisLoc, Id, InitKind, InitExpr);
      Init = InitExpr;
    });
  }

  SourceLocation LocEnd = PrevTokLocation;

  Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
                   InitCaptureType, SourceRange(LocStart, LocEnd));
}

T.consumeClose();
Intro.Range.setEnd(T.getCloseLocation());
return false;
1151}

1153static void tryConsumeLambdaSpecifierToken(Parser &P,
                                         SourceLocation &MutableLoc,
                                         SourceLocation &ConstexprLoc,
                                         SourceLocation &ConstevalLoc,
                                         SourceLocation &DeclEndLoc) {
assert(MutableLoc.isInvalid())((MutableLoc.isInvalid()) ? static_cast<void> (0) : __assert_fail
 ("MutableLoc.isInvalid()", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1158, __PRETTY_FUNCTION__));
assert(ConstexprLoc.isInvalid())((ConstexprLoc.isInvalid()) ? static_cast<void> (0) : __assert_fail
 ("ConstexprLoc.isInvalid()", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1159, __PRETTY_FUNCTION__));
// Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
// to the final of those locations. Emit an error if we have multiple
// copies of those keywords and recover.

while (true) {
  switch (P.getCurToken().getKind()) {
  case tok::kw_mutable: {
    if (MutableLoc.isValid()) {
      P.Diag(P.getCurToken().getLocation(),
             diag::err_lambda_decl_specifier_repeated)
          << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
    }
    MutableLoc = P.ConsumeToken();
    DeclEndLoc = MutableLoc;
    break /*switch*/;
  }
  case tok::kw_constexpr:
    if (ConstexprLoc.isValid()) {
      P.Diag(P.getCurToken().getLocation(),
             diag::err_lambda_decl_specifier_repeated)
          << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
    }
    ConstexprLoc = P.ConsumeToken();
    DeclEndLoc = ConstexprLoc;
    break /*switch*/;
  case tok::kw_consteval:
    if (ConstevalLoc.isValid()) {
      P.Diag(P.getCurToken().getLocation(),
             diag::err_lambda_decl_specifier_repeated)
          << 2 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
    }
    ConstevalLoc = P.ConsumeToken();
    DeclEndLoc = ConstevalLoc;
    break /*switch*/;
  default:
    return;
  }
}
1198}

1200static void
1201addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
                                DeclSpec &DS) {
if (ConstexprLoc.isValid()) {
  P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17
                           ? diag::ext_constexpr_on_lambda_cxx17
                           : diag::warn_cxx14_compat_constexpr_on_lambda);
  const char *PrevSpec = nullptr;
  unsigned DiagID = 0;
  DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, ConstexprLoc, PrevSpec,
                      DiagID);
  assert(PrevSpec == nullptr && DiagID == 0 &&((PrevSpec == nullptr && DiagID == 0 && "Constexpr cannot have been set previously!"
) ? static_cast<void> (0) : __assert_fail ("PrevSpec == nullptr && DiagID == 0 && \"Constexpr cannot have been set previously!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1212, __PRETTY_FUNCTION__))
         "Constexpr cannot have been set previously!")((PrevSpec == nullptr && DiagID == 0 && "Constexpr cannot have been set previously!"
) ? static_cast<void> (0) : __assert_fail ("PrevSpec == nullptr && DiagID == 0 && \"Constexpr cannot have been set previously!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1212, __PRETTY_FUNCTION__));
}
1214}

1216static void addConstevalToLambdaDeclSpecifier(Parser &P,
                                            SourceLocation ConstevalLoc,
                                            DeclSpec &DS) {
if (ConstevalLoc.isValid()) {
  P.Diag(ConstevalLoc, diag::warn_cxx20_compat_consteval);
  const char *PrevSpec = nullptr;
  unsigned DiagID = 0;
  DS.SetConstexprSpec(ConstexprSpecKind::Consteval, ConstevalLoc, PrevSpec,
                      DiagID);
  if (DiagID != 0)
    P.Diag(ConstevalLoc, DiagID) << PrevSpec;
}
1228}

1230/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1231/// expression.
1232ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
                   LambdaIntroducer &Intro) {
SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);

PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
                              "lambda expression parsing");



// FIXME: Call into Actions to add any init-capture declarations to the
// scope while parsing the lambda-declarator and compound-statement.

// Parse lambda-declarator[opt].
DeclSpec DS(AttrFactory);
Declarator D(DS, DeclaratorContext::LambdaExpr);
TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
Actions.PushLambdaScope();

ParsedAttributes Attr(AttrFactory);
SourceLocation DeclLoc = Tok.getLocation();
if (getLangOpts().CUDA) {
  // In CUDA code, GNU attributes are allowed to appear immediately after the
  // "[...]", even if there is no "(...)" before the lambda body.
  MaybeParseGNUAttributes(D);
}

// Helper to emit a warning if we see a CUDA host/device/global attribute
// after '(...)'. nvcc doesn't accept this.
auto WarnIfHasCUDATargetAttr = [&] {
  if (getLangOpts().CUDA)
    for (const ParsedAttr &A : Attr)
      if (A.getKind() == ParsedAttr::AT_CUDADevice ||
          A.getKind() == ParsedAttr::AT_CUDAHost ||
          A.getKind() == ParsedAttr::AT_CUDAGlobal)
        Diag(A.getLoc(), diag::warn_cuda_attr_lambda_position)
            << A.getAttrName()->getName();
};

MultiParseScope TemplateParamScope(*this);
if (Tok.is(tok::less)) {
  Diag(Tok, getLangOpts().CPlusPlus20
                ? diag::warn_cxx17_compat_lambda_template_parameter_list
                : diag::ext_lambda_template_parameter_list);

  SmallVector<NamedDecl*, 4> TemplateParams;
  SourceLocation LAngleLoc, RAngleLoc;
  if (ParseTemplateParameters(TemplateParamScope,
                              CurTemplateDepthTracker.getDepth(),
                              TemplateParams, LAngleLoc, RAngleLoc)) {
    Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
    return ExprError();
  }

  if (TemplateParams.empty()) {
    Diag(RAngleLoc,
         diag::err_lambda_template_parameter_list_empty);
  } else {
    ExprResult RequiresClause;
    if (TryConsumeToken(tok::kw_requires)) {
      RequiresClause =
          Actions.ActOnRequiresClause(ParseConstraintLogicalOrExpression(
              /*IsTrailingRequiresClause=*/false));
      if (RequiresClause.isInvalid())
        SkipUntil({tok::l_brace, tok::l_paren}, StopAtSemi | StopBeforeMatch);
    }

    Actions.ActOnLambdaExplicitTemplateParameterList(
        LAngleLoc, TemplateParams, RAngleLoc, RequiresClause);
    ++CurTemplateDepthTracker;
  }
}

// Implement WG21 P2173, which allows attributes immediately before the
// lambda declarator and applies them to the corresponding function operator
// or operator template declaration. We accept this as a conforming extension
// in all language modes that support lambdas.
if (isCXX11AttributeSpecifier()) {
  Diag(Tok, getLangOpts().CPlusPlus2b
                ? diag::warn_cxx20_compat_decl_attrs_on_lambda
                : diag::ext_decl_attrs_on_lambda);
  MaybeParseCXX11Attributes(D);
}

TypeResult TrailingReturnType;
SourceLocation TrailingReturnTypeLoc;
if (Tok.is(tok::l_paren)) {
  ParseScope PrototypeScope(this,
                            Scope::FunctionPrototypeScope |
                            Scope::FunctionDeclarationScope |
                            Scope::DeclScope);

  BalancedDelimiterTracker T(*this, tok::l_paren);
  T.consumeOpen();
  SourceLocation LParenLoc = T.getOpenLocation();

  // Parse parameter-declaration-clause.
  SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
  SourceLocation EllipsisLoc;

  if (Tok.isNot(tok::r_paren)) {
    Actions.RecordParsingTemplateParameterDepth(
        CurTemplateDepthTracker.getOriginalDepth());

    ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo,
                                    EllipsisLoc);
    // For a generic lambda, each 'auto' within the parameter declaration
    // clause creates a template type parameter, so increment the depth.
    // If we've parsed any explicit template parameters, then the depth will
    // have already been incremented. So we make sure that at most a single
    // depth level is added.
    if (Actions.getCurGenericLambda())
      CurTemplateDepthTracker.setAddedDepth(1);
  }

  T.consumeClose();
  SourceLocation RParenLoc = T.getCloseLocation();
  SourceLocation DeclEndLoc = RParenLoc;

  // GNU-style attributes must be parsed before the mutable specifier to be
  // compatible with GCC. MSVC-style attributes must be parsed before the
  // mutable specifier to be compatible with MSVC.
  MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr);

  // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update the
  // DeclEndLoc.
  SourceLocation MutableLoc;
  SourceLocation ConstexprLoc;
  SourceLocation ConstevalLoc;
  tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
                                 ConstevalLoc, DeclEndLoc);

  addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
  addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
  // Parse exception-specification[opt].
  ExceptionSpecificationType ESpecType = EST_None;
  SourceRange ESpecRange;
  SmallVector<ParsedType, 2> DynamicExceptions;
  SmallVector<SourceRange, 2> DynamicExceptionRanges;
  ExprResult NoexceptExpr;
  CachedTokens *ExceptionSpecTokens;
  ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
                                             ESpecRange,
                                             DynamicExceptions,
                                             DynamicExceptionRanges,
                                             NoexceptExpr,
                                             ExceptionSpecTokens);

  if (ESpecType != EST_None)
    DeclEndLoc = ESpecRange.getEnd();

  // Parse attribute-specifier[opt].
  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);

  // Parse OpenCL addr space attribute.
  if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local,
                  tok::kw___constant, tok::kw___generic)) {
    ParseOpenCLQualifiers(DS.getAttributes());
    ConsumeToken();
  }

  SourceLocation FunLocalRangeEnd = DeclEndLoc;

  // Parse trailing-return-type[opt].
  if (Tok.is(tok::arrow)) {
    FunLocalRangeEnd = Tok.getLocation();
    SourceRange Range;
    TrailingReturnType =
        ParseTrailingReturnType(Range, /*MayBeFollowedByDirectInit*/ false);
    TrailingReturnTypeLoc = Range.getBegin();
    if (Range.getEnd().isValid())
      DeclEndLoc = Range.getEnd();
  }

  SourceLocation NoLoc;
  D.AddTypeInfo(DeclaratorChunk::getFunction(
                    /*HasProto=*/true,
                    /*IsAmbiguous=*/false, LParenLoc, ParamInfo.data(),
                    ParamInfo.size(), EllipsisLoc, RParenLoc,
                    /*RefQualifierIsLvalueRef=*/true,
                    /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType,
                    ESpecRange, DynamicExceptions.data(),
                    DynamicExceptionRanges.data(), DynamicExceptions.size(),
                    NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
                    /*ExceptionSpecTokens*/ nullptr,
                    /*DeclsInPrototype=*/None, LParenLoc, FunLocalRangeEnd, D,
                    TrailingReturnType, TrailingReturnTypeLoc, &DS),
                std::move(Attr), DeclEndLoc);

  // Parse requires-clause[opt].
  if (Tok.is(tok::kw_requires))
    ParseTrailingRequiresClause(D);

  PrototypeScope.Exit();

  WarnIfHasCUDATargetAttr();
} else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
                       tok::kw_constexpr, tok::kw_consteval,
                       tok::kw___private, tok::kw___global, tok::kw___local,
                       tok::kw___constant, tok::kw___generic,
                       tok::kw_requires) ||
           (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
  // It's common to forget that one needs '()' before 'mutable', an attribute
  // specifier, the result type, or the requires clause. Deal with this.
  unsigned TokKind = 0;
  switch (Tok.getKind()) {
  case tok::kw_mutable: TokKind = 0; break;
  case tok::arrow: TokKind = 1; break;
  case tok::kw___attribute:
  case tok::kw___private:
  case tok::kw___global:
  case tok::kw___local:
  case tok::kw___constant:
  case tok::kw___generic:
  case tok::l_square: TokKind = 2; break;
  case tok::kw_constexpr: TokKind = 3; break;
  case tok::kw_consteval: TokKind = 4; break;
  case tok::kw_requires: TokKind = 5; break;
  default: llvm_unreachable("Unknown token kind")::llvm::llvm_unreachable_internal("Unknown token kind", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1450);
  }

  Diag(Tok, diag::err_lambda_missing_parens)
    << TokKind
    << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
  SourceLocation DeclEndLoc = DeclLoc;

  // GNU-style attributes must be parsed before the mutable specifier to be
  // compatible with GCC.
  MaybeParseGNUAttributes(Attr, &DeclEndLoc);

  // Parse 'mutable', if it's there.
  SourceLocation MutableLoc;
  if (Tok.is(tok::kw_mutable)) {
    MutableLoc = ConsumeToken();
    DeclEndLoc = MutableLoc;
  }

  // Parse attribute-specifier[opt].
  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);

  // Parse the return type, if there is one.
  if (Tok.is(tok::arrow)) {
    SourceRange Range;
    TrailingReturnType =
        ParseTrailingReturnType(Range, /*MayBeFollowedByDirectInit*/ false);
    if (Range.getEnd().isValid())
      DeclEndLoc = Range.getEnd();
  }

  SourceLocation NoLoc;
  D.AddTypeInfo(DeclaratorChunk::getFunction(
                    /*HasProto=*/true,
                    /*IsAmbiguous=*/false,
                    /*LParenLoc=*/NoLoc,
                    /*Params=*/nullptr,
                    /*NumParams=*/0,
                    /*EllipsisLoc=*/NoLoc,
                    /*RParenLoc=*/NoLoc,
                    /*RefQualifierIsLvalueRef=*/true,
                    /*RefQualifierLoc=*/NoLoc, MutableLoc, EST_None,
                    /*ESpecRange=*/SourceRange(),
                    /*Exceptions=*/nullptr,
                    /*ExceptionRanges=*/nullptr,
                    /*NumExceptions=*/0,
                    /*NoexceptExpr=*/nullptr,
                    /*ExceptionSpecTokens=*/nullptr,
                    /*DeclsInPrototype=*/None, DeclLoc, DeclEndLoc, D,
                    TrailingReturnType),
                std::move(Attr), DeclEndLoc);

  // Parse the requires-clause, if present.
  if (Tok.is(tok::kw_requires))
    ParseTrailingRequiresClause(D);

  WarnIfHasCUDATargetAttr();
}

// FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
// it.
unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
                      Scope::CompoundStmtScope;
ParseScope BodyScope(this, ScopeFlags);

Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());

// Parse compound-statement.
if (!Tok.is(tok::l_brace)) {
  Diag(Tok, diag::err_expected_lambda_body);
  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
  return ExprError();
}

StmtResult Stmt(ParseCompoundStatementBody());
BodyScope.Exit();
TemplateParamScope.Exit();

if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
  return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());

Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
return ExprError();
1533}

1535/// ParseCXXCasts - This handles the various ways to cast expressions to another
1536/// type.
1537///
1538///       postfix-expression: [C++ 5.2p1]
1539///         'dynamic_cast' '<' type-name '>' '(' expression ')'
1540///         'static_cast' '<' type-name '>' '(' expression ')'
1541///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
1542///         'const_cast' '<' type-name '>' '(' expression ')'
1543///
1544/// C++ for OpenCL s2.3.1 adds:
1545///         'addrspace_cast' '<' type-name '>' '(' expression ')'
1546ExprResult Parser::ParseCXXCasts() {
tok::TokenKind Kind = Tok.getKind();
const char *CastName = nullptr; // For error messages

switch (Kind) {
default: llvm_unreachable("Unknown C++ cast!")::llvm::llvm_unreachable_internal("Unknown C++ cast!", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1551);
case tok::kw_addrspace_cast:   CastName = "addrspace_cast";   break;
case tok::kw_const_cast:       CastName = "const_cast";       break;
case tok::kw_dynamic_cast:     CastName = "dynamic_cast";     break;
case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
case tok::kw_static_cast:      CastName = "static_cast";      break;
}

SourceLocation OpLoc = ConsumeToken();
SourceLocation LAngleBracketLoc = Tok.getLocation();

// Check for "<::" which is parsed as "[:".  If found, fix token stream,
// diagnose error, suggest fix, and recover parsing.
if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
  Token Next = NextToken();
  if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
    FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
}

if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
  return ExprError();

// Parse the common declaration-specifiers piece.
DeclSpec DS(AttrFactory);
ParseSpecifierQualifierList(DS);

// Parse the abstract-declarator, if present.
Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
ParseDeclarator(DeclaratorInfo);

SourceLocation RAngleBracketLoc = Tok.getLocation();

if (ExpectAndConsume(tok::greater))
  return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);

BalancedDelimiterTracker T(*this, tok::l_paren);

if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
  return ExprError();

ExprResult Result = ParseExpression();

// Match the ')'.
T.consumeClose();

if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
  Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
                                     LAngleBracketLoc, DeclaratorInfo,
                                     RAngleBracketLoc,
                                     T.getOpenLocation(), Result.get(),
                                     T.getCloseLocation());

return Result;
1604}

1606/// ParseCXXTypeid - This handles the C++ typeid expression.
1607///
1608///       postfix-expression: [C++ 5.2p1]
1609///         'typeid' '(' expression ')'
1610///         'typeid' '(' type-id ')'
1611///
1612ExprResult Parser::ParseCXXTypeid() {
assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!")((Tok.is(tok::kw_typeid) && "Not 'typeid'!") ? static_cast
<void> (0) : __assert_fail ("Tok.is(tok::kw_typeid) && \"Not 'typeid'!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1613, __PRETTY_FUNCTION__));

SourceLocation OpLoc = ConsumeToken();
SourceLocation LParenLoc, RParenLoc;
BalancedDelimiterTracker T(*this, tok::l_paren);

// typeid expressions are always parenthesized.
if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
  return ExprError();
LParenLoc = T.getOpenLocation();

ExprResult Result;

// C++0x [expr.typeid]p3:
//   When typeid is applied to an expression other than an lvalue of a
//   polymorphic class type [...] The expression is an unevaluated
//   operand (Clause 5).
//
// Note that we can't tell whether the expression is an lvalue of a
// polymorphic class type until after we've parsed the expression; we
// speculatively assume the subexpression is unevaluated, and fix it up
// later.
//
// We enter the unevaluated context before trying to determine whether we
// have a type-id, because the tentative parse logic will try to resolve
// names, and must treat them as unevaluated.
EnterExpressionEvaluationContext Unevaluated(
    Actions, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

if (isTypeIdInParens()) {
  TypeResult Ty = ParseTypeName();

  // Match the ')'.
  T.consumeClose();
  RParenLoc = T.getCloseLocation();
  if (Ty.isInvalid() || RParenLoc.isInvalid())
    return ExprError();

  Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
                                  Ty.get().getAsOpaquePtr(), RParenLoc);
} else {
  Result = ParseExpression();

  // Match the ')'.
  if (Result.isInvalid())
    SkipUntil(tok::r_paren, StopAtSemi);
  else {
    T.consumeClose();
    RParenLoc = T.getCloseLocation();
    if (RParenLoc.isInvalid())
      return ExprError();

    Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
                                    Result.get(), RParenLoc);
  }
}

return Result;
1672}

1674/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1675///
1676///         '__uuidof' '(' expression ')'
1677///         '__uuidof' '(' type-id ')'
1678///
1679ExprResult Parser::ParseCXXUuidof() {
assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!")((Tok.is(tok::kw___uuidof) && "Not '__uuidof'!") ? static_cast
<void> (0) : __assert_fail ("Tok.is(tok::kw___uuidof) && \"Not '__uuidof'!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1680, __PRETTY_FUNCTION__));

SourceLocation OpLoc = ConsumeToken();
BalancedDelimiterTracker T(*this, tok::l_paren);

// __uuidof expressions are always parenthesized.
if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
  return ExprError();

ExprResult Result;

if (isTypeIdInParens()) {
  TypeResult Ty = ParseTypeName();

  // Match the ')'.
  T.consumeClose();

  if (Ty.isInvalid())
    return ExprError();

  Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
                                  Ty.get().getAsOpaquePtr(),
                                  T.getCloseLocation());
} else {
  EnterExpressionEvaluationContext Unevaluated(
      Actions, Sema::ExpressionEvaluationContext::Unevaluated);
  Result = ParseExpression();

  // Match the ')'.
  if (Result.isInvalid())
    SkipUntil(tok::r_paren, StopAtSemi);
  else {
    T.consumeClose();

    Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
                                    /*isType=*/false,
                                    Result.get(), T.getCloseLocation());
  }
}

return Result;
1721}

1723/// Parse a C++ pseudo-destructor expression after the base,
1724/// . or -> operator, and nested-name-specifier have already been
1725/// parsed. We're handling this fragment of the grammar:
1726///
1727///       postfix-expression: [C++2a expr.post]
1728///         postfix-expression . template[opt] id-expression
1729///         postfix-expression -> template[opt] id-expression
1730///
1731///       id-expression:
1732///         qualified-id
1733///         unqualified-id
1734///
1735///       qualified-id:
1736///         nested-name-specifier template[opt] unqualified-id
1737///
1738///       nested-name-specifier:
1739///         type-name ::
1740///         decltype-specifier ::    FIXME: not implemented, but probably only
1741///                                         allowed in C++ grammar by accident
1742///         nested-name-specifier identifier ::
1743///         nested-name-specifier template[opt] simple-template-id ::
1744///         [...]
1745///
1746///       unqualified-id:
1747///         ~ type-name
1748///         ~ decltype-specifier
1749///         [...]
1750///
1751/// ... where the all but the last component of the nested-name-specifier
1752/// has already been parsed, and the base expression is not of a non-dependent
1753/// class type.
1754ExprResult
1755Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
                               tok::TokenKind OpKind,
                               CXXScopeSpec &SS,
                               ParsedType ObjectType) {
// If the last component of the (optional) nested-name-specifier is
// template[opt] simple-template-id, it has already been annotated.
UnqualifiedId FirstTypeName;
SourceLocation CCLoc;
if (Tok.is(tok::identifier)) {
  FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
  ConsumeToken();
  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail")((Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::coloncolon) &&\"ParseOptionalCXXScopeSpecifier fail\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1766, __PRETTY_FUNCTION__));
  CCLoc = ConsumeToken();
} else if (Tok.is(tok::annot_template_id)) {
  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
  // FIXME: Carry on and build an AST representation for tooling.
  if (TemplateId->isInvalid())
    return ExprError();
  FirstTypeName.setTemplateId(TemplateId);
  ConsumeAnnotationToken();
  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail")((Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::coloncolon) &&\"ParseOptionalCXXScopeSpecifier fail\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1775, __PRETTY_FUNCTION__));
  CCLoc = ConsumeToken();
} else {
  assert(SS.isEmpty() && "missing last component of nested name specifier")((SS.isEmpty() && "missing last component of nested name specifier"
) ? static_cast<void> (0) : __assert_fail ("SS.isEmpty() && \"missing last component of nested name specifier\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1778, __PRETTY_FUNCTION__));
  FirstTypeName.setIdentifier(nullptr, SourceLocation());
}

// Parse the tilde.
assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail")((Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::tilde) && \"ParseOptionalCXXScopeSpecifier fail\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1783, __PRETTY_FUNCTION__));
SourceLocation TildeLoc = ConsumeToken();

if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid()) {
  DeclSpec DS(AttrFactory);
  ParseDecltypeSpecifier(DS);
  if (DS.getTypeSpecType() == TST_error)
    return ExprError();
  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
                                           TildeLoc, DS);
}

if (!Tok.is(tok::identifier)) {
  Diag(Tok, diag::err_destructor_tilde_identifier);
  return ExprError();
}

// Parse the second type.
UnqualifiedId SecondTypeName;
IdentifierInfo *Name = Tok.getIdentifierInfo();
SourceLocation NameLoc = ConsumeToken();
SecondTypeName.setIdentifier(Name, NameLoc);

// If there is a '<', the second type name is a template-id. Parse
// it as such.
//
// FIXME: This is not a context in which a '<' is assumed to start a template
// argument list. This affects examples such as
//   void f(auto *p) { p->~X<int>(); }
// ... but there's no ambiguity, and nowhere to write 'template' in such an
// example, so we accept it anyway.
if (Tok.is(tok::less) &&
    ParseUnqualifiedIdTemplateId(
        SS, ObjectType, Base && Base->containsErrors(), SourceLocation(),
        Name, NameLoc, false, SecondTypeName,
        /*AssumeTemplateId=*/true))
  return ExprError();

return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
                                         SS, FirstTypeName, CCLoc, TildeLoc,
                                         SecondTypeName);
1824}

1826/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1827///
1828///       boolean-literal: [C++ 2.13.5]
1829///         'true'
1830///         'false'
1831ExprResult Parser::ParseCXXBoolLiteral() {
tok::TokenKind Kind = Tok.getKind();
return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1834}

1836/// ParseThrowExpression - This handles the C++ throw expression.
1837///
1838///       throw-expression: [C++ 15]
1839///         'throw' assignment-expression[opt]
1840ExprResult Parser::ParseThrowExpression() {
assert(Tok.is(tok::kw_throw) && "Not throw!")((Tok.is(tok::kw_throw) && "Not throw!") ? static_cast
<void> (0) : __assert_fail ("Tok.is(tok::kw_throw) && \"Not throw!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1841, __PRETTY_FUNCTION__));
SourceLocation ThrowLoc = ConsumeToken();           // Eat the throw token.

// If the current token isn't the start of an assignment-expression,
// then the expression is not present.  This handles things like:
//   "C ? throw : (void)42", which is crazy but legal.
switch (Tok.getKind()) {  // FIXME: move this predicate somewhere common.
case tok::semi:
case tok::r_paren:
case tok::r_square:
case tok::r_brace:
case tok::colon:
case tok::comma:
  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);

default:
  ExprResult Expr(ParseAssignmentExpression());
  if (Expr.isInvalid()) return Expr;
  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
}
1861}

1863/// Parse the C++ Coroutines co_yield expression.
1864///
1865///       co_yield-expression:
1866///         'co_yield' assignment-expression[opt]
1867ExprResult Parser::ParseCoyieldExpression() {
assert(Tok.is(tok::kw_co_yield) && "Not co_yield!")((Tok.is(tok::kw_co_yield) && "Not co_yield!") ? static_cast
<void> (0) : __assert_fail ("Tok.is(tok::kw_co_yield) && \"Not co_yield!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1868, __PRETTY_FUNCTION__));

SourceLocation Loc = ConsumeToken();
ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
                                       : ParseAssignmentExpression();
if (!Expr.isInvalid())
  Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
return Expr;
1876}

1878/// ParseCXXThis - This handles the C++ 'this' pointer.
1879///
1880/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1881/// a non-lvalue expression whose value is the address of the object for which
1882/// the function is called.
1883ExprResult Parser::ParseCXXThis() {
assert(Tok.is(tok::kw_this) && "Not 'this'!")((Tok.is(tok::kw_this) && "Not 'this'!") ? static_cast
<void> (0) : __assert_fail ("Tok.is(tok::kw_this) && \"Not 'this'!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1884, __PRETTY_FUNCTION__));
SourceLocation ThisLoc = ConsumeToken();
return Actions.ActOnCXXThis(ThisLoc);
1887}

1889/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1890/// Can be interpreted either as function-style casting ("int(x)")
1891/// or class type construction ("ClassType(x,y,z)")
1892/// or creation of a value-initialized type ("int()").
1893/// See [C++ 5.2.3].
1894///
1895///       postfix-expression: [C++ 5.2p1]
1896///         simple-type-specifier '(' expression-list[opt] ')'
1897/// [C++0x] simple-type-specifier braced-init-list
1898///         typename-specifier '(' expression-list[opt] ')'
1899/// [C++0x] typename-specifier braced-init-list
1900///
1901/// In C++1z onwards, the type specifier can also be a template-name.
1902ExprResult
1903Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCast);
ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();

assert((Tok.is(tok::l_paren) ||(((Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 &&
 Tok.is(tok::l_brace))) && "Expected '(' or '{'!") ? static_cast
<void> (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1909, __PRETTY_FUNCTION__))
        (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))(((Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 &&
 Tok.is(tok::l_brace))) && "Expected '(' or '{'!") ? static_cast
<void> (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1909, __PRETTY_FUNCTION__))
       && "Expected '(' or '{'!")(((Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 &&
 Tok.is(tok::l_brace))) && "Expected '(' or '{'!") ? static_cast
<void> (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1909, __PRETTY_FUNCTION__));

if (Tok.is(tok::l_brace)) {
  PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
  ExprResult Init = ParseBraceInitializer();
  if (Init.isInvalid())
    return Init;
  Expr *InitList = Init.get();
  return Actions.ActOnCXXTypeConstructExpr(
      TypeRep, InitList->getBeginLoc(), MultiExprArg(&InitList, 1),
      InitList->getEndLoc(), /*ListInitialization=*/true);
} else {
  BalancedDelimiterTracker T(*this, tok::l_paren);
  T.consumeOpen();

  PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());

  ExprVector Exprs;
  CommaLocsTy CommaLocs;

  auto RunSignatureHelp = [&]() {
    QualType PreferredType;
    if (TypeRep)
      PreferredType = Actions.ProduceConstructorSignatureHelp(
          getCurScope(), TypeRep.get()->getCanonicalTypeInternal(),
          DS.getEndLoc(), Exprs, T.getOpenLocation());
    CalledSignatureHelp = true;
    return PreferredType;
  };

  if (Tok.isNot(tok::r_paren)) {
    if (ParseExpressionList(Exprs, CommaLocs, [&] {
          PreferredType.enterFunctionArgument(Tok.getLocation(),
                                              RunSignatureHelp);
        })) {
      if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
        RunSignatureHelp();
      SkipUntil(tok::r_paren, StopAtSemi);
      return ExprError();
    }
  }

  // Match the ')'.
  T.consumeClose();

  // TypeRep could be null, if it references an invalid typedef.
  if (!TypeRep)
    return ExprError();

  assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&(((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
 "Unexpected number of commas!") ? static_cast<void> (0
) : __assert_fail ("(Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& \"Unexpected number of commas!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1959, __PRETTY_FUNCTION__))
         "Unexpected number of commas!")(((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
 "Unexpected number of commas!") ? static_cast<void> (0
) : __assert_fail ("(Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& \"Unexpected number of commas!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 1959, __PRETTY_FUNCTION__));
  return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
                                           Exprs, T.getCloseLocation(),
                                           /*ListInitialization=*/false);
}
1964}

1966/// ParseCXXCondition - if/switch/while condition expression.
1967///
1968///       condition:
1969///         expression
1970///         type-specifier-seq declarator '=' assignment-expression
1971/// [C++11] type-specifier-seq declarator '=' initializer-clause
1972/// [C++11] type-specifier-seq declarator braced-init-list
1973/// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
1974///             brace-or-equal-initializer
1975/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1976///             '=' assignment-expression
1977///
1978/// In C++1z, a condition may in some contexts be preceded by an
1979/// optional init-statement. This function will parse that too.
1980///
1981/// \param InitStmt If non-null, an init-statement is permitted, and if present
1982/// will be parsed and stored here.
1983///
1984/// \param Loc The location of the start of the statement that requires this
1985/// condition, e.g., the "for" in a for loop.
1986///
1987/// \param FRI If non-null, a for range declaration is permitted, and if
1988/// present will be parsed and stored here, and a null result will be returned.
1989///
1990/// \returns The parsed condition.
1991Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
                                              SourceLocation Loc,
                                              Sema::ConditionKind CK,
                                              ForRangeInfo *FRI) {
ParenBraceBracketBalancer BalancerRAIIObj(*this);
PreferredType.enterCondition(Actions, Tok.getLocation());

if (Tok.is(tok::code_completion)) {
1
Taking false branch→
5
←
Calling 'Token::is'→
8
←
Returning from 'Token::is'→
9
←
Taking false branch→
  Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
  cutOffParsing();
  return Sema::ConditionError();
}

ParsedAttributesWithRange attrs(AttrFactory);
MaybeParseCXX11Attributes(attrs);

const auto WarnOnInit = [this, &CK] {
  Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
                              ? diag::warn_cxx14_compat_init_statement
                              : diag::ext_init_statement)
      << (CK == Sema::ConditionKind::Switch);
};

// Determine what kind of thing we have.
switch (isCXXConditionDeclarationOrInitStatement(InitStmt, FRI)) {
2
←
Control jumps to 'case InitStmtDecl:'  at line 2049→
10
←
Control jumps to 'case InitStmtDecl:'  at line 2049→
case ConditionOrInitStatement::Expression: {
  ProhibitAttributes(attrs);

  // We can have an empty expression here.
  //   if (; true);
  if (InitStmt && Tok.is(tok::semi)) {
    WarnOnInit();
    SourceLocation SemiLoc = Tok.getLocation();
    if (!Tok.hasLeadingEmptyMacro() && !SemiLoc.isMacroID()) {
      Diag(SemiLoc, diag::warn_empty_init_statement)
          << (CK == Sema::ConditionKind::Switch)
          << FixItHint::CreateRemoval(SemiLoc);
    }
    ConsumeToken();
    *InitStmt = Actions.ActOnNullStmt(SemiLoc);
    return ParseCXXCondition(nullptr, Loc, CK);
  }

  // Parse the expression.
  ExprResult Expr = ParseExpression(); // expression
  if (Expr.isInvalid())
    return Sema::ConditionError();

  if (InitStmt && Tok.is(tok::semi)) {
    WarnOnInit();
    *InitStmt = Actions.ActOnExprStmt(Expr.get());
    ConsumeToken();
    return ParseCXXCondition(nullptr, Loc, CK);
  }

  return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK);
}

case ConditionOrInitStatement::InitStmtDecl: {
  WarnOnInit();
  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
  DeclGroupPtrTy DG = ParseSimpleDeclaration(
      DeclaratorContext::SelectionInit, DeclEnd, attrs, /*RequireSemi=*/true);
  *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
11
←
Called C++ object pointer is null
  return ParseCXXCondition(nullptr, Loc, CK);
3
←
Passing null pointer value via 1st parameter 'InitStmt'→
4
←
Calling 'Parser::ParseCXXCondition'→
}

case ConditionOrInitStatement::ForRangeDecl: {
  assert(FRI && "should not parse a for range declaration here")((FRI && "should not parse a for range declaration here"
) ? static_cast<void> (0) : __assert_fail ("FRI && \"should not parse a for range declaration here\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 2059, __PRETTY_FUNCTION__));
  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
  DeclGroupPtrTy DG = ParseSimpleDeclaration(DeclaratorContext::ForInit,
                                             DeclEnd, attrs, false, FRI);
  FRI->LoopVar = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
  return Sema::ConditionResult();
}

case ConditionOrInitStatement::ConditionDecl:
case ConditionOrInitStatement::Error:
  break;
}

// type-specifier-seq
DeclSpec DS(AttrFactory);
DS.takeAttributesFrom(attrs);
ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition);

// declarator
Declarator DeclaratorInfo(DS, DeclaratorContext::Condition);
ParseDeclarator(DeclaratorInfo);

// simple-asm-expr[opt]
if (Tok.is(tok::kw_asm)) {
  SourceLocation Loc;
  ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc));
  if (AsmLabel.isInvalid()) {
    SkipUntil(tok::semi, StopAtSemi);
    return Sema::ConditionError();
  }
  DeclaratorInfo.setAsmLabel(AsmLabel.get());
  DeclaratorInfo.SetRangeEnd(Loc);
}

// If attributes are present, parse them.
MaybeParseGNUAttributes(DeclaratorInfo);

// Type-check the declaration itself.
DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
                                                      DeclaratorInfo);
if (Dcl.isInvalid())
  return Sema::ConditionError();
Decl *DeclOut = Dcl.get();

// '=' assignment-expression
// If a '==' or '+=' is found, suggest a fixit to '='.
bool CopyInitialization = isTokenEqualOrEqualTypo();
if (CopyInitialization)
  ConsumeToken();

ExprResult InitExpr = ExprError();
if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
  Diag(Tok.getLocation(),
       diag::warn_cxx98_compat_generalized_initializer_lists);
  InitExpr = ParseBraceInitializer();
} else if (CopyInitialization) {
  PreferredType.enterVariableInit(Tok.getLocation(), DeclOut);
  InitExpr = ParseAssignmentExpression();
} else if (Tok.is(tok::l_paren)) {
  // This was probably an attempt to initialize the variable.
  SourceLocation LParen = ConsumeParen(), RParen = LParen;
  if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
    RParen = ConsumeParen();
  Diag(DeclOut->getLocation(),
       diag::err_expected_init_in_condition_lparen)
    << SourceRange(LParen, RParen);
} else {
  Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
}

if (!InitExpr.isInvalid())
  Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
else
  Actions.ActOnInitializerError(DeclOut);

Actions.FinalizeDeclaration(DeclOut);
return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
2136}

2138/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
2139/// This should only be called when the current token is known to be part of
2140/// simple-type-specifier.
2141///
2142///       simple-type-specifier:
2143///         '::'[opt] nested-name-specifier[opt] type-name
2144///         '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
2145///         char
2146///         wchar_t
2147///         bool
2148///         short
2149///         int
2150///         long
2151///         signed
2152///         unsigned
2153///         float
2154///         double
2155///         void
2156/// [GNU]   typeof-specifier
2157/// [C++0x] auto               [TODO]
2158///
2159///       type-name:
2160///         class-name
2161///         enum-name
2162///         typedef-name
2163///
2164void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
DS.SetRangeStart(Tok.getLocation());
const char *PrevSpec;
unsigned DiagID;
SourceLocation Loc = Tok.getLocation();
const clang::PrintingPolicy &Policy =
    Actions.getASTContext().getPrintingPolicy();

switch (Tok.getKind()) {
case tok::identifier:   // foo::bar
case tok::coloncolon:   // ::foo::bar
  llvm_unreachable("Annotation token should already be formed!")::llvm::llvm_unreachable_internal("Annotation token should already be formed!"
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 2175);
default:
  llvm_unreachable("Not a simple-type-specifier token!")::llvm::llvm_unreachable_internal("Not a simple-type-specifier token!"
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 2177);

// type-name
case tok::annot_typename: {
  DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
                     getTypeAnnotation(Tok), Policy);
  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
  ConsumeAnnotationToken();

  DS.Finish(Actions, Policy);
  return;
}

case tok::kw__ExtInt: {
  ExprResult ER = ParseExtIntegerArgument();
  if (ER.isInvalid())
    DS.SetTypeSpecError();
  else
    DS.SetExtIntType(Loc, ER.get(), PrevSpec, DiagID, Policy);

  // Do this here because we have already consumed the close paren.
  DS.SetRangeEnd(PrevTokLocation);
  DS.Finish(Actions, Policy);
  return;
}

// builtin types
case tok::kw_short:
  DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec, DiagID,
                      Policy);
  break;
case tok::kw_long:
  DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec, DiagID,
                      Policy);
  break;
case tok::kw___int64:
  DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc, PrevSpec, DiagID,
                      Policy);
  break;
case tok::kw_signed:
  DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
  break;
case tok::kw_unsigned:
  DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec, DiagID);
  break;
case tok::kw_void:
  DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_char:
  DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_int:
  DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw___int128:
  DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw___bf16:
  DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_half:
  DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_float:
  DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_double:
  DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw__Float16:
  DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw___float128:
  DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_wchar_t:
  DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_char8_t:
  DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_char16_t:
  DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_char32_t:
  DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_bool:
  DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
  break;
2267#define GENERIC_IMAGE_TYPE(ImgType, Id)                                        \
case tok::kw_##ImgType##_t:                                                  \
  DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, DiagID,     \
                     Policy);                                                \
  break;
2272#include "clang/Basic/OpenCLImageTypes.def"

case tok::annot_decltype:
case tok::kw_decltype:
  DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
  return DS.Finish(Actions, Policy);

// GNU typeof support.
case tok::kw_typeof:
  ParseTypeofSpecifier(DS);
  DS.Finish(Actions, Policy);
  return;
}
ConsumeAnyToken();
DS.SetRangeEnd(PrevTokLocation);
DS.Finish(Actions, Policy);
2288}

2290/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
2291/// [dcl.name]), which is a non-empty sequence of type-specifiers,
2292/// e.g., "const short int". Note that the DeclSpec is *not* finished
2293/// by parsing the type-specifier-seq, because these sequences are
2294/// typically followed by some form of declarator. Returns true and
2295/// emits diagnostics if this is not a type-specifier-seq, false
2296/// otherwise.
2297///
2298///   type-specifier-seq: [C++ 8.1]
2299///     type-specifier type-specifier-seq[opt]
2300///
2301bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_type_specifier);
DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
return false;
2305}

2307/// Finish parsing a C++ unqualified-id that is a template-id of
2308/// some form.
2309///
2310/// This routine is invoked when a '<' is encountered after an identifier or
2311/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
2312/// whether the unqualified-id is actually a template-id. This routine will
2313/// then parse the template arguments and form the appropriate template-id to
2314/// return to the caller.
2315///
2316/// \param SS the nested-name-specifier that precedes this template-id, if
2317/// we're actually parsing a qualified-id.
2318///
2319/// \param ObjectType if this unqualified-id occurs within a member access
2320/// expression, the type of the base object whose member is being accessed.
2321///
2322/// \param ObjectHadErrors this unqualified-id occurs within a member access
2323/// expression, indicates whether the original subexpressions had any errors.
2324///
2325/// \param Name for constructor and destructor names, this is the actual
2326/// identifier that may be a template-name.
2327///
2328/// \param NameLoc the location of the class-name in a constructor or
2329/// destructor.
2330///
2331/// \param EnteringContext whether we're entering the scope of the
2332/// nested-name-specifier.
2333///
2334/// \param Id as input, describes the template-name or operator-function-id
2335/// that precedes the '<'. If template arguments were parsed successfully,
2336/// will be updated with the template-id.
2337///
2338/// \param AssumeTemplateId When true, this routine will assume that the name
2339/// refers to a template without performing name lookup to verify.
2340///
2341/// \returns true if a parse error occurred, false otherwise.
2342bool Parser::ParseUnqualifiedIdTemplateId(
  CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
  SourceLocation TemplateKWLoc, IdentifierInfo *Name, SourceLocation NameLoc,
  bool EnteringContext, UnqualifiedId &Id, bool AssumeTemplateId) {
assert(Tok.is(tok::less) && "Expected '<' to finish parsing a template-id")((Tok.is(tok::less) && "Expected '<' to finish parsing a template-id"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::less) && \"Expected '<' to finish parsing a template-id\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 2346, __PRETTY_FUNCTION__));

TemplateTy Template;
TemplateNameKind TNK = TNK_Non_template;
switch (Id.getKind()) {
case UnqualifiedIdKind::IK_Identifier:
case UnqualifiedIdKind::IK_OperatorFunctionId:
case UnqualifiedIdKind::IK_LiteralOperatorId:
  if (AssumeTemplateId) {
    // We defer the injected-class-name checks until we've found whether
    // this template-id is used to form a nested-name-specifier or not.
    TNK = Actions.ActOnTemplateName(getCurScope(), SS, TemplateKWLoc, Id,
                                    ObjectType, EnteringContext, Template,
                                    /*AllowInjectedClassName*/ true);
  } else {
    bool MemberOfUnknownSpecialization;
    TNK = Actions.isTemplateName(getCurScope(), SS,
                                 TemplateKWLoc.isValid(), Id,
                                 ObjectType, EnteringContext, Template,
                                 MemberOfUnknownSpecialization);
    // If lookup found nothing but we're assuming that this is a template
    // name, double-check that makes sense syntactically before committing
    // to it.
    if (TNK == TNK_Undeclared_template &&
        isTemplateArgumentList(0) == TPResult::False)
      return false;

    if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
        ObjectType && isTemplateArgumentList(0) == TPResult::True) {
      // If we had errors before, ObjectType can be dependent even without any
      // templates, do not report missing template keyword in that case.
      if (!ObjectHadErrors) {
        // We have something like t->getAs<T>(), where getAs is a
        // member of an unknown specialization. However, this will only
        // parse correctly as a template, so suggest the keyword 'template'
        // before 'getAs' and treat this as a dependent template name.
        std::string Name;
        if (Id.getKind() == UnqualifiedIdKind::IK_Identifier)
          Name = std::string(Id.Identifier->getName());
        else {
          Name = "operator ";
          if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId)
            Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
          else
            Name += Id.Identifier->getName();
        }
        Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
            << Name
            << FixItHint::CreateInsertion(Id.StartLocation, "template ");
      }
      TNK = Actions.ActOnTemplateName(
          getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
          Template, /*AllowInjectedClassName*/ true);
    } else if (TNK == TNK_Non_template) {
      return false;
    }
  }
  break;

case UnqualifiedIdKind::IK_ConstructorName: {
  UnqualifiedId TemplateName;
  bool MemberOfUnknownSpecialization;
  TemplateName.setIdentifier(Name, NameLoc);
  TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
                               TemplateName, ObjectType,
                               EnteringContext, Template,
                               MemberOfUnknownSpecialization);
  if (TNK == TNK_Non_template)
    return false;
  break;
}

case UnqualifiedIdKind::IK_DestructorName: {
  UnqualifiedId TemplateName;
  bool MemberOfUnknownSpecialization;
  TemplateName.setIdentifier(Name, NameLoc);
  if (ObjectType) {
    TNK = Actions.ActOnTemplateName(
        getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
        EnteringContext, Template, /*AllowInjectedClassName*/ true);
  } else {
    TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
                                 TemplateName, ObjectType,
                                 EnteringContext, Template,
                                 MemberOfUnknownSpecialization);

    if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
      Diag(NameLoc, diag::err_destructor_template_id)
        << Name << SS.getRange();
      // Carry on to parse the template arguments before bailing out.
    }
  }
  break;
}

default:
  return false;
}

// Parse the enclosed template argument list.
SourceLocation LAngleLoc, RAngleLoc;
TemplateArgList TemplateArgs;
if (ParseTemplateIdAfterTemplateName(true, LAngleLoc, TemplateArgs,
                                     RAngleLoc))
  return true;

// If this is a non-template, we already issued a diagnostic.
if (TNK == TNK_Non_template)
  return true;

if (Id.getKind() == UnqualifiedIdKind::IK_Identifier ||
    Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
    Id.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) {
  // Form a parsed representation of the template-id to be stored in the
  // UnqualifiedId.

  // FIXME: Store name for literal operator too.
  IdentifierInfo *TemplateII =
      Id.getKind() == UnqualifiedIdKind::IK_Identifier ? Id.Identifier
                                                       : nullptr;
  OverloadedOperatorKind OpKind =
      Id.getKind() == UnqualifiedIdKind::IK_Identifier
          ? OO_None
          : Id.OperatorFunctionId.Operator;

  TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create(
      TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
      LAngleLoc, RAngleLoc, TemplateArgs, /*ArgsInvalid*/false, TemplateIds);

  Id.setTemplateId(TemplateId);
  return false;
}

// Bundle the template arguments together.
ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);

// Constructor and destructor names.
TypeResult Type = Actions.ActOnTemplateIdType(
    getCurScope(), SS, TemplateKWLoc, Template, Name, NameLoc, LAngleLoc,
    TemplateArgsPtr, RAngleLoc, /*IsCtorOrDtorName=*/true);
if (Type.isInvalid())
  return true;

if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
  Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
else
  Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);

return false;
2495}

2497/// Parse an operator-function-id or conversion-function-id as part
2498/// of a C++ unqualified-id.
2499///
2500/// This routine is responsible only for parsing the operator-function-id or
2501/// conversion-function-id; it does not handle template arguments in any way.
2502///
2503/// \code
2504///       operator-function-id: [C++ 13.5]
2505///         'operator' operator
2506///
2507///       operator: one of
2508///            new   delete  new[]   delete[]
2509///            +     -    *  /    %  ^    &   |   ~
2510///            !     =    <  >    += -=   *=  /=  %=
2511///            ^=    &=   |= <<   >> >>= <<=  ==  !=
2512///            <=    >=   && ||   ++ --   ,   ->* ->
2513///            ()    []   <=>
2514///
2515///       conversion-function-id: [C++ 12.3.2]
2516///         operator conversion-type-id
2517///
2518///       conversion-type-id:
2519///         type-specifier-seq conversion-declarator[opt]
2520///
2521///       conversion-declarator:
2522///         ptr-operator conversion-declarator[opt]
2523/// \endcode
2524///
2525/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2526/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2527///
2528/// \param EnteringContext whether we are entering the scope of the
2529/// nested-name-specifier.
2530///
2531/// \param ObjectType if this unqualified-id occurs within a member access
2532/// expression, the type of the base object whose member is being accessed.
2533///
2534/// \param Result on a successful parse, contains the parsed unqualified-id.
2535///
2536/// \returns true if parsing fails, false otherwise.
2537bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
                                      ParsedType ObjectType,
                                      UnqualifiedId &Result) {
assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword")((Tok.is(tok::kw_operator) && "Expected 'operator' keyword"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::kw_operator) && \"Expected 'operator' keyword\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 2540, __PRETTY_FUNCTION__));

// Consume the 'operator' keyword.
SourceLocation KeywordLoc = ConsumeToken();

// Determine what kind of operator name we have.
unsigned SymbolIdx = 0;
SourceLocation SymbolLocations[3];
OverloadedOperatorKind Op = OO_None;
switch (Tok.getKind()) {
  case tok::kw_new:
  case tok::kw_delete: {
    bool isNew = Tok.getKind() == tok::kw_new;
    // Consume the 'new' or 'delete'.
    SymbolLocations[SymbolIdx++] = ConsumeToken();
    // Check for array new/delete.
    if (Tok.is(tok::l_square) &&
        (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
      // Consume the '[' and ']'.
      BalancedDelimiterTracker T(*this, tok::l_square);
      T.consumeOpen();
      T.consumeClose();
      if (T.getCloseLocation().isInvalid())
        return true;

      SymbolLocations[SymbolIdx++] = T.getOpenLocation();
      SymbolLocations[SymbolIdx++] = T.getCloseLocation();
      Op = isNew? OO_Array_New : OO_Array_Delete;
    } else {
      Op = isNew? OO_New : OO_Delete;
    }
    break;
  }

2574#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
  case tok::Token:                                                     \
    SymbolLocations[SymbolIdx++] = ConsumeToken();                     \
    Op = OO_##Name;                                                    \
    break;
2579#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2580#include "clang/Basic/OperatorKinds.def"

  case tok::l_paren: {
    // Consume the '(' and ')'.
    BalancedDelimiterTracker T(*this, tok::l_paren);
    T.consumeOpen();
    T.consumeClose();
    if (T.getCloseLocation().isInvalid())
      return true;

    SymbolLocations[SymbolIdx++] = T.getOpenLocation();
    SymbolLocations[SymbolIdx++] = T.getCloseLocation();
    Op = OO_Call;
    break;
  }

  case tok::l_square: {
    // Consume the '[' and ']'.
    BalancedDelimiterTracker T(*this, tok::l_square);
    T.consumeOpen();
    T.consumeClose();
    if (T.getCloseLocation().isInvalid())
      return true;

    SymbolLocations[SymbolIdx++] = T.getOpenLocation();
    SymbolLocations[SymbolIdx++] = T.getCloseLocation();
    Op = OO_Subscript;
    break;
  }

  case tok::code_completion: {
    // Code completion for the operator name.
    Actions.CodeCompleteOperatorName(getCurScope());
    cutOffParsing();
    // Don't try to parse any further.
    return true;
  }

  default:
    break;
}

if (Op != OO_None) {
  // We have parsed an operator-function-id.
  Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
  return false;
}

// Parse a literal-operator-id.
//
//   literal-operator-id: C++11 [over.literal]
//     operator string-literal identifier
//     operator user-defined-string-literal

if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
  Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);

  SourceLocation DiagLoc;
  unsigned DiagId = 0;

  // We're past translation phase 6, so perform string literal concatenation
  // before checking for "".
  SmallVector<Token, 4> Toks;
  SmallVector<SourceLocation, 4> TokLocs;
  while (isTokenStringLiteral()) {
    if (!Tok.is(tok::string_literal) && !DiagId) {
      // C++11 [over.literal]p1:
      //   The string-literal or user-defined-string-literal in a
      //   literal-operator-id shall have no encoding-prefix [...].
      DiagLoc = Tok.getLocation();
      DiagId = diag::err_literal_operator_string_prefix;
    }
    Toks.push_back(Tok);
    TokLocs.push_back(ConsumeStringToken());
  }

  StringLiteralParser Literal(Toks, PP);
  if (Literal.hadError)
    return true;

  // Grab the literal operator's suffix, which will be either the next token
  // or a ud-suffix from the string literal.
  IdentifierInfo *II = nullptr;
  SourceLocation SuffixLoc;
  if (!Literal.getUDSuffix().empty()) {
    II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
    SuffixLoc =
      Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
                                     Literal.getUDSuffixOffset(),
                                     PP.getSourceManager(), getLangOpts());
  } else if (Tok.is(tok::identifier)) {
    II = Tok.getIdentifierInfo();
    SuffixLoc = ConsumeToken();
    TokLocs.push_back(SuffixLoc);
  } else {
    Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
    return true;
  }

  // The string literal must be empty.
  if (!Literal.GetString().empty() || Literal.Pascal) {
    // C++11 [over.literal]p1:
    //   The string-literal or user-defined-string-literal in a
    //   literal-operator-id shall [...] contain no characters
    //   other than the implicit terminating '\0'.
    DiagLoc = TokLocs.front();
    DiagId = diag::err_literal_operator_string_not_empty;
  }

  if (DiagId) {
    // This isn't a valid literal-operator-id, but we think we know
    // what the user meant. Tell them what they should have written.
    SmallString<32> Str;
    Str += "\"\"";
    Str += II->getName();
    Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
        SourceRange(TokLocs.front(), TokLocs.back()), Str);
  }

  Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);

  return Actions.checkLiteralOperatorId(SS, Result);
}

// Parse a conversion-function-id.
//
//   conversion-function-id: [C++ 12.3.2]
//     operator conversion-type-id
//
//   conversion-type-id:
//     type-specifier-seq conversion-declarator[opt]
//
//   conversion-declarator:
//     ptr-operator conversion-declarator[opt]

// Parse the type-specifier-seq.
DeclSpec DS(AttrFactory);
if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
  return true;

// Parse the conversion-declarator, which is merely a sequence of
// ptr-operators.
Declarator D(DS, DeclaratorContext::ConversionId);
ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);

// Finish up the type.
TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
if (Ty.isInvalid())
  return true;

// Note that this is a conversion-function-id.
Result.setConversionFunctionId(KeywordLoc, Ty.get(),
                               D.getSourceRange().getEnd());
return false;
2734}

2736/// Parse a C++ unqualified-id (or a C identifier), which describes the
2737/// name of an entity.
2738///
2739/// \code
2740///       unqualified-id: [C++ expr.prim.general]
2741///         identifier
2742///         operator-function-id
2743///         conversion-function-id
2744/// [C++0x] literal-operator-id [TODO]
2745///         ~ class-name
2746///         template-id
2747///
2748/// \endcode
2749///
2750/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2751/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2752///
2753/// \param ObjectType if this unqualified-id occurs within a member access
2754/// expression, the type of the base object whose member is being accessed.
2755///
2756/// \param ObjectHadErrors if this unqualified-id occurs within a member access
2757/// expression, indicates whether the original subexpressions had any errors.
2758/// When true, diagnostics for missing 'template' keyword will be supressed.
2759///
2760/// \param EnteringContext whether we are entering the scope of the
2761/// nested-name-specifier.
2762///
2763/// \param AllowDestructorName whether we allow parsing of a destructor name.
2764///
2765/// \param AllowConstructorName whether we allow parsing a constructor name.
2766///
2767/// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2768///
2769/// \param Result on a successful parse, contains the parsed unqualified-id.
2770///
2771/// \returns true if parsing fails, false otherwise.
2772bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType,
                              bool ObjectHadErrors, bool EnteringContext,
                              bool AllowDestructorName,
                              bool AllowConstructorName,
                              bool AllowDeductionGuide,
                              SourceLocation *TemplateKWLoc,
                              UnqualifiedId &Result) {
if (TemplateKWLoc)
  *TemplateKWLoc = SourceLocation();

// Handle 'A::template B'. This is for template-ids which have not
// already been annotated by ParseOptionalCXXScopeSpecifier().
bool TemplateSpecified = false;
if (Tok.is(tok::kw_template)) {
  if (TemplateKWLoc && (ObjectType || SS.isSet())) {
    TemplateSpecified = true;
    *TemplateKWLoc = ConsumeToken();
  } else {
    SourceLocation TemplateLoc = ConsumeToken();
    Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
      << FixItHint::CreateRemoval(TemplateLoc);
  }
}

// unqualified-id:
//   identifier
//   template-id (when it hasn't already been annotated)
if (Tok.is(tok::identifier)) {
  // Consume the identifier.
  IdentifierInfo *Id = Tok.getIdentifierInfo();
  SourceLocation IdLoc = ConsumeToken();

  if (!getLangOpts().CPlusPlus) {
    // If we're not in C++, only identifiers matter. Record the
    // identifier and return.
    Result.setIdentifier(Id, IdLoc);
    return false;
  }

  ParsedTemplateTy TemplateName;
  if (AllowConstructorName &&
      Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
    // We have parsed a constructor name.
    ParsedType Ty = Actions.getConstructorName(*Id, IdLoc, getCurScope(), SS,
                                               EnteringContext);
    if (!Ty)
      return true;
    Result.setConstructorName(Ty, IdLoc, IdLoc);
  } else if (getLangOpts().CPlusPlus17 &&
             AllowDeductionGuide && SS.isEmpty() &&
             Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
                                          &TemplateName)) {
    // We have parsed a template-name naming a deduction guide.
    Result.setDeductionGuideName(TemplateName, IdLoc);
  } else {
    // We have parsed an identifier.
    Result.setIdentifier(Id, IdLoc);
  }

  // If the next token is a '<', we may have a template.
  TemplateTy Template;
  if (Tok.is(tok::less))
    return ParseUnqualifiedIdTemplateId(
        SS, ObjectType, ObjectHadErrors,
        TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), Id, IdLoc,
        EnteringContext, Result, TemplateSpecified);
  else if (TemplateSpecified &&
           Actions.ActOnTemplateName(
               getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
               EnteringContext, Template,
               /*AllowInjectedClassName*/ true) == TNK_Non_template)
    return true;

  return false;
}

// unqualified-id:
//   template-id (already parsed and annotated)
if (Tok.is(tok::annot_template_id)) {
  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);

  // FIXME: Consider passing invalid template-ids on to callers; they may
  // be able to recover better than we can.
  if (TemplateId->isInvalid()) {
    ConsumeAnnotationToken();
    return true;
  }

  // If the template-name names the current class, then this is a constructor
  if (AllowConstructorName && TemplateId->Name &&
      Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
    if (SS.isSet()) {
      // C++ [class.qual]p2 specifies that a qualified template-name
      // is taken as the constructor name where a constructor can be
      // declared. Thus, the template arguments are extraneous, so
      // complain about them and remove them entirely.
      Diag(TemplateId->TemplateNameLoc,
           diag::err_out_of_line_constructor_template_id)
        << TemplateId->Name
        << FixItHint::CreateRemoval(
                  SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
      ParsedType Ty = Actions.getConstructorName(
          *TemplateId->Name, TemplateId->TemplateNameLoc, getCurScope(), SS,
          EnteringContext);
      if (!Ty)
        return true;
      Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
                                TemplateId->RAngleLoc);
      ConsumeAnnotationToken();
      return false;
    }

    Result.setConstructorTemplateId(TemplateId);
    ConsumeAnnotationToken();
    return false;
  }

  // We have already parsed a template-id; consume the annotation token as
  // our unqualified-id.
  Result.setTemplateId(TemplateId);
  SourceLocation TemplateLoc = TemplateId->TemplateKWLoc;
  if (TemplateLoc.isValid()) {
    if (TemplateKWLoc && (ObjectType || SS.isSet()))
      *TemplateKWLoc = TemplateLoc;
    else
      Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
          << FixItHint::CreateRemoval(TemplateLoc);
  }
  ConsumeAnnotationToken();
  return false;
}

// unqualified-id:
//   operator-function-id
//   conversion-function-id
if (Tok.is(tok::kw_operator)) {
  if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
    return true;

  // If we have an operator-function-id or a literal-operator-id and the next
  // token is a '<', we may have a
  //
  //   template-id:
  //     operator-function-id < template-argument-list[opt] >
  TemplateTy Template;
  if ((Result.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
       Result.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) &&
      Tok.is(tok::less))
    return ParseUnqualifiedIdTemplateId(
        SS, ObjectType, ObjectHadErrors,
        TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), nullptr,
        SourceLocation(), EnteringContext, Result, TemplateSpecified);
  else if (TemplateSpecified &&
           Actions.ActOnTemplateName(
               getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
               EnteringContext, Template,
               /*AllowInjectedClassName*/ true) == TNK_Non_template)
    return true;

  return false;
}

if (getLangOpts().CPlusPlus &&
    (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
  // C++ [expr.unary.op]p10:
  //   There is an ambiguity in the unary-expression ~X(), where X is a
  //   class-name. The ambiguity is resolved in favor of treating ~ as a
  //    unary complement rather than treating ~X as referring to a destructor.

  // Parse the '~'.
  SourceLocation TildeLoc = ConsumeToken();

  if (TemplateSpecified) {
    // C++ [temp.names]p3:
    //   A name prefixed by the keyword template shall be a template-id [...]
    //
    // A template-id cannot begin with a '~' token. This would never work
    // anyway: x.~A<int>() would specify that the destructor is a template,
    // not that 'A' is a template.
    //
    // FIXME: Suggest replacing the attempted destructor name with a correct
    // destructor name and recover. (This is not trivial if this would become
    // a pseudo-destructor name).
    Diag(*TemplateKWLoc, diag::err_unexpected_template_in_destructor_name)
      << Tok.getLocation();
    return true;
  }

  if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
    DeclSpec DS(AttrFactory);
    SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
    if (ParsedType Type =
            Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
      Result.setDestructorName(TildeLoc, Type, EndLoc);
      return false;
    }
    return true;
  }

  // Parse the class-name.
  if (Tok.isNot(tok::identifier)) {
    Diag(Tok, diag::err_destructor_tilde_identifier);
    return true;
  }

  // If the user wrote ~T::T, correct it to T::~T.
  DeclaratorScopeObj DeclScopeObj(*this, SS);
  if (NextToken().is(tok::coloncolon)) {
    // Don't let ParseOptionalCXXScopeSpecifier() "correct"
    // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
    // it will confuse this recovery logic.
    ColonProtectionRAIIObject ColonRAII(*this, false);

    if (SS.isSet()) {
      AnnotateScopeToken(SS, /*NewAnnotation*/true);
      SS.clear();
    }
    if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, ObjectHadErrors,
                                       EnteringContext))
      return true;
    if (SS.isNotEmpty())
      ObjectType = nullptr;
    if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
        !SS.isSet()) {
      Diag(TildeLoc, diag::err_destructor_tilde_scope);
      return true;
    }

    // Recover as if the tilde had been written before the identifier.
    Diag(TildeLoc, diag::err_destructor_tilde_scope)
      << FixItHint::CreateRemoval(TildeLoc)
      << FixItHint::CreateInsertion(Tok.getLocation(), "~");

    // Temporarily enter the scope for the rest of this function.
    if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
      DeclScopeObj.EnterDeclaratorScope();
  }

  // Parse the class-name (or template-name in a simple-template-id).
  IdentifierInfo *ClassName = Tok.getIdentifierInfo();
  SourceLocation ClassNameLoc = ConsumeToken();

  if (Tok.is(tok::less)) {
    Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
    return ParseUnqualifiedIdTemplateId(
        SS, ObjectType, ObjectHadErrors,
        TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), ClassName,
        ClassNameLoc, EnteringContext, Result, TemplateSpecified);
  }

  // Note that this is a destructor name.
  ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
                                            ClassNameLoc, getCurScope(),
                                            SS, ObjectType,
                                            EnteringContext);
  if (!Ty)
    return true;

  Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
  return false;
}

Diag(Tok, diag::err_expected_unqualified_id)
  << getLangOpts().CPlusPlus;
return true;
3037}

3039/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
3040/// memory in a typesafe manner and call constructors.
3041///
3042/// This method is called to parse the new expression after the optional :: has
3043/// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
3044/// is its location.  Otherwise, "Start" is the location of the 'new' token.
3045///
3046///        new-expression:
3047///                   '::'[opt] 'new' new-placement[opt] new-type-id
3048///                                     new-initializer[opt]
3049///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3050///                                     new-initializer[opt]
3051///
3052///        new-placement:
3053///                   '(' expression-list ')'
3054///
3055///        new-type-id:
3056///                   type-specifier-seq new-declarator[opt]
3057/// [GNU]             attributes type-specifier-seq new-declarator[opt]
3058///
3059///        new-declarator:
3060///                   ptr-operator new-declarator[opt]
3061///                   direct-new-declarator
3062///
3063///        new-initializer:
3064///                   '(' expression-list[opt] ')'
3065/// [C++0x]           braced-init-list
3066///
3067ExprResult
3068Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
assert(Tok.is(tok::kw_new) && "expected 'new' token")((Tok.is(tok::kw_new) && "expected 'new' token") ? static_cast
<void> (0) : __assert_fail ("Tok.is(tok::kw_new) && \"expected 'new' token\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3069, __PRETTY_FUNCTION__));
ConsumeToken();   // Consume 'new'

// A '(' now can be a new-placement or the '(' wrapping the type-id in the
// second form of new-expression. It can't be a new-type-id.

ExprVector PlacementArgs;
SourceLocation PlacementLParen, PlacementRParen;

SourceRange TypeIdParens;
DeclSpec DS(AttrFactory);
Declarator DeclaratorInfo(DS, DeclaratorContext::CXXNew);
if (Tok.is(tok::l_paren)) {
  // If it turns out to be a placement, we change the type location.
  BalancedDelimiterTracker T(*this, tok::l_paren);
  T.consumeOpen();
  PlacementLParen = T.getOpenLocation();
  if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
    SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
    return ExprError();
  }

  T.consumeClose();
  PlacementRParen = T.getCloseLocation();
  if (PlacementRParen.isInvalid()) {
    SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
    return ExprError();
  }

  if (PlacementArgs.empty()) {
    // Reset the placement locations. There was no placement.
    TypeIdParens = T.getRange();
    PlacementLParen = PlacementRParen = SourceLocation();
  } else {
    // We still need the type.
    if (Tok.is(tok::l_paren)) {
      BalancedDelimiterTracker T(*this, tok::l_paren);
      T.consumeOpen();
      MaybeParseGNUAttributes(DeclaratorInfo);
      ParseSpecifierQualifierList(DS);
      DeclaratorInfo.SetSourceRange(DS.getSourceRange());
      ParseDeclarator(DeclaratorInfo);
      T.consumeClose();
      TypeIdParens = T.getRange();
    } else {
      MaybeParseGNUAttributes(DeclaratorInfo);
      if (ParseCXXTypeSpecifierSeq(DS))
        DeclaratorInfo.setInvalidType(true);
      else {
        DeclaratorInfo.SetSourceRange(DS.getSourceRange());
        ParseDeclaratorInternal(DeclaratorInfo,
                                &Parser::ParseDirectNewDeclarator);
      }
    }
  }
} else {
  // A new-type-id is a simplified type-id, where essentially the
  // direct-declarator is replaced by a direct-new-declarator.
  MaybeParseGNUAttributes(DeclaratorInfo);
  if (ParseCXXTypeSpecifierSeq(DS))
    DeclaratorInfo.setInvalidType(true);
  else {
    DeclaratorInfo.SetSourceRange(DS.getSourceRange());
    ParseDeclaratorInternal(DeclaratorInfo,
                            &Parser::ParseDirectNewDeclarator);
  }
}
if (DeclaratorInfo.isInvalidType()) {
  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
  return ExprError();
}

ExprResult Initializer;

if (Tok.is(tok::l_paren)) {
  SourceLocation ConstructorLParen, ConstructorRParen;
  ExprVector ConstructorArgs;
  BalancedDelimiterTracker T(*this, tok::l_paren);
  T.consumeOpen();
  ConstructorLParen = T.getOpenLocation();
  if (Tok.isNot(tok::r_paren)) {
    CommaLocsTy CommaLocs;
    auto RunSignatureHelp = [&]() {
      ParsedType TypeRep =
          Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
      QualType PreferredType;
      // ActOnTypeName might adjust DeclaratorInfo and return a null type even
      // the passing DeclaratorInfo is valid, e.g. running SignatureHelp on
      // `new decltype(invalid) (^)`.
      if (TypeRep)
        PreferredType = Actions.ProduceConstructorSignatureHelp(
            getCurScope(), TypeRep.get()->getCanonicalTypeInternal(),
            DeclaratorInfo.getEndLoc(), ConstructorArgs, ConstructorLParen);
      CalledSignatureHelp = true;
      return PreferredType;
    };
    if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
          PreferredType.enterFunctionArgument(Tok.getLocation(),
                                              RunSignatureHelp);
        })) {
      if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
        RunSignatureHelp();
      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
      return ExprError();
    }
  }
  T.consumeClose();
  ConstructorRParen = T.getCloseLocation();
  if (ConstructorRParen.isInvalid()) {
    SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
    return ExprError();
  }
  Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
                                           ConstructorRParen,
                                           ConstructorArgs);
} else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
  Diag(Tok.getLocation(),
       diag::warn_cxx98_compat_generalized_initializer_lists);
  Initializer = ParseBraceInitializer();
}
if (Initializer.isInvalid())
  return Initializer;

return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
                           PlacementArgs, PlacementRParen,
                           TypeIdParens, DeclaratorInfo, Initializer.get());
3195}

3197/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
3198/// passed to ParseDeclaratorInternal.
3199///
3200///        direct-new-declarator:
3201///                   '[' expression[opt] ']'
3202///                   direct-new-declarator '[' constant-expression ']'
3203///
3204void Parser::ParseDirectNewDeclarator(Declarator &D) {
// Parse the array dimensions.
bool First = true;
while (Tok.is(tok::l_square)) {
  // An array-size expression can't start with a lambda.
  if (CheckProhibitedCXX11Attribute())
    continue;

  BalancedDelimiterTracker T(*this, tok::l_square);
  T.consumeOpen();

  ExprResult Size =
      First ? (Tok.is(tok::r_square) ? ExprResult() : ParseExpression())
            : ParseConstantExpression();
  if (Size.isInvalid()) {
    // Recover
    SkipUntil(tok::r_square, StopAtSemi);
    return;
  }
  First = false;

  T.consumeClose();

  // Attributes here appertain to the array type. C++11 [expr.new]p5.
  ParsedAttributes Attrs(AttrFactory);
  MaybeParseCXX11Attributes(Attrs);

  D.AddTypeInfo(DeclaratorChunk::getArray(0,
                                          /*isStatic=*/false, /*isStar=*/false,
                                          Size.get(), T.getOpenLocation(),
                                          T.getCloseLocation()),
                std::move(Attrs), T.getCloseLocation());

  if (T.getCloseLocation().isInvalid())
    return;
}
3240}

3242/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
3243/// This ambiguity appears in the syntax of the C++ new operator.
3244///
3245///        new-expression:
3246///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3247///                                     new-initializer[opt]
3248///
3249///        new-placement:
3250///                   '(' expression-list ')'
3251///
3252bool Parser::ParseExpressionListOrTypeId(
                                 SmallVectorImpl<Expr*> &PlacementArgs,
                                       Declarator &D) {
// The '(' was already consumed.
if (isTypeIdInParens()) {
  ParseSpecifierQualifierList(D.getMutableDeclSpec());
  D.SetSourceRange(D.getDeclSpec().getSourceRange());
  ParseDeclarator(D);
  return D.isInvalidType();
}

// It's not a type, it has to be an expression list.
// Discard the comma locations - ActOnCXXNew has enough parameters.
CommaLocsTy CommaLocs;
return ParseExpressionList(PlacementArgs, CommaLocs);
3267}

3269/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
3270/// to free memory allocated by new.
3271///
3272/// This method is called to parse the 'delete' expression after the optional
3273/// '::' has been already parsed.  If the '::' was present, "UseGlobal" is true
3274/// and "Start" is its location.  Otherwise, "Start" is the location of the
3275/// 'delete' token.
3276///
3277///        delete-expression:
3278///                   '::'[opt] 'delete' cast-expression
3279///                   '::'[opt] 'delete' '[' ']' cast-expression
3280ExprResult
3281Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword")((Tok.is(tok::kw_delete) && "Expected 'delete' keyword"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::kw_delete) && \"Expected 'delete' keyword\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3282, __PRETTY_FUNCTION__));
ConsumeToken(); // Consume 'delete'

// Array delete?
bool ArrayDelete = false;
if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
  // C++11 [expr.delete]p1:
  //   Whenever the delete keyword is followed by empty square brackets, it
  //   shall be interpreted as [array delete].
  //   [Footnote: A lambda expression with a lambda-introducer that consists
  //              of empty square brackets can follow the delete keyword if
  //              the lambda expression is enclosed in parentheses.]

  const Token Next = GetLookAheadToken(2);

  // Basic lookahead to check if we have a lambda expression.
  if (Next.isOneOf(tok::l_brace, tok::less) ||
      (Next.is(tok::l_paren) &&
       (GetLookAheadToken(3).is(tok::r_paren) ||
        (GetLookAheadToken(3).is(tok::identifier) &&
         GetLookAheadToken(4).is(tok::identifier))))) {
    TentativeParsingAction TPA(*this);
    SourceLocation LSquareLoc = Tok.getLocation();
    SourceLocation RSquareLoc = NextToken().getLocation();

    // SkipUntil can't skip pairs of </*...*/>; don't emit a FixIt in this
    // case.
    SkipUntil({tok::l_brace, tok::less}, StopBeforeMatch);
    SourceLocation RBraceLoc;
    bool EmitFixIt = false;
    if (Tok.is(tok::l_brace)) {
      ConsumeBrace();
      SkipUntil(tok::r_brace, StopBeforeMatch);
      RBraceLoc = Tok.getLocation();
      EmitFixIt = true;
    }

    TPA.Revert();

    if (EmitFixIt)
      Diag(Start, diag::err_lambda_after_delete)
          << SourceRange(Start, RSquareLoc)
          << FixItHint::CreateInsertion(LSquareLoc, "(")
          << FixItHint::CreateInsertion(
                 Lexer::getLocForEndOfToken(
                     RBraceLoc, 0, Actions.getSourceManager(), getLangOpts()),
                 ")");
    else
      Diag(Start, diag::err_lambda_after_delete)
          << SourceRange(Start, RSquareLoc);

    // Warn that the non-capturing lambda isn't surrounded by parentheses
    // to disambiguate it from 'delete[]'.
    ExprResult Lambda = ParseLambdaExpression();
    if (Lambda.isInvalid())
      return ExprError();

    // Evaluate any postfix expressions used on the lambda.
    Lambda = ParsePostfixExpressionSuffix(Lambda);
    if (Lambda.isInvalid())
      return ExprError();
    return Actions.ActOnCXXDelete(Start, UseGlobal, /*ArrayForm=*/false,
                                  Lambda.get());
  }

  ArrayDelete = true;
  BalancedDelimiterTracker T(*this, tok::l_square);

  T.consumeOpen();
  T.consumeClose();
  if (T.getCloseLocation().isInvalid())
    return ExprError();
}

ExprResult Operand(ParseCastExpression(AnyCastExpr));
if (Operand.isInvalid())
  return Operand;

return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
3361}

3363/// ParseRequiresExpression - Parse a C++2a requires-expression.
3364/// C++2a [expr.prim.req]p1
3365///     A requires-expression provides a concise way to express requirements on
3366///     template arguments. A requirement is one that can be checked by name
3367///     lookup (6.4) or by checking properties of types and expressions.
3368///
3369///     requires-expression:
3370///         'requires' requirement-parameter-list[opt] requirement-body
3371///
3372///     requirement-parameter-list:
3373///         '(' parameter-declaration-clause[opt] ')'
3374///
3375///     requirement-body:
3376///         '{' requirement-seq '}'
3377///
3378///     requirement-seq:
3379///         requirement
3380///         requirement-seq requirement
3381///
3382///     requirement:
3383///         simple-requirement
3384///         type-requirement
3385///         compound-requirement
3386///         nested-requirement
3387ExprResult Parser::ParseRequiresExpression() {
assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword")((Tok.is(tok::kw_requires) && "Expected 'requires' keyword"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::kw_requires) && \"Expected 'requires' keyword\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3388, __PRETTY_FUNCTION__));
SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires'

llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls;
if (Tok.is(tok::l_paren)) {
  // requirement parameter list is present.
  ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope |
                                  Scope::DeclScope);
  BalancedDelimiterTracker Parens(*this, tok::l_paren);
  Parens.consumeOpen();
  if (!Tok.is(tok::r_paren)) {
    ParsedAttributes FirstArgAttrs(getAttrFactory());
    SourceLocation EllipsisLoc;
    llvm::SmallVector<DeclaratorChunk::ParamInfo, 2> LocalParameters;
    ParseParameterDeclarationClause(DeclaratorContext::RequiresExpr,
                                    FirstArgAttrs, LocalParameters,
                                    EllipsisLoc);
    if (EllipsisLoc.isValid())
      Diag(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis);
    for (auto &ParamInfo : LocalParameters)
      LocalParameterDecls.push_back(cast<ParmVarDecl>(ParamInfo.Param));
  }
  Parens.consumeClose();
}

BalancedDelimiterTracker Braces(*this, tok::l_brace);
if (Braces.expectAndConsume())
  return ExprError();

// Start of requirement list
llvm::SmallVector<concepts::Requirement *, 2> Requirements;

// C++2a [expr.prim.req]p2
//   Expressions appearing within a requirement-body are unevaluated operands.
EnterExpressionEvaluationContext Ctx(
    Actions, Sema::ExpressionEvaluationContext::Unevaluated);

ParseScope BodyScope(this, Scope::DeclScope);
RequiresExprBodyDecl *Body = Actions.ActOnStartRequiresExpr(
    RequiresKWLoc, LocalParameterDecls, getCurScope());

if (Tok.is(tok::r_brace)) {
  // Grammar does not allow an empty body.
  // requirement-body:
  //   { requirement-seq }
  // requirement-seq:
  //   requirement
  //   requirement-seq requirement
  Diag(Tok, diag::err_empty_requires_expr);
  // Continue anyway and produce a requires expr with no requirements.
} else {
  while (!Tok.is(tok::r_brace)) {
    switch (Tok.getKind()) {
    case tok::l_brace: {
      // Compound requirement
      // C++ [expr.prim.req.compound]
      //     compound-requirement:
      //         '{' expression '}' 'noexcept'[opt]
      //             return-type-requirement[opt] ';'
      //     return-type-requirement:
      //         trailing-return-type
      //         '->' cv-qualifier-seq[opt] constrained-parameter
      //             cv-qualifier-seq[opt] abstract-declarator[opt]
      BalancedDelimiterTracker ExprBraces(*this, tok::l_brace);
      ExprBraces.consumeOpen();
      ExprResult Expression =
          Actions.CorrectDelayedTyposInExpr(ParseExpression());
      if (!Expression.isUsable()) {
        ExprBraces.skipToEnd();
        SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
        break;
      }
      if (ExprBraces.consumeClose())
        ExprBraces.skipToEnd();

      concepts::Requirement *Req = nullptr;
      SourceLocation NoexceptLoc;
      TryConsumeToken(tok::kw_noexcept, NoexceptLoc);
      if (Tok.is(tok::semi)) {
        Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc);
        if (Req)
          Requirements.push_back(Req);
        break;
      }
      if (!TryConsumeToken(tok::arrow))
        // User probably forgot the arrow, remind them and try to continue.
        Diag(Tok, diag::err_requires_expr_missing_arrow)
            << FixItHint::CreateInsertion(Tok.getLocation(), "->");
      // Try to parse a 'type-constraint'
      if (TryAnnotateTypeConstraint()) {
        SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
        break;
      }
      if (!isTypeConstraintAnnotation()) {
        Diag(Tok, diag::err_requires_expr_expected_type_constraint);
        SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
        break;
      }
      CXXScopeSpec SS;
      if (Tok.is(tok::annot_cxxscope)) {
        Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
                                                     Tok.getAnnotationRange(),
                                                     SS);
        ConsumeAnnotationToken();
      }

      Req = Actions.ActOnCompoundRequirement(
          Expression.get(), NoexceptLoc, SS, takeTemplateIdAnnotation(Tok),
          TemplateParameterDepth);
      ConsumeAnnotationToken();
      if (Req)
        Requirements.push_back(Req);
      break;
    }
    default: {
      bool PossibleRequiresExprInSimpleRequirement = false;
      if (Tok.is(tok::kw_requires)) {
        auto IsNestedRequirement = [&] {
          RevertingTentativeParsingAction TPA(*this);
          ConsumeToken(); // 'requires'
          if (Tok.is(tok::l_brace))
            // This is a requires expression
            // requires (T t) {
            //   requires { t++; };
            //   ...      ^
            // }
            return false;
          if (Tok.is(tok::l_paren)) {
            // This might be the parameter list of a requires expression
            ConsumeParen();
            auto Res = TryParseParameterDeclarationClause();
            if (Res != TPResult::False) {
              // Skip to the closing parenthesis
              // FIXME: Don't traverse these tokens twice (here and in
              //  TryParseParameterDeclarationClause).
              unsigned Depth = 1;
              while (Depth != 0) {
                if (Tok.is(tok::l_paren))
                  Depth++;
                else if (Tok.is(tok::r_paren))
                  Depth--;
                ConsumeAnyToken();
              }
              // requires (T t) {
              //   requires () ?
              //   ...         ^
              //   - OR -
              //   requires (int x) ?
              //   ...              ^
              // }
              if (Tok.is(tok::l_brace))
                // requires (...) {
                //                ^ - a requires expression as a
                //                    simple-requirement.
                return false;
            }
          }
          return true;
        };
        if (IsNestedRequirement()) {
          ConsumeToken();
          // Nested requirement
          // C++ [expr.prim.req.nested]
          //     nested-requirement:
          //         'requires' constraint-expression ';'
          ExprResult ConstraintExpr =
              Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression());
          if (ConstraintExpr.isInvalid() || !ConstraintExpr.isUsable()) {
            SkipUntil(tok::semi, tok::r_brace,
                      SkipUntilFlags::StopBeforeMatch);
            break;
          }
          if (auto *Req =
                  Actions.ActOnNestedRequirement(ConstraintExpr.get()))
            Requirements.push_back(Req);
          else {
            SkipUntil(tok::semi, tok::r_brace,
                      SkipUntilFlags::StopBeforeMatch);
            break;
          }
          break;
        } else
          PossibleRequiresExprInSimpleRequirement = true;
      } else if (Tok.is(tok::kw_typename)) {
        // This might be 'typename T::value_type;' (a type requirement) or
        // 'typename T::value_type{};' (a simple requirement).
        TentativeParsingAction TPA(*this);

        // We need to consume the typename to allow 'requires { typename a; }'
        SourceLocation TypenameKWLoc = ConsumeToken();
        if (TryAnnotateCXXScopeToken()) {
          TPA.Commit();
          SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
          break;
        }
        CXXScopeSpec SS;
        if (Tok.is(tok::annot_cxxscope)) {
          Actions.RestoreNestedNameSpecifierAnnotation(
              Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
          ConsumeAnnotationToken();
        }

        if (Tok.isOneOf(tok::identifier, tok::annot_template_id) &&
            !NextToken().isOneOf(tok::l_brace, tok::l_paren)) {
          TPA.Commit();
          SourceLocation NameLoc = Tok.getLocation();
          IdentifierInfo *II = nullptr;
          TemplateIdAnnotation *TemplateId = nullptr;
          if (Tok.is(tok::identifier)) {
            II = Tok.getIdentifierInfo();
            ConsumeToken();
          } else {
            TemplateId = takeTemplateIdAnnotation(Tok);
            ConsumeAnnotationToken();
            if (TemplateId->isInvalid())
              break;
          }

          if (auto *Req = Actions.ActOnTypeRequirement(TypenameKWLoc, SS,
                                                       NameLoc, II,
                                                       TemplateId)) {
            Requirements.push_back(Req);
          }
          break;
        }
        TPA.Revert();
      }
      // Simple requirement
      // C++ [expr.prim.req.simple]
      //     simple-requirement:
      //         expression ';'
      SourceLocation StartLoc = Tok.getLocation();
      ExprResult Expression =
          Actions.CorrectDelayedTyposInExpr(ParseExpression());
      if (!Expression.isUsable()) {
        SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
        break;
      }
      if (!Expression.isInvalid() && PossibleRequiresExprInSimpleRequirement)
        Diag(StartLoc, diag::warn_requires_expr_in_simple_requirement)
            << FixItHint::CreateInsertion(StartLoc, "requires");
      if (auto *Req = Actions.ActOnSimpleRequirement(Expression.get()))
        Requirements.push_back(Req);
      else {
        SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
        break;
      }
      // User may have tried to put some compound requirement stuff here
      if (Tok.is(tok::kw_noexcept)) {
        Diag(Tok, diag::err_requires_expr_simple_requirement_noexcept)
            << FixItHint::CreateInsertion(StartLoc, "{")
            << FixItHint::CreateInsertion(Tok.getLocation(), "}");
        SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
        break;
      }
      break;
    }
    }
    if (ExpectAndConsumeSemi(diag::err_expected_semi_requirement)) {
      SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
      TryConsumeToken(tok::semi);
      break;
    }
  }
  if (Requirements.empty()) {
    // Don't emit an empty requires expr here to avoid confusing the user with
    // other diagnostics quoting an empty requires expression they never
    // wrote.
    Braces.consumeClose();
    Actions.ActOnFinishRequiresExpr();
    return ExprError();
  }
}
Braces.consumeClose();
Actions.ActOnFinishRequiresExpr();
return Actions.ActOnRequiresExpr(RequiresKWLoc, Body, LocalParameterDecls,
                                 Requirements, Braces.getCloseLocation());
3665}

3667static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
switch (kind) {
default: llvm_unreachable("Not a known type trait")::llvm::llvm_unreachable_internal("Not a known type trait", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3669);
3670#define TYPE_TRAIT_1(Spelling, Name, Key) \
3671case tok::kw_ ## Spelling: return UTT_ ## Name;
3672#define TYPE_TRAIT_2(Spelling, Name, Key) \
3673case tok::kw_ ## Spelling: return BTT_ ## Name;
3674#include "clang/Basic/TokenKinds.def"
3675#define TYPE_TRAIT_N(Spelling, Name, Key) \
case tok::kw_ ## Spelling: return TT_ ## Name;
3677#include "clang/Basic/TokenKinds.def"
}
3679}

3681static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
switch (kind) {
default:
  llvm_unreachable("Not a known array type trait")::llvm::llvm_unreachable_internal("Not a known array type trait"
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3684);
3685#define ARRAY_TYPE_TRAIT(Spelling, Name, Key)                                  \
case tok::kw_##Spelling:                                                     \
  return ATT_##Name;
3688#include "clang/Basic/TokenKinds.def"
}
3690}

3692static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
switch (kind) {
default:
  llvm_unreachable("Not a known unary expression trait.")::llvm::llvm_unreachable_internal("Not a known unary expression trait."
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3695);
3696#define EXPRESSION_TRAIT(Spelling, Name, Key)                                  \
case tok::kw_##Spelling:                                                     \
  return ET_##Name;
3699#include "clang/Basic/TokenKinds.def"
}
3701}

3703static unsigned TypeTraitArity(tok::TokenKind kind) {
switch (kind) {
  default: llvm_unreachable("Not a known type trait")::llvm::llvm_unreachable_internal("Not a known type trait", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3705);
3706#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
3707#include "clang/Basic/TokenKinds.def"
}
3709}

3711/// Parse the built-in type-trait pseudo-functions that allow
3712/// implementation of the TR1/C++11 type traits templates.
3713///
3714///       primary-expression:
3715///          unary-type-trait '(' type-id ')'
3716///          binary-type-trait '(' type-id ',' type-id ')'
3717///          type-trait '(' type-id-seq ')'
3718///
3719///       type-id-seq:
3720///          type-id ...[opt] type-id-seq[opt]
3721///
3722ExprResult Parser::ParseTypeTrait() {
tok::TokenKind Kind = Tok.getKind();
unsigned Arity = TypeTraitArity(Kind);

SourceLocation Loc = ConsumeToken();

BalancedDelimiterTracker Parens(*this, tok::l_paren);
if (Parens.expectAndConsume())
  return ExprError();

SmallVector<ParsedType, 2> Args;
do {
  // Parse the next type.
  TypeResult Ty = ParseTypeName();
  if (Ty.isInvalid()) {
    Parens.skipToEnd();
    return ExprError();
  }

  // Parse the ellipsis, if present.
  if (Tok.is(tok::ellipsis)) {
    Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
    if (Ty.isInvalid()) {
      Parens.skipToEnd();
      return ExprError();
    }
  }

  // Add this type to the list of arguments.
  Args.push_back(Ty.get());
} while (TryConsumeToken(tok::comma));

if (Parens.consumeClose())
  return ExprError();

SourceLocation EndLoc = Parens.getCloseLocation();

if (Arity && Args.size() != Arity) {
  Diag(EndLoc, diag::err_type_trait_arity)
    << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
  return ExprError();
}

if (!Arity && Args.empty()) {
  Diag(EndLoc, diag::err_type_trait_arity)
    << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
  return ExprError();
}

return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
3772}

3774/// ParseArrayTypeTrait - Parse the built-in array type-trait
3775/// pseudo-functions.
3776///
3777///       primary-expression:
3778/// [Embarcadero]     '__array_rank' '(' type-id ')'
3779/// [Embarcadero]     '__array_extent' '(' type-id ',' expression ')'
3780///
3781ExprResult Parser::ParseArrayTypeTrait() {
ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
SourceLocation Loc = ConsumeToken();

BalancedDelimiterTracker T(*this, tok::l_paren);
if (T.expectAndConsume())
  return ExprError();

TypeResult Ty = ParseTypeName();
if (Ty.isInvalid()) {
  SkipUntil(tok::comma, StopAtSemi);
  SkipUntil(tok::r_paren, StopAtSemi);
  return ExprError();
}

switch (ATT) {
case ATT_ArrayRank: {
  T.consumeClose();
  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
                                     T.getCloseLocation());
}
case ATT_ArrayExtent: {
  if (ExpectAndConsume(tok::comma)) {
    SkipUntil(tok::r_paren, StopAtSemi);
    return ExprError();
  }

  ExprResult DimExpr = ParseExpression();
  T.consumeClose();

  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
                                     T.getCloseLocation());
}
}
llvm_unreachable("Invalid ArrayTypeTrait!")::llvm::llvm_unreachable_internal("Invalid ArrayTypeTrait!", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3815);
3816}

3818/// ParseExpressionTrait - Parse built-in expression-trait
3819/// pseudo-functions like __is_lvalue_expr( xxx ).
3820///
3821///       primary-expression:
3822/// [Embarcadero]     expression-trait '(' expression ')'
3823///
3824ExprResult Parser::ParseExpressionTrait() {
ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
SourceLocation Loc = ConsumeToken();

BalancedDelimiterTracker T(*this, tok::l_paren);
if (T.expectAndConsume())
  return ExprError();

ExprResult Expr = ParseExpression();

T.consumeClose();

return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
                                    T.getCloseLocation());
3838}


3841/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3842/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3843/// based on the context past the parens.
3844ExprResult
3845Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
                                       ParsedType &CastTy,
                                       BalancedDelimiterTracker &Tracker,
                                       ColonProtectionRAIIObject &ColonProt) {
assert(getLangOpts().CPlusPlus && "Should only be called for C++!")((getLangOpts().CPlusPlus && "Should only be called for C++!"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Should only be called for C++!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3849, __PRETTY_FUNCTION__));
assert(ExprType == CastExpr && "Compound literals are not ambiguous!")((ExprType == CastExpr && "Compound literals are not ambiguous!"
) ? static_cast<void> (0) : __assert_fail ("ExprType == CastExpr && \"Compound literals are not ambiguous!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3850, __PRETTY_FUNCTION__));
assert(isTypeIdInParens() && "Not a type-id!")((isTypeIdInParens() && "Not a type-id!") ? static_cast
<void> (0) : __assert_fail ("isTypeIdInParens() && \"Not a type-id!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3851, __PRETTY_FUNCTION__));

ExprResult Result(true);
CastTy = nullptr;

// We need to disambiguate a very ugly part of the C++ syntax:
//
// (T())x;  - type-id
// (T())*x; - type-id
// (T())/x; - expression
// (T());   - expression
//
// The bad news is that we cannot use the specialized tentative parser, since
// it can only verify that the thing inside the parens can be parsed as
// type-id, it is not useful for determining the context past the parens.
//
// The good news is that the parser can disambiguate this part without
// making any unnecessary Action calls.
//
// It uses a scheme similar to parsing inline methods. The parenthesized
// tokens are cached, the context that follows is determined (possibly by
// parsing a cast-expression), and then we re-introduce the cached tokens
// into the token stream and parse them appropriately.

ParenParseOption ParseAs;
CachedTokens Toks;

// Store the tokens of the parentheses. We will parse them after we determine
// the context that follows them.
if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
  // We didn't find the ')' we expected.
  Tracker.consumeClose();
  return ExprError();
}

if (Tok.is(tok::l_brace)) {
  ParseAs = CompoundLiteral;
} else {
  bool NotCastExpr;
  if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
    NotCastExpr = true;
  } else {
    // Try parsing the cast-expression that may follow.
    // If it is not a cast-expression, NotCastExpr will be true and no token
    // will be consumed.
    ColonProt.restore();
    Result = ParseCastExpression(AnyCastExpr,
                                 false/*isAddressofOperand*/,
                                 NotCastExpr,
                                 // type-id has priority.
                                 IsTypeCast);
  }

  // If we parsed a cast-expression, it's really a type-id, otherwise it's
  // an expression.
  ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
}

// Create a fake EOF to mark end of Toks buffer.
Token AttrEnd;
AttrEnd.startToken();
AttrEnd.setKind(tok::eof);
AttrEnd.setLocation(Tok.getLocation());
AttrEnd.setEofData(Toks.data());
Toks.push_back(AttrEnd);

// The current token should go after the cached tokens.
Toks.push_back(Tok);
// Re-enter the stored parenthesized tokens into the token stream, so we may
// parse them now.
PP.EnterTokenStream(Toks, /*DisableMacroExpansion*/ true,
                    /*IsReinject*/ true);
// Drop the current token and bring the first cached one. It's the same token
// as when we entered this function.
ConsumeAnyToken();

if (ParseAs >= CompoundLiteral) {
  // Parse the type declarator.
  DeclSpec DS(AttrFactory);
  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
  {
    ColonProtectionRAIIObject InnerColonProtection(*this);
    ParseSpecifierQualifierList(DS);
    ParseDeclarator(DeclaratorInfo);
  }

  // Match the ')'.
  Tracker.consumeClose();
  ColonProt.restore();

  // Consume EOF marker for Toks buffer.
  assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())((Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData
()) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()"
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3942, __PRETTY_FUNCTION__));
  ConsumeAnyToken();

  if (ParseAs == CompoundLiteral) {
    ExprType = CompoundLiteral;
    if (DeclaratorInfo.isInvalidType())
      return ExprError();

    TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
    return ParseCompoundLiteralExpression(Ty.get(),
                                          Tracker.getOpenLocation(),
                                          Tracker.getCloseLocation());
  }

  // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
  assert(ParseAs == CastExpr)((ParseAs == CastExpr) ? static_cast<void> (0) : __assert_fail
 ("ParseAs == CastExpr", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3957, __PRETTY_FUNCTION__));

  if (DeclaratorInfo.isInvalidType())
    return ExprError();

  // Result is what ParseCastExpression returned earlier.
  if (!Result.isInvalid())
    Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
                                  DeclaratorInfo, CastTy,
                                  Tracker.getCloseLocation(), Result.get());
  return Result;
}

// Not a compound literal, and not followed by a cast-expression.
assert(ParseAs == SimpleExpr)((ParseAs == SimpleExpr) ? static_cast<void> (0) : __assert_fail
 ("ParseAs == SimpleExpr", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3971, __PRETTY_FUNCTION__));

ExprType = SimpleExpr;
Result = ParseExpression();
if (!Result.isInvalid() && Tok.is(tok::r_paren))
  Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
                                  Tok.getLocation(), Result.get());

// Match the ')'.
if (Result.isInvalid()) {
  while (Tok.isNot(tok::eof))
    ConsumeAnyToken();
  assert(Tok.getEofData() == AttrEnd.getEofData())((Tok.getEofData() == AttrEnd.getEofData()) ? static_cast<
void> (0) : __assert_fail ("Tok.getEofData() == AttrEnd.getEofData()"
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3983, __PRETTY_FUNCTION__));
  ConsumeAnyToken();
  return ExprError();
}

Tracker.consumeClose();
// Consume EOF marker for Toks buffer.
assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())((Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData
()) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()"
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/lib/Parse/ParseExprCXX.cpp"
, 3990, __PRETTY_FUNCTION__));
ConsumeAnyToken();
return Result;
3993}

3995/// Parse a __builtin_bit_cast(T, E).
3996ExprResult Parser::ParseBuiltinBitCast() {
SourceLocation KWLoc = ConsumeToken();

BalancedDelimiterTracker T(*this, tok::l_paren);
if (T.expectAndConsume(diag::err_expected_lparen_after, "__builtin_bit_cast"))
  return ExprError();

// Parse the common declaration-specifiers piece.
DeclSpec DS(AttrFactory);
ParseSpecifierQualifierList(DS);

// Parse the abstract-declarator, if present.
Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
ParseDeclarator(DeclaratorInfo);

if (ExpectAndConsume(tok::comma)) {
  Diag(Tok.getLocation(), diag::err_expected) << tok::comma;
  SkipUntil(tok::r_paren, StopAtSemi);
  return ExprError();
}

ExprResult Operand = ParseExpression();

if (T.consumeClose())
  return ExprError();

if (Operand.isInvalid() || DeclaratorInfo.isInvalidType())
  return ExprError();

return Actions.ActOnBuiltinBitCastExpr(KWLoc, DeclaratorInfo, Operand,
                                       T.getCloseLocation());
4027}

←

/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h

1//===--- Token.h - Token interface ------------------------------*- C++ -*-===//
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 defines the Token interface.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_LEX_TOKEN_H
14#define LLVM_CLANG_LEX_TOKEN_H

16#include "clang/Basic/SourceLocation.h"
17#include "clang/Basic/TokenKinds.h"
18#include "llvm/ADT/StringRef.h"
19#include <cassert>

21namespace clang {

23class IdentifierInfo;

25/// Token - This structure provides full information about a lexed token.
26/// It is not intended to be space efficient, it is intended to return as much
27/// information as possible about each returned token.  This is expected to be
28/// compressed into a smaller form if memory footprint is important.
29///
30/// The parser can create a special "annotation token" representing a stream of
31/// tokens that were parsed and semantically resolved, e.g.: "foo::MyClass<int>"
32/// can be represented by a single typename annotation token that carries
33/// information about the SourceRange of the tokens and the type object.
34class Token {
/// The location of the token. This is actually a SourceLocation.
unsigned Loc;

// Conceptually these next two fields could be in a union.  However, this
// causes gcc 4.2 to pessimize LexTokenInternal, a very performance critical
// routine. Keeping as separate members with casts until a more beautiful fix
// presents itself.

/// UintData - This holds either the length of the token text, when
/// a normal token, or the end of the SourceRange when an annotation
/// token.
unsigned UintData;

/// PtrData - This is a union of four different pointer types, which depends
/// on what type of token this is:
///  Identifiers, keywords, etc:
///    This is an IdentifierInfo*, which contains the uniqued identifier
///    spelling.
///  Literals:  isLiteral() returns true.
///    This is a pointer to the start of the token in a text buffer, which
///    may be dirty (have trigraphs / escaped newlines).
///  Annotations (resolved type names, C++ scopes, etc): isAnnotation().
///    This is a pointer to sema-specific data for the annotation token.
///  Eof:
//     This is a pointer to a Decl.
///  Other:
///    This is null.
void *PtrData;

/// Kind - The actual flavor of token this is.
tok::TokenKind Kind;

/// Flags - Bits we track about this token, members of the TokenFlags enum.
unsigned short Flags;

70public:
// Various flags set per token:
enum TokenFlags {
  StartOfLine = 0x01,   // At start of line or only after whitespace
                        // (considering the line after macro expansion).
  LeadingSpace = 0x02,  // Whitespace exists before this token (considering
                        // whitespace after macro expansion).
  DisableExpand = 0x04, // This identifier may never be macro expanded.
  NeedsCleaning = 0x08, // Contained an escaped newline or trigraph.
  LeadingEmptyMacro = 0x10, // Empty macro exists before this token.
  HasUDSuffix = 0x20,  // This string or character literal has a ud-suffix.
  HasUCN = 0x40,       // This identifier contains a UCN.
  IgnoredComma = 0x80, // This comma is not a macro argument separator (MS).
  StringifiedInMacro = 0x100, // This string or character literal is formed by
                              // macro stringizing or charizing operator.
  CommaAfterElided = 0x200, // The comma following this token was elided (MS).
  IsEditorPlaceholder = 0x400, // This identifier is a placeholder.
  IsReinjected = 0x800, // A phase 4 token that was produced before and
                        // re-added, e.g. via EnterTokenStream. Annotation
                        // tokens are *not* reinjected.
};

tok::TokenKind getKind() const { return Kind; }
void setKind(tok::TokenKind K) { Kind = K; }

/// is/isNot - Predicates to check if this token is a specific kind, as in
/// "if (Tok.is(tok::l_brace)) {...}".
bool is(tok::TokenKind K) const { return Kind == K; }
6
←
Assuming 'K' is not equal to field 'Kind'→
7
←
Returning zero, which participates in a condition later→
bool isNot(tok::TokenKind K) const { return Kind != K; }
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const {
  return is(K1) || is(K2);
}
template <typename... Ts>
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2, Ts... Ks) const {
  return is(K1) || isOneOf(K2, Ks...);
}

/// Return true if this is a raw identifier (when lexing
/// in raw mode) or a non-keyword identifier (when lexing in non-raw mode).
bool isAnyIdentifier() const {
  return tok::isAnyIdentifier(getKind());
}

/// Return true if this is a "literal", like a numeric
/// constant, string, etc.
bool isLiteral() const {
  return tok::isLiteral(getKind());
}

/// Return true if this is any of tok::annot_* kind tokens.
bool isAnnotation() const {
  return tok::isAnnotation(getKind());
}

/// Return a source location identifier for the specified
/// offset in the current file.
SourceLocation getLocation() const {
  return SourceLocation::getFromRawEncoding(Loc);
}
unsigned getLength() const {
  assert(!isAnnotation() && "Annotation tokens have no length field")((!isAnnotation() && "Annotation tokens have no length field"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 130, __PRETTY_FUNCTION__));
  return UintData;
}

void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
void setLength(unsigned Len) {
  assert(!isAnnotation() && "Annotation tokens have no length field")((!isAnnotation() && "Annotation tokens have no length field"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 136, __PRETTY_FUNCTION__));
  UintData = Len;
}

SourceLocation getAnnotationEndLoc() const {
  assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 141, __PRETTY_FUNCTION__));
  return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
}
void setAnnotationEndLoc(SourceLocation L) {
  assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 145, __PRETTY_FUNCTION__));
  UintData = L.getRawEncoding();
}

SourceLocation getLastLoc() const {
  return isAnnotation() ? getAnnotationEndLoc() : getLocation();
}

SourceLocation getEndLoc() const {
  return isAnnotation() ? getAnnotationEndLoc()
                        : getLocation().getLocWithOffset(getLength());
}

/// SourceRange of the group of tokens that this annotation token
/// represents.
SourceRange getAnnotationRange() const {
  return SourceRange(getLocation(), getAnnotationEndLoc());
}
void setAnnotationRange(SourceRange R) {
  setLocation(R.getBegin());
  setAnnotationEndLoc(R.getEnd());
}

const char *getName() const { return tok::getTokenName(Kind); }

/// Reset all flags to cleared.
void startToken() {
  Kind = tok::unknown;
  Flags = 0;
  PtrData = nullptr;
  UintData = 0;
  Loc = SourceLocation().getRawEncoding();
}

IdentifierInfo *getIdentifierInfo() const {
  assert(isNot(tok::raw_identifier) &&((isNot(tok::raw_identifier) && "getIdentifierInfo() on a tok::raw_identifier token!"
) ? static_cast<void> (0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 181, __PRETTY_FUNCTION__))
         "getIdentifierInfo() on a tok::raw_identifier token!")((isNot(tok::raw_identifier) && "getIdentifierInfo() on a tok::raw_identifier token!"
) ? static_cast<void> (0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 181, __PRETTY_FUNCTION__));
  assert(!isAnnotation() &&((!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 183, __PRETTY_FUNCTION__))
         "getIdentifierInfo() on an annotation token!")((!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? static_cast<void> (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 183, __PRETTY_FUNCTION__));
  if (isLiteral()) return nullptr;
  if (is(tok::eof)) return nullptr;
  return (IdentifierInfo*) PtrData;
}
void setIdentifierInfo(IdentifierInfo *II) {
  PtrData = (void*) II;
}

const void *getEofData() const {
  assert(is(tok::eof))((is(tok::eof)) ? static_cast<void> (0) : __assert_fail
 ("is(tok::eof)", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 193, __PRETTY_FUNCTION__));
  return reinterpret_cast<const void *>(PtrData);
}
void setEofData(const void *D) {
  assert(is(tok::eof))((is(tok::eof)) ? static_cast<void> (0) : __assert_fail
 ("is(tok::eof)", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 197, __PRETTY_FUNCTION__));
  assert(!PtrData)((!PtrData) ? static_cast<void> (0) : __assert_fail ("!PtrData"
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 198, __PRETTY_FUNCTION__));
  PtrData = const_cast<void *>(D);
}

/// getRawIdentifier - For a raw identifier token (i.e., an identifier
/// lexed in raw mode), returns a reference to the text substring in the
/// buffer if known.
StringRef getRawIdentifier() const {
  assert(is(tok::raw_identifier))((is(tok::raw_identifier)) ? static_cast<void> (0) : __assert_fail
 ("is(tok::raw_identifier)", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 206, __PRETTY_FUNCTION__));
  return StringRef(reinterpret_cast<const char *>(PtrData), getLength());
}
void setRawIdentifierData(const char *Ptr) {
  assert(is(tok::raw_identifier))((is(tok::raw_identifier)) ? static_cast<void> (0) : __assert_fail
 ("is(tok::raw_identifier)", "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 210, __PRETTY_FUNCTION__));
  PtrData = const_cast<char*>(Ptr);
}

/// getLiteralData - For a literal token (numeric constant, string, etc), this
/// returns a pointer to the start of it in the text buffer if known, null
/// otherwise.
const char *getLiteralData() const {
  assert(isLiteral() && "Cannot get literal data of non-literal")((isLiteral() && "Cannot get literal data of non-literal"
) ? static_cast<void> (0) : __assert_fail ("isLiteral() && \"Cannot get literal data of non-literal\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 218, __PRETTY_FUNCTION__));
  return reinterpret_cast<const char*>(PtrData);
}
void setLiteralData(const char *Ptr) {
  assert(isLiteral() && "Cannot set literal data of non-literal")((isLiteral() && "Cannot set literal data of non-literal"
) ? static_cast<void> (0) : __assert_fail ("isLiteral() && \"Cannot set literal data of non-literal\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 222, __PRETTY_FUNCTION__));
  PtrData = const_cast<char*>(Ptr);
}

void *getAnnotationValue() const {
  assert(isAnnotation() && "Used AnnotVal on non-annotation token")((isAnnotation() && "Used AnnotVal on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 227, __PRETTY_FUNCTION__));
  return PtrData;
}
void setAnnotationValue(void *val) {
  assert(isAnnotation() && "Used AnnotVal on non-annotation token")((isAnnotation() && "Used AnnotVal on non-annotation token"
) ? static_cast<void> (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210314100619+a28facba1ccd/clang/include/clang/Lex/Token.h"
, 231, __PRETTY_FUNCTION__));
  PtrData = val;
}

/// Set the specified flag.
void setFlag(TokenFlags Flag) {
  Flags |= Flag;
}

/// Get the specified flag.
bool getFlag(TokenFlags Flag) const {
  return (Flags & Flag) != 0;
}

/// Unset the specified flag.
void clearFlag(TokenFlags Flag) {
  Flags &= ~Flag;
}

/// Return the internal represtation of the flags.
///
/// This is only intended for low-level operations such as writing tokens to
/// disk.
unsigned getFlags() const {
  return Flags;
}

/// Set a flag to either true or false.
void setFlagValue(TokenFlags Flag, bool Val) {
  if (Val)
    setFlag(Flag);
  else
    clearFlag(Flag);
}

/// isAtStartOfLine - Return true if this token is at the start of a line.
///
bool isAtStartOfLine() const { return getFlag(StartOfLine); }

/// Return true if this token has whitespace before it.
///
bool hasLeadingSpace() const { return getFlag(LeadingSpace); }

/// Return true if this identifier token should never
/// be expanded in the future, due to C99 6.10.3.4p2.
bool isExpandDisabled() const { return getFlag(DisableExpand); }

/// Return true if we have an ObjC keyword identifier.
bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const;

/// Return the ObjC keyword kind.
tok::ObjCKeywordKind getObjCKeywordID() const;

/// Return true if this token has trigraphs or escaped newlines in it.
bool needsCleaning() const { return getFlag(NeedsCleaning); }

/// Return true if this token has an empty macro before it.
///
bool hasLeadingEmptyMacro() const { return getFlag(LeadingEmptyMacro); }

/// Return true if this token is a string or character literal which
/// has a ud-suffix.
bool hasUDSuffix() const { return getFlag(HasUDSuffix); }

/// Returns true if this token contains a universal character name.
bool hasUCN() const { return getFlag(HasUCN); }

/// Returns true if this token is formed by macro by stringizing or charizing
/// operator.
bool stringifiedInMacro() const { return getFlag(StringifiedInMacro); }

/// Returns true if the comma after this token was elided.
bool commaAfterElided() const { return getFlag(CommaAfterElided); }

/// Returns true if this token is an editor placeholder.
///
/// Editor placeholders are produced by the code-completion engine and are
/// represented as characters between '<#' and '#>' in the source code. The
/// lexer uses identifier tokens to represent placeholders.
bool isEditorPlaceholder() const { return getFlag(IsEditorPlaceholder); }
311};

313/// Information about the conditional stack (\#if directives)
314/// currently active.
315struct PPConditionalInfo {
/// Location where the conditional started.
SourceLocation IfLoc;

/// True if this was contained in a skipping directive, e.g.,
/// in a "\#if 0" block.
bool WasSkipping;

/// True if we have emitted tokens already, and now we're in
/// an \#else block or something.  Only useful in Skipping blocks.
bool FoundNonSkip;

/// True if we've seen a \#else in this block.  If so,
/// \#elif/\#else directives are not allowed.
bool FoundElse;
330};

332} // end namespace clang

334#endif // LLVM_CLANG_LEX_TOKEN_H