/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp

Bug Summary

File:	tools/clang/lib/Parse/ParseExprCXX.cpp
Warning:	line 1775, column 5 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ParseExprCXX.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/tools/clang/lib/Parse -I /build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse -I /build/llvm-toolchain-snapshot-7~svn326551/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326551/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/tools/clang/lib/Parse -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-03-02-155150-1477-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp
1//===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expression parsing implementation for C++.
11//
12//===----------------------------------------------------------------------===//
13#include "clang/Parse/Parser.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/DeclTemplate.h"
16#include "clang/Basic/PrettyStackTrace.h"
17#include "clang/Lex/LiteralSupport.h"
18#include "clang/Parse/ParseDiagnostic.h"
19#include "clang/Parse/RAIIObjectsForParser.h"
20#include "clang/Sema/DeclSpec.h"
21#include "clang/Sema/ParsedTemplate.h"
22#include "clang/Sema/Scope.h"
23#include "llvm/Support/ErrorHandling.h"


26using namespace clang;

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

42// Are the two tokens adjacent in the same source file?
43bool 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());
48}

50// Suggest fixit for "<::" after a cast.
51static 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);
if (!AtDigraph)
  PP.EnterToken(DigraphToken);
76}

78// Check for '<::' which should be '< ::' instead of '[:' when following
79// a template name.
80void 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);
101}

103/// \brief Parse global scope or nested-name-specifier if present.
104///
105/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
106/// may be preceded by '::'). Note that this routine will not parse ::new or
107/// ::delete; it will just leave them in the token stream.
108///
109///       '::'[opt] nested-name-specifier
110///       '::'
111///
112///       nested-name-specifier:
113///         type-name '::'
114///         namespace-name '::'
115///         nested-name-specifier identifier '::'
116///         nested-name-specifier 'template'[opt] simple-template-id '::'
117///
118///
119/// \param SS the scope specifier that will be set to the parsed
120/// nested-name-specifier (or empty)
121///
122/// \param ObjectType if this nested-name-specifier is being parsed following
123/// the "." or "->" of a member access expression, this parameter provides the
124/// type of the object whose members are being accessed.
125///
126/// \param EnteringContext whether we will be entering into the context of
127/// the nested-name-specifier after parsing it.
128///
129/// \param MayBePseudoDestructor When non-NULL, points to a flag that
130/// indicates whether this nested-name-specifier may be part of a
131/// pseudo-destructor name. In this case, the flag will be set false
132/// if we don't actually end up parsing a destructor name. Moreorover,
133/// if we do end up determining that we are parsing a destructor name,
134/// the last component of the nested-name-specifier is not parsed as
135/// part of the scope specifier.
136///
137/// \param IsTypename If \c true, this nested-name-specifier is known to be
138/// part of a type name. This is used to improve error recovery.
139///
140/// \param LastII When non-NULL, points to an IdentifierInfo* that will be
141/// filled in with the leading identifier in the last component of the
142/// nested-name-specifier, if any.
143///
144/// \param OnlyNamespace If true, only considers namespaces in lookup.
145///
146/// \returns true if there was an error parsing a scope specifier
147bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
                                          ParsedType ObjectType,
                                          bool EnteringContext,
                                          bool *MayBePseudoDestructor,
                                          bool IsTypename,
                                          IdentifierInfo **LastII,
                                          bool OnlyNamespace) {
assert(getLangOpts().CPlusPlus &&(static_cast <bool> (getLangOpts().CPlusPlus &&
 "Call sites of this function should be guarded by checking for C++"
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Call sites of this function should be guarded by checking for C++\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 155, __extension__ __PRETTY_FUNCTION__))
       "Call sites of this function should be guarded by checking for C++")(static_cast <bool> (getLangOpts().CPlusPlus &&
 "Call sites of this function should be guarded by checking for C++"
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Call sites of this function should be guarded by checking for C++\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 155, __extension__ __PRETTY_FUNCTION__));

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

if (Tok.is(tok::annot_template_id)) {
  // If the current token is an annotated template id, it may already have
  // a scope specifier. Restore it.
  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
  SS = TemplateId->SS;
}

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

while (true) {
  if (HasScopeSpecifier) {
    // 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;

    if (Tok.is(tok::code_completion)) {
      // Code completion for a nested-name-specifier, where the code
      // completion token follows the '::'.
      Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext);
      // Include code completion token into the range of the scope otherwise
      // when we try to annotate the scope tokens the dangling code completion
      // token will cause assertion in
      // Preprocessor::AnnotatePreviousCachedTokens.
      SS.setEndLoc(Tok.getLocation());
      cutOffParsing();
      return true;
    }
  }

  // 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;
    if (TemplateNameKind TNK = Actions.ActOnDependentTemplateName(
            getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
            EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
      if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
                                  TemplateName, false))
        return true;
    } else
      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!")(static_cast <bool> (Tok.is(tok::coloncolon) &&
 "NextToken() not working properly!") ? void (0) : __assert_fail
 ("Tok.is(tok::coloncolon) && \"NextToken() not working properly!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 351, __extension__ __PRETTY_FUNCTION__));
    SourceLocation CCLoc = ConsumeToken();

    HasScopeSpecifier = true;

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

    if (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) &&
        !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, IdInfo)) {
      *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);
        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) &&(static_cast <bool> (Tok.isOneOf(tok::coloncolon, tok::
colon) && "NextToken() not working properly!") ? void
 (0) : __assert_fail ("Tok.isOneOf(tok::coloncolon, tok::colon) && \"NextToken() not working properly!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 450, __extension__ __PRETTY_FUNCTION__))
           "NextToken() not working properly!")(static_cast <bool> (Tok.isOneOf(tok::coloncolon, tok::
colon) && "NextToken() not working properly!") ? void
 (0) : __assert_fail ("Tok.isOneOf(tok::coloncolon, tok::colon) && \"NextToken() not working properly!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 450, __extension__ __PRETTY_FUNCTION__));
    Token ColonColon = Tok;
    SourceLocation CCLoc = ConsumeToken();

    bool IsCorrectedToColon = false;
    bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
    if (Actions.ActOnCXXNestedNameSpecifier(
            getCurScope(), IdInfo, EnteringContext, SS, false,
            CorrectionFlagPtr, OnlyNamespace)) {
      // Identifier is not recognized as a nested name, but we can have
      // mistyped '::' instead of ':'.
      if (CorrectionFlagPtr && IsCorrectedToColon) {
        ColonColon.setKind(tok::colon);
        PP.EnterToken(Tok);
        PP.EnterToken(ColonColon);
        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)) {
      // 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.
      ConsumeToken();
      if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
                                  TemplateName, false))
        return true;
      continue;
    }

    if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) && 
        (IsTypename || IsTemplateArgumentList(1))) {
      // 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 ");

      if (TemplateNameKind TNK = Actions.ActOnDependentTemplateName(
              getCurScope(), SS, SourceLocation(), TemplateName, ObjectType,
              EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
        // Consume the identifier.
        ConsumeToken();
        if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
                                    TemplateName, false))
          return true;
      }
      else
        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 && Tok.is(tok::tilde))
  *MayBePseudoDestructor = true;

return false;
545}

547ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand,
                                         Token &Replacement) {
SourceLocation TemplateKWLoc;
UnqualifiedId Name;
if (ParseUnqualifiedId(SS,
                       /*EnteringContext=*/false,
                       /*AllowDestructorName=*/false,
                       /*AllowConstructorName=*/false,
                       /*AllowDeductionGuide=*/false,
                       /*ObjectType=*/nullptr, 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;

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

570/// ParseCXXIdExpression - Handle id-expression.
571///
572///       id-expression:
573///         unqualified-id
574///         qualified-id
575///
576///       qualified-id:
577///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
578///         '::' identifier
579///         '::' operator-function-id
580///         '::' template-id
581///
582/// NOTE: The standard specifies that, for qualified-id, the parser does not
583/// expect:
584///
585///   '::' conversion-function-id
586///   '::' '~' class-name
587///
588/// This may cause a slight inconsistency on diagnostics:
589///
590/// class C {};
591/// namespace A {}
592/// void f() {
593///   :: A :: ~ C(); // Some Sema error about using destructor with a
594///                  // namespace.
595///   :: ~ C(); // Some Parser error like 'unexpected ~'.
596/// }
597///
598/// We simplify the parser a bit and make it work like:
599///
600///       qualified-id:
601///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
602///         '::' unqualified-id
603///
604/// That way Sema can handle and report similar errors for namespaces and the
605/// global scope.
606///
607/// The isAddressOfOperand parameter indicates that this id-expression is a
608/// direct operand of the address-of operator. This is, besides member contexts,
609/// the only place where a qualified-id naming a non-static class member may
610/// appear.
611///
612ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
// qualified-id:
//   '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
//   '::' unqualified-id
//
CXXScopeSpec SS;
ParseOptionalCXXScopeSpecifier(SS, nullptr, /*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 "(static_cast <bool> (!Result.isUnset() && "Typo correction suggested a keyword replacement "
 "for a previous keyword suggestion") ? void (0) : __assert_fail
 ("!Result.isUnset() && \"Typo correction suggested a keyword replacement \" \"for a previous keyword suggestion\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 630, __extension__ __PRETTY_FUNCTION__))
                            "for a previous keyword suggestion")(static_cast <bool> (!Result.isUnset() && "Typo correction suggested a keyword replacement "
 "for a previous keyword suggestion") ? void (0) : __assert_fail
 ("!Result.isUnset() && \"Typo correction suggested a keyword replacement \" \"for a previous keyword suggestion\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 630, __extension__ __PRETTY_FUNCTION__));
return Result;
632}

634/// ParseLambdaExpression - Parse a C++11 lambda expression.
635///
636///       lambda-expression:
637///         lambda-introducer lambda-declarator[opt] compound-statement
638///
639///       lambda-introducer:
640///         '[' lambda-capture[opt] ']'
641///
642///       lambda-capture:
643///         capture-default
644///         capture-list
645///         capture-default ',' capture-list
646///
647///       capture-default:
648///         '&'
649///         '='
650///
651///       capture-list:
652///         capture
653///         capture-list ',' capture
654///
655///       capture:
656///         simple-capture
657///         init-capture     [C++1y]
658///
659///       simple-capture:
660///         identifier
661///         '&' identifier
662///         'this'
663///
664///       init-capture:      [C++1y]
665///         identifier initializer
666///         '&' identifier initializer
667///
668///       lambda-declarator:
669///         '(' parameter-declaration-clause ')' attribute-specifier[opt]
670///           'mutable'[opt] exception-specification[opt]
671///           trailing-return-type[opt]
672///
673ExprResult Parser::ParseLambdaExpression() {
// Parse lambda-introducer.
LambdaIntroducer Intro;
Optional<unsigned> DiagID = ParseLambdaIntroducer(Intro);
if (DiagID) {
  Diag(Tok, DiagID.getValue());
  SkipUntil(tok::r_square, StopAtSemi);
  SkipUntil(tok::l_brace, StopAtSemi);
  SkipUntil(tok::r_brace, StopAtSemi);
  return ExprError();
}

return ParseLambdaExpressionAfterIntroducer(Intro);
686}

688/// TryParseLambdaExpression - Use lookahead and potentially tentative
689/// parsing to determine if we are looking at a C++0x lambda expression, and parse
690/// it if we are.
691///
692/// If we are not looking at a lambda expression, returns ExprError().
693ExprResult Parser::TryParseLambdaExpression() {
assert(getLangOpts().CPlusPlus11(static_cast <bool> (getLangOpts().CPlusPlus11 &&
 Tok.is(tok::l_square) && "Not at the start of a possible lambda expression."
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 696, __extension__ __PRETTY_FUNCTION__))
       && Tok.is(tok::l_square)(static_cast <bool> (getLangOpts().CPlusPlus11 &&
 Tok.is(tok::l_square) && "Not at the start of a possible lambda expression."
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 696, __extension__ __PRETTY_FUNCTION__))
       && "Not at the start of a possible lambda expression.")(static_cast <bool> (getLangOpts().CPlusPlus11 &&
 Tok.is(tok::l_square) && "Not at the start of a possible lambda expression."
) ? void (0) : __assert_fail ("getLangOpts().CPlusPlus11 && Tok.is(tok::l_square) && \"Not at the start of a possible lambda expression.\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 696, __extension__ __PRETTY_FUNCTION__));

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

const Token After = GetLookAheadToken(2);
// If lookahead indicates this is a lambda...
if (Next.is(tok::r_square) ||     // []
    Next.is(tok::equal) ||        // [=
    (Next.is(tok::amp) &&         // [&] or [&,
     (After.is(tok::r_square) ||
      After.is(tok::comma))) ||
    (Next.is(tok::identifier) &&  // [identifier]
     After.is(tok::r_square))) {
  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.
// (TryParseLambdaIntroducer never produces any diagnostic output.)
LambdaIntroducer Intro;
if (TryParseLambdaIntroducer(Intro))
  return ExprEmpty();

return ParseLambdaExpressionAfterIntroducer(Intro);
731}

733/// \brief Parse a lambda introducer.
734/// \param Intro A LambdaIntroducer filled in with information about the
735///        contents of the lambda-introducer.
736/// \param SkippedInits If non-null, we are disambiguating between an Obj-C
737///        message send and a lambda expression. In this mode, we will
738///        sometimes skip the initializers for init-captures and not fully
739///        populate \p Intro. This flag will be set to \c true if we do so.
740/// \return A DiagnosticID if it hit something unexpected. The location for
741///         the diagnostic is that of the current token.
742Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
                                               bool *SkippedInits) {
typedef Optional<unsigned> DiagResult;

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

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

bool first = true;

// 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;
} else if (Tok.is(tok::equal)) {
  Intro.Default = LCD_ByCopy;
  Intro.DefaultLoc = ConsumeToken();
  first = false;
}

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().ObjC1 && Intro.Default == LCD_None &&
            !Intro.Captures.empty())) {
        Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 
                                             /*AfterAmpersand=*/false);
        cutOffParsing();
        break;
      }

      return DiagResult(diag::err_expected_comma_or_rsquare);
    }
    ConsumeToken();
  }

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

  first = false;
  
  // Parse capture.
  LambdaCaptureKind Kind = LCK_ByCopy;
  LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
  SourceLocation Loc;
  IdentifierInfo *Id = nullptr;
  SourceLocation EllipsisLoc;
  ExprResult Init;

  if (Tok.is(tok::star)) {
    Loc = ConsumeToken(); 
    if (Tok.is(tok::kw_this)) {
      ConsumeToken();     
      Kind = LCK_StarThis;      
    } else {
      return DiagResult(diag::err_expected_star_this_capture);
    }
  } else if (Tok.is(tok::kw_this)) {
    Kind = LCK_This;
    Loc = ConsumeToken();
  } else {
    if (Tok.is(tok::amp)) {
      Kind = LCK_ByRef;
      ConsumeToken();

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

    if (Tok.is(tok::identifier)) {
      Id = Tok.getIdentifierInfo();
      Loc = ConsumeToken();
    } else if (Tok.is(tok::kw_this)) {
      // FIXME: If we want to suggest a fixit here, will need to return more
      // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be
      // Clear()ed to prevent emission in case of tentative parsing?
      return DiagResult(diag::err_this_captured_by_reference);
    } else {
      return DiagResult(diag::err_expected_capture);
    }

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

      InitKind = LambdaCaptureInitKind::DirectInit;

      ExprVector Exprs;
      CommaLocsTy Commas;
      if (SkippedInits) {
        Parens.skipToEnd();
        *SkippedInits = true;
      } 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 (!SkippedInits) {
        Init = ParseInitializer();
      } else if (Tok.is(tok::l_brace)) {
        BalancedDelimiterTracker Braces(*this, tok::l_brace);
        Braces.consumeOpen();
        Braces.skipToEnd();
        *SkippedInits = true;
      } 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();
        }
      }
    } else
      TryConsumeToken(tok::ellipsis, EllipsisLoc);
  }
  // If this is an init capture, process the initialization expression
  // right away.  For lambda init-captures such as the following:
  // const int x = 10;
  //  auto L = [i = x+1](int a) {
  //    return [j = x+2,
  //           &k = x](char b) { };
  //  };
  // keep in mind that each lambda init-capture has to have:
  //  - its initialization expression executed in the context
  //    of the enclosing/parent decl-context.
  //  - but the variable itself has to be 'injected' into the
  //    decl-context of its lambda's call-operator (which has
  //    not yet been created).
  // Each init-expression is a full-expression that has to get
  // Sema-analyzed (for capturing etc.) before its lambda's
  // call-operator's decl-context, scope & scopeinfo are pushed on their
  // respective stacks.  Thus if any variable is odr-used in the init-capture
  // it will correctly get captured in the enclosing lambda, if one exists.
  // The init-variables above are created later once the lambdascope and
  // call-operators decl-context is pushed onto its respective stack.

  // Since the lambda init-capture's initializer expression occurs in the
  // context of the enclosing function or lambda, therefore we can not wait
  // till a lambda scope has been pushed on before deciding whether the
  // variable needs to be captured.  We also need to process all
  // lvalue-to-rvalue conversions and discarded-value conversions,
  // so that we can avoid capturing certain constant variables.
  // For e.g.,
  //  void test() {
  //   const int x = 10;
  //   auto L = [&z = x](char a) { <-- don't capture by the current lambda
  //     return [y = x](int i) { <-- don't capture by enclosing lambda
  //          return y;
  //     }
  //   };
  // }
  // If x was not const, the second use would require 'L' to capture, and
  // that would be an error.

  ParsedType InitCaptureType;
  if (!Init.isInvalid())
    Init = Actions.CorrectDelayedTyposInExpr(Init.get());
  if (Init.isUsable()) {
    // 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, Id, InitKind, InitExpr);
    Init = InitExpr;
  }
  Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
                   InitCaptureType);
}

T.consumeClose();
Intro.Range.setEnd(T.getCloseLocation());
return DiagResult();
988}

990/// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
991///
992/// Returns true if it hit something unexpected.
993bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
{
  bool SkippedInits = false;
  TentativeParsingAction PA1(*this);

  if (ParseLambdaIntroducer(Intro, &SkippedInits)) {
    PA1.Revert();
    return true;
  }

  if (!SkippedInits) {
    PA1.Commit();
    return false;
  }

  PA1.Revert();
}

// Try to parse it again, but this time parse the init-captures too.
Intro = LambdaIntroducer();
TentativeParsingAction PA2(*this);

if (!ParseLambdaIntroducer(Intro)) {
  PA2.Commit();
  return false;
}

PA2.Revert();
return true;
1022}

1024static void
1025tryConsumeMutableOrConstexprToken(Parser &P, SourceLocation &MutableLoc,
                                SourceLocation &ConstexprLoc,
                                SourceLocation &DeclEndLoc) {
assert(MutableLoc.isInvalid())(static_cast <bool> (MutableLoc.isInvalid()) ? void (0)
 : __assert_fail ("MutableLoc.isInvalid()", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1028, __extension__ __PRETTY_FUNCTION__));
assert(ConstexprLoc.isInvalid())(static_cast <bool> (ConstexprLoc.isInvalid()) ? void (
0) : __assert_fail ("ConstexprLoc.isInvalid()", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1029, __extension__ __PRETTY_FUNCTION__));
// Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
// to the final of those locations. Emit an error if we have multiple
// copies of those keywords and recover.

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

1061static void
1062addConstexprToLambdaDeclSpecifier(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(ConstexprLoc, PrevSpec, DiagID);
  assert(PrevSpec == nullptr && DiagID == 0 &&(static_cast <bool> (PrevSpec == nullptr && DiagID
 == 0 && "Constexpr cannot have been set previously!"
) ? void (0) : __assert_fail ("PrevSpec == nullptr && DiagID == 0 && \"Constexpr cannot have been set previously!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1072, __extension__ __PRETTY_FUNCTION__))
         "Constexpr cannot have been set previously!")(static_cast <bool> (PrevSpec == nullptr && DiagID
 == 0 && "Constexpr cannot have been set previously!"
) ? void (0) : __assert_fail ("PrevSpec == nullptr && DiagID == 0 && \"Constexpr cannot have been set previously!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1072, __extension__ __PRETTY_FUNCTION__));
}
1074}

1076/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1077/// expression.
1078ExprResult 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::LambdaExprContext);
TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
Actions.PushLambdaScope();

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

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

TypeResult TrailingReturnType;
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(TemplateParameterDepth);
    ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
    // For a generic lambda, each 'auto' within the parameter declaration 
    // clause creates a template type parameter, so increment the depth.
    if (Actions.getCurGenericLambda()) 
      ++CurTemplateDepthTracker;
  }
  T.consumeClose();
  SourceLocation RParenLoc = T.getCloseLocation();
  SourceLocation DeclEndLoc = RParenLoc;

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

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

  // Parse mutable-opt and/or constexpr-opt, and update the DeclEndLoc.
  SourceLocation MutableLoc;
  SourceLocation ConstexprLoc;
  tryConsumeMutableOrConstexprToken(*this, MutableLoc, ConstexprLoc,
                                    DeclEndLoc);
  
  addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, 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);

  SourceLocation FunLocalRangeEnd = DeclEndLoc;

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

  PrototypeScope.Exit();

  WarnIfHasCUDATargetAttr();

  SourceLocation NoLoc;
  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
                                         /*isAmbiguous=*/false,
                                         LParenLoc,
                                         ParamInfo.data(), ParamInfo.size(),
                                         EllipsisLoc, RParenLoc,
                                         DS.getTypeQualifiers(),
                                         /*RefQualifierIsLValueRef=*/true,
                                         /*RefQualifierLoc=*/NoLoc,
                                         /*ConstQualifierLoc=*/NoLoc,
                                         /*VolatileQualifierLoc=*/NoLoc,
                                         /*RestrictQualifierLoc=*/NoLoc,
                                         MutableLoc,
                                         ESpecType, ESpecRange,
                                         DynamicExceptions.data(),
                                         DynamicExceptionRanges.data(),
                                         DynamicExceptions.size(),
                                         NoexceptExpr.isUsable() ?
                                           NoexceptExpr.get() : nullptr,
                                         /*ExceptionSpecTokens*/nullptr,
                                         /*DeclsInPrototype=*/None,
                                         LParenLoc, FunLocalRangeEnd, D,
                                         TrailingReturnType),
                Attr, DeclEndLoc);
} else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
                       tok::kw_constexpr) ||
           (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
  // It's common to forget that one needs '()' before 'mutable', an attribute
  // specifier, or the result type. Deal with this.
  unsigned TokKind = 0;
  switch (Tok.getKind()) {
  case tok::kw_mutable: TokKind = 0; break;
  case tok::arrow: TokKind = 1; break;
  case tok::kw___attribute:
  case tok::l_square: TokKind = 2; break;
  case tok::kw_constexpr: TokKind = 3; break;
  default: llvm_unreachable("Unknown token kind")::llvm::llvm_unreachable_internal("Unknown token kind", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1232);
  }

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

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

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

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

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

  WarnIfHasCUDATargetAttr();

  SourceLocation NoLoc;
  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
                                             /*isAmbiguous=*/false,
                                             /*LParenLoc=*/NoLoc,
                                             /*Params=*/nullptr,
                                             /*NumParams=*/0,
                                             /*EllipsisLoc=*/NoLoc,
                                             /*RParenLoc=*/NoLoc,
                                             /*TypeQuals=*/0,
                                             /*RefQualifierIsLValueRef=*/true,
                                             /*RefQualifierLoc=*/NoLoc,
                                             /*ConstQualifierLoc=*/NoLoc,
                                             /*VolatileQualifierLoc=*/NoLoc,
                                             /*RestrictQualifierLoc=*/NoLoc,
                                             MutableLoc,
                                             EST_None,
                                             /*ESpecRange=*/SourceRange(),
                                             /*Exceptions=*/nullptr,
                                             /*ExceptionRanges=*/nullptr,
                                             /*NumExceptions=*/0,
                                             /*NoexceptExpr=*/nullptr,
                                             /*ExceptionSpecTokens=*/nullptr,
                                             /*DeclsInPrototype=*/None,
                                             DeclLoc, DeclEndLoc, D,
                                             TrailingReturnType),
                Attr, DeclEndLoc);
}

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

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

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

1318/// ParseCXXCasts - This handles the various ways to cast expressions to another
1319/// type.
1320///
1321///       postfix-expression: [C++ 5.2p1]
1322///         'dynamic_cast' '<' type-name '>' '(' expression ')'
1323///         'static_cast' '<' type-name '>' '(' expression ')'
1324///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
1325///         'const_cast' '<' type-name '>' '(' expression ')'
1326///
1327ExprResult Parser::ParseCXXCasts() {
tok::TokenKind Kind = Tok.getKind();
const char *CastName = nullptr; // For error messages

switch (Kind) {
default: llvm_unreachable("Unknown C++ cast!")::llvm::llvm_unreachable_internal("Unknown C++ cast!", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1332);
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::TypeNameContext);
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;
1384}

1386/// ParseCXXTypeid - This handles the C++ typeid expression.
1387///
1388///       postfix-expression: [C++ 5.2p1]
1389///         'typeid' '(' expression ')'
1390///         'typeid' '(' type-id ')'
1391///
1392ExprResult Parser::ParseCXXTypeid() {
assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!")(static_cast <bool> (Tok.is(tok::kw_typeid) && "Not 'typeid'!"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_typeid) && \"Not 'typeid'!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1393, __extension__ __PRETTY_FUNCTION__));

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

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

ExprResult Result;

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

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

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

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

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

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

return Result;
1452}

1454/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1455///
1456///         '__uuidof' '(' expression ')'
1457///         '__uuidof' '(' type-id ')'
1458///
1459ExprResult Parser::ParseCXXUuidof() {
assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!")(static_cast <bool> (Tok.is(tok::kw___uuidof) &&
 "Not '__uuidof'!") ? void (0) : __assert_fail ("Tok.is(tok::kw___uuidof) && \"Not '__uuidof'!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1460, __extension__ __PRETTY_FUNCTION__));

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

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

ExprResult Result;

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

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

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

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

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

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

return Result;
1501}

1503/// \brief Parse a C++ pseudo-destructor expression after the base,
1504/// . or -> operator, and nested-name-specifier have already been
1505/// parsed.
1506///
1507///       postfix-expression: [C++ 5.2]
1508///         postfix-expression . pseudo-destructor-name
1509///         postfix-expression -> pseudo-destructor-name
1510///
1511///       pseudo-destructor-name: 
1512///         ::[opt] nested-name-specifier[opt] type-name :: ~type-name 
1513///         ::[opt] nested-name-specifier template simple-template-id :: 
1514///                 ~type-name 
1515///         ::[opt] nested-name-specifier[opt] ~type-name
1516///       
1517ExprResult 
1518Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
                               tok::TokenKind OpKind,
                               CXXScopeSpec &SS,
                               ParsedType ObjectType) {
// We're parsing either a pseudo-destructor-name or a dependent
// member access that has the same form as a
// pseudo-destructor-name. We parse both in the same way and let
// the action model sort them out.
//
// Note that the ::[opt] nested-name-specifier[opt] has already
// been parsed, and if there was a simple-template-id, it has
// been coalesced into a template-id annotation token.
UnqualifiedId FirstTypeName;
SourceLocation CCLoc;
if (Tok.is(tok::identifier)) {
  FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
  ConsumeToken();
  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail")(static_cast <bool> (Tok.is(tok::coloncolon) &&
"ParseOptionalCXXScopeSpecifier fail") ? void (0) : __assert_fail
 ("Tok.is(tok::coloncolon) &&\"ParseOptionalCXXScopeSpecifier fail\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1535, __extension__ __PRETTY_FUNCTION__));
  CCLoc = ConsumeToken();
} else if (Tok.is(tok::annot_template_id)) {
  // FIXME: retrieve TemplateKWLoc from template-id annotation and
  // store it in the pseudo-dtor node (to be used when instantiating it).
  FirstTypeName.setTemplateId(
                            (TemplateIdAnnotation *)Tok.getAnnotationValue());
  ConsumeAnnotationToken();
  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail")(static_cast <bool> (Tok.is(tok::coloncolon) &&
"ParseOptionalCXXScopeSpecifier fail") ? void (0) : __assert_fail
 ("Tok.is(tok::coloncolon) &&\"ParseOptionalCXXScopeSpecifier fail\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1543, __extension__ __PRETTY_FUNCTION__));
  CCLoc = ConsumeToken();
} else {
  FirstTypeName.setIdentifier(nullptr, SourceLocation());
}

// Parse the tilde.
assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail")(static_cast <bool> (Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail"
) ? void (0) : __assert_fail ("Tok.is(tok::tilde) && \"ParseOptionalCXXScopeSpecifier fail\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1550, __extension__ __PRETTY_FUNCTION__));
SourceLocation TildeLoc = ConsumeToken();

if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
  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.
if (Tok.is(tok::less) &&
    ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
                                 Name, NameLoc,
                                 false, ObjectType, SecondTypeName,
                                 /*AssumeTemplateName=*/true))
  return ExprError();

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

1587/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1588///
1589///       boolean-literal: [C++ 2.13.5]
1590///         'true'
1591///         'false'
1592ExprResult Parser::ParseCXXBoolLiteral() {
tok::TokenKind Kind = Tok.getKind();
return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1595}

1597/// ParseThrowExpression - This handles the C++ throw expression.
1598///
1599///       throw-expression: [C++ 15]
1600///         'throw' assignment-expression[opt]
1601ExprResult Parser::ParseThrowExpression() {
assert(Tok.is(tok::kw_throw) && "Not throw!")(static_cast <bool> (Tok.is(tok::kw_throw) && "Not throw!"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_throw) && \"Not throw!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1602, __extension__ __PRETTY_FUNCTION__));
SourceLocation ThrowLoc = ConsumeToken();           // Eat the throw token.

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

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

1624/// \brief Parse the C++ Coroutines co_yield expression.
1625///
1626///       co_yield-expression:
1627///         'co_yield' assignment-expression[opt]
1628ExprResult Parser::ParseCoyieldExpression() {
assert(Tok.is(tok::kw_co_yield) && "Not co_yield!")(static_cast <bool> (Tok.is(tok::kw_co_yield) &&
 "Not co_yield!") ? void (0) : __assert_fail ("Tok.is(tok::kw_co_yield) && \"Not co_yield!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1629, __extension__ __PRETTY_FUNCTION__));

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

1639/// ParseCXXThis - This handles the C++ 'this' pointer.
1640///
1641/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1642/// a non-lvalue expression whose value is the address of the object for which
1643/// the function is called.
1644ExprResult Parser::ParseCXXThis() {
assert(Tok.is(tok::kw_this) && "Not 'this'!")(static_cast <bool> (Tok.is(tok::kw_this) && "Not 'this'!"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_this) && \"Not 'this'!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1645, __extension__ __PRETTY_FUNCTION__));
SourceLocation ThisLoc = ConsumeToken();
return Actions.ActOnCXXThis(ThisLoc);
1648}

1650/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1651/// Can be interpreted either as function-style casting ("int(x)")
1652/// or class type construction ("ClassType(x,y,z)")
1653/// or creation of a value-initialized type ("int()").
1654/// See [C++ 5.2.3].
1655///
1656///       postfix-expression: [C++ 5.2p1]
1657///         simple-type-specifier '(' expression-list[opt] ')'
1658/// [C++0x] simple-type-specifier braced-init-list
1659///         typename-specifier '(' expression-list[opt] ')'
1660/// [C++0x] typename-specifier braced-init-list
1661///
1662/// In C++1z onwards, the type specifier can also be a template-name.
1663ExprResult
1664Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCastContext);
ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();

assert((Tok.is(tok::l_paren) ||(static_cast <bool> ((Tok.is(tok::l_paren) || (getLangOpts
().CPlusPlus11 && Tok.is(tok::l_brace))) && "Expected '(' or '{'!"
) ? void (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1670, __extension__ __PRETTY_FUNCTION__))
        (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))(static_cast <bool> ((Tok.is(tok::l_paren) || (getLangOpts
().CPlusPlus11 && Tok.is(tok::l_brace))) && "Expected '(' or '{'!"
) ? void (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1670, __extension__ __PRETTY_FUNCTION__))
       && "Expected '(' or '{'!")(static_cast <bool> ((Tok.is(tok::l_paren) || (getLangOpts
().CPlusPlus11 && Tok.is(tok::l_brace))) && "Expected '(' or '{'!"
) ? void (0) : __assert_fail ("(Tok.is(tok::l_paren) || (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) && \"Expected '(' or '{'!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1670, __extension__ __PRETTY_FUNCTION__));

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

  ExprVector Exprs;
  CommaLocsTy CommaLocs;

  if (Tok.isNot(tok::r_paren)) {
    if (ParseExpressionList(Exprs, CommaLocs, [&] {
          Actions.CodeCompleteConstructor(getCurScope(),
                                    TypeRep.get()->getCanonicalTypeInternal(),
                                          DS.getLocEnd(), Exprs);
       })) {
      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())&&(static_cast <bool> ((Exprs.size() == 0 || Exprs.size()
-1 == CommaLocs.size())&& "Unexpected number of commas!"
) ? void (0) : __assert_fail ("(Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& \"Unexpected number of commas!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1706, __extension__ __PRETTY_FUNCTION__))
         "Unexpected number of commas!")(static_cast <bool> ((Exprs.size() == 0 || Exprs.size()
-1 == CommaLocs.size())&& "Unexpected number of commas!"
) ? void (0) : __assert_fail ("(Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&& \"Unexpected number of commas!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 1706, __extension__ __PRETTY_FUNCTION__));
  return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
                                           Exprs, T.getCloseLocation(),
                                           /*ListInitialization=*/false);
}
1711}

1713/// ParseCXXCondition - if/switch/while condition expression.
1714///
1715///       condition:
1716///         expression
1717///         type-specifier-seq declarator '=' assignment-expression
1718/// [C++11] type-specifier-seq declarator '=' initializer-clause
1719/// [C++11] type-specifier-seq declarator braced-init-list
1720/// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
1721///             brace-or-equal-initializer
1722/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1723///             '=' assignment-expression
1724///
1725/// In C++1z, a condition may in some contexts be preceded by an
1726/// optional init-statement. This function will parse that too.
1727///
1728/// \param InitStmt If non-null, an init-statement is permitted, and if present
1729/// will be parsed and stored here.
1730///
1731/// \param Loc The location of the start of the statement that requires this
1732/// condition, e.g., the "for" in a for loop.
1733///
1734/// \returns The parsed condition.
1735Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
                                              SourceLocation Loc,
                                              Sema::ConditionKind CK) {
if (Tok.is(tok::code_completion)) {
1
Taking false branch→
8
←
Taking false branch→
  Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
  cutOffParsing();
  return Sema::ConditionError();
}

ParsedAttributesWithRange attrs(AttrFactory);
MaybeParseCXX11Attributes(attrs);

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

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

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

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

case ConditionOrInitStatement::InitStmtDecl: {
  Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
3
←
Assuming the condition is false→
4
←
'?' condition is false→
10
←
Assuming the condition is false→
11
←
'?' condition is false→
                              ? diag::warn_cxx14_compat_init_statement
                              : diag::ext_init_statement)
      << (CK == Sema::ConditionKind::Switch);
5
←
Assuming 'CK' is equal to Switch→
  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
  DeclGroupPtrTy DG =
      ParseSimpleDeclaration(DeclaratorContext::InitStmtContext, DeclEnd,
                             attrs, /*RequireSemi=*/true);
  *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
12
←
Called C++ object pointer is null
  return ParseCXXCondition(nullptr, Loc, CK);
6
←
Passing null pointer value via 1st parameter 'InitStmt'→
7
←
Calling 'Parser::ParseCXXCondition'→
}

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

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

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

// simple-asm-expr[opt]
if (Tok.is(tok::kw_asm)) {
  SourceLocation Loc;
  ExprResult AsmLabel(ParseSimpleAsm(&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) {
  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);
1847}

1849/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1850/// This should only be called when the current token is known to be part of
1851/// simple-type-specifier.
1852///
1853///       simple-type-specifier:
1854///         '::'[opt] nested-name-specifier[opt] type-name
1855///         '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1856///         char
1857///         wchar_t
1858///         bool
1859///         short
1860///         int
1861///         long
1862///         signed
1863///         unsigned
1864///         float
1865///         double
1866///         void
1867/// [GNU]   typeof-specifier
1868/// [C++0x] auto               [TODO]
1869///
1870///       type-name:
1871///         class-name
1872///         enum-name
1873///         typedef-name
1874///
1875void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
DS.SetRangeStart(Tok.getLocation());
const char *PrevSpec;
unsigned DiagID;
SourceLocation Loc = Tok.getLocation();
const clang::PrintingPolicy &Policy =
    Actions.getASTContext().getPrintingPolicy();

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

// type-name
case tok::annot_typename: {
  if (getTypeAnnotation(Tok))
    DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
                       getTypeAnnotation(Tok), Policy);
  else
    DS.SetTypeSpecError();
  
  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
  ConsumeAnnotationToken();
  
  DS.Finish(Actions, Policy);
  return;
}

// builtin types
case tok::kw_short:
  DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_long:
  DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw___int64:
  DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy);
  break;
case tok::kw_signed:
  DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
  break;
case tok::kw_unsigned:
  DS.SetTypeSpecSign(DeclSpec::TSS_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_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_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;
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);
1974}

1976/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1977/// [dcl.name]), which is a non-empty sequence of type-specifiers,
1978/// e.g., "const short int". Note that the DeclSpec is *not* finished
1979/// by parsing the type-specifier-seq, because these sequences are
1980/// typically followed by some form of declarator. Returns true and
1981/// emits diagnostics if this is not a type-specifier-seq, false
1982/// otherwise.
1983///
1984///   type-specifier-seq: [C++ 8.1]
1985///     type-specifier type-specifier-seq[opt]
1986///
1987bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_type_specifier);
DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
return false;
1991}

1993/// \brief Finish parsing a C++ unqualified-id that is a template-id of
1994/// some form. 
1995///
1996/// This routine is invoked when a '<' is encountered after an identifier or
1997/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1998/// whether the unqualified-id is actually a template-id. This routine will
1999/// then parse the template arguments and form the appropriate template-id to
2000/// return to the caller.
2001///
2002/// \param SS the nested-name-specifier that precedes this template-id, if
2003/// we're actually parsing a qualified-id.
2004///
2005/// \param Name for constructor and destructor names, this is the actual
2006/// identifier that may be a template-name.
2007///
2008/// \param NameLoc the location of the class-name in a constructor or 
2009/// destructor.
2010///
2011/// \param EnteringContext whether we're entering the scope of the 
2012/// nested-name-specifier.
2013///
2014/// \param ObjectType if this unqualified-id occurs within a member access
2015/// expression, the type of the base object whose member is being accessed.
2016///
2017/// \param Id as input, describes the template-name or operator-function-id
2018/// that precedes the '<'. If template arguments were parsed successfully,
2019/// will be updated with the template-id.
2020/// 
2021/// \param AssumeTemplateId When true, this routine will assume that the name
2022/// refers to a template without performing name lookup to verify. 
2023///
2024/// \returns true if a parse error occurred, false otherwise.
2025bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
                                        SourceLocation TemplateKWLoc,
                                        IdentifierInfo *Name,
                                        SourceLocation NameLoc,
                                        bool EnteringContext,
                                        ParsedType ObjectType,
                                        UnqualifiedId &Id,
                                        bool AssumeTemplateId) {
assert((AssumeTemplateId || Tok.is(tok::less)) &&(static_cast <bool> ((AssumeTemplateId || Tok.is(tok::less
)) && "Expected '<' to finish parsing a template-id"
) ? void (0) : __assert_fail ("(AssumeTemplateId || Tok.is(tok::less)) && \"Expected '<' to finish parsing a template-id\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2034, __extension__ __PRETTY_FUNCTION__))
       "Expected '<' to finish parsing a template-id")(static_cast <bool> ((AssumeTemplateId || Tok.is(tok::less
)) && "Expected '<' to finish parsing a template-id"
) ? void (0) : __assert_fail ("(AssumeTemplateId || Tok.is(tok::less)) && \"Expected '<' to finish parsing a template-id\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2034, __extension__ __PRETTY_FUNCTION__));

TemplateTy Template;
TemplateNameKind TNK = TNK_Non_template;
switch (Id.getKind()) {
case UnqualifiedIdKind::IK_Identifier:
case UnqualifiedIdKind::IK_OperatorFunctionId:
case UnqualifiedIdKind::IK_LiteralOperatorId:
  if (AssumeTemplateId) {
    // We defer the injected-class-name checks until we've found whether
    // this template-id is used to form a nested-name-specifier or not.
    TNK = Actions.ActOnDependentTemplateName(
        getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
        Template, /*AllowInjectedClassName*/ true);
    if (TNK == TNK_Non_template)
      return true;
  } else {
    bool MemberOfUnknownSpecialization;
    TNK = Actions.isTemplateName(getCurScope(), SS,
                                 TemplateKWLoc.isValid(), Id,
                                 ObjectType, EnteringContext, Template,
                                 MemberOfUnknownSpecialization);
    
    if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
        ObjectType && IsTemplateArgumentList()) {
      // 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 = 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.ActOnDependentTemplateName(
          getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
          Template, /*AllowInjectedClassName*/ true);
      if (TNK == TNK_Non_template)
        return true;              
    }
  }
  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);
  break;
}
    
case UnqualifiedIdKind::IK_DestructorName: {
  UnqualifiedId TemplateName;
  bool MemberOfUnknownSpecialization;
  TemplateName.setIdentifier(Name, NameLoc);
  if (ObjectType) {
    TNK = Actions.ActOnDependentTemplateName(
        getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
        EnteringContext, Template, /*AllowInjectedClassName*/ true);
    if (TNK == TNK_Non_template)
      return 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();
      return true;        
    }
  }
  break;
}
    
default:
  return false;
}

if (TNK == TNK_Non_template)
  return false;

// Parse the enclosed template argument list.
SourceLocation LAngleLoc, RAngleLoc;
TemplateArgList TemplateArgs;
if (Tok.is(tok::less) && ParseTemplateIdAfterTemplateName(
                             true, LAngleLoc, TemplateArgs, RAngleLoc))
  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(
      SS, TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
      LAngleLoc, RAngleLoc, TemplateArgs, TemplateIds);

  Id.setTemplateId(TemplateId);
  return false;
}

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

// Constructor and destructor names.
TypeResult Type
  = Actions.ActOnTemplateIdType(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;
2176}

2178/// \brief Parse an operator-function-id or conversion-function-id as part
2179/// of a C++ unqualified-id.
2180///
2181/// This routine is responsible only for parsing the operator-function-id or
2182/// conversion-function-id; it does not handle template arguments in any way.
2183///
2184/// \code
2185///       operator-function-id: [C++ 13.5]
2186///         'operator' operator
2187///
2188///       operator: one of
2189///            new   delete  new[]   delete[]
2190///            +     -    *  /    %  ^    &   |   ~
2191///            !     =    <  >    += -=   *=  /=  %=
2192///            ^=    &=   |= <<   >> >>= <<=  ==  !=
2193///            <=    >=   && ||   ++ --   ,   ->* ->
2194///            ()    []   <=>
2195///
2196///       conversion-function-id: [C++ 12.3.2]
2197///         operator conversion-type-id
2198///
2199///       conversion-type-id:
2200///         type-specifier-seq conversion-declarator[opt]
2201///
2202///       conversion-declarator:
2203///         ptr-operator conversion-declarator[opt]
2204/// \endcode
2205///
2206/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2207/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2208///
2209/// \param EnteringContext whether we are entering the scope of the 
2210/// nested-name-specifier.
2211///
2212/// \param ObjectType if this unqualified-id occurs within a member access
2213/// expression, the type of the base object whose member is being accessed.
2214///
2215/// \param Result on a successful parse, contains the parsed unqualified-id.
2216///
2217/// \returns true if parsing fails, false otherwise.
2218bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
                                      ParsedType ObjectType,
                                      UnqualifiedId &Result) {
assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword")(static_cast <bool> (Tok.is(tok::kw_operator) &&
 "Expected 'operator' keyword") ? void (0) : __assert_fail ("Tok.is(tok::kw_operator) && \"Expected 'operator' keyword\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2221, __extension__ __PRETTY_FUNCTION__));

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

// Determine what kind of operator name we have.
unsigned SymbolIdx = 0;
SourceLocation SymbolLocations[3];
OverloadedOperatorKind Op = OO_None;
switch (Tok.getKind()) {
  case tok::kw_new:
  case tok::kw_delete: {
    bool isNew = Tok.getKind() == tok::kw_new;
    // Consume the 'new' or 'delete'.
    SymbolLocations[SymbolIdx++] = ConsumeToken();
    // Check for array new/delete.
    if (Tok.is(tok::l_square) &&
        (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
      // Consume the '[' and ']'.
      BalancedDelimiterTracker T(*this, tok::l_square);
      T.consumeOpen();
      T.consumeClose();
      if (T.getCloseLocation().isInvalid())
        return true;
      
      SymbolLocations[SymbolIdx++] = T.getOpenLocation();
      SymbolLocations[SymbolIdx++] = T.getCloseLocation();
      Op = isNew? OO_Array_New : OO_Array_Delete;
    } else {
      Op = isNew? OO_New : OO_Delete;
    }
    break;
  }
    
2255#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
  case tok::Token:                                                     \
    SymbolLocations[SymbolIdx++] = ConsumeToken();                     \
    Op = OO_##Name;                                                    \
    break;
2260#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2261#include "clang/Basic/OperatorKinds.def"
    
  case tok::l_paren: {
    // Consume the '(' and ')'.
    BalancedDelimiterTracker T(*this, tok::l_paren);
    T.consumeOpen();
    T.consumeClose();
    if (T.getCloseLocation().isInvalid())
      return true;
    
    SymbolLocations[SymbolIdx++] = T.getOpenLocation();
    SymbolLocations[SymbolIdx++] = T.getCloseLocation();
    Op = OO_Call;
    break;
  }
    
  case tok::l_square: {
    // Consume the '[' and ']'.
    BalancedDelimiterTracker T(*this, tok::l_square);
    T.consumeOpen();
    T.consumeClose();
    if (T.getCloseLocation().isInvalid())
      return true;
    
    SymbolLocations[SymbolIdx++] = T.getOpenLocation();
    SymbolLocations[SymbolIdx++] = T.getCloseLocation();
    Op = OO_Subscript;
    break;
  }
    
  case tok::code_completion: {
    // Code completion for the operator name.
    Actions.CodeCompleteOperatorName(getCurScope());
    cutOffParsing();      
    // Don't try to parse any further.
    return true;
  }
    
  default:
    break;
}

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

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

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

  SourceLocation DiagLoc;
  unsigned DiagId = 0;

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

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

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

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

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

  Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);

  return Actions.checkLiteralOperatorId(SS, Result);
}

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

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

// Parse the conversion-declarator, which is merely a sequence of
// ptr-operators.
Declarator D(DS, DeclaratorContext::ConversionIdContext);
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;  
2415}

2417/// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
2418/// name of an entity.
2419///
2420/// \code
2421///       unqualified-id: [C++ expr.prim.general]
2422///         identifier
2423///         operator-function-id
2424///         conversion-function-id
2425/// [C++0x] literal-operator-id [TODO]
2426///         ~ class-name
2427///         template-id
2428///
2429/// \endcode
2430///
2431/// \param SS The nested-name-specifier that preceded this unqualified-id. If
2432/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2433///
2434/// \param EnteringContext whether we are entering the scope of the 
2435/// nested-name-specifier.
2436///
2437/// \param AllowDestructorName whether we allow parsing of a destructor name.
2438///
2439/// \param AllowConstructorName whether we allow parsing a constructor name.
2440///
2441/// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2442///
2443/// \param ObjectType if this unqualified-id occurs within a member access
2444/// expression, the type of the base object whose member is being accessed.
2445///
2446/// \param Result on a successful parse, contains the parsed unqualified-id.
2447///
2448/// \returns true if parsing fails, false otherwise.
2449bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
                              bool AllowDestructorName,
                              bool AllowConstructorName,
                              bool AllowDeductionGuide,
                              ParsedType ObjectType,
                              SourceLocation& TemplateKWLoc,
                              UnqualifiedId &Result) {

// Handle 'A::template B'. This is for template-ids which have not
// already been annotated by ParseOptionalCXXScopeSpecifier().
bool TemplateSpecified = false;
if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
    (ObjectType || SS.isSet())) {
  TemplateSpecified = true;
  TemplateKWLoc = ConsumeToken();
}

// 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.getTypeName(*Id, IdLoc, getCurScope(), &SS, false,
                                        false, nullptr,
                                        /*IsCtorOrDtorName=*/true,
                                        /*NonTrivialTypeSourceInfo=*/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.
  if (TemplateSpecified || Tok.is(tok::less))
    return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
                                        EnteringContext, ObjectType,
                                        Result, TemplateSpecified);
  
  return false;
}

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

  // 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.getTypeName(*TemplateId->Name, TemplateId->TemplateNameLoc,
                              getCurScope(), &SS, false, false, nullptr,
                              /*IsCtorOrDtorName=*/true,
                              /*NontrivialTypeSourceInfo=*/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);
  TemplateKWLoc = TemplateId->TemplateKWLoc;
  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] >
  if ((Result.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
       Result.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) &&
      (TemplateSpecified || Tok.is(tok::less)))
    return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
                                        nullptr, SourceLocation(),
                                        EnteringContext, ObjectType,
                                        Result, TemplateSpecified);

  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 (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 (!TemplateSpecified && 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, 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 (TemplateSpecified || Tok.is(tok::less)) {
    Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
    return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
                                        ClassName, ClassNameLoc,
                                        EnteringContext, ObjectType,
                                        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;
2661}

2663/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2664/// memory in a typesafe manner and call constructors.
2665///
2666/// This method is called to parse the new expression after the optional :: has
2667/// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
2668/// is its location.  Otherwise, "Start" is the location of the 'new' token.
2669///
2670///        new-expression:
2671///                   '::'[opt] 'new' new-placement[opt] new-type-id
2672///                                     new-initializer[opt]
2673///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2674///                                     new-initializer[opt]
2675///
2676///        new-placement:
2677///                   '(' expression-list ')'
2678///
2679///        new-type-id:
2680///                   type-specifier-seq new-declarator[opt]
2681/// [GNU]             attributes type-specifier-seq new-declarator[opt]
2682///
2683///        new-declarator:
2684///                   ptr-operator new-declarator[opt]
2685///                   direct-new-declarator
2686///
2687///        new-initializer:
2688///                   '(' expression-list[opt] ')'
2689/// [C++0x]           braced-init-list
2690///
2691ExprResult
2692Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
assert(Tok.is(tok::kw_new) && "expected 'new' token")(static_cast <bool> (Tok.is(tok::kw_new) && "expected 'new' token"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_new) && \"expected 'new' token\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2693, __extension__ __PRETTY_FUNCTION__));
ConsumeToken();   // Consume 'new'

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

ExprVector PlacementArgs;
SourceLocation PlacementLParen, PlacementRParen;

SourceRange TypeIdParens;
DeclSpec DS(AttrFactory);
Declarator DeclaratorInfo(DS, DeclaratorContext::CXXNewContext);
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;
    if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
          ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(),
                                                     DeclaratorInfo).get();
          Actions.CodeCompleteConstructor(getCurScope(),
                                    TypeRep.get()->getCanonicalTypeInternal(),
                                          DeclaratorInfo.getLocEnd(),
                                          ConstructorArgs);
    })) {
      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());
2807}

2809/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2810/// passed to ParseDeclaratorInternal.
2811///
2812///        direct-new-declarator:
2813///                   '[' expression ']'
2814///                   direct-new-declarator '[' constant-expression ']'
2815///
2816void 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 ? 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,
                                          /*static=*/false, /*star=*/false,
                                          Size.get(),
                                          T.getOpenLocation(),
                                          T.getCloseLocation()),
                Attrs, T.getCloseLocation());

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

2854/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2855/// This ambiguity appears in the syntax of the C++ new operator.
2856///
2857///        new-expression:
2858///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2859///                                     new-initializer[opt]
2860///
2861///        new-placement:
2862///                   '(' expression-list ')'
2863///
2864bool 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);
2879}

2881/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2882/// to free memory allocated by new.
2883///
2884/// This method is called to parse the 'delete' expression after the optional
2885/// '::' has been already parsed.  If the '::' was present, "UseGlobal" is true
2886/// and "Start" is its location.  Otherwise, "Start" is the location of the
2887/// 'delete' token.
2888///
2889///        delete-expression:
2890///                   '::'[opt] 'delete' cast-expression
2891///                   '::'[opt] 'delete' '[' ']' cast-expression
2892ExprResult
2893Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword")(static_cast <bool> (Tok.is(tok::kw_delete) && "Expected 'delete' keyword"
) ? void (0) : __assert_fail ("Tok.is(tok::kw_delete) && \"Expected 'delete' keyword\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2894, __extension__ __PRETTY_FUNCTION__));
ConsumeToken(); // Consume 'delete'

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

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

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

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

2924static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
switch (kind) {
default: llvm_unreachable("Not a known type trait")::llvm::llvm_unreachable_internal("Not a known type trait", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2926);
2927#define TYPE_TRAIT_1(Spelling, Name, Key) \
2928case tok::kw_ ## Spelling: return UTT_ ## Name;
2929#define TYPE_TRAIT_2(Spelling, Name, Key) \
2930case tok::kw_ ## Spelling: return BTT_ ## Name;
2931#include "clang/Basic/TokenKinds.def"
2932#define TYPE_TRAIT_N(Spelling, Name, Key) \
case tok::kw_ ## Spelling: return TT_ ## Name;
2934#include "clang/Basic/TokenKinds.def"
}
2936}

2938static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
switch(kind) {
default: llvm_unreachable("Not a known binary type trait")::llvm::llvm_unreachable_internal("Not a known binary type trait"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2940);
case tok::kw___array_rank:                 return ATT_ArrayRank;
case tok::kw___array_extent:               return ATT_ArrayExtent;
}
2944}

2946static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
switch(kind) {
default: llvm_unreachable("Not a known unary expression trait.")::llvm::llvm_unreachable_internal("Not a known unary expression trait."
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2948);
case tok::kw___is_lvalue_expr:             return ET_IsLValueExpr;
case tok::kw___is_rvalue_expr:             return ET_IsRValueExpr;
}
2952}

2954static unsigned TypeTraitArity(tok::TokenKind kind) {
switch (kind) {
  default: llvm_unreachable("Not a known type trait")::llvm::llvm_unreachable_internal("Not a known type trait", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 2956);
2957#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
2958#include "clang/Basic/TokenKinds.def"
}
2960}

2962/// \brief Parse the built-in type-trait pseudo-functions that allow 
2963/// implementation of the TR1/C++11 type traits templates.
2964///
2965///       primary-expression:
2966///          unary-type-trait '(' type-id ')'
2967///          binary-type-trait '(' type-id ',' type-id ')'
2968///          type-trait '(' type-id-seq ')'
2969///
2970///       type-id-seq:
2971///          type-id ...[opt] type-id-seq[opt]
2972///
2973ExprResult 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);
3023}

3025/// ParseArrayTypeTrait - Parse the built-in array type-trait
3026/// pseudo-functions.
3027///
3028///       primary-expression:
3029/// [Embarcadero]     '__array_rank' '(' type-id ')'
3030/// [Embarcadero]     '__array_extent' '(' type-id ',' expression ')'
3031///
3032ExprResult Parser::ParseArrayTypeTrait() {
ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
SourceLocation Loc = ConsumeToken();

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

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

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

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

  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
                                     T.getCloseLocation());
}
}
llvm_unreachable("Invalid ArrayTypeTrait!")::llvm::llvm_unreachable_internal("Invalid ArrayTypeTrait!", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 3066);
3067}

3069/// ParseExpressionTrait - Parse built-in expression-trait
3070/// pseudo-functions like __is_lvalue_expr( xxx ).
3071///
3072///       primary-expression:
3073/// [Embarcadero]     expression-trait '(' expression ')'
3074///
3075ExprResult 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());
3089}


3092/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3093/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3094/// based on the context past the parens.
3095ExprResult
3096Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
                                       ParsedType &CastTy,
                                       BalancedDelimiterTracker &Tracker,
                                       ColonProtectionRAIIObject &ColonProt) {
assert(getLangOpts().CPlusPlus && "Should only be called for C++!")(static_cast <bool> (getLangOpts().CPlusPlus &&
 "Should only be called for C++!") ? void (0) : __assert_fail
 ("getLangOpts().CPlusPlus && \"Should only be called for C++!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 3100, __extension__ __PRETTY_FUNCTION__));
assert(ExprType == CastExpr && "Compound literals are not ambiguous!")(static_cast <bool> (ExprType == CastExpr && "Compound literals are not ambiguous!"
) ? void (0) : __assert_fail ("ExprType == CastExpr && \"Compound literals are not ambiguous!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 3101, __extension__ __PRETTY_FUNCTION__));
assert(isTypeIdInParens() && "Not a type-id!")(static_cast <bool> (isTypeIdInParens() && "Not a type-id!"
) ? void (0) : __assert_fail ("isTypeIdInParens() && \"Not a type-id!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 3102, __extension__ __PRETTY_FUNCTION__));

ExprResult Result(true);
CastTy = nullptr;

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

ParenParseOption ParseAs;
CachedTokens Toks;

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

if (Tok.is(tok::l_brace)) {
  ParseAs = CompoundLiteral;
} else {
  bool NotCastExpr;
  if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
    NotCastExpr = true;
  } else {
    // Try parsing the cast-expression that may follow.
    // If it is not a cast-expression, NotCastExpr will be true and no token
    // will be consumed.
    ColonProt.restore();
    Result = ParseCastExpression(false/*isUnaryExpression*/,
                                 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, true /*DisableMacroExpansion*/);
// 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::TypeNameContext);
  {
    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())(static_cast <bool> (Tok.is(tok::eof) && Tok.getEofData
() == AttrEnd.getEofData()) ? void (0) : __assert_fail ("Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 3192, __extension__ __PRETTY_FUNCTION__));
  ConsumeAnyToken();

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

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

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

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

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

// Not a compound literal, and not followed by a cast-expression.
assert(ParseAs == SimpleExpr)(static_cast <bool> (ParseAs == SimpleExpr) ? void (0) :
 __assert_fail ("ParseAs == SimpleExpr", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 3221, __extension__ __PRETTY_FUNCTION__));

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

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

Tracker.consumeClose();
// Consume EOF marker for Toks buffer.
assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())(static_cast <bool> (Tok.is(tok::eof) && Tok.getEofData
() == AttrEnd.getEofData()) ? void (0) : __assert_fail ("Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData()"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Parse/ParseExprCXX.cpp"
, 3240, __extension__ __PRETTY_FUNCTION__));
ConsumeAnyToken();
return Result;
3243}