/usr/src/gnu/usr.bin/clang/libclangParse/../../../llvm/clang/lib/Parse/ParseExprCXX.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangParse/../../../llvm/clang/lib/Parse/ParseExprCXX.cpp
Warning:	line 2023, column 5 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangParse/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangParse/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangParse/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangParse/../include -I /usr/src/gnu/usr.bin/clang/libclangParse/obj -I /usr/src/gnu/usr.bin/clang/libclangParse/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangParse/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangParse/../../../llvm/clang/lib/Parse/ParseExprCXX.cpp

/usr/src/gnu/usr.bin/clang/libclangParse/../../../llvm/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/AST/ASTContext.h"
13#include "clang/AST/Decl.h"
14#include "clang/AST/DeclTemplate.h"
15#include "clang/AST/ExprCXX.h"
16#include "clang/Basic/PrettyStackTrace.h"
17#include "clang/Lex/LiteralSupport.h"
18#include "clang/Parse/ParseDiagnostic.h"
19#include "clang/Parse/Parser.h"
20#include "clang/Parse/RAIIObjectsForParser.h"
21#include "clang/Sema/DeclSpec.h"
22#include "clang/Sema/ParsedTemplate.h"
23#include "clang/Sema/Scope.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <numeric>

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.")__builtin_unreachable();
}
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 &&((void)0)
       "Call sites of this function should be guarded by checking for C++")((void)0);

if (Tok.is(tok::annot_cxxscope)) {
  assert(!LastII && "want last identifier but have already annotated scope")((void)0);
  assert(!MayBePseudoDestructor && "unexpected annot_cxxscope")((void)0);
  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)) {
      cutOffParsing();
      // 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());
      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!")((void)0);
    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) &&((void)0)
           "NextToken() not working properly!")((void)0);
    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() &&((void)0)
         "undeclared non-type annotation should be unqualified")((void)0);
  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 "((void)0)
                            "for a previous keyword suggestion")((void)0);
return Result;
686}

688/// ParseLambdaExpression - Parse a C++11 lambda expression.
689///
690///       lambda-expression:
691///         lambda-introducer lambda-declarator compound-statement
692///         lambda-introducer '<' template-parameter-list '>'
693///             requires-clause[opt] lambda-declarator compound-statement
694///
695///       lambda-introducer:
696///         '[' lambda-capture[opt] ']'
697///
698///       lambda-capture:
699///         capture-default
700///         capture-list
701///         capture-default ',' capture-list
702///
703///       capture-default:
704///         '&'
705///         '='
706///
707///       capture-list:
708///         capture
709///         capture-list ',' capture
710///
711///       capture:
712///         simple-capture
713///         init-capture     [C++1y]
714///
715///       simple-capture:
716///         identifier
717///         '&' identifier
718///         'this'
719///
720///       init-capture:      [C++1y]
721///         identifier initializer
722///         '&' identifier initializer
723///
724///       lambda-declarator:
725///         lambda-specifiers     [C++2b]
726///         '(' parameter-declaration-clause ')' lambda-specifiers
727///             requires-clause[opt]
728///
729///       lambda-specifiers:
730///         decl-specifier-seq[opt] noexcept-specifier[opt]
731///             attribute-specifier-seq[opt] trailing-return-type[opt]
732///
733ExprResult 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);
744}

746/// Use lookahead and potentially tentative parsing to determine if we are
747/// looking at a C++11 lambda expression, and parse it if we are.
748///
749/// If we are not looking at a lambda expression, returns ExprError().
750ExprResult Parser::TryParseLambdaExpression() {
assert(getLangOpts().CPlusPlus11((void)0)
       && Tok.is(tok::l_square)((void)0)
       && "Not at the start of a possible lambda expression.")((void)0);

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);
813}

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

assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.")((void)0);
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)) {
        cutOffParsing();
        Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
                                             /*AfterAmpersand=*/false);
        break;
      }

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

  if (Tok.is(tok::code_completion)) {
    cutOffParsing();
    // 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);
    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)) {
        cutOffParsing();
        Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
                                             /*AfterAmpersand=*/true);
        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")((void)0);

        // 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;
1155}

1157static void tryConsumeLambdaSpecifierToken(Parser &P,
                                         SourceLocation &MutableLoc,
                                         SourceLocation &ConstexprLoc,
                                         SourceLocation &ConstevalLoc,
                                         SourceLocation &DeclEndLoc) {
assert(MutableLoc.isInvalid())((void)0);
assert(ConstexprLoc.isInvalid())((void)0);
// 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;
  }
}
1202}

1204static void
1205addConstexprToLambdaDeclSpecifier(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 &&((void)0)
         "Constexpr cannot have been set previously!")((void)0);
}
1218}

1220static 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;
}
1232}

1234/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1235/// expression.
1236ExprResult 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);
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;

auto ParseLambdaSpecifiers =
    [&](SourceLocation LParenLoc, SourceLocation RParenLoc,
        MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo,
        SourceLocation EllipsisLoc) {
      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);
    };

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();

  // Parse lambda-specifiers.
  ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(),
                        ParamInfo, EllipsisLoc);

  // Parse requires-clause[opt].
  if (Tok.is(tok::kw_requires))
    ParseTrailingRequiresClause(D);
} 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::kw_noexcept) ||
           (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
  if (!getLangOpts().CPlusPlus2b)
    // It's common to forget that one needs '()' before 'mutable', an
    // attribute specifier, the result type, or the requires clause. Deal with
    // this.
    Diag(Tok, diag::ext_lambda_missing_parens)
        << FixItHint::CreateInsertion(Tok.getLocation(), "() ");

  SourceLocation NoLoc;
  // Parse lambda-specifiers.
  std::vector<DeclaratorChunk::ParamInfo> EmptyParamInfo;
  ParseLambdaSpecifiers(/*LParenLoc=*/NoLoc, /*RParenLoc=*/NoLoc,
                        EmptyParamInfo, /*EllipsisLoc=*/NoLoc);
}

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();
1480}

1482/// ParseCXXCasts - This handles the various ways to cast expressions to another
1483/// type.
1484///
1485///       postfix-expression: [C++ 5.2p1]
1486///         'dynamic_cast' '<' type-name '>' '(' expression ')'
1487///         'static_cast' '<' type-name '>' '(' expression ')'
1488///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
1489///         'const_cast' '<' type-name '>' '(' expression ')'
1490///
1491/// C++ for OpenCL s2.3.1 adds:
1492///         'addrspace_cast' '<' type-name '>' '(' expression ')'
1493ExprResult Parser::ParseCXXCasts() {
tok::TokenKind Kind = Tok.getKind();
const char *CastName = nullptr; // For error messages

switch (Kind) {
default: llvm_unreachable("Unknown C++ cast!")__builtin_unreachable();
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;
1551}

1553/// ParseCXXTypeid - This handles the C++ typeid expression.
1554///
1555///       postfix-expression: [C++ 5.2p1]
1556///         'typeid' '(' expression ')'
1557///         'typeid' '(' type-id ')'
1558///
1559ExprResult Parser::ParseCXXTypeid() {
assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!")((void)0);

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;
1619}

1621/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1622///
1623///         '__uuidof' '(' expression ')'
1624///         '__uuidof' '(' type-id ')'
1625///
1626ExprResult Parser::ParseCXXUuidof() {
assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!")((void)0);

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;
1668}

1670/// Parse a C++ pseudo-destructor expression after the base,
1671/// . or -> operator, and nested-name-specifier have already been
1672/// parsed. We're handling this fragment of the grammar:
1673///
1674///       postfix-expression: [C++2a expr.post]
1675///         postfix-expression . template[opt] id-expression
1676///         postfix-expression -> template[opt] id-expression
1677///
1678///       id-expression:
1679///         qualified-id
1680///         unqualified-id
1681///
1682///       qualified-id:
1683///         nested-name-specifier template[opt] unqualified-id
1684///
1685///       nested-name-specifier:
1686///         type-name ::
1687///         decltype-specifier ::    FIXME: not implemented, but probably only
1688///                                         allowed in C++ grammar by accident
1689///         nested-name-specifier identifier ::
1690///         nested-name-specifier template[opt] simple-template-id ::
1691///         [...]
1692///
1693///       unqualified-id:
1694///         ~ type-name
1695///         ~ decltype-specifier
1696///         [...]
1697///
1698/// ... where the all but the last component of the nested-name-specifier
1699/// has already been parsed, and the base expression is not of a non-dependent
1700/// class type.
1701ExprResult
1702Parser::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")((void)0);
  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")((void)0);
  CCLoc = ConsumeToken();
} else {
  assert(SS.isEmpty() && "missing last component of nested name specifier")((void)0);
  FirstTypeName.setIdentifier(nullptr, SourceLocation());
}

// Parse the tilde.
assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail")((void)0);
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);
1771}

1773/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1774///
1775///       boolean-literal: [C++ 2.13.5]
1776///         'true'
1777///         'false'
1778ExprResult Parser::ParseCXXBoolLiteral() {
tok::TokenKind Kind = Tok.getKind();
return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1781}

1783/// ParseThrowExpression - This handles the C++ throw expression.
1784///
1785///       throw-expression: [C++ 15]
1786///         'throw' assignment-expression[opt]
1787ExprResult Parser::ParseThrowExpression() {
assert(Tok.is(tok::kw_throw) && "Not throw!")((void)0);
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());
}
1808}

1810/// Parse the C++ Coroutines co_yield expression.
1811///
1812///       co_yield-expression:
1813///         'co_yield' assignment-expression[opt]
1814ExprResult Parser::ParseCoyieldExpression() {
assert(Tok.is(tok::kw_co_yield) && "Not co_yield!")((void)0);

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

1825/// ParseCXXThis - This handles the C++ 'this' pointer.
1826///
1827/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1828/// a non-lvalue expression whose value is the address of the object for which
1829/// the function is called.
1830ExprResult Parser::ParseCXXThis() {
assert(Tok.is(tok::kw_this) && "Not 'this'!")((void)0);
SourceLocation ThisLoc = ConsumeToken();
return Actions.ActOnCXXThis(ThisLoc);
1834}

1836/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1837/// Can be interpreted either as function-style casting ("int(x)")
1838/// or class type construction ("ClassType(x,y,z)")
1839/// or creation of a value-initialized type ("int()").
1840/// See [C++ 5.2.3].
1841///
1842///       postfix-expression: [C++ 5.2p1]
1843///         simple-type-specifier '(' expression-list[opt] ')'
1844/// [C++0x] simple-type-specifier braced-init-list
1845///         typename-specifier '(' expression-list[opt] ')'
1846/// [C++0x] typename-specifier braced-init-list
1847///
1848/// In C++1z onwards, the type specifier can also be a template-name.
1849ExprResult
1850Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCast);
ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();

assert((Tok.is(tok::l_paren) ||((void)0)
        (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))((void)0)
       && "Expected '(' or '{'!")((void)0);

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())&&((void)0)
         "Unexpected number of commas!")((void)0);
  return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
                                           Exprs, T.getCloseLocation(),
                                           /*ListInitialization=*/false);
}
1911}

1913/// ParseCXXCondition - if/switch/while condition expression.
1914///
1915///       condition:
1916///         expression
1917///         type-specifier-seq declarator '=' assignment-expression
1918/// [C++11] type-specifier-seq declarator '=' initializer-clause
1919/// [C++11] type-specifier-seq declarator braced-init-list
1920/// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
1921///             brace-or-equal-initializer
1922/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1923///             '=' assignment-expression
1924///
1925/// In C++1z, a condition may in some contexts be preceded by an
1926/// optional init-statement. This function will parse that too.
1927///
1928/// \param InitStmt If non-null, an init-statement is permitted, and if present
1929/// will be parsed and stored here.
1930///
1931/// \param Loc The location of the start of the statement that requires this
1932/// condition, e.g., the "for" in a for loop.
1933///
1934/// \param FRI If non-null, a for range declaration is permitted, and if
1935/// present will be parsed and stored here, and a null result will be returned.
1936///
1937/// \param EnterForConditionScope If true, enter a continue/break scope at the
1938/// appropriate moment for a 'for' loop.
1939///
1940/// \returns The parsed condition.
1941Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
                                              SourceLocation Loc,
                                              Sema::ConditionKind CK,
                                              ForRangeInfo *FRI,
                                              bool EnterForConditionScope) {
// Helper to ensure we always enter a continue/break scope if requested.
struct ForConditionScopeRAII {
  Scope *S;
  void enter(bool IsConditionVariable) {
    if (S) {
      S->AddFlags(Scope::BreakScope | Scope::ContinueScope);
      S->setIsConditionVarScope(IsConditionVariable);
    }
  }
  ~ForConditionScopeRAII() {
    if (S)
      S->setIsConditionVarScope(false);
  }
} ForConditionScope{EnterForConditionScope6.1
'EnterForConditionScope' is false
1
'EnterForConditionScope' is false
 ? getCurScope() : nullptr};
1
Assuming 'EnterForConditionScope' is false→
2
←
'?' condition is false→
7
←
'?' condition is false→

ParenBraceBracketBalancer BalancerRAIIObj(*this);
PreferredType.enterCondition(Actions, Tok.getLocation());

if (Tok.is(tok::code_completion)) {
3
←
Taking false branch→
8
←
Calling 'Token::is'→
11
←
Returning from 'Token::is'→
12
←
Taking false branch→
  cutOffParsing();
  Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
  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)) {
4
←
Control jumps to 'case InitStmtDecl:'  at line 2018→
13
←
Control jumps to 'case InitStmtDecl:'  at line 2018→
case ConditionOrInitStatement::Expression: {
  // If this is a for loop, we're entering its condition.
  ForConditionScope.enter(/*IsConditionVariable=*/false);

  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);
14
←
Called C++ object pointer is null
  return ParseCXXCondition(nullptr, Loc, CK);
5
←
Passing null pointer value via 1st parameter 'InitStmt'→
6
←
Calling 'Parser::ParseCXXCondition'→
}

case ConditionOrInitStatement::ForRangeDecl: {
  // This is 'for (init-stmt; for-range-decl : range-expr)'.
  // We're not actually in a for loop yet, so 'break' and 'continue' aren't
  // permitted here.
  assert(FRI && "should not parse a for range declaration here")((void)0);
  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
  DeclGroupPtrTy DG = ParseSimpleDeclaration(DeclaratorContext::ForInit,
                                             DeclEnd, attrs, false, FRI);
  FRI->LoopVar = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
  assert((FRI->ColonLoc.isValid() || !DG) &&((void)0)
         "cannot find for range declaration")((void)0);
  return Sema::ConditionResult();
}

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

// If this is a for loop, we're entering its condition.
ForConditionScope.enter(/*IsConditionVariable=*/true);

// 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);
2113}

2115/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
2116/// This should only be called when the current token is known to be part of
2117/// simple-type-specifier.
2118///
2119///       simple-type-specifier:
2120///         '::'[opt] nested-name-specifier[opt] type-name
2121///         '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
2122///         char
2123///         wchar_t
2124///         bool
2125///         short
2126///         int
2127///         long
2128///         signed
2129///         unsigned
2130///         float
2131///         double
2132///         void
2133/// [GNU]   typeof-specifier
2134/// [C++0x] auto               [TODO]
2135///
2136///       type-name:
2137///         class-name
2138///         enum-name
2139///         typedef-name
2140///
2141void 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!")__builtin_unreachable();
default:
  llvm_unreachable("Not a simple-type-specifier token!")__builtin_unreachable();

// 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;
2244#define GENERIC_IMAGE_TYPE(ImgType, Id)                                        \
case tok::kw_##ImgType##_t:                                                  \
  DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, DiagID,     \
                     Policy);                                                \
  break;
2249#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);
2265}

2267/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
2268/// [dcl.name]), which is a non-empty sequence of type-specifiers,
2269/// e.g., "const short int". Note that the DeclSpec is *not* finished
2270/// by parsing the type-specifier-seq, because these sequences are
2271/// typically followed by some form of declarator. Returns true and
2272/// emits diagnostics if this is not a type-specifier-seq, false
2273/// otherwise.
2274///
2275///   type-specifier-seq: [C++ 8.1]
2276///     type-specifier type-specifier-seq[opt]
2277///
2278bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_type_specifier);
DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
return false;
2282}

2284/// Finish parsing a C++ unqualified-id that is a template-id of
2285/// some form.
2286///
2287/// This routine is invoked when a '<' is encountered after an identifier or
2288/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
2289/// whether the unqualified-id is actually a template-id. This routine will
2290/// then parse the template arguments and form the appropriate template-id to
2291/// return to the caller.
2292///
2293/// \param SS the nested-name-specifier that precedes this template-id, if
2294/// we're actually parsing a qualified-id.
2295///
2296/// \param ObjectType if this unqualified-id occurs within a member access
2297/// expression, the type of the base object whose member is being accessed.
2298///
2299/// \param ObjectHadErrors this unqualified-id occurs within a member access
2300/// expression, indicates whether the original subexpressions had any errors.
2301///
2302/// \param Name for constructor and destructor names, this is the actual
2303/// identifier that may be a template-name.
2304///
2305/// \param NameLoc the location of the class-name in a constructor or
2306/// destructor.
2307///
2308/// \param EnteringContext whether we're entering the scope of the
2309/// nested-name-specifier.
2310///
2311/// \param Id as input, describes the template-name or operator-function-id
2312/// that precedes the '<'. If template arguments were parsed successfully,
2313/// will be updated with the template-id.
2314///
2315/// \param AssumeTemplateId When true, this routine will assume that the name
2316/// refers to a template without performing name lookup to verify.
2317///
2318/// \returns true if a parse error occurred, false otherwise.
2319bool 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")((void)0);

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;
2472}

2474/// Parse an operator-function-id or conversion-function-id as part
2475/// of a C++ unqualified-id.
2476///
2477/// This routine is responsible only for parsing the operator-function-id or
2478/// conversion-function-id; it does not handle template arguments in any way.
2479///
2480/// \code
2481///       operator-function-id: [C++ 13.5]
2482///         'operator' operator
2483///
2484///       operator: one of
2485///            new   delete  new[]   delete[]
2486///            +     -    *  /    %  ^    &   |   ~
2487///            !     =    <  >    += -=   *=  /=  %=
2488///            ^=    &=   |= <<   >> >>= <<=  ==  !=
2489///            <=    >=   && ||   ++ --   ,   ->* ->
2490///            ()    []   <=>
2491///
2492///       conversion-function-id: [C++ 12.3.2]
2493///         operator conversion-type-id
2494///
2495///       conversion-type-id:
2496///         type-specifier-seq conversion-declarator[opt]
2497///
2498///       conversion-declarator:
2499///         ptr-operator conversion-declarator[opt]
2500/// \endcode
2501///
2502/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2503/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2504///
2505/// \param EnteringContext whether we are entering the scope of the
2506/// nested-name-specifier.
2507///
2508/// \param ObjectType if this unqualified-id occurs within a member access
2509/// expression, the type of the base object whose member is being accessed.
2510///
2511/// \param Result on a successful parse, contains the parsed unqualified-id.
2512///
2513/// \returns true if parsing fails, false otherwise.
2514bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
                                      ParsedType ObjectType,
                                      UnqualifiedId &Result) {
assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword")((void)0);

// 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;
  }

2551#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
  case tok::Token:                                                     \
    SymbolLocations[SymbolIdx++] = ConsumeToken();                     \
    Op = OO_##Name;                                                    \
    break;
2556#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2557#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: {
    // Don't try to parse any further.
    cutOffParsing();
    // Code completion for the operator name.
    Actions.CodeCompleteOperatorName(getCurScope());
    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.
  bool IsUDSuffix = !Literal.getUDSuffix().empty();
  IdentifierInfo *II = nullptr;
  SourceLocation SuffixLoc;
  if (IsUDSuffix) {
    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, IsUDSuffix);
}

// 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;
2712}

2714/// Parse a C++ unqualified-id (or a C identifier), which describes the
2715/// name of an entity.
2716///
2717/// \code
2718///       unqualified-id: [C++ expr.prim.general]
2719///         identifier
2720///         operator-function-id
2721///         conversion-function-id
2722/// [C++0x] literal-operator-id [TODO]
2723///         ~ class-name
2724///         template-id
2725///
2726/// \endcode
2727///
2728/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2729/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2730///
2731/// \param ObjectType if this unqualified-id occurs within a member access
2732/// expression, the type of the base object whose member is being accessed.
2733///
2734/// \param ObjectHadErrors if this unqualified-id occurs within a member access
2735/// expression, indicates whether the original subexpressions had any errors.
2736/// When true, diagnostics for missing 'template' keyword will be supressed.
2737///
2738/// \param EnteringContext whether we are entering the scope of the
2739/// nested-name-specifier.
2740///
2741/// \param AllowDestructorName whether we allow parsing of a destructor name.
2742///
2743/// \param AllowConstructorName whether we allow parsing a constructor name.
2744///
2745/// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2746///
2747/// \param Result on a successful parse, contains the parsed unqualified-id.
2748///
2749/// \returns true if parsing fails, false otherwise.
2750bool 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;
3015}

3017/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
3018/// memory in a typesafe manner and call constructors.
3019///
3020/// This method is called to parse the new expression after the optional :: has
3021/// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
3022/// is its location.  Otherwise, "Start" is the location of the 'new' token.
3023///
3024///        new-expression:
3025///                   '::'[opt] 'new' new-placement[opt] new-type-id
3026///                                     new-initializer[opt]
3027///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3028///                                     new-initializer[opt]
3029///
3030///        new-placement:
3031///                   '(' expression-list ')'
3032///
3033///        new-type-id:
3034///                   type-specifier-seq new-declarator[opt]
3035/// [GNU]             attributes type-specifier-seq new-declarator[opt]
3036///
3037///        new-declarator:
3038///                   ptr-operator new-declarator[opt]
3039///                   direct-new-declarator
3040///
3041///        new-initializer:
3042///                   '(' expression-list[opt] ')'
3043/// [C++0x]           braced-init-list
3044///
3045ExprResult
3046Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
assert(Tok.is(tok::kw_new) && "expected 'new' token")((void)0);
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());
3173}

3175/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
3176/// passed to ParseDeclaratorInternal.
3177///
3178///        direct-new-declarator:
3179///                   '[' expression[opt] ']'
3180///                   direct-new-declarator '[' constant-expression ']'
3181///
3182void 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;
}
3218}

3220/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
3221/// This ambiguity appears in the syntax of the C++ new operator.
3222///
3223///        new-expression:
3224///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3225///                                     new-initializer[opt]
3226///
3227///        new-placement:
3228///                   '(' expression-list ')'
3229///
3230bool 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);
3245}

3247/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
3248/// to free memory allocated by new.
3249///
3250/// This method is called to parse the 'delete' expression after the optional
3251/// '::' has been already parsed.  If the '::' was present, "UseGlobal" is true
3252/// and "Start" is its location.  Otherwise, "Start" is the location of the
3253/// 'delete' token.
3254///
3255///        delete-expression:
3256///                   '::'[opt] 'delete' cast-expression
3257///                   '::'[opt] 'delete' '[' ']' cast-expression
3258ExprResult
3259Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword")((void)0);
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());
3339}

3341/// ParseRequiresExpression - Parse a C++2a requires-expression.
3342/// C++2a [expr.prim.req]p1
3343///     A requires-expression provides a concise way to express requirements on
3344///     template arguments. A requirement is one that can be checked by name
3345///     lookup (6.4) or by checking properties of types and expressions.
3346///
3347///     requires-expression:
3348///         'requires' requirement-parameter-list[opt] requirement-body
3349///
3350///     requirement-parameter-list:
3351///         '(' parameter-declaration-clause[opt] ')'
3352///
3353///     requirement-body:
3354///         '{' requirement-seq '}'
3355///
3356///     requirement-seq:
3357///         requirement
3358///         requirement-seq requirement
3359///
3360///     requirement:
3361///         simple-requirement
3362///         type-requirement
3363///         compound-requirement
3364///         nested-requirement
3365ExprResult Parser::ParseRequiresExpression() {
assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword")((void)0);
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());
3643}

3645static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
switch (kind) {
default: llvm_unreachable("Not a known type trait")__builtin_unreachable();
3648#define TYPE_TRAIT_1(Spelling, Name, Key) \
3649case tok::kw_ ## Spelling: return UTT_ ## Name;
3650#define TYPE_TRAIT_2(Spelling, Name, Key) \
3651case tok::kw_ ## Spelling: return BTT_ ## Name;
3652#include "clang/Basic/TokenKinds.def"
3653#define TYPE_TRAIT_N(Spelling, Name, Key) \
case tok::kw_ ## Spelling: return TT_ ## Name;
3655#include "clang/Basic/TokenKinds.def"
}
3657}

3659static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
switch (kind) {
default:
  llvm_unreachable("Not a known array type trait")__builtin_unreachable();
3663#define ARRAY_TYPE_TRAIT(Spelling, Name, Key)                                  \
case tok::kw_##Spelling:                                                     \
  return ATT_##Name;
3666#include "clang/Basic/TokenKinds.def"
}
3668}

3670static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
switch (kind) {
default:
  llvm_unreachable("Not a known unary expression trait.")__builtin_unreachable();
3674#define EXPRESSION_TRAIT(Spelling, Name, Key)                                  \
case tok::kw_##Spelling:                                                     \
  return ET_##Name;
3677#include "clang/Basic/TokenKinds.def"
}
3679}

3681static unsigned TypeTraitArity(tok::TokenKind kind) {
switch (kind) {
  default: llvm_unreachable("Not a known type trait")__builtin_unreachable();
3684#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
3685#include "clang/Basic/TokenKinds.def"
}
3687}

3689/// Parse the built-in type-trait pseudo-functions that allow
3690/// implementation of the TR1/C++11 type traits templates.
3691///
3692///       primary-expression:
3693///          unary-type-trait '(' type-id ')'
3694///          binary-type-trait '(' type-id ',' type-id ')'
3695///          type-trait '(' type-id-seq ')'
3696///
3697///       type-id-seq:
3698///          type-id ...[opt] type-id-seq[opt]
3699///
3700ExprResult 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);
3750}

3752/// ParseArrayTypeTrait - Parse the built-in array type-trait
3753/// pseudo-functions.
3754///
3755///       primary-expression:
3756/// [Embarcadero]     '__array_rank' '(' type-id ')'
3757/// [Embarcadero]     '__array_extent' '(' type-id ',' expression ')'
3758///
3759ExprResult 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!")__builtin_unreachable();
3794}

3796/// ParseExpressionTrait - Parse built-in expression-trait
3797/// pseudo-functions like __is_lvalue_expr( xxx ).
3798///
3799///       primary-expression:
3800/// [Embarcadero]     expression-trait '(' expression ')'
3801///
3802ExprResult 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());
3816}


3819/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3820/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3821/// based on the context past the parens.
3822ExprResult
3823Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
                                       ParsedType &CastTy,
                                       BalancedDelimiterTracker &Tracker,
                                       ColonProtectionRAIIObject &ColonProt) {
assert(getLangOpts().CPlusPlus && "Should only be called for C++!")((void)0);
assert(ExprType == CastExpr && "Compound literals are not ambiguous!")((void)0);
assert(isTypeIdInParens() && "Not a type-id!")((void)0);

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())((void)0);
  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)((void)0);

  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)((void)0);

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())((void)0);
  ConsumeAnyToken();
  return ExprError();
}

Tracker.consumeClose();
// Consume EOF marker for Toks buffer.
assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())((void)0);
ConsumeAnyToken();
return Result;
3971}

3973/// Parse a __builtin_bit_cast(T, E).
3974ExprResult 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());
4005}

←

/usr/src/gnu/usr.bin/clang/libclangParse/../../../llvm/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.
SourceLocation::UIntTy 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.
SourceLocation::UIntTy 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; }
9
←
Assuming 'K' is not equal to field 'Kind'→
10
←
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")((void)0);
  return UintData;
}

void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
void setLength(unsigned Len) {
  assert(!isAnnotation() && "Annotation tokens have no length field")((void)0);
  UintData = Len;
}

SourceLocation getAnnotationEndLoc() const {
  assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((void)0);
  return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
}
void setAnnotationEndLoc(SourceLocation L) {
  assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((void)0);
  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) &&((void)0)
         "getIdentifierInfo() on a tok::raw_identifier token!")((void)0);
  assert(!isAnnotation() &&((void)0)
         "getIdentifierInfo() on an annotation token!")((void)0);
  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))((void)0);
  return reinterpret_cast<const void *>(PtrData);
}
void setEofData(const void *D) {
  assert(is(tok::eof))((void)0);
  assert(!PtrData)((void)0);
  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))((void)0);
  return StringRef(reinterpret_cast<const char *>(PtrData), getLength());
}
void setRawIdentifierData(const char *Ptr) {
  assert(is(tok::raw_identifier))((void)0);
  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")((void)0);
  return reinterpret_cast<const char*>(PtrData);
}
void setLiteralData(const char *Ptr) {
  assert(isLiteral() && "Cannot set literal data of non-literal")((void)0);
  PtrData = const_cast<char*>(Ptr);
}

void *getAnnotationValue() const {
  assert(isAnnotation() && "Used AnnotVal on non-annotation token")((void)0);
  return PtrData;
}
void setAnnotationValue(void *val) {
  assert(isAnnotation() && "Used AnnotVal on non-annotation token")((void)0);
  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