//===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file implements the Expression parsing implementation for C++.

//

//===----------------------------------------------------------------------===//

#include "clang/AST/ASTContext.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/ExprCXX.h"

#include "clang/Basic/PrettyStackTrace.h"

#include "clang/Lex/LiteralSupport.h"

#include "clang/Parse/ParseDiagnostic.h"

#include "clang/Parse/Parser.h"

#include "clang/Parse/RAIIObjectsForParser.h"

#include "clang/Sema/DeclSpec.h"

#include "clang/Sema/ParsedTemplate.h"

#include "clang/Sema/Scope.h"

#include "llvm/Support/ErrorHandling.h"

#include <numeric>

using namespace clang;

static int SelectDigraphErrorMessage(tok::TokenKind Kind) {

  switch (Kind) {

    // template name

    case tok::unknown:             return 0;

    // casts

    case tok::kw_addrspace_cast:   return 1;

    case tok::kw_const_cast:       return 2;

    case tok::kw_dynamic_cast:     return 3;

    case tok::kw_reinterpret_cast: return 4;

    case tok::kw_static_cast:      return 5;

    default:

      llvm_unreachable("Unknown type for digraph error message.");

  }

}

// Are the two tokens adjacent in the same source file?

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

}

// Suggest fixit for "<::" after a cast.

static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,

                       Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {

  // Pull '<:' and ':' off token stream.

  if (!AtDigraph)

    PP.Lex(DigraphToken);

  PP.Lex(ColonToken);

  SourceRange Range;

  Range.setBegin(DigraphToken.getLocation());

  Range.setEnd(ColonToken.getLocation());

  P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)

      << SelectDigraphErrorMessage(Kind)

      << FixItHint::CreateReplacement(Range, "< ::");

  // Update token information to reflect their change in token type.

  ColonToken.setKind(tok::coloncolon);

  ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));

  ColonToken.setLength(2);

  DigraphToken.setKind(tok::less);

  DigraphToken.setLength(1);

  // Push new tokens back to token stream.

  PP.EnterToken(ColonToken, /*IsReinject*/ true);

  if (!AtDigraph)

    PP.EnterToken(DigraphToken, /*IsReinject*/ true);

}

// Check for '<::' which should be '< ::' instead of '[:' when following

// a template name.

void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,

                                        bool EnteringContext,

                                        IdentifierInfo &II, CXXScopeSpec &SS) {

  if (!Next.is(tok::l_square) || 
Next.getLength() != 2198k
)

    return;

  Token SecondToken = GetLookAheadToken(2);

  if (!SecondToken.is(tok::colon) || 
!areTokensAdjacent(Next, SecondToken)18
)

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

}

/// Parse global scope or nested-name-specifier if present.

///

/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which

/// may be preceded by '::'). Note that this routine will not parse ::new or

/// ::delete; it will just leave them in the token stream.

///

///       '::'[opt] nested-name-specifier

///       '::'

///

///       nested-name-specifier:

///         type-name '::'

///         namespace-name '::'

///         nested-name-specifier identifier '::'

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

///

///

/// \param SS the scope specifier that will be set to the parsed

/// nested-name-specifier (or empty)

///

/// \param ObjectType if this nested-name-specifier is being parsed following

/// the "." or "->" of a member access expression, this parameter provides the

/// type of the object whose members are being accessed.

///

/// \param ObjectHadErrors if this unqualified-id occurs within a member access

/// expression, indicates whether the original subexpressions had any errors.

/// When true, diagnostics for missing 'template' keyword will be supressed.

///

/// \param EnteringContext whether we will be entering into the context of

/// the nested-name-specifier after parsing it.

///

/// \param MayBePseudoDestructor When non-NULL, points to a flag that

/// indicates whether this nested-name-specifier may be part of a

/// pseudo-destructor name. In this case, the flag will be set false

/// if we don't actually end up parsing a destructor name. Moreover,

/// if we do end up determining that we are parsing a destructor name,

/// the last component of the nested-name-specifier is not parsed as

/// part of the scope specifier.

///

/// \param IsTypename If \c true, this nested-name-specifier is known to be

/// part of a type name. This is used to improve error recovery.

///

/// \param LastII When non-NULL, points to an IdentifierInfo* that will be

/// filled in with the leading identifier in the last component of the

/// nested-name-specifier, if any.

///

/// \param OnlyNamespace If true, only considers namespaces in lookup.

///

///

/// \returns true if there was an error parsing a scope specifier

bool Parser::ParseOptionalCXXScopeSpecifier(

    CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,

    bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename,

    IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) {

  assert(getLangOpts().CPlusPlus &&

         "Call sites of this function should be guarded by checking for C++");

  if (Tok.is(tok::annot_cxxscope)) {

    assert(!LastII && "want last identifier but have already annotated scope");

    assert(!MayBePseudoDestructor && "unexpected annot_cxxscope");

    Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),

                                                 Tok.getAnnotationRange(),

                                                 SS);

    ConsumeAnnotationToken();

    return false;

  }

  // Has to happen before any "return false"s in this function.

  bool CheckForDestructor = false;

  if (MayBePseudoDestructor && 
*MayBePseudoDestructor1.05M
) {

    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_delete273k
)

      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)90.8M
) {

    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)38.7k
) {

      AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);

      return false;

    }

    if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))

      SS.SetInvalid(SourceRange(DeclLoc, CCLoc));

    HasScopeSpecifier = true;

  }

  // Preferred type might change when parsing qualifiers, we need the original.

  auto SavedType = PreferredType;

  while (true) {

    if (HasScopeSpecifier) {

      if (Tok.is(tok::code_completion)) {

        cutOffParsing();

        // Code completion for a nested-name-specifier, where the code

        // completion token follows the '::'.

        Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext,

                                        InUsingDeclaration, ObjectType.get(),

                                        SavedType.get(SS.getBeginLoc()));

        // Include code completion token into the range of the scope otherwise

        // when we try to annotate the scope tokens the dangling code completion

        // token will cause assertion in

        // Preprocessor::AnnotatePreviousCachedTokens.

        SS.setEndLoc(Tok.getLocation());

        return true;

      }

      // C++ [basic.lookup.classref]p5:

      //   If the qualified-id has the form

      //

      //       ::class-name-or-namespace-name::...

      //

      //   the class-name-or-namespace-name is looked up in global scope as a

      //   class-name or namespace-name.

      //

      // To implement this, we clear out the object type as soon as we've

      // seen a leading '::' or part of a nested-name-specifier.

      ObjectType = nullptr;

    }

    // nested-name-specifier:

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

    // Parse the optional 'template' keyword, then make sure we have

    // 'identifier <' after it.

    if (Tok.is(tok::kw_template)) {

      // If we don't have a scope specifier or an object type, this isn't a

      // nested-name-specifier, since they aren't allowed to start with

      // 'template'.

      if (!HasScopeSpecifier && 
!ObjectType1.35k
)

        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 (73
Tok.is(tok::kw_operator)73
) {

        // 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_LiteralOperatorId1
) {

          Diag(TemplateName.getSourceRange().getBegin(),

               diag::err_id_after_template_in_nested_name_spec)

            << TemplateName.getSourceRange();

          TPA.Commit();

          break;

        }

      } else {

        TPA.Revert();

        break;

      }

      // If the next token is not '<', we have a qualified-id that refers

      // to a template name, such as T::template apply, but is not a

      // template-id.

      if (Tok.isNot(tok::less)) {

        TPA.Revert();

        break;

      }

      // Commit to parsing the template-id.

      TPA.Commit();

      TemplateTy Template;

      TemplateNameKind TNK = Actions.ActOnTemplateName(

          getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,

          EnteringContext, Template, /*AllowInjectedClassName*/ true);

      if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,

                                  TemplateName, false))

        return true;

      continue;

    }

    if (Tok.is(tok::annot_template_id) && 
NextToken().is(tok::coloncolon)2.80M
) {

      // 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)75
) {

        *MayBePseudoDestructor = true;

        return false;

      }

      if (LastII)

        *LastII = TemplateId->Name;

      // Consume the template-id token.

      ConsumeAnnotationToken();

      assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");

      SourceLocation CCLoc = ConsumeToken();

      HasScopeSpecifier = true;

      ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),

                                         TemplateId->NumArgs);

      if (TemplateId->isInvalid() ||

          Actions.ActOnCXXNestedNameSpecifier(getCurScope(),

                                              SS,

                                              TemplateId->TemplateKWLoc,

                                              TemplateId->Template,

                                              TemplateId->TemplateNameLoc,

                                              TemplateId->LAngleLoc,

                                              TemplateArgsPtr,

                                              TemplateId->RAngleLoc,

                                              CCLoc,

                                              EnteringContext)) {

        SourceLocation StartLoc

          = SS.getBeginLoc().isValid()? 
SS.getBeginLoc()49

                                      : 
TemplateId->TemplateNameLoc275
;

        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) && 
!ColonIsSacred188k
) {

      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)160
) {

        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)1.02M
) {

      // 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)395
) {

        *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)87.1k
) {

          Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)

              << Next2.getName()

              << FixItHint::CreateReplacement(Next.getLocation(), ":");

          Token ColonColon;

          PP.Lex(ColonColon);

          ColonColon.setKind(tok::colon);

          PP.EnterToken(ColonColon, /*IsReinject*/ true);

          break;

        }

      }

      if (LastII)

        *LastII = ⅈ

      // 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) &&

             "NextToken() not working properly!");

      Token ColonColon = Tok;

      SourceLocation CCLoc = ConsumeToken();

      bool IsCorrectedToColon = false;

      bool *CorrectionFlagPtr = ColonIsSacred ? 
&IsCorrectedToColon87.1k
 : 
nullptr936k
;

      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 && 
IsCorrectedToColon49
) {

          ColonColon.setKind(tok::colon);

          PP.EnterToken(Tok, /*IsReinject*/ true);

          PP.EnterToken(ColonColon, /*IsReinject*/ true);

          Tok = Identifier;

          break;

        }

        SS.SetInvalid(SourceRange(IdLoc, CCLoc));

      }

      HasScopeSpecifier = true;

      continue;

    }

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

    // nested-name-specifier:

    //   type-name '<'

    if (Next.is(tok::less)) {

      TemplateTy Template;

      UnqualifiedId TemplateName;

      TemplateName.setIdentifier(&II, Tok.getLocation());

      bool MemberOfUnknownSpecialization;

      if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,

                                              /*hasTemplateKeyword=*/false,

                                                        TemplateName,

                                                        ObjectType,

                                                        EnteringContext,

                                                        Template,

                                              MemberOfUnknownSpecialization)) {

        // If lookup didn't find anything, we treat the name as a template-name

        // anyway. C++20 requires this, and in prior language modes it improves

        // error recovery. But before we commit to this, check that we actually

        // have something that looks like a template-argument-list next.

        if (!IsTypename && 
TNK == TNK_Undeclared_template2.26M
 &&

            
isTemplateArgumentList(1) == TPResult::False291
)

          break;

        // We have found a template name, so annotate this token

        // with a template-id annotation. We do not permit the

        // template-id to be translated into a type annotation,

        // because some clients (e.g., the parsing of class template

        // specializations) still want to see the original template-id

        // token, and it might not be a type at all (e.g. a concept name in a

        // type-constraint).

        ConsumeToken();

        if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),

                                    TemplateName, false))

          return true;

        continue;

      }

      if (MemberOfUnknownSpecialization && 
(1.58k
ObjectType1.58k
 || 
SS.isSet()77
) &&

          
(1.58k
IsTypename1.58k
 || 
isTemplateArgumentList(1) == TPResult::True1.56k
)) {

        // If we had errors before, ObjectType can be dependent even without any

        // templates. Do not report missing template keyword in that case.

        if (!ObjectHadErrors) {

          // We have something like t::getAs<T>, where getAs is a

          // member of an unknown specialization. However, this will only

          // parse correctly as a template, so suggest the keyword 'template'

          // before 'getAs' and treat this as a dependent template name.

          unsigned DiagID = diag::err_missing_dependent_template_keyword;

          if (getLangOpts().MicrosoftExt)

            DiagID = diag::warn_missing_dependent_template_keyword;

          Diag(Tok.getLocation(), DiagID)

              << II.getName()

              << FixItHint::CreateInsertion(Tok.getLocation(), "template ");

        }

        SourceLocation TemplateNameLoc = ConsumeToken();

        TemplateNameKind TNK = Actions.ActOnTemplateName(

            getCurScope(), SS, TemplateNameLoc, TemplateName, ObjectType,

            EnteringContext, Template, /*AllowInjectedClassName*/ true);

        if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),

                                    TemplateName, false))

          return true;

        continue;

      }

    }

    // We don't have any tokens that form the beginning of a

    // nested-name-specifier, so we're done.

    break;

  }

  // Even if we didn't see any pieces of a nested-name-specifier, we

  // still check whether there is a tilde in this position, which

  // indicates a potential pseudo-destructor.

  if (CheckForDestructor && 
!HasScopeSpecifier781k
 && 
Tok.is(tok::tilde)781k
)

    *MayBePseudoDestructor = true;

  return false;

}

ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS,

                                           bool isAddressOfOperand,

                                           Token &Replacement) {

  ExprResult E;

  // We may have already annotated this id-expression.

  switch (Tok.getKind()) {

  case tok::annot_non_type: {

    NamedDecl *ND = getNonTypeAnnotation(Tok);

    SourceLocation Loc = ConsumeAnnotationToken();

    E = Actions.ActOnNameClassifiedAsNonType(getCurScope(), SS, ND, Loc, Tok);

    break;

  }

  case tok::annot_non_type_dependent: {

    IdentifierInfo *II = getIdentifierAnnotation(Tok);

    SourceLocation Loc = ConsumeAnnotationToken();

    // This is only the direct operand of an & operator if it is not

    // followed by a postfix-expression suffix.

    if (isAddressOfOperand && 
isPostfixExpressionSuffixStart()0
)

      isAddressOfOperand = false;

    E = Actions.ActOnNameClassifiedAsDependentNonType(SS, II, Loc,

                                                      isAddressOfOperand);

    break;

  }

  case tok::annot_non_type_undeclared: {

    assert(SS.isEmpty() &&

           "undeclared non-type annotation should be unqualified");

    IdentifierInfo *II = getIdentifierAnnotation(Tok);

    SourceLocation Loc = ConsumeAnnotationToken();

    E = Actions.ActOnNameClassifiedAsUndeclaredNonType(II, Loc);

    break;

  }

  default:

    SourceLocation TemplateKWLoc;

    UnqualifiedId Name;

    if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,

                           /*ObjectHadErrors=*/false,

                           /*EnteringContext=*/false,

                           /*AllowDestructorName=*/false,

                           /*AllowConstructorName=*/false,

                           /*AllowDeductionGuide=*/false, &TemplateKWLoc, Name))

      return ExprError();

    // This is only the direct operand of an & operator if it is not

    // followed by a postfix-expression suffix.

    if (isAddressOfOperand && 
isPostfixExpressionSuffixStart()4.03k
)

      isAddressOfOperand = false;

    E = Actions.ActOnIdExpression(

        getCurScope(), SS, TemplateKWLoc, Name, Tok.is(tok::l_paren),

        isAddressOfOperand, /*CCC=*/nullptr, /*IsInlineAsmIdentifier=*/false,

        &Replacement);

    break;

  }

  if (!E.isInvalid() && 
!E.isUnset()2.90M
 && 
Tok.is(tok::less)2.90M
)

    checkPotentialAngleBracket(E);

  return E;

}

/// ParseCXXIdExpression - Handle id-expression.

///

///       id-expression:

///         unqualified-id

///         qualified-id

///

///       qualified-id:

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

///         '::' identifier

///         '::' operator-function-id

///         '::' template-id

///

/// NOTE: The standard specifies that, for qualified-id, the parser does not

/// expect:

///

///   '::' conversion-function-id

///   '::' '~' class-name

///

/// This may cause a slight inconsistency on diagnostics:

///

/// class C {};

/// namespace A {}

/// void f() {

///   :: A :: ~ C(); // Some Sema error about using destructor with a

///                  // namespace.

///   :: ~ C(); // Some Parser error like 'unexpected ~'.

/// }

///

/// We simplify the parser a bit and make it work like:

///

///       qualified-id:

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

///         '::' unqualified-id

///

/// That way Sema can handle and report similar errors for namespaces and the

/// global scope.

///

/// The isAddressOfOperand parameter indicates that this id-expression is a

/// direct operand of the address-of operator. This is, besides member contexts,

/// the only place where a qualified-id naming a non-static class member may

/// appear.

///

ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {

  // qualified-id:

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

  //   '::' unqualified-id

  //

  CXXScopeSpec SS;

  ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,

                                 /*ObjectHasErrors=*/false,

                                 /*EnteringContext=*/false);

  Token Replacement;

  ExprResult Result =

      tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);

  if (Result.isUnset()) {

    // If the ExprResult is valid but null, then typo correction suggested a

    // keyword replacement that needs to be reparsed.

    UnconsumeToken(Replacement);

    Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);

  }

  assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "

                              "for a previous keyword suggestion");

  return Result;

}

/// ParseLambdaExpression - Parse a C++11 lambda expression.

///

///       lambda-expression:

///         lambda-introducer lambda-declarator compound-statement

///         lambda-introducer '<' template-parameter-list '>'

///             requires-clause[opt] lambda-declarator compound-statement

///

///       lambda-introducer:

///         '[' lambda-capture[opt] ']'

///

///       lambda-capture:

///         capture-default

///         capture-list

///         capture-default ',' capture-list

///

///       capture-default:

///         '&'

///         '='

///

///       capture-list:

///         capture

///         capture-list ',' capture

///

///       capture:

///         simple-capture

///         init-capture     [C++1y]

///

///       simple-capture:

///         identifier

///         '&' identifier

///         'this'

///

///       init-capture:      [C++1y]

///         identifier initializer

///         '&' identifier initializer

///

///       lambda-declarator:

///         lambda-specifiers     [C++2b]

///         '(' parameter-declaration-clause ')' lambda-specifiers

///             requires-clause[opt]

///

///       lambda-specifiers:

///         decl-specifier-seq[opt] noexcept-specifier[opt]

///             attribute-specifier-seq[opt] trailing-return-type[opt]

///

ExprResult Parser::ParseLambdaExpression() {

  // Parse lambda-introducer.

  LambdaIntroducer Intro;

  if (ParseLambdaIntroducer(Intro)) {

    SkipUntil(tok::r_square, StopAtSemi);

    SkipUntil(tok::l_brace, StopAtSemi);

    SkipUntil(tok::r_brace, StopAtSemi);

    return ExprError();

  }

  return ParseLambdaExpressionAfterIntroducer(Intro);

}

/// Use lookahead and potentially tentative parsing to determine if we are

/// looking at a C++11 lambda expression, and parse it if we are.

///

/// If we are not looking at a lambda expression, returns ExprError().

ExprResult Parser::TryParseLambdaExpression() {

  assert(getLangOpts().CPlusPlus11

         && Tok.is(tok::l_square)

         && "Not at the start of a possible lambda expression.");

  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)2.88k
 ||        // [=

      
(2.84k
Next.is(tok::amp)2.84k
 &&         // [&] or [&,

       
After.isOneOf(tok::r_square, tok::comma)41
) ||

      
(2.81k
Next.is(tok::identifier)2.81k
 &&  // [identifier]

       
After.is(tok::r_square)2.02k
) ||

      
Next.is(tok::ellipsis)2.79k
) {     // [...

    return ParseLambdaExpression();

  }

  // If lookahead indicates an ObjC message send...

  // [identifier identifier

  if (Next.is(tok::identifier) && 
After.is(tok::identifier)2.01k
)

    return ExprEmpty();

  // Here, we're stuck: lambda introducers and Objective-C message sends are

  // unambiguous, but it requires arbitrary lookhead.  [a,b,c,d,e,f,g] is a

  // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send.  Instead of

  // writing two routines to parse a lambda introducer, just try to parse

  // a lambda introducer first, and fall back if that fails.

  LambdaIntroducer Intro;

  {

    TentativeParsingAction TPA(*this);

    LambdaIntroducerTentativeParse Tentative;

    if (ParseLambdaIntroducer(Intro, &Tentative)) {

      TPA.Commit();

      return ExprError();

    }

    switch (Tentative) {

    case LambdaIntroducerTentativeParse::Success:

      TPA.Commit();

      break;

    case LambdaIntroducerTentativeParse::Incomplete:

      // Didn't fully parse the lambda-introducer, try again with a

      // non-tentative parse.

      TPA.Revert();

      Intro = LambdaIntroducer();

      if (ParseLambdaIntroducer(Intro))

        return ExprError();

      break;

    case LambdaIntroducerTentativeParse::MessageSend:

    case LambdaIntroducerTentativeParse::Invalid:

      // Not a lambda-introducer, might be a message send.

      TPA.Revert();

      return ExprEmpty();

    }

  }

  return ParseLambdaExpressionAfterIntroducer(Intro);

}

/// Parse a lambda introducer.

/// \param Intro A LambdaIntroducer filled in with information about the

///        contents of the lambda-introducer.

/// \param Tentative If non-null, we are disambiguating between a

///        lambda-introducer and some other construct. In this mode, we do not

///        produce any diagnostics or take any other irreversible action unless

///        we're sure that this is a lambda-expression.

/// \return \c true if parsing (or disambiguation) failed with a diagnostic and

///         the caller should bail out / recover.

bool Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,

                                   LambdaIntroducerTentativeParse *Tentative) {

  if (Tentative)

    *Tentative = LambdaIntroducerTentativeParse::Success;

  assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");

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

  T.consumeOpen();

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

  bool First = true;

  // Produce a diagnostic if we're not tentatively parsing; otherwise track

  // that our parse has failed.

  auto Invalid = [&](llvm::function_ref<void()> Action) {

    if (Tentative) {

      *Tentative = LambdaIntroducerTentativeParse::Invalid;

      return false;

    }

    Action();

    return true;

  };

  // Perform some irreversible action if this is a non-tentative parse;

  // otherwise note that our actions were incomplete.

  auto NonTentativeAction = [&](llvm::function_ref<void()> Action) {

    if (Tentative)

      *Tentative = LambdaIntroducerTentativeParse::Incomplete;

    else

      Action();

  };

  // Parse capture-default.

  if (Tok.is(tok::amp) &&

      
(2.13k
NextToken().is(tok::comma)2.13k
 || 
NextToken().is(tok::r_square)2.05k
)) {

    Intro.Default = LCD_ByRef;

    Intro.DefaultLoc = ConsumeToken();

    First = false;

    if (!Tok.getIdentifierInfo()) {

      // This can only be a lambda; no need for tentative parsing any more.

      // '[[and]]' can still be an attribute, though.

      Tentative = nullptr;

    }

  } else if (Tok.is(tok::equal)) {

    Intro.Default = LCD_ByCopy;

    Intro.DefaultLoc = ConsumeToken();

    First = false;

    Tentative = nullptr;

  }

  while (Tok.isNot(tok::r_square)) {

    if (!First) {

      if (Tok.isNot(tok::comma)) {

        // Provide a completion for a lambda introducer here. Except

        // in Objective-C, where this is Almost Surely meant to be a message

        // send. In that case, fail here and let the ObjC message

        // expression parser perform the completion.

        if (Tok.is(tok::code_completion) &&

            
!(7
getLangOpts().ObjC7
 && 
Tentative7
)) {

          cutOffParsing();

          Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,

                                               /*AfterAmpersand=*/false);

          break;

        }

        return Invalid([&] {

          Diag(Tok.getLocation(), diag::err_expected_comma_or_rsquare);

        });

      }

      ConsumeToken();

    }

    if (Tok.is(tok::code_completion)) {

      cutOffParsing();

      // If we're in Objective-C++ and we have a bare '[', then this is more

      // likely to be a message receiver.

      if (getLangOpts().ObjC && 
Tentative5
 && 
First5
)

        Actions.CodeCompleteObjCMessageReceiver(getCurScope());

      else

        Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,

                                             /*AfterAmpersand=*/false);

      break;

    }

    First = false;

    // Parse capture.

    LambdaCaptureKind Kind = LCK_ByCopy;

    LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;

    SourceLocation Loc;

    IdentifierInfo *Id = nullptr;

    SourceLocation EllipsisLocs[4];

    ExprResult Init;

    SourceLocation LocStart = Tok.getLocation();

    if (Tok.is(tok::star)) {

      Loc = ConsumeToken();

      if (Tok.is(tok::kw_this)) {

        ConsumeToken();

        Kind = LCK_StarThis;

      } else {

        return Invalid([&] {

          Diag(Tok.getLocation(), diag::err_expected_star_this_capture);

        });

      }

    } else if (Tok.is(tok::kw_this)) {

      Kind = LCK_This;

      Loc = ConsumeToken();

    } else if (Tok.isOneOf(tok::amp, tok::equal) &&

               
NextToken().isOneOf(tok::comma, tok::r_square)334
 &&

               
Intro.Default == LCD_None11
) {

      // We have a lone "&" or "=" which is either a misplaced capture-default

      // or the start of a capture (in the "&" case) with the rest of the

      // capture missing. Both are an error but a misplaced capture-default

      // is more likely if we don't already have a capture default.

      return Invalid(

          [&] { Diag(Tok.getLocation(), diag::err_capture_default_first); });

    } else {

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

      if (Tok.is(tok::amp)) {

        Kind = LCK_ByRef;

        ConsumeToken();

        if (Tok.is(tok::code_completion)) {

          cutOffParsing();

          Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,

                                               /*AfterAmpersand=*/true);

          break;

        }

      }

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

      if (Tok.is(tok::identifier)) {

        Id = Tok.getIdentifierInfo();

        Loc = ConsumeToken();

      } else 
if (824
Tok.is(tok::kw_this)824
) {

        return Invalid([&] {

          // FIXME: Suggest a fixit here.

          Diag(Tok.getLocation(), diag::err_this_captured_by_reference);

        });

      } else {

        return Invalid([&] {

          Diag(Tok.getLocation(), diag::err_expected_capture);

        });

      }

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

      if (Tok.is(tok::l_paren)) {

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

        Parens.consumeOpen();

        InitKind = LambdaCaptureInitKind::DirectInit;

        ExprVector Exprs;

        CommaLocsTy Commas;

        if (Tentative) {

          Parens.skipToEnd();

          *Tentative = LambdaIntroducerTentativeParse::Incomplete;

        } else if (ParseExpressionList(Exprs, Commas)) {

          Parens.skipToEnd();

          Init = ExprError();

        } else {

          Parens.consumeClose();

          Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),

                                            Parens.getCloseLocation(),

                                            Exprs);

        }

      } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {

        // Each lambda init-capture forms its own full expression, which clears

        // Actions.MaybeODRUseExprs. So create an expression evaluation context

        // to save the necessary state, and restore it later.

        EnterExpressionEvaluationContext EC(

            Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

        if (TryConsumeToken(tok::equal))

          InitKind = LambdaCaptureInitKind::CopyInit;

        else

          InitKind = LambdaCaptureInitKind::ListInit;

        if (!Tentative) {

          Init = ParseInitializer();

        } else 
if (23
Tok.is(tok::l_brace)23
) {

          BalancedDelimiterTracker Braces(*this, tok::l_brace);

          Braces.consumeOpen();

          Braces.skipToEnd();

          *Tentative = LambdaIntroducerTentativeParse::Incomplete;

        } else {

          // We're disambiguating this:

          //

          //   [..., x = expr

          //

          // We need to find the end of the following expression in order to

          // determine whether this is an Obj-C message send's receiver, a

          // C99 designator, or a lambda init-capture.

          //

          // Parse the expression to find where it ends, and annotate it back

          // onto the tokens. We would have parsed this expression the same way

          // in either case: both the RHS of an init-capture and the RHS of an

          // assignment expression are parsed as an initializer-clause, and in

          // neither case can anything be added to the scope between the '[' and

          // here.

          //

          // FIXME: This is horrible. Adding a mechanism to skip an expression

          // would be much cleaner.

          // FIXME: If there is a ',' before the next ']' or ':', we can skip to

          // that instead. (And if we see a ':' with no matching '?', we can

          // classify this as an Obj-C message send.)

          SourceLocation StartLoc = Tok.getLocation();

          InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);