contrib/llvm/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"
  24
  25
  26 using namespace clang;
  27
  28 static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
  29   switch (Kind) {
  30     // template name
  31     case tok::unknown:             return 0;
  32     // casts
  33     case tok::kw_const_cast:       return 1;
  34     case tok::kw_dynamic_cast:     return 2;
  35     case tok::kw_reinterpret_cast: return 3;
  36     case tok::kw_static_cast:      return 4;
  37     default:
  38       llvm_unreachable("Unknown type for digraph error message.");
  39   }
  40 }
  41
  42 // Are the two tokens adjacent in the same source file?
  43 bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
  44   SourceManager &SM = PP.getSourceManager();
  45   SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
  46   SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
  47   return FirstEnd == SM.getSpellingLoc(Second.getLocation());
  48 }
  49
  50 // Suggest fixit for "<::" after a cast.
  51 static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
  52                        Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
  53   // Pull '<:' and ':' off token stream.
  54   if (!AtDigraph)
  55     PP.Lex(DigraphToken);
  56   PP.Lex(ColonToken);
  57
  58   SourceRange Range;
  59   Range.setBegin(DigraphToken.getLocation());
  60   Range.setEnd(ColonToken.getLocation());
  61   P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
  62       << SelectDigraphErrorMessage(Kind)
  63       << FixItHint::CreateReplacement(Range, "< ::");
  64
  65   // Update token information to reflect their change in token type.
  66   ColonToken.setKind(tok::coloncolon);
  67   ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
  68   ColonToken.setLength(2);
  69   DigraphToken.setKind(tok::less);
  70   DigraphToken.setLength(1);
  71
  72   // Push new tokens back to token stream.
  73   PP.EnterToken(ColonToken);
  74   if (!AtDigraph)
  75     PP.EnterToken(DigraphToken);
  76 }
  77
  78 // Check for '<::' which should be '< ::' instead of '[:' when following
  79 // a template name.
  80 void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
  81                                         bool EnteringContext,
  82                                         IdentifierInfo &II, CXXScopeSpec &SS) {
  83   if (!Next.is(tok::l_square) || Next.getLength() != 2)
  84     return;
  85
  86   Token SecondToken = GetLookAheadToken(2);
  87   if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
  88     return;
  89
  90   TemplateTy Template;
  91   UnqualifiedId TemplateName;
  92   TemplateName.setIdentifier(&II, Tok.getLocation());
  93   bool MemberOfUnknownSpecialization;
  94   if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
  95                               TemplateName, ObjectType, EnteringContext,
  96                               Template, MemberOfUnknownSpecialization))
  97     return;
  98
  99   FixDigraph(*this, PP, Next, SecondToken, tok::unknown,
 100              /*AtDigraph*/false);
 101 }
 102
 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
 147 bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
 148                                             ParsedType ObjectType,
 149                                             bool EnteringContext,
 150                                             bool *MayBePseudoDestructor,
 151                                             bool IsTypename,
 152                                             IdentifierInfo **LastII,
 153                                             bool OnlyNamespace) {
 154   assert(getLangOpts().CPlusPlus &&
 155          "Call sites of this function should be guarded by checking for C++");
 156
 157   if (Tok.is(tok::annot_cxxscope)) {
 158     assert(!LastII && "want last identifier but have already annotated scope");
 159     assert(!MayBePseudoDestructor && "unexpected annot_cxxscope");
 160     Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
 161                                                  Tok.getAnnotationRange(),
 162                                                  SS);
 163     ConsumeAnnotationToken();
 164     return false;
 165   }
 166
 167   if (Tok.is(tok::annot_template_id)) {
 168     // If the current token is an annotated template id, it may already have
 169     // a scope specifier. Restore it.
 170     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
 171     SS = TemplateId->SS;
 172   }
 173
 174   // Has to happen before any "return false"s in this function.
 175   bool CheckForDestructor = false;
 176   if (MayBePseudoDestructor && *MayBePseudoDestructor) {
 177     CheckForDestructor = true;
 178     *MayBePseudoDestructor = false;
 179   }
 180
 181   if (LastII)
 182     *LastII = nullptr;
 183
 184   bool HasScopeSpecifier = false;
 185
 186   if (Tok.is(tok::coloncolon)) {
 187     // ::new and ::delete aren't nested-name-specifiers.
 188     tok::TokenKind NextKind = NextToken().getKind();
 189     if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
 190       return false;
 191
 192     if (NextKind == tok::l_brace) {
 193       // It is invalid to have :: {, consume the scope qualifier and pretend
 194       // like we never saw it.
 195       Diag(ConsumeToken(), diag::err_expected) << tok::identifier;
 196     } else {
 197       // '::' - Global scope qualifier.
 198       if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS))
 199         return true;
 200
 201       HasScopeSpecifier = true;
 202     }
 203   }
 204
 205   if (Tok.is(tok::kw___super)) {
 206     SourceLocation SuperLoc = ConsumeToken();
 207     if (!Tok.is(tok::coloncolon)) {
 208       Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super);
 209       return true;
 210     }
 211
 212     return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS);
 213   }
 214
 215   if (!HasScopeSpecifier &&
 216       Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {
 217     DeclSpec DS(AttrFactory);
 218     SourceLocation DeclLoc = Tok.getLocation();
 219     SourceLocation EndLoc  = ParseDecltypeSpecifier(DS);
 220
 221     SourceLocation CCLoc;
 222     // Work around a standard defect: 'decltype(auto)::' is not a
 223     // nested-name-specifier.
 224     if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto ||
 225         !TryConsumeToken(tok::coloncolon, CCLoc)) {
 226       AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
 227       return false;
 228     }
 229
 230     if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
 231       SS.SetInvalid(SourceRange(DeclLoc, CCLoc));
 232
 233     HasScopeSpecifier = true;
 234   }
 235
 236   while (true) {
 237     if (HasScopeSpecifier) {
 238       // C++ [basic.lookup.classref]p5:
 239       //   If the qualified-id has the form
 240       //
 241       //       ::class-name-or-namespace-name::...
 242       //
 243       //   the class-name-or-namespace-name is looked up in global scope as a
 244       //   class-name or namespace-name.
 245       //
 246       // To implement this, we clear out the object type as soon as we've
 247       // seen a leading '::' or part of a nested-name-specifier.
 248       ObjectType = nullptr;
 249
 250       if (Tok.is(tok::code_completion)) {
 251         // Code completion for a nested-name-specifier, where the code
 252         // code completion token follows the '::'.
 253         Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext);
 254         // Include code completion token into the range of the scope otherwise
 255         // when we try to annotate the scope tokens the dangling code completion
 256         // token will cause assertion in
 257         // Preprocessor::AnnotatePreviousCachedTokens.
 258         SS.setEndLoc(Tok.getLocation());
 259         cutOffParsing();
 260         return true;
 261       }
 262     }
 263
 264     // nested-name-specifier:
 265     //   nested-name-specifier 'template'[opt] simple-template-id '::'
 266
 267     // Parse the optional 'template' keyword, then make sure we have
 268     // 'identifier <' after it.
 269     if (Tok.is(tok::kw_template)) {
 270       // If we don't have a scope specifier or an object type, this isn't a
 271       // nested-name-specifier, since they aren't allowed to start with
 272       // 'template'.
 273       if (!HasScopeSpecifier && !ObjectType)
 274         break;
 275
 276       TentativeParsingAction TPA(*this);
 277       SourceLocation TemplateKWLoc = ConsumeToken();
 278
 279       UnqualifiedId TemplateName;
 280       if (Tok.is(tok::identifier)) {
 281         // Consume the identifier.
 282         TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
 283         ConsumeToken();
 284       } else if (Tok.is(tok::kw_operator)) {
 285         // We don't need to actually parse the unqualified-id in this case,
 286         // because a simple-template-id cannot start with 'operator', but
 287         // go ahead and parse it anyway for consistency with the case where
 288         // we already annotated the template-id.
 289         if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
 290                                        TemplateName)) {
 291           TPA.Commit();
 292           break;
 293         }
 294
 295         if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId &&
 296             TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) {
 297           Diag(TemplateName.getSourceRange().getBegin(),
 298                diag::err_id_after_template_in_nested_name_spec)
 299             << TemplateName.getSourceRange();
 300           TPA.Commit();
 301           break;
 302         }
 303       } else {
 304         TPA.Revert();
 305         break;
 306       }
 307
 308       // If the next token is not '<', we have a qualified-id that refers
 309       // to a template name, such as T::template apply, but is not a
 310       // template-id.
 311       if (Tok.isNot(tok::less)) {
 312         TPA.Revert();
 313         break;
 314       }
 315
 316       // Commit to parsing the template-id.
 317       TPA.Commit();
 318       TemplateTy Template;
 319       if (TemplateNameKind TNK = Actions.ActOnDependentTemplateName(
 320               getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
 321               EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
 322         if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
 323                                     TemplateName, false))
 324           return true;
 325       } else
 326         return true;
 327
 328       continue;
 329     }
 330
 331     if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
 332       // We have
 333       //
 334       //   template-id '::'
 335       //
 336       // So we need to check whether the template-id is a simple-template-id of
 337       // the right kind (it should name a type or be dependent), and then
 338       // convert it into a type within the nested-name-specifier.
 339       TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
 340       if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
 341         *MayBePseudoDestructor = true;
 342         return false;
 343       }
 344
 345       if (LastII)
 346         *LastII = TemplateId->Name;
 347
 348       // Consume the template-id token.
 349       ConsumeAnnotationToken();
 350
 351       assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
 352       SourceLocation CCLoc = ConsumeToken();
 353
 354       HasScopeSpecifier = true;
 355
 356       ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
 357                                          TemplateId->NumArgs);
 358
 359       if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
 360                                               SS,
 361                                               TemplateId->TemplateKWLoc,
 362                                               TemplateId->Template,
 363                                               TemplateId->TemplateNameLoc,
 364                                               TemplateId->LAngleLoc,
 365                                               TemplateArgsPtr,
 366                                               TemplateId->RAngleLoc,
 367                                               CCLoc,
 368                                               EnteringContext)) {
 369         SourceLocation StartLoc
 370           = SS.getBeginLoc().isValid()? SS.getBeginLoc()
 371                                       : TemplateId->TemplateNameLoc;
 372         SS.SetInvalid(SourceRange(StartLoc, CCLoc));
 373       }
 374
 375       continue;
 376     }
 377
 378     // The rest of the nested-name-specifier possibilities start with
 379     // tok::identifier.
 380     if (Tok.isNot(tok::identifier))
 381       break;
 382
 383     IdentifierInfo &II = *Tok.getIdentifierInfo();
 384
 385     // nested-name-specifier:
 386     //   type-name '::'
 387     //   namespace-name '::'
 388     //   nested-name-specifier identifier '::'
 389     Token Next = NextToken();
 390     Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(),
 391                                     ObjectType);
 392
 393     // If we get foo:bar, this is almost certainly a typo for foo::bar.  Recover
 394     // and emit a fixit hint for it.
 395     if (Next.is(tok::colon) && !ColonIsSacred) {
 396       if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo,
 397                                             EnteringContext) &&
 398           // If the token after the colon isn't an identifier, it's still an
 399           // error, but they probably meant something else strange so don't
 400           // recover like this.
 401           PP.LookAhead(1).is(tok::identifier)) {
 402         Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
 403           << FixItHint::CreateReplacement(Next.getLocation(), "::");
 404         // Recover as if the user wrote '::'.
 405         Next.setKind(tok::coloncolon);
 406       }
 407     }
 408
 409     if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) {
 410       // It is invalid to have :: {, consume the scope qualifier and pretend
 411       // like we never saw it.
 412       Token Identifier = Tok; // Stash away the identifier.
 413       ConsumeToken();         // Eat the identifier, current token is now '::'.
 414       Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected)
 415           << tok::identifier;
 416       UnconsumeToken(Identifier); // Stick the identifier back.
 417       Next = NextToken();         // Point Next at the '{' token.
 418     }
 419
 420     if (Next.is(tok::coloncolon)) {
 421       if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) &&
 422           !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, IdInfo)) {
 423         *MayBePseudoDestructor = true;
 424         return false;
 425       }
 426
 427       if (ColonIsSacred) {
 428         const Token &Next2 = GetLookAheadToken(2);
 429         if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
 430             Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {
 431           Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
 432               << Next2.getName()
 433               << FixItHint::CreateReplacement(Next.getLocation(), ":");
 434           Token ColonColon;
 435           PP.Lex(ColonColon);
 436           ColonColon.setKind(tok::colon);
 437           PP.EnterToken(ColonColon);
 438           break;
 439         }
 440       }
 441
 442       if (LastII)
 443         *LastII = &II;
 444
 445       // We have an identifier followed by a '::'. Lookup this name
 446       // as the name in a nested-name-specifier.
 447       Token Identifier = Tok;
 448       SourceLocation IdLoc = ConsumeToken();
 449       assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
 450              "NextToken() not working properly!");
 451       Token ColonColon = Tok;
 452       SourceLocation CCLoc = ConsumeToken();
 453
 454       bool IsCorrectedToColon = false;
 455       bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
 456       if (Actions.ActOnCXXNestedNameSpecifier(
 457               getCurScope(), IdInfo, EnteringContext, SS, false,
 458               CorrectionFlagPtr, OnlyNamespace)) {
 459         // Identifier is not recognized as a nested name, but we can have
 460         // mistyped '::' instead of ':'.
 461         if (CorrectionFlagPtr && IsCorrectedToColon) {
 462           ColonColon.setKind(tok::colon);
 463           PP.EnterToken(Tok);
 464           PP.EnterToken(ColonColon);
 465           Tok = Identifier;
 466           break;
 467         }
 468         SS.SetInvalid(SourceRange(IdLoc, CCLoc));
 469       }
 470       HasScopeSpecifier = true;
 471       continue;
 472     }
 473
 474     CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
 475
 476     // nested-name-specifier:
 477     //   type-name '<'
 478     if (Next.is(tok::less)) {
 479       TemplateTy Template;
 480       UnqualifiedId TemplateName;
 481       TemplateName.setIdentifier(&II, Tok.getLocation());
 482       bool MemberOfUnknownSpecialization;
 483       if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
 484                                               /*hasTemplateKeyword=*/false,
 485                                                         TemplateName,
 486                                                         ObjectType,
 487                                                         EnteringContext,
 488                                                         Template,
 489                                               MemberOfUnknownSpecialization)) {
 490         // We have found a template name, so annotate this token
 491         // with a template-id annotation. We do not permit the
 492         // template-id to be translated into a type annotation,
 493         // because some clients (e.g., the parsing of class template
 494         // specializations) still want to see the original template-id
 495         // token.
 496         ConsumeToken();
 497         if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
 498                                     TemplateName, false))
 499           return true;
 500         continue;
 501       }
 502
 503       if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
 504           (IsTypename || IsTemplateArgumentList(1))) {
 505         // We have something like t::getAs<T>, where getAs is a
 506         // member of an unknown specialization. However, this will only
 507         // parse correctly as a template, so suggest the keyword 'template'
 508         // before 'getAs' and treat this as a dependent template name.
 509         unsigned DiagID = diag::err_missing_dependent_template_keyword;
 510         if (getLangOpts().MicrosoftExt)
 511           DiagID = diag::warn_missing_dependent_template_keyword;
 512
 513         Diag(Tok.getLocation(), DiagID)
 514           << II.getName()
 515           << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
 516
 517         if (TemplateNameKind TNK = Actions.ActOnDependentTemplateName(
 518                 getCurScope(), SS, SourceLocation(), TemplateName, ObjectType,
 519                 EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
 520           // Consume the identifier.
 521           ConsumeToken();
 522           if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
 523                                       TemplateName, false))
 524             return true;
 525         }
 526         else
 527           return true;
 528
 529         continue;
 530       }
 531     }
 532
 533     // We don't have any tokens that form the beginning of a
 534     // nested-name-specifier, so we're done.
 535     break;
 536   }
 537
 538   // Even if we didn't see any pieces of a nested-name-specifier, we
 539   // still check whether there is a tilde in this position, which
 540   // indicates a potential pseudo-destructor.
 541   if (CheckForDestructor && Tok.is(tok::tilde))
 542     *MayBePseudoDestructor = true;
 543
 544   return false;
 545 }
 546
 547 ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand,
 548                                            Token &Replacement) {
 549   SourceLocation TemplateKWLoc;
 550   UnqualifiedId Name;
 551   if (ParseUnqualifiedId(SS,
 552                          /*EnteringContext=*/false,
 553                          /*AllowDestructorName=*/false,
 554                          /*AllowConstructorName=*/false,
 555                          /*AllowDeductionGuide=*/false,
 556                          /*ObjectType=*/nullptr, TemplateKWLoc, Name))
 557     return ExprError();
 558
 559   // This is only the direct operand of an & operator if it is not
 560   // followed by a postfix-expression suffix.
 561   if (isAddressOfOperand && isPostfixExpressionSuffixStart())
 562     isAddressOfOperand = false;
 563
 564   return Actions.ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Name,
 565                                    Tok.is(tok::l_paren), isAddressOfOperand,
 566                                    nullptr, /*IsInlineAsmIdentifier=*/false,
 567                                    &Replacement);
 568 }
 569
 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 ///
 612 ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
 613   // qualified-id:
 614   //   '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
 615   //   '::' unqualified-id
 616   //
 617   CXXScopeSpec SS;
 618   ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext=*/false);
 619
 620   Token Replacement;
 621   ExprResult Result =
 622       tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
 623   if (Result.isUnset()) {
 624     // If the ExprResult is valid but null, then typo correction suggested a
 625     // keyword replacement that needs to be reparsed.
 626     UnconsumeToken(Replacement);
 627     Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
 628   }
 629   assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "
 630                               "for a previous keyword suggestion");
 631   return Result;
 632 }
 633
 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 ///
 673 ExprResult Parser::ParseLambdaExpression() {
 674   // Parse lambda-introducer.
 675   LambdaIntroducer Intro;
 676   Optional<unsigned> DiagID = ParseLambdaIntroducer(Intro);
 677   if (DiagID) {
 678     Diag(Tok, DiagID.getValue());
 679     SkipUntil(tok::r_square, StopAtSemi);
 680     SkipUntil(tok::l_brace, StopAtSemi);
 681     SkipUntil(tok::r_brace, StopAtSemi);
 682     return ExprError();
 683   }
 684
 685   return ParseLambdaExpressionAfterIntroducer(Intro);
 686 }
 687
 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().
 693 ExprResult Parser::TryParseLambdaExpression() {
 694   assert(getLangOpts().CPlusPlus11
 695          && Tok.is(tok::l_square)
 696          && "Not at the start of a possible lambda expression.");
 697
 698   const Token Next = NextToken();
 699   if (Next.is(tok::eof)) // Nothing else to lookup here...
 700     return ExprEmpty();
 701
 702   const Token After = GetLookAheadToken(2);
 703   // If lookahead indicates this is a lambda...
 704   if (Next.is(tok::r_square) ||     // []
 705       Next.is(tok::equal) ||        // [=
 706       (Next.is(tok::amp) &&         // [&] or [&,
 707        (After.is(tok::r_square) ||
 708         After.is(tok::comma))) ||
 709       (Next.is(tok::identifier) &&  // [identifier]
 710        After.is(tok::r_square))) {
 711     return ParseLambdaExpression();
 712   }
 713
 714   // If lookahead indicates an ObjC message send...
 715   // [identifier identifier
 716   if (Next.is(tok::identifier) && After.is(tok::identifier)) {
 717     return ExprEmpty();
 718   }
 719
 720   // Here, we're stuck: lambda introducers and Objective-C message sends are
 721   // unambiguous, but it requires arbitrary lookhead.  [a,b,c,d,e,f,g] is a
 722   // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send.  Instead of
 723   // writing two routines to parse a lambda introducer, just try to parse
 724   // a lambda introducer first, and fall back if that fails.
 725   // (TryParseLambdaIntroducer never produces any diagnostic output.)
 726   LambdaIntroducer Intro;
 727   if (TryParseLambdaIntroducer(Intro))
 728     return ExprEmpty();
 729
 730   return ParseLambdaExpressionAfterIntroducer(Intro);
 731 }
 732
 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.
 742 Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
 743                                                  bool *SkippedInits) {
 744   typedef Optional<unsigned> DiagResult;
 745
 746   assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
 747   BalancedDelimiterTracker T(*this, tok::l_square);
 748   T.consumeOpen();
 749
 750   Intro.Range.setBegin(T.getOpenLocation());
 751
 752   bool first = true;
 753
 754   // Parse capture-default.
 755   if (Tok.is(tok::amp) &&
 756       (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
 757     Intro.Default = LCD_ByRef;
 758     Intro.DefaultLoc = ConsumeToken();
 759     first = false;
 760   } else if (Tok.is(tok::equal)) {
 761     Intro.Default = LCD_ByCopy;
 762     Intro.DefaultLoc = ConsumeToken();
 763     first = false;
 764   }
 765
 766   while (Tok.isNot(tok::r_square)) {
 767     if (!first) {
 768       if (Tok.isNot(tok::comma)) {
 769         // Provide a completion for a lambda introducer here. Except
 770         // in Objective-C, where this is Almost Surely meant to be a message
 771         // send. In that case, fail here and let the ObjC message
 772         // expression parser perform the completion.
 773         if (Tok.is(tok::code_completion) &&
 774             !(getLangOpts().ObjC1 && Intro.Default == LCD_None &&
 775               !Intro.Captures.empty())) {
 776           Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
 777                                                /*AfterAmpersand=*/false);
 778           cutOffParsing();
 779           break;
 780         }
 781
 782         return DiagResult(diag::err_expected_comma_or_rsquare);
 783       }
 784       ConsumeToken();
 785     }
 786
 787     if (Tok.is(tok::code_completion)) {
 788       // If we're in Objective-C++ and we have a bare '[', then this is more
 789       // likely to be a message receiver.
 790       if (getLangOpts().ObjC1 && first)
 791         Actions.CodeCompleteObjCMessageReceiver(getCurScope());
 792       else
 793         Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
 794                                              /*AfterAmpersand=*/false);
 795       cutOffParsing();
 796       break;
 797     }
 798
 799     first = false;
 800
 801     // Parse capture.
 802     LambdaCaptureKind Kind = LCK_ByCopy;
 803     LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
 804     SourceLocation Loc;
 805     IdentifierInfo *Id = nullptr;
 806     SourceLocation EllipsisLoc;
 807     ExprResult Init;
 808
 809     if (Tok.is(tok::star)) {
 810       Loc = ConsumeToken();
 811       if (Tok.is(tok::kw_this)) {
 812         ConsumeToken();
 813         Kind = LCK_StarThis;
 814       } else {
 815         return DiagResult(diag::err_expected_star_this_capture);
 816       }
 817     } else if (Tok.is(tok::kw_this)) {
 818       Kind = LCK_This;
 819       Loc = ConsumeToken();
 820     } else {
 821       if (Tok.is(tok::amp)) {
 822         Kind = LCK_ByRef;
 823         ConsumeToken();
 824
 825         if (Tok.is(tok::code_completion)) {
 826           Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
 827                                                /*AfterAmpersand=*/true);
 828           cutOffParsing();
 829           break;
 830         }
 831       }
 832
 833       if (Tok.is(tok::identifier)) {
 834         Id = Tok.getIdentifierInfo();
 835         Loc = ConsumeToken();
 836       } else if (Tok.is(tok::kw_this)) {
 837         // FIXME: If we want to suggest a fixit here, will need to return more
 838         // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be
 839         // Clear()ed to prevent emission in case of tentative parsing?
 840         return DiagResult(diag::err_this_captured_by_reference);
 841       } else {
 842         return DiagResult(diag::err_expected_capture);
 843       }
 844
 845       if (Tok.is(tok::l_paren)) {
 846         BalancedDelimiterTracker Parens(*this, tok::l_paren);
 847         Parens.consumeOpen();
 848
 849         InitKind = LambdaCaptureInitKind::DirectInit;
 850
 851         ExprVector Exprs;
 852         CommaLocsTy Commas;
 853         if (SkippedInits) {
 854           Parens.skipToEnd();
 855           *SkippedInits = true;
 856         } else if (ParseExpressionList(Exprs, Commas)) {
 857           Parens.skipToEnd();
 858           Init = ExprError();
 859         } else {
 860           Parens.consumeClose();
 861           Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
 862                                             Parens.getCloseLocation(),
 863                                             Exprs);
 864         }
 865       } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
 866         // Each lambda init-capture forms its own full expression, which clears
 867         // Actions.MaybeODRUseExprs. So create an expression evaluation context
 868         // to save the necessary state, and restore it later.
 869         EnterExpressionEvaluationContext EC(
 870             Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
 871
 872         if (TryConsumeToken(tok::equal))
 873           InitKind = LambdaCaptureInitKind::CopyInit;
 874         else
 875           InitKind = LambdaCaptureInitKind::ListInit;
 876
 877         if (!SkippedInits) {
 878           Init = ParseInitializer();
 879         } else if (Tok.is(tok::l_brace)) {
 880           BalancedDelimiterTracker Braces(*this, tok::l_brace);
 881           Braces.consumeOpen();
 882           Braces.skipToEnd();
 883           *SkippedInits = true;
 884         } else {
 885           // We're disambiguating this:
 886           //
 887           //   [..., x = expr
 888           //
 889           // We need to find the end of the following expression in order to
 890           // determine whether this is an Obj-C message send's receiver, a
 891           // C99 designator, or a lambda init-capture.
 892           //
 893           // Parse the expression to find where it ends, and annotate it back
 894           // onto the tokens. We would have parsed this expression the same way
 895           // in either case: both the RHS of an init-capture and the RHS of an
 896           // assignment expression are parsed as an initializer-clause, and in
 897           // neither case can anything be added to the scope between the '[' and
 898           // here.
 899           //
 900           // FIXME: This is horrible. Adding a mechanism to skip an expression
 901           // would be much cleaner.
 902           // FIXME: If there is a ',' before the next ']' or ':', we can skip to
 903           // that instead. (And if we see a ':' with no matching '?', we can
 904           // classify this as an Obj-C message send.)
 905           SourceLocation StartLoc = Tok.getLocation();
 906           InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
 907           Init = ParseInitializer();
 908           if (!Init.isInvalid())
 909             Init = Actions.CorrectDelayedTyposInExpr(Init.get());
 910
 911           if (Tok.getLocation() != StartLoc) {
 912             // Back out the lexing of the token after the initializer.
 913             PP.RevertCachedTokens(1);
 914
 915             // Replace the consumed tokens with an appropriate annotation.
 916             Tok.setLocation(StartLoc);
 917             Tok.setKind(tok::annot_primary_expr);
 918             setExprAnnotation(Tok, Init);
 919             Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation());
 920             PP.AnnotateCachedTokens(Tok);
 921
 922             // Consume the annotated initializer.
 923             ConsumeAnnotationToken();
 924           }
 925         }
 926       } else
 927         TryConsumeToken(tok::ellipsis, EllipsisLoc);
 928     }
 929     // If this is an init capture, process the initialization expression
 930     // right away.  For lambda init-captures such as the following:
 931     // const int x = 10;
 932     //  auto L = [i = x+1](int a) {
 933     //    return [j = x+2,
 934     //           &k = x](char b) { };
 935     //  };
 936     // keep in mind that each lambda init-capture has to have:
 937     //  - its initialization expression executed in the context
 938     //    of the enclosing/parent decl-context.
 939     //  - but the variable itself has to be 'injected' into the
 940     //    decl-context of its lambda's call-operator (which has
 941     //    not yet been created).
 942     // Each init-expression is a full-expression that has to get
 943     // Sema-analyzed (for capturing etc.) before its lambda's
 944     // call-operator's decl-context, scope & scopeinfo are pushed on their
 945     // respective stacks.  Thus if any variable is odr-used in the init-capture
 946     // it will correctly get captured in the enclosing lambda, if one exists.
 947     // The init-variables above are created later once the lambdascope and
 948     // call-operators decl-context is pushed onto its respective stack.
 949
 950     // Since the lambda init-capture's initializer expression occurs in the
 951     // context of the enclosing function or lambda, therefore we can not wait
 952     // till a lambda scope has been pushed on before deciding whether the
 953     // variable needs to be captured.  We also need to process all
 954     // lvalue-to-rvalue conversions and discarded-value conversions,
 955     // so that we can avoid capturing certain constant variables.
 956     // For e.g.,
 957     //  void test() {
 958     //   const int x = 10;
 959     //   auto L = [&z = x](char a) { <-- don't capture by the current lambda
 960     //     return [y = x](int i) { <-- don't capture by enclosing lambda
 961     //          return y;
 962     //     }
 963     //   };
 964     // }
 965     // If x was not const, the second use would require 'L' to capture, and
 966     // that would be an error.
 967
 968     ParsedType InitCaptureType;
 969     if (Init.isUsable()) {
 970       // Get the pointer and store it in an lvalue, so we can use it as an
 971       // out argument.
 972       Expr *InitExpr = Init.get();
 973       // This performs any lvalue-to-rvalue conversions if necessary, which
 974       // can affect what gets captured in the containing decl-context.
 975       InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
 976           Loc, Kind == LCK_ByRef, Id, InitKind, InitExpr);
 977       Init = InitExpr;
 978     }
 979     Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
 980                      InitCaptureType);
 981   }
 982
 983   T.consumeClose();
 984   Intro.Range.setEnd(T.getCloseLocation());
 985   return DiagResult();
 986 }
 987
 988 /// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
 989 ///
 990 /// Returns true if it hit something unexpected.
 991 bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
 992   TentativeParsingAction PA(*this);
 993
 994   bool SkippedInits = false;
 995   Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro, &SkippedInits));
 996
 997   if (DiagID) {
 998     PA.Revert();
 999     return true;
1000   }
1001
1002   if (SkippedInits) {
1003     // Parse it again, but this time parse the init-captures too.
1004     PA.Revert();
1005     Intro = LambdaIntroducer();
1006     DiagID = ParseLambdaIntroducer(Intro);
1007     assert(!DiagID && "parsing lambda-introducer failed on reparse");
1008     return false;
1009   }
1010
1011   PA.Commit();
1012   return false;
1013 }
1014
1015 static void
1016 tryConsumeMutableOrConstexprToken(Parser &P, SourceLocation &MutableLoc,
1017                                   SourceLocation &ConstexprLoc,
1018                                   SourceLocation &DeclEndLoc) {
1019   assert(MutableLoc.isInvalid());
1020   assert(ConstexprLoc.isInvalid());
1021   // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
1022   // to the final of those locations. Emit an error if we have multiple
1023   // copies of those keywords and recover.
1024
1025   while (true) {
1026     switch (P.getCurToken().getKind()) {
1027     case tok::kw_mutable: {
1028       if (MutableLoc.isValid()) {
1029         P.Diag(P.getCurToken().getLocation(),
1030                diag::err_lambda_decl_specifier_repeated)
1031             << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1032       }
1033       MutableLoc = P.ConsumeToken();
1034       DeclEndLoc = MutableLoc;
1035       break /*switch*/;
1036     }
1037     case tok::kw_constexpr:
1038       if (ConstexprLoc.isValid()) {
1039         P.Diag(P.getCurToken().getLocation(),
1040                diag::err_lambda_decl_specifier_repeated)
1041             << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1042       }
1043       ConstexprLoc = P.ConsumeToken();
1044       DeclEndLoc = ConstexprLoc;
1045       break /*switch*/;
1046     default:
1047       return;
1048     }
1049   }
1050 }
1051
1052 static void
1053 addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
1054                                   DeclSpec &DS) {
1055   if (ConstexprLoc.isValid()) {
1056     P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus1z
1057                              ? diag::ext_constexpr_on_lambda_cxx1z
1058                              : diag::warn_cxx14_compat_constexpr_on_lambda);
1059     const char *PrevSpec = nullptr;
1060     unsigned DiagID = 0;
1061     DS.SetConstexprSpec(ConstexprLoc, PrevSpec, DiagID);
1062     assert(PrevSpec == nullptr && DiagID == 0 &&
1063            "Constexpr cannot have been set previously!");
1064   }
1065 }
1066
1067 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1068 /// expression.
1069 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1070                      LambdaIntroducer &Intro) {
1071   SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1072   Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1073
1074   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1075                                 "lambda expression parsing");
1076
1077
1078
1079   // FIXME: Call into Actions to add any init-capture declarations to the
1080   // scope while parsing the lambda-declarator and compound-statement.
1081
1082   // Parse lambda-declarator[opt].
1083   DeclSpec DS(AttrFactory);
1084   Declarator D(DS, Declarator::LambdaExprContext);
1085   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1086   Actions.PushLambdaScope();
1087
1088   ParsedAttributes Attr(AttrFactory);
1089   SourceLocation DeclLoc = Tok.getLocation();
1090   if (getLangOpts().CUDA) {
1091     // In CUDA code, GNU attributes are allowed to appear immediately after the
1092     // "[...]", even if there is no "(...)" before the lambda body.
1093     MaybeParseGNUAttributes(D);
1094   }
1095
1096   // Helper to emit a warning if we see a CUDA host/device/global attribute
1097   // after '(...)'. nvcc doesn't accept this.
1098   auto WarnIfHasCUDATargetAttr = [&] {
1099     if (getLangOpts().CUDA)
1100       for (auto *A = Attr.getList(); A != nullptr; A = A->getNext())
1101         if (A->getKind() == AttributeList::AT_CUDADevice ||
1102             A->getKind() == AttributeList::AT_CUDAHost ||
1103             A->getKind() == AttributeList::AT_CUDAGlobal)
1104           Diag(A->getLoc(), diag::warn_cuda_attr_lambda_position)
1105               << A->getName()->getName();
1106   };
1107
1108   TypeResult TrailingReturnType;
1109   if (Tok.is(tok::l_paren)) {
1110     ParseScope PrototypeScope(this,
1111                               Scope::FunctionPrototypeScope |
1112                               Scope::FunctionDeclarationScope |
1113                               Scope::DeclScope);
1114
1115     BalancedDelimiterTracker T(*this, tok::l_paren);
1116     T.consumeOpen();
1117     SourceLocation LParenLoc = T.getOpenLocation();
1118
1119     // Parse parameter-declaration-clause.
1120     SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
1121     SourceLocation EllipsisLoc;
1122
1123     if (Tok.isNot(tok::r_paren)) {
1124       Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth);
1125       ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
1126       // For a generic lambda, each 'auto' within the parameter declaration
1127       // clause creates a template type parameter, so increment the depth.
1128       if (Actions.getCurGenericLambda())
1129         ++CurTemplateDepthTracker;
1130     }
1131     T.consumeClose();
1132     SourceLocation RParenLoc = T.getCloseLocation();
1133     SourceLocation DeclEndLoc = RParenLoc;
1134
1135     // GNU-style attributes must be parsed before the mutable specifier to be
1136     // compatible with GCC.
1137     MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1138
1139     // MSVC-style attributes must be parsed before the mutable specifier to be
1140     // compatible with MSVC.
1141     MaybeParseMicrosoftDeclSpecs(Attr, &DeclEndLoc);
1142
1143     // Parse mutable-opt and/or constexpr-opt, and update the DeclEndLoc.
1144     SourceLocation MutableLoc;
1145     SourceLocation ConstexprLoc;
1146     tryConsumeMutableOrConstexprToken(*this, MutableLoc, ConstexprLoc,
1147                                       DeclEndLoc);
1148
1149     addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
1150
1151     // Parse exception-specification[opt].
1152     ExceptionSpecificationType ESpecType = EST_None;
1153     SourceRange ESpecRange;
1154     SmallVector<ParsedType, 2> DynamicExceptions;
1155     SmallVector<SourceRange, 2> DynamicExceptionRanges;
1156     ExprResult NoexceptExpr;
1157     CachedTokens *ExceptionSpecTokens;
1158     ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
1159                                                ESpecRange,
1160                                                DynamicExceptions,
1161                                                DynamicExceptionRanges,
1162                                                NoexceptExpr,
1163                                                ExceptionSpecTokens);
1164
1165     if (ESpecType != EST_None)
1166       DeclEndLoc = ESpecRange.getEnd();
1167
1168     // Parse attribute-specifier[opt].
1169     MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1170
1171     SourceLocation FunLocalRangeEnd = DeclEndLoc;
1172
1173     // Parse trailing-return-type[opt].
1174     if (Tok.is(tok::arrow)) {
1175       FunLocalRangeEnd = Tok.getLocation();
1176       SourceRange Range;
1177       TrailingReturnType = ParseTrailingReturnType(Range);
1178       if (Range.getEnd().isValid())
1179         DeclEndLoc = Range.getEnd();
1180     }
1181
1182     PrototypeScope.Exit();
1183
1184     WarnIfHasCUDATargetAttr();
1185
1186     SourceLocation NoLoc;
1187     D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1188                                            /*isAmbiguous=*/false,
1189                                            LParenLoc,
1190                                            ParamInfo.data(), ParamInfo.size(),
1191                                            EllipsisLoc, RParenLoc,
1192                                            DS.getTypeQualifiers(),
1193                                            /*RefQualifierIsLValueRef=*/true,
1194                                            /*RefQualifierLoc=*/NoLoc,
1195                                            /*ConstQualifierLoc=*/NoLoc,
1196                                            /*VolatileQualifierLoc=*/NoLoc,
1197                                            /*RestrictQualifierLoc=*/NoLoc,
1198                                            MutableLoc,
1199                                            ESpecType, ESpecRange,
1200                                            DynamicExceptions.data(),
1201                                            DynamicExceptionRanges.data(),
1202                                            DynamicExceptions.size(),
1203                                            NoexceptExpr.isUsable() ?
1204                                              NoexceptExpr.get() : nullptr,
1205                                            /*ExceptionSpecTokens*/nullptr,
1206                                            /*DeclsInPrototype=*/None,
1207                                            LParenLoc, FunLocalRangeEnd, D,
1208                                            TrailingReturnType),
1209                   Attr, DeclEndLoc);
1210   } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1211                          tok::kw_constexpr) ||
1212              (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
1213     // It's common to forget that one needs '()' before 'mutable', an attribute
1214     // specifier, or the result type. Deal with this.
1215     unsigned TokKind = 0;
1216     switch (Tok.getKind()) {
1217     case tok::kw_mutable: TokKind = 0; break;
1218     case tok::arrow: TokKind = 1; break;
1219     case tok::kw___attribute:
1220     case tok::l_square: TokKind = 2; break;
1221     case tok::kw_constexpr: TokKind = 3; break;
1222     default: llvm_unreachable("Unknown token kind");
1223     }
1224
1225     Diag(Tok, diag::err_lambda_missing_parens)
1226       << TokKind
1227       << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
1228     SourceLocation DeclEndLoc = DeclLoc;
1229
1230     // GNU-style attributes must be parsed before the mutable specifier to be
1231     // compatible with GCC.
1232     MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1233
1234     // Parse 'mutable', if it's there.
1235     SourceLocation MutableLoc;
1236     if (Tok.is(tok::kw_mutable)) {
1237       MutableLoc = ConsumeToken();
1238       DeclEndLoc = MutableLoc;
1239     }
1240
1241     // Parse attribute-specifier[opt].
1242     MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1243
1244     // Parse the return type, if there is one.
1245     if (Tok.is(tok::arrow)) {
1246       SourceRange Range;
1247       TrailingReturnType = ParseTrailingReturnType(Range);
1248       if (Range.getEnd().isValid())
1249         DeclEndLoc = Range.getEnd();
1250     }
1251
1252     WarnIfHasCUDATargetAttr();
1253
1254     SourceLocation NoLoc;
1255     D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1256                                                /*isAmbiguous=*/false,
1257                                                /*LParenLoc=*/NoLoc,
1258                                                /*Params=*/nullptr,
1259                                                /*NumParams=*/0,
1260                                                /*EllipsisLoc=*/NoLoc,
1261                                                /*RParenLoc=*/NoLoc,
1262                                                /*TypeQuals=*/0,
1263                                                /*RefQualifierIsLValueRef=*/true,
1264                                                /*RefQualifierLoc=*/NoLoc,
1265                                                /*ConstQualifierLoc=*/NoLoc,
1266                                                /*VolatileQualifierLoc=*/NoLoc,
1267                                                /*RestrictQualifierLoc=*/NoLoc,
1268                                                MutableLoc,
1269                                                EST_None,
1270                                                /*ESpecRange=*/SourceRange(),
1271                                                /*Exceptions=*/nullptr,
1272                                                /*ExceptionRanges=*/nullptr,
1273                                                /*NumExceptions=*/0,
1274                                                /*NoexceptExpr=*/nullptr,
1275                                                /*ExceptionSpecTokens=*/nullptr,
1276                                                /*DeclsInPrototype=*/None,
1277                                                DeclLoc, DeclEndLoc, D,
1278                                                TrailingReturnType),
1279                   Attr, DeclEndLoc);
1280   }
1281
1282   // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1283   // it.
1284   unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope;
1285   ParseScope BodyScope(this, ScopeFlags);
1286
1287   Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
1288
1289   // Parse compound-statement.
1290   if (!Tok.is(tok::l_brace)) {
1291     Diag(Tok, diag::err_expected_lambda_body);
1292     Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1293     return ExprError();
1294   }
1295
1296   StmtResult Stmt(ParseCompoundStatementBody());
1297   BodyScope.Exit();
1298
1299   if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
1300     return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
1301
1302   Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1303   return ExprError();
1304 }
1305
1306 /// ParseCXXCasts - This handles the various ways to cast expressions to another
1307 /// type.
1308 ///
1309 ///       postfix-expression: [C++ 5.2p1]
1310 ///         'dynamic_cast' '<' type-name '>' '(' expression ')'
1311 ///         'static_cast' '<' type-name '>' '(' expression ')'
1312 ///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
1313 ///         'const_cast' '<' type-name '>' '(' expression ')'
1314 ///
1315 ExprResult Parser::ParseCXXCasts() {
1316   tok::TokenKind Kind = Tok.getKind();
1317   const char *CastName = nullptr; // For error messages
1318
1319   switch (Kind) {
1320   default: llvm_unreachable("Unknown C++ cast!");
1321   case tok::kw_const_cast:       CastName = "const_cast";       break;
1322   case tok::kw_dynamic_cast:     CastName = "dynamic_cast";     break;
1323   case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1324   case tok::kw_static_cast:      CastName = "static_cast";      break;
1325   }
1326
1327   SourceLocation OpLoc = ConsumeToken();
1328   SourceLocation LAngleBracketLoc = Tok.getLocation();
1329
1330   // Check for "<::" which is parsed as "[:".  If found, fix token stream,
1331   // diagnose error, suggest fix, and recover parsing.
1332   if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
1333     Token Next = NextToken();
1334     if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1335       FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1336   }
1337
1338   if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1339     return ExprError();
1340
1341   // Parse the common declaration-specifiers piece.
1342   DeclSpec DS(AttrFactory);
1343   ParseSpecifierQualifierList(DS);
1344
1345   // Parse the abstract-declarator, if present.
1346   Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1347   ParseDeclarator(DeclaratorInfo);
1348
1349   SourceLocation RAngleBracketLoc = Tok.getLocation();
1350
1351   if (ExpectAndConsume(tok::greater))
1352     return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1353
1354   SourceLocation LParenLoc, RParenLoc;
1355   BalancedDelimiterTracker T(*this, tok::l_paren);
1356
1357   if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
1358     return ExprError();
1359
1360   ExprResult Result = ParseExpression();
1361
1362   // Match the ')'.
1363   T.consumeClose();
1364
1365   if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
1366     Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
1367                                        LAngleBracketLoc, DeclaratorInfo,
1368                                        RAngleBracketLoc,
1369                                        T.getOpenLocation(), Result.get(),
1370                                        T.getCloseLocation());
1371
1372   return Result;
1373 }
1374
1375 /// ParseCXXTypeid - This handles the C++ typeid expression.
1376 ///
1377 ///       postfix-expression: [C++ 5.2p1]
1378 ///         'typeid' '(' expression ')'
1379 ///         'typeid' '(' type-id ')'
1380 ///
1381 ExprResult Parser::ParseCXXTypeid() {
1382   assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
1383
1384   SourceLocation OpLoc = ConsumeToken();
1385   SourceLocation LParenLoc, RParenLoc;
1386   BalancedDelimiterTracker T(*this, tok::l_paren);
1387
1388   // typeid expressions are always parenthesized.
1389   if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
1390     return ExprError();
1391   LParenLoc = T.getOpenLocation();
1392
1393   ExprResult Result;
1394
1395   // C++0x [expr.typeid]p3:
1396   //   When typeid is applied to an expression other than an lvalue of a
1397   //   polymorphic class type [...] The expression is an unevaluated
1398   //   operand (Clause 5).
1399   //
1400   // Note that we can't tell whether the expression is an lvalue of a
1401   // polymorphic class type until after we've parsed the expression; we
1402   // speculatively assume the subexpression is unevaluated, and fix it up
1403   // later.
1404   //
1405   // We enter the unevaluated context before trying to determine whether we
1406   // have a type-id, because the tentative parse logic will try to resolve
1407   // names, and must treat them as unevaluated.
1408   EnterExpressionEvaluationContext Unevaluated(
1409       Actions, Sema::ExpressionEvaluationContext::Unevaluated,
1410       Sema::ReuseLambdaContextDecl);
1411
1412   if (isTypeIdInParens()) {
1413     TypeResult Ty = ParseTypeName();
1414
1415     // Match the ')'.
1416     T.consumeClose();
1417     RParenLoc = T.getCloseLocation();
1418     if (Ty.isInvalid() || RParenLoc.isInvalid())
1419       return ExprError();
1420
1421     Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1422                                     Ty.get().getAsOpaquePtr(), RParenLoc);
1423   } else {
1424     Result = ParseExpression();
1425
1426     // Match the ')'.
1427     if (Result.isInvalid())
1428       SkipUntil(tok::r_paren, StopAtSemi);
1429     else {
1430       T.consumeClose();
1431       RParenLoc = T.getCloseLocation();
1432       if (RParenLoc.isInvalid())
1433         return ExprError();
1434
1435       Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1436                                       Result.get(), RParenLoc);
1437     }
1438   }
1439
1440   return Result;
1441 }
1442
1443 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1444 ///
1445 ///         '__uuidof' '(' expression ')'
1446 ///         '__uuidof' '(' type-id ')'
1447 ///
1448 ExprResult Parser::ParseCXXUuidof() {
1449   assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1450
1451   SourceLocation OpLoc = ConsumeToken();
1452   BalancedDelimiterTracker T(*this, tok::l_paren);
1453
1454   // __uuidof expressions are always parenthesized.
1455   if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1456     return ExprError();
1457
1458   ExprResult Result;
1459
1460   if (isTypeIdInParens()) {
1461     TypeResult Ty = ParseTypeName();
1462
1463     // Match the ')'.
1464     T.consumeClose();
1465
1466     if (Ty.isInvalid())
1467       return ExprError();
1468
1469     Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1470                                     Ty.get().getAsOpaquePtr(),
1471                                     T.getCloseLocation());
1472   } else {
1473     EnterExpressionEvaluationContext Unevaluated(
1474         Actions, Sema::ExpressionEvaluationContext::Unevaluated);
1475     Result = ParseExpression();
1476
1477     // Match the ')'.
1478     if (Result.isInvalid())
1479       SkipUntil(tok::r_paren, StopAtSemi);
1480     else {
1481       T.consumeClose();
1482
1483       Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1484                                       /*isType=*/false,
1485                                       Result.get(), T.getCloseLocation());
1486     }
1487   }
1488
1489   return Result;
1490 }
1491
1492 /// \brief Parse a C++ pseudo-destructor expression after the base,
1493 /// . or -> operator, and nested-name-specifier have already been
1494 /// parsed.
1495 ///
1496 ///       postfix-expression: [C++ 5.2]
1497 ///         postfix-expression . pseudo-destructor-name
1498 ///         postfix-expression -> pseudo-destructor-name
1499 ///
1500 ///       pseudo-destructor-name:
1501 ///         ::[opt] nested-name-specifier[opt] type-name :: ~type-name
1502 ///         ::[opt] nested-name-specifier template simple-template-id ::
1503 ///                 ~type-name
1504 ///         ::[opt] nested-name-specifier[opt] ~type-name
1505 ///
1506 ExprResult
1507 Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1508                                  tok::TokenKind OpKind,
1509                                  CXXScopeSpec &SS,
1510                                  ParsedType ObjectType) {
1511   // We're parsing either a pseudo-destructor-name or a dependent
1512   // member access that has the same form as a
1513   // pseudo-destructor-name. We parse both in the same way and let
1514   // the action model sort them out.
1515   //
1516   // Note that the ::[opt] nested-name-specifier[opt] has already
1517   // been parsed, and if there was a simple-template-id, it has
1518   // been coalesced into a template-id annotation token.
1519   UnqualifiedId FirstTypeName;
1520   SourceLocation CCLoc;
1521   if (Tok.is(tok::identifier)) {
1522     FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1523     ConsumeToken();
1524     assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1525     CCLoc = ConsumeToken();
1526   } else if (Tok.is(tok::annot_template_id)) {
1527     // FIXME: retrieve TemplateKWLoc from template-id annotation and
1528     // store it in the pseudo-dtor node (to be used when instantiating it).
1529     FirstTypeName.setTemplateId(
1530                               (TemplateIdAnnotation *)Tok.getAnnotationValue());
1531     ConsumeAnnotationToken();
1532     assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1533     CCLoc = ConsumeToken();
1534   } else {
1535     FirstTypeName.setIdentifier(nullptr, SourceLocation());
1536   }
1537
1538   // Parse the tilde.
1539   assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1540   SourceLocation TildeLoc = ConsumeToken();
1541
1542   if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
1543     DeclSpec DS(AttrFactory);
1544     ParseDecltypeSpecifier(DS);
1545     if (DS.getTypeSpecType() == TST_error)
1546       return ExprError();
1547     return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1548                                              TildeLoc, DS);
1549   }
1550
1551   if (!Tok.is(tok::identifier)) {
1552     Diag(Tok, diag::err_destructor_tilde_identifier);
1553     return ExprError();
1554   }
1555
1556   // Parse the second type.
1557   UnqualifiedId SecondTypeName;
1558   IdentifierInfo *Name = Tok.getIdentifierInfo();
1559   SourceLocation NameLoc = ConsumeToken();
1560   SecondTypeName.setIdentifier(Name, NameLoc);
1561
1562   // If there is a '<', the second type name is a template-id. Parse
1563   // it as such.
1564   if (Tok.is(tok::less) &&
1565       ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
1566                                    Name, NameLoc,
1567                                    false, ObjectType, SecondTypeName,
1568                                    /*AssumeTemplateName=*/true))
1569     return ExprError();
1570
1571   return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1572                                            SS, FirstTypeName, CCLoc, TildeLoc,
1573                                            SecondTypeName);
1574 }
1575
1576 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1577 ///
1578 ///       boolean-literal: [C++ 2.13.5]
1579 ///         'true'
1580 ///         'false'
1581 ExprResult Parser::ParseCXXBoolLiteral() {
1582   tok::TokenKind Kind = Tok.getKind();
1583   return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1584 }
1585
1586 /// ParseThrowExpression - This handles the C++ throw expression.
1587 ///
1588 ///       throw-expression: [C++ 15]
1589 ///         'throw' assignment-expression[opt]
1590 ExprResult Parser::ParseThrowExpression() {
1591   assert(Tok.is(tok::kw_throw) && "Not throw!");
1592   SourceLocation ThrowLoc = ConsumeToken();           // Eat the throw token.
1593
1594   // If the current token isn't the start of an assignment-expression,
1595   // then the expression is not present.  This handles things like:
1596   //   "C ? throw : (void)42", which is crazy but legal.
1597   switch (Tok.getKind()) {  // FIXME: move this predicate somewhere common.
1598   case tok::semi:
1599   case tok::r_paren:
1600   case tok::r_square:
1601   case tok::r_brace:
1602   case tok::colon:
1603   case tok::comma:
1604     return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
1605
1606   default:
1607     ExprResult Expr(ParseAssignmentExpression());
1608     if (Expr.isInvalid()) return Expr;
1609     return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
1610   }
1611 }
1612
1613 /// \brief Parse the C++ Coroutines co_yield expression.
1614 ///
1615 ///       co_yield-expression:
1616 ///         'co_yield' assignment-expression[opt]
1617 ExprResult Parser::ParseCoyieldExpression() {
1618   assert(Tok.is(tok::kw_co_yield) && "Not co_yield!");
1619
1620   SourceLocation Loc = ConsumeToken();
1621   ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
1622                                          : ParseAssignmentExpression();
1623   if (!Expr.isInvalid())
1624     Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
1625   return Expr;
1626 }
1627
1628 /// ParseCXXThis - This handles the C++ 'this' pointer.
1629 ///
1630 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1631 /// a non-lvalue expression whose value is the address of the object for which
1632 /// the function is called.
1633 ExprResult Parser::ParseCXXThis() {
1634   assert(Tok.is(tok::kw_this) && "Not 'this'!");
1635   SourceLocation ThisLoc = ConsumeToken();
1636   return Actions.ActOnCXXThis(ThisLoc);
1637 }
1638
1639 /// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1640 /// Can be interpreted either as function-style casting ("int(x)")
1641 /// or class type construction ("ClassType(x,y,z)")
1642 /// or creation of a value-initialized type ("int()").
1643 /// See [C++ 5.2.3].
1644 ///
1645 ///       postfix-expression: [C++ 5.2p1]
1646 ///         simple-type-specifier '(' expression-list[opt] ')'
1647 /// [C++0x] simple-type-specifier braced-init-list
1648 ///         typename-specifier '(' expression-list[opt] ')'
1649 /// [C++0x] typename-specifier braced-init-list
1650 ///
1651 /// In C++1z onwards, the type specifier can also be a template-name.
1652 ExprResult
1653 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1654   Declarator DeclaratorInfo(DS, Declarator::FunctionalCastContext);
1655   ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
1656
1657   assert((Tok.is(tok::l_paren) ||
1658           (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
1659          && "Expected '(' or '{'!");
1660
1661   if (Tok.is(tok::l_brace)) {
1662     ExprResult Init = ParseBraceInitializer();
1663     if (Init.isInvalid())
1664       return Init;
1665     Expr *InitList = Init.get();
1666     return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(),
1667                                              MultiExprArg(&InitList, 1),
1668                                              SourceLocation());
1669   } else {
1670     BalancedDelimiterTracker T(*this, tok::l_paren);
1671     T.consumeOpen();
1672
1673     ExprVector Exprs;
1674     CommaLocsTy CommaLocs;
1675
1676     if (Tok.isNot(tok::r_paren)) {
1677       if (ParseExpressionList(Exprs, CommaLocs, [&] {
1678             Actions.CodeCompleteConstructor(getCurScope(),
1679                                       TypeRep.get()->getCanonicalTypeInternal(),
1680                                             DS.getLocEnd(), Exprs);
1681          })) {
1682         SkipUntil(tok::r_paren, StopAtSemi);
1683         return ExprError();
1684       }
1685     }
1686
1687     // Match the ')'.
1688     T.consumeClose();
1689
1690     // TypeRep could be null, if it references an invalid typedef.
1691     if (!TypeRep)
1692       return ExprError();
1693
1694     assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1695            "Unexpected number of commas!");
1696     return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1697                                              Exprs,
1698                                              T.getCloseLocation());
1699   }
1700 }
1701
1702 /// ParseCXXCondition - if/switch/while condition expression.
1703 ///
1704 ///       condition:
1705 ///         expression
1706 ///         type-specifier-seq declarator '=' assignment-expression
1707 /// [C++11] type-specifier-seq declarator '=' initializer-clause
1708 /// [C++11] type-specifier-seq declarator braced-init-list
1709 /// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1710 ///             '=' assignment-expression
1711 ///
1712 /// In C++1z, a condition may in some contexts be preceded by an
1713 /// optional init-statement. This function will parse that too.
1714 ///
1715 /// \param InitStmt If non-null, an init-statement is permitted, and if present
1716 /// will be parsed and stored here.
1717 ///
1718 /// \param Loc The location of the start of the statement that requires this
1719 /// condition, e.g., the "for" in a for loop.
1720 ///
1721 /// \returns The parsed condition.
1722 Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
1723                                                 SourceLocation Loc,
1724                                                 Sema::ConditionKind CK) {
1725   if (Tok.is(tok::code_completion)) {
1726     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
1727     cutOffParsing();
1728     return Sema::ConditionError();
1729   }
1730
1731   ParsedAttributesWithRange attrs(AttrFactory);
1732   MaybeParseCXX11Attributes(attrs);
1733
1734   // Determine what kind of thing we have.
1735   switch (isCXXConditionDeclarationOrInitStatement(InitStmt)) {
1736   case ConditionOrInitStatement::Expression: {
1737     ProhibitAttributes(attrs);
1738
1739     // Parse the expression.
1740     ExprResult Expr = ParseExpression(); // expression
1741     if (Expr.isInvalid())
1742       return Sema::ConditionError();
1743
1744     if (InitStmt && Tok.is(tok::semi)) {
1745       *InitStmt = Actions.ActOnExprStmt(Expr.get());
1746       ConsumeToken();
1747       return ParseCXXCondition(nullptr, Loc, CK);
1748     }
1749
1750     return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK);
1751   }
1752
1753   case ConditionOrInitStatement::InitStmtDecl: {
1754     Diag(Tok.getLocation(), getLangOpts().CPlusPlus1z
1755                                 ? diag::warn_cxx14_compat_init_statement
1756                                 : diag::ext_init_statement)
1757         << (CK == Sema::ConditionKind::Switch);
1758     SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1759     DeclGroupPtrTy DG = ParseSimpleDeclaration(
1760         Declarator::InitStmtContext, DeclEnd, attrs, /*RequireSemi=*/true);
1761     *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
1762     return ParseCXXCondition(nullptr, Loc, CK);
1763   }
1764
1765   case ConditionOrInitStatement::ConditionDecl:
1766   case ConditionOrInitStatement::Error:
1767     break;
1768   }
1769
1770   // type-specifier-seq
1771   DeclSpec DS(AttrFactory);
1772   DS.takeAttributesFrom(attrs);
1773   ParseSpecifierQualifierList(DS, AS_none, DSC_condition);
1774
1775   // declarator
1776   Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
1777   ParseDeclarator(DeclaratorInfo);
1778
1779   // simple-asm-expr[opt]
1780   if (Tok.is(tok::kw_asm)) {
1781     SourceLocation Loc;
1782     ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1783     if (AsmLabel.isInvalid()) {
1784       SkipUntil(tok::semi, StopAtSemi);
1785       return Sema::ConditionError();
1786     }
1787     DeclaratorInfo.setAsmLabel(AsmLabel.get());
1788     DeclaratorInfo.SetRangeEnd(Loc);
1789   }
1790
1791   // If attributes are present, parse them.
1792   MaybeParseGNUAttributes(DeclaratorInfo);
1793
1794   // Type-check the declaration itself.
1795   DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
1796                                                         DeclaratorInfo);
1797   if (Dcl.isInvalid())
1798     return Sema::ConditionError();
1799   Decl *DeclOut = Dcl.get();
1800
1801   // '=' assignment-expression
1802   // If a '==' or '+=' is found, suggest a fixit to '='.
1803   bool CopyInitialization = isTokenEqualOrEqualTypo();
1804   if (CopyInitialization)
1805     ConsumeToken();
1806
1807   ExprResult InitExpr = ExprError();
1808   if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
1809     Diag(Tok.getLocation(),
1810          diag::warn_cxx98_compat_generalized_initializer_lists);
1811     InitExpr = ParseBraceInitializer();
1812   } else if (CopyInitialization) {
1813     InitExpr = ParseAssignmentExpression();
1814   } else if (Tok.is(tok::l_paren)) {
1815     // This was probably an attempt to initialize the variable.
1816     SourceLocation LParen = ConsumeParen(), RParen = LParen;
1817     if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
1818       RParen = ConsumeParen();
1819     Diag(DeclOut->getLocation(),
1820          diag::err_expected_init_in_condition_lparen)
1821       << SourceRange(LParen, RParen);
1822   } else {
1823     Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
1824   }
1825
1826   if (!InitExpr.isInvalid())
1827     Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
1828   else
1829     Actions.ActOnInitializerError(DeclOut);
1830
1831   Actions.FinalizeDeclaration(DeclOut);
1832   return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
1833 }
1834
1835 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1836 /// This should only be called when the current token is known to be part of
1837 /// simple-type-specifier.
1838 ///
1839 ///       simple-type-specifier:
1840 ///         '::'[opt] nested-name-specifier[opt] type-name
1841 ///         '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1842 ///         char
1843 ///         wchar_t
1844 ///         bool
1845 ///         short
1846 ///         int
1847 ///         long
1848 ///         signed
1849 ///         unsigned
1850 ///         float
1851 ///         double
1852 ///         void
1853 /// [GNU]   typeof-specifier
1854 /// [C++0x] auto               [TODO]
1855 ///
1856 ///       type-name:
1857 ///         class-name
1858 ///         enum-name
1859 ///         typedef-name
1860 ///
1861 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
1862   DS.SetRangeStart(Tok.getLocation());
1863   const char *PrevSpec;
1864   unsigned DiagID;
1865   SourceLocation Loc = Tok.getLocation();
1866   const clang::PrintingPolicy &Policy =
1867       Actions.getASTContext().getPrintingPolicy();
1868
1869   switch (Tok.getKind()) {
1870   case tok::identifier:   // foo::bar
1871   case tok::coloncolon:   // ::foo::bar
1872     llvm_unreachable("Annotation token should already be formed!");
1873   default:
1874     llvm_unreachable("Not a simple-type-specifier token!");
1875
1876   // type-name
1877   case tok::annot_typename: {
1878     if (getTypeAnnotation(Tok))
1879       DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
1880                          getTypeAnnotation(Tok), Policy);
1881     else
1882       DS.SetTypeSpecError();
1883
1884     DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1885     ConsumeAnnotationToken();
1886
1887     DS.Finish(Actions, Policy);
1888     return;
1889   }
1890
1891   // builtin types
1892   case tok::kw_short:
1893     DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy);
1894     break;
1895   case tok::kw_long:
1896     DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy);
1897     break;
1898   case tok::kw___int64:
1899     DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy);
1900     break;
1901   case tok::kw_signed:
1902     DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
1903     break;
1904   case tok::kw_unsigned:
1905     DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
1906     break;
1907   case tok::kw_void:
1908     DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
1909     break;
1910   case tok::kw_char:
1911     DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
1912     break;
1913   case tok::kw_int:
1914     DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
1915     break;
1916   case tok::kw___int128:
1917     DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
1918     break;
1919   case tok::kw_half:
1920     DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
1921     break;
1922   case tok::kw_float:
1923     DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
1924     break;
1925   case tok::kw_double:
1926     DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
1927     break;
1928   case tok::kw___float128:
1929     DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
1930     break;
1931   case tok::kw_wchar_t:
1932     DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
1933     break;
1934   case tok::kw_char16_t:
1935     DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
1936     break;
1937   case tok::kw_char32_t:
1938     DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
1939     break;
1940   case tok::kw_bool:
1941     DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
1942     break;
1943   case tok::annot_decltype:
1944   case tok::kw_decltype:
1945     DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
1946     return DS.Finish(Actions, Policy);
1947
1948   // GNU typeof support.
1949   case tok::kw_typeof:
1950     ParseTypeofSpecifier(DS);
1951     DS.Finish(Actions, Policy);
1952     return;
1953   }
1954   ConsumeAnyToken();
1955   DS.SetRangeEnd(PrevTokLocation);
1956   DS.Finish(Actions, Policy);
1957 }
1958
1959 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1960 /// [dcl.name]), which is a non-empty sequence of type-specifiers,
1961 /// e.g., "const short int". Note that the DeclSpec is *not* finished
1962 /// by parsing the type-specifier-seq, because these sequences are
1963 /// typically followed by some form of declarator. Returns true and
1964 /// emits diagnostics if this is not a type-specifier-seq, false
1965 /// otherwise.
1966 ///
1967 ///   type-specifier-seq: [C++ 8.1]
1968 ///     type-specifier type-specifier-seq[opt]
1969 ///
1970 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
1971   ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
1972   DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
1973   return false;
1974 }
1975
1976 /// \brief Finish parsing a C++ unqualified-id that is a template-id of
1977 /// some form.
1978 ///
1979 /// This routine is invoked when a '<' is encountered after an identifier or
1980 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1981 /// whether the unqualified-id is actually a template-id. This routine will
1982 /// then parse the template arguments and form the appropriate template-id to
1983 /// return to the caller.
1984 ///
1985 /// \param SS the nested-name-specifier that precedes this template-id, if
1986 /// we're actually parsing a qualified-id.
1987 ///
1988 /// \param Name for constructor and destructor names, this is the actual
1989 /// identifier that may be a template-name.
1990 ///
1991 /// \param NameLoc the location of the class-name in a constructor or
1992 /// destructor.
1993 ///
1994 /// \param EnteringContext whether we're entering the scope of the
1995 /// nested-name-specifier.
1996 ///
1997 /// \param ObjectType if this unqualified-id occurs within a member access
1998 /// expression, the type of the base object whose member is being accessed.
1999 ///
2000 /// \param Id as input, describes the template-name or operator-function-id
2001 /// that precedes the '<'. If template arguments were parsed successfully,
2002 /// will be updated with the template-id.
2003 ///
2004 /// \param AssumeTemplateId When true, this routine will assume that the name
2005 /// refers to a template without performing name lookup to verify.
2006 ///
2007 /// \returns true if a parse error occurred, false otherwise.
2008 bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
2009                                           SourceLocation TemplateKWLoc,
2010                                           IdentifierInfo *Name,
2011                                           SourceLocation NameLoc,
2012                                           bool EnteringContext,
2013                                           ParsedType ObjectType,
2014                                           UnqualifiedId &Id,
2015                                           bool AssumeTemplateId) {
2016   assert((AssumeTemplateId || Tok.is(tok::less)) &&
2017          "Expected '<' to finish parsing a template-id");
2018
2019   TemplateTy Template;
2020   TemplateNameKind TNK = TNK_Non_template;
2021   switch (Id.getKind()) {
2022   case UnqualifiedId::IK_Identifier:
2023   case UnqualifiedId::IK_OperatorFunctionId:
2024   case UnqualifiedId::IK_LiteralOperatorId:
2025     if (AssumeTemplateId) {
2026       // We defer the injected-class-name checks until we've found whether
2027       // this template-id is used to form a nested-name-specifier or not.
2028       TNK = Actions.ActOnDependentTemplateName(
2029           getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2030           Template, /*AllowInjectedClassName*/ true);
2031       if (TNK == TNK_Non_template)
2032         return true;
2033     } else {
2034       bool MemberOfUnknownSpecialization;
2035       TNK = Actions.isTemplateName(getCurScope(), SS,
2036                                    TemplateKWLoc.isValid(), Id,
2037                                    ObjectType, EnteringContext, Template,
2038                                    MemberOfUnknownSpecialization);
2039
2040       if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
2041           ObjectType && IsTemplateArgumentList()) {
2042         // We have something like t->getAs<T>(), where getAs is a
2043         // member of an unknown specialization. However, this will only
2044         // parse correctly as a template, so suggest the keyword 'template'
2045         // before 'getAs' and treat this as a dependent template name.
2046         std::string Name;
2047         if (Id.getKind() == UnqualifiedId::IK_Identifier)
2048           Name = Id.Identifier->getName();
2049         else {
2050           Name = "operator ";
2051           if (Id.getKind() == UnqualifiedId::IK_OperatorFunctionId)
2052             Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
2053           else
2054             Name += Id.Identifier->getName();
2055         }
2056         Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
2057           << Name
2058           << FixItHint::CreateInsertion(Id.StartLocation, "template ");
2059         TNK = Actions.ActOnDependentTemplateName(
2060             getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2061             Template, /*AllowInjectedClassName*/ true);
2062         if (TNK == TNK_Non_template)
2063           return true;
2064       }
2065     }
2066     break;
2067
2068   case UnqualifiedId::IK_ConstructorName: {
2069     UnqualifiedId TemplateName;
2070     bool MemberOfUnknownSpecialization;
2071     TemplateName.setIdentifier(Name, NameLoc);
2072     TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2073                                  TemplateName, ObjectType,
2074                                  EnteringContext, Template,
2075                                  MemberOfUnknownSpecialization);
2076     break;
2077   }
2078
2079   case UnqualifiedId::IK_DestructorName: {
2080     UnqualifiedId TemplateName;
2081     bool MemberOfUnknownSpecialization;
2082     TemplateName.setIdentifier(Name, NameLoc);
2083     if (ObjectType) {
2084       TNK = Actions.ActOnDependentTemplateName(
2085           getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2086           EnteringContext, Template, /*AllowInjectedClassName*/ true);
2087       if (TNK == TNK_Non_template)
2088         return true;
2089     } else {
2090       TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2091                                    TemplateName, ObjectType,
2092                                    EnteringContext, Template,
2093                                    MemberOfUnknownSpecialization);
2094
2095       if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
2096         Diag(NameLoc, diag::err_destructor_template_id)
2097           << Name << SS.getRange();
2098         return true;
2099       }
2100     }
2101     break;
2102   }
2103
2104   default:
2105     return false;
2106   }
2107
2108   if (TNK == TNK_Non_template)
2109     return false;
2110
2111   // Parse the enclosed template argument list.
2112   SourceLocation LAngleLoc, RAngleLoc;
2113   TemplateArgList TemplateArgs;
2114   if (Tok.is(tok::less) && ParseTemplateIdAfterTemplateName(
2115                                true, LAngleLoc, TemplateArgs, RAngleLoc))
2116     return true;
2117
2118   if (Id.getKind() == UnqualifiedId::IK_Identifier ||
2119       Id.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2120       Id.getKind() == UnqualifiedId::IK_LiteralOperatorId) {
2121     // Form a parsed representation of the template-id to be stored in the
2122     // UnqualifiedId.
2123
2124     // FIXME: Store name for literal operator too.
2125     IdentifierInfo *TemplateII =
2126         Id.getKind() == UnqualifiedId::IK_Identifier ? Id.Identifier : nullptr;
2127     OverloadedOperatorKind OpKind = Id.getKind() == UnqualifiedId::IK_Identifier
2128                                         ? OO_None
2129                                         : Id.OperatorFunctionId.Operator;
2130
2131     TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create(
2132         SS, TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
2133         LAngleLoc, RAngleLoc, TemplateArgs, TemplateIds);
2134
2135     Id.setTemplateId(TemplateId);
2136     return false;
2137   }
2138
2139   // Bundle the template arguments together.
2140   ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
2141
2142   // Constructor and destructor names.
2143   TypeResult Type
2144     = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
2145                                   Template, Name, NameLoc,
2146                                   LAngleLoc, TemplateArgsPtr, RAngleLoc,
2147                                   /*IsCtorOrDtorName=*/true);
2148   if (Type.isInvalid())
2149     return true;
2150
2151   if (Id.getKind() == UnqualifiedId::IK_ConstructorName)
2152     Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2153   else
2154     Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2155
2156   return false;
2157 }
2158
2159 /// \brief Parse an operator-function-id or conversion-function-id as part
2160 /// of a C++ unqualified-id.
2161 ///
2162 /// This routine is responsible only for parsing the operator-function-id or
2163 /// conversion-function-id; it does not handle template arguments in any way.
2164 ///
2165 /// \code
2166 ///       operator-function-id: [C++ 13.5]
2167 ///         'operator' operator
2168 ///
2169 ///       operator: one of
2170 ///            new   delete  new[]   delete[]
2171 ///            +     -    *  /    %  ^    &   |   ~
2172 ///            !     =    <  >    += -=   *=  /=  %=
2173 ///            ^=    &=   |= <<   >> >>= <<=  ==  !=
2174 ///            <=    >=   && ||   ++ --   ,   ->* ->
2175 ///            ()    []
2176 ///
2177 ///       conversion-function-id: [C++ 12.3.2]
2178 ///         operator conversion-type-id
2179 ///
2180 ///       conversion-type-id:
2181 ///         type-specifier-seq conversion-declarator[opt]
2182 ///
2183 ///       conversion-declarator:
2184 ///         ptr-operator conversion-declarator[opt]
2185 /// \endcode
2186 ///
2187 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2188 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2189 ///
2190 /// \param EnteringContext whether we are entering the scope of the
2191 /// nested-name-specifier.
2192 ///
2193 /// \param ObjectType if this unqualified-id occurs within a member access
2194 /// expression, the type of the base object whose member is being accessed.
2195 ///
2196 /// \param Result on a successful parse, contains the parsed unqualified-id.
2197 ///
2198 /// \returns true if parsing fails, false otherwise.
2199 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2200                                         ParsedType ObjectType,
2201                                         UnqualifiedId &Result) {
2202   assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
2203
2204   // Consume the 'operator' keyword.
2205   SourceLocation KeywordLoc = ConsumeToken();
2206
2207   // Determine what kind of operator name we have.
2208   unsigned SymbolIdx = 0;
2209   SourceLocation SymbolLocations[3];
2210   OverloadedOperatorKind Op = OO_None;
2211   switch (Tok.getKind()) {
2212     case tok::kw_new:
2213     case tok::kw_delete: {
2214       bool isNew = Tok.getKind() == tok::kw_new;
2215       // Consume the 'new' or 'delete'.
2216       SymbolLocations[SymbolIdx++] = ConsumeToken();
2217       // Check for array new/delete.
2218       if (Tok.is(tok::l_square) &&
2219           (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
2220         // Consume the '[' and ']'.
2221         BalancedDelimiterTracker T(*this, tok::l_square);
2222         T.consumeOpen();
2223         T.consumeClose();
2224         if (T.getCloseLocation().isInvalid())
2225           return true;
2226
2227         SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2228         SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2229         Op = isNew? OO_Array_New : OO_Array_Delete;
2230       } else {
2231         Op = isNew? OO_New : OO_Delete;
2232       }
2233       break;
2234     }
2235
2236 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2237     case tok::Token:                                                     \
2238       SymbolLocations[SymbolIdx++] = ConsumeToken();                     \
2239       Op = OO_##Name;                                                    \
2240       break;
2241 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2242 #include "clang/Basic/OperatorKinds.def"
2243
2244     case tok::l_paren: {
2245       // Consume the '(' and ')'.
2246       BalancedDelimiterTracker T(*this, tok::l_paren);
2247       T.consumeOpen();
2248       T.consumeClose();
2249       if (T.getCloseLocation().isInvalid())
2250         return true;
2251
2252       SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2253       SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2254       Op = OO_Call;
2255       break;
2256     }
2257
2258     case tok::l_square: {
2259       // Consume the '[' and ']'.
2260       BalancedDelimiterTracker T(*this, tok::l_square);
2261       T.consumeOpen();
2262       T.consumeClose();
2263       if (T.getCloseLocation().isInvalid())
2264         return true;
2265
2266       SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2267       SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2268       Op = OO_Subscript;
2269       break;
2270     }
2271
2272     case tok::code_completion: {
2273       // Code completion for the operator name.
2274       Actions.CodeCompleteOperatorName(getCurScope());
2275       cutOffParsing();
2276       // Don't try to parse any further.
2277       return true;
2278     }
2279
2280     default:
2281       break;
2282   }
2283
2284   if (Op != OO_None) {
2285     // We have parsed an operator-function-id.
2286     Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2287     return false;
2288   }
2289
2290   // Parse a literal-operator-id.
2291   //
2292   //   literal-operator-id: C++11 [over.literal]
2293   //     operator string-literal identifier
2294   //     operator user-defined-string-literal
2295
2296   if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
2297     Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
2298
2299     SourceLocation DiagLoc;
2300     unsigned DiagId = 0;
2301
2302     // We're past translation phase 6, so perform string literal concatenation
2303     // before checking for "".
2304     SmallVector<Token, 4> Toks;
2305     SmallVector<SourceLocation, 4> TokLocs;
2306     while (isTokenStringLiteral()) {
2307       if (!Tok.is(tok::string_literal) && !DiagId) {
2308         // C++11 [over.literal]p1:
2309         //   The string-literal or user-defined-string-literal in a
2310         //   literal-operator-id shall have no encoding-prefix [...].
2311         DiagLoc = Tok.getLocation();
2312         DiagId = diag::err_literal_operator_string_prefix;
2313       }
2314       Toks.push_back(Tok);
2315       TokLocs.push_back(ConsumeStringToken());
2316     }
2317
2318     StringLiteralParser Literal(Toks, PP);
2319     if (Literal.hadError)
2320       return true;
2321
2322     // Grab the literal operator's suffix, which will be either the next token
2323     // or a ud-suffix from the string literal.
2324     IdentifierInfo *II = nullptr;
2325     SourceLocation SuffixLoc;
2326     if (!Literal.getUDSuffix().empty()) {
2327       II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2328       SuffixLoc =
2329         Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
2330                                        Literal.getUDSuffixOffset(),
2331                                        PP.getSourceManager(), getLangOpts());
2332     } else if (Tok.is(tok::identifier)) {
2333       II = Tok.getIdentifierInfo();
2334       SuffixLoc = ConsumeToken();
2335       TokLocs.push_back(SuffixLoc);
2336     } else {
2337       Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
2338       return true;
2339     }
2340
2341     // The string literal must be empty.
2342     if (!Literal.GetString().empty() || Literal.Pascal) {
2343       // C++11 [over.literal]p1:
2344       //   The string-literal or user-defined-string-literal in a
2345       //   literal-operator-id shall [...] contain no characters
2346       //   other than the implicit terminating '\0'.
2347       DiagLoc = TokLocs.front();
2348       DiagId = diag::err_literal_operator_string_not_empty;
2349     }
2350
2351     if (DiagId) {
2352       // This isn't a valid literal-operator-id, but we think we know
2353       // what the user meant. Tell them what they should have written.
2354       SmallString<32> Str;
2355       Str += "\"\"";
2356       Str += II->getName();
2357       Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2358           SourceRange(TokLocs.front(), TokLocs.back()), Str);
2359     }
2360
2361     Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
2362
2363     return Actions.checkLiteralOperatorId(SS, Result);
2364   }
2365
2366   // Parse a conversion-function-id.
2367   //
2368   //   conversion-function-id: [C++ 12.3.2]
2369   //     operator conversion-type-id
2370   //
2371   //   conversion-type-id:
2372   //     type-specifier-seq conversion-declarator[opt]
2373   //
2374   //   conversion-declarator:
2375   //     ptr-operator conversion-declarator[opt]
2376
2377   // Parse the type-specifier-seq.
2378   DeclSpec DS(AttrFactory);
2379   if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
2380     return true;
2381
2382   // Parse the conversion-declarator, which is merely a sequence of
2383   // ptr-operators.
2384   Declarator D(DS, Declarator::ConversionIdContext);
2385   ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2386
2387   // Finish up the type.
2388   TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
2389   if (Ty.isInvalid())
2390     return true;
2391
2392   // Note that this is a conversion-function-id.
2393   Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2394                                  D.getSourceRange().getEnd());
2395   return false;
2396 }
2397
2398 /// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
2399 /// name of an entity.
2400 ///
2401 /// \code
2402 ///       unqualified-id: [C++ expr.prim.general]
2403 ///         identifier
2404 ///         operator-function-id
2405 ///         conversion-function-id
2406 /// [C++0x] literal-operator-id [TODO]
2407 ///         ~ class-name
2408 ///         template-id
2409 ///
2410 /// \endcode
2411 ///
2412 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2413 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2414 ///
2415 /// \param EnteringContext whether we are entering the scope of the
2416 /// nested-name-specifier.
2417 ///
2418 /// \param AllowDestructorName whether we allow parsing of a destructor name.
2419 ///
2420 /// \param AllowConstructorName whether we allow parsing a constructor name.
2421 ///
2422 /// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2423 ///
2424 /// \param ObjectType if this unqualified-id occurs within a member access
2425 /// expression, the type of the base object whose member is being accessed.
2426 ///
2427 /// \param Result on a successful parse, contains the parsed unqualified-id.
2428 ///
2429 /// \returns true if parsing fails, false otherwise.
2430 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2431                                 bool AllowDestructorName,
2432                                 bool AllowConstructorName,
2433                                 bool AllowDeductionGuide,
2434                                 ParsedType ObjectType,
2435                                 SourceLocation& TemplateKWLoc,
2436                                 UnqualifiedId &Result) {
2437
2438   // Handle 'A::template B'. This is for template-ids which have not
2439   // already been annotated by ParseOptionalCXXScopeSpecifier().
2440   bool TemplateSpecified = false;
2441   if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
2442       (ObjectType || SS.isSet())) {
2443     TemplateSpecified = true;
2444     TemplateKWLoc = ConsumeToken();
2445   }
2446
2447   // unqualified-id:
2448   //   identifier
2449   //   template-id (when it hasn't already been annotated)
2450   if (Tok.is(tok::identifier)) {
2451     // Consume the identifier.
2452     IdentifierInfo *Id = Tok.getIdentifierInfo();
2453     SourceLocation IdLoc = ConsumeToken();
2454
2455     if (!getLangOpts().CPlusPlus) {
2456       // If we're not in C++, only identifiers matter. Record the
2457       // identifier and return.
2458       Result.setIdentifier(Id, IdLoc);
2459       return false;
2460     }
2461
2462     ParsedTemplateTy TemplateName;
2463     if (AllowConstructorName &&
2464         Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
2465       // We have parsed a constructor name.
2466       ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, false,
2467                                           false, nullptr,
2468                                           /*IsCtorOrDtorName=*/true,
2469                                           /*NonTrivialTypeSourceInfo=*/true);
2470       Result.setConstructorName(Ty, IdLoc, IdLoc);
2471     } else if (getLangOpts().CPlusPlus1z &&
2472                AllowDeductionGuide && SS.isEmpty() &&
2473                Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
2474                                             &TemplateName)) {
2475       // We have parsed a template-name naming a deduction guide.
2476       Result.setDeductionGuideName(TemplateName, IdLoc);
2477     } else {
2478       // We have parsed an identifier.
2479       Result.setIdentifier(Id, IdLoc);
2480     }
2481
2482     // If the next token is a '<', we may have a template.
2483     if (TemplateSpecified || Tok.is(tok::less))
2484       return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2485                                           EnteringContext, ObjectType,
2486                                           Result, TemplateSpecified);
2487
2488     return false;
2489   }
2490
2491   // unqualified-id:
2492   //   template-id (already parsed and annotated)
2493   if (Tok.is(tok::annot_template_id)) {
2494     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2495
2496     // If the template-name names the current class, then this is a constructor
2497     if (AllowConstructorName && TemplateId->Name &&
2498         Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2499       if (SS.isSet()) {
2500         // C++ [class.qual]p2 specifies that a qualified template-name
2501         // is taken as the constructor name where a constructor can be
2502         // declared. Thus, the template arguments are extraneous, so
2503         // complain about them and remove them entirely.
2504         Diag(TemplateId->TemplateNameLoc,
2505              diag::err_out_of_line_constructor_template_id)
2506           << TemplateId->Name
2507           << FixItHint::CreateRemoval(
2508                     SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2509         ParsedType Ty =
2510             Actions.getTypeName(*TemplateId->Name, TemplateId->TemplateNameLoc,
2511                                 getCurScope(), &SS, false, false, nullptr,
2512                                 /*IsCtorOrDtorName=*/true,
2513                                 /*NontrivialTypeSourceInfo=*/true);
2514         Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2515                                   TemplateId->RAngleLoc);
2516         ConsumeAnnotationToken();
2517         return false;
2518       }
2519
2520       Result.setConstructorTemplateId(TemplateId);
2521       ConsumeAnnotationToken();
2522       return false;
2523     }
2524
2525     // We have already parsed a template-id; consume the annotation token as
2526     // our unqualified-id.
2527     Result.setTemplateId(TemplateId);
2528     TemplateKWLoc = TemplateId->TemplateKWLoc;
2529     ConsumeAnnotationToken();
2530     return false;
2531   }
2532
2533   // unqualified-id:
2534   //   operator-function-id
2535   //   conversion-function-id
2536   if (Tok.is(tok::kw_operator)) {
2537     if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2538       return true;
2539
2540     // If we have an operator-function-id or a literal-operator-id and the next
2541     // token is a '<', we may have a
2542     //
2543     //   template-id:
2544     //     operator-function-id < template-argument-list[opt] >
2545     if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2546          Result.getKind() == UnqualifiedId::IK_LiteralOperatorId) &&
2547         (TemplateSpecified || Tok.is(tok::less)))
2548       return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2549                                           nullptr, SourceLocation(),
2550                                           EnteringContext, ObjectType,
2551                                           Result, TemplateSpecified);
2552
2553     return false;
2554   }
2555
2556   if (getLangOpts().CPlusPlus &&
2557       (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
2558     // C++ [expr.unary.op]p10:
2559     //   There is an ambiguity in the unary-expression ~X(), where X is a
2560     //   class-name. The ambiguity is resolved in favor of treating ~ as a
2561     //    unary complement rather than treating ~X as referring to a destructor.
2562
2563     // Parse the '~'.
2564     SourceLocation TildeLoc = ConsumeToken();
2565
2566     if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2567       DeclSpec DS(AttrFactory);
2568       SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2569       if (ParsedType Type =
2570               Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
2571         Result.setDestructorName(TildeLoc, Type, EndLoc);
2572         return false;
2573       }
2574       return true;
2575     }
2576
2577     // Parse the class-name.
2578     if (Tok.isNot(tok::identifier)) {
2579       Diag(Tok, diag::err_destructor_tilde_identifier);
2580       return true;
2581     }
2582
2583     // If the user wrote ~T::T, correct it to T::~T.
2584     DeclaratorScopeObj DeclScopeObj(*this, SS);
2585     if (!TemplateSpecified && NextToken().is(tok::coloncolon)) {
2586       // Don't let ParseOptionalCXXScopeSpecifier() "correct"
2587       // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
2588       // it will confuse this recovery logic.
2589       ColonProtectionRAIIObject ColonRAII(*this, false);
2590
2591       if (SS.isSet()) {
2592         AnnotateScopeToken(SS, /*NewAnnotation*/true);
2593         SS.clear();
2594       }
2595       if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, EnteringContext))
2596         return true;
2597       if (SS.isNotEmpty())
2598         ObjectType = nullptr;
2599       if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
2600           !SS.isSet()) {
2601         Diag(TildeLoc, diag::err_destructor_tilde_scope);
2602         return true;
2603       }
2604
2605       // Recover as if the tilde had been written before the identifier.
2606       Diag(TildeLoc, diag::err_destructor_tilde_scope)
2607         << FixItHint::CreateRemoval(TildeLoc)
2608         << FixItHint::CreateInsertion(Tok.getLocation(), "~");
2609
2610       // Temporarily enter the scope for the rest of this function.
2611       if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
2612         DeclScopeObj.EnterDeclaratorScope();
2613     }
2614
2615     // Parse the class-name (or template-name in a simple-template-id).
2616     IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2617     SourceLocation ClassNameLoc = ConsumeToken();
2618
2619     if (TemplateSpecified || Tok.is(tok::less)) {
2620       Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
2621       return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2622                                           ClassName, ClassNameLoc,
2623                                           EnteringContext, ObjectType,
2624                                           Result, TemplateSpecified);
2625     }
2626
2627     // Note that this is a destructor name.
2628     ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
2629                                               ClassNameLoc, getCurScope(),
2630                                               SS, ObjectType,
2631                                               EnteringContext);
2632     if (!Ty)
2633       return true;
2634
2635     Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
2636     return false;
2637   }
2638
2639   Diag(Tok, diag::err_expected_unqualified_id)
2640     << getLangOpts().CPlusPlus;
2641   return true;
2642 }
2643
2644 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2645 /// memory in a typesafe manner and call constructors.
2646 ///
2647 /// This method is called to parse the new expression after the optional :: has
2648 /// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
2649 /// is its location.  Otherwise, "Start" is the location of the 'new' token.
2650 ///
2651 ///        new-expression:
2652 ///                   '::'[opt] 'new' new-placement[opt] new-type-id
2653 ///                                     new-initializer[opt]
2654 ///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2655 ///                                     new-initializer[opt]
2656 ///
2657 ///        new-placement:
2658 ///                   '(' expression-list ')'
2659 ///
2660 ///        new-type-id:
2661 ///                   type-specifier-seq new-declarator[opt]
2662 /// [GNU]             attributes type-specifier-seq new-declarator[opt]
2663 ///
2664 ///        new-declarator:
2665 ///                   ptr-operator new-declarator[opt]
2666 ///                   direct-new-declarator
2667 ///
2668 ///        new-initializer:
2669 ///                   '(' expression-list[opt] ')'
2670 /// [C++0x]           braced-init-list
2671 ///
2672 ExprResult
2673 Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
2674   assert(Tok.is(tok::kw_new) && "expected 'new' token");
2675   ConsumeToken();   // Consume 'new'
2676
2677   // A '(' now can be a new-placement or the '(' wrapping the type-id in the
2678   // second form of new-expression. It can't be a new-type-id.
2679
2680   ExprVector PlacementArgs;
2681   SourceLocation PlacementLParen, PlacementRParen;
2682
2683   SourceRange TypeIdParens;
2684   DeclSpec DS(AttrFactory);
2685   Declarator DeclaratorInfo(DS, Declarator::CXXNewContext);
2686   if (Tok.is(tok::l_paren)) {
2687     // If it turns out to be a placement, we change the type location.
2688     BalancedDelimiterTracker T(*this, tok::l_paren);
2689     T.consumeOpen();
2690     PlacementLParen = T.getOpenLocation();
2691     if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
2692       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2693       return ExprError();
2694     }
2695
2696     T.consumeClose();
2697     PlacementRParen = T.getCloseLocation();
2698     if (PlacementRParen.isInvalid()) {
2699       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2700       return ExprError();
2701     }
2702
2703     if (PlacementArgs.empty()) {
2704       // Reset the placement locations. There was no placement.
2705       TypeIdParens = T.getRange();
2706       PlacementLParen = PlacementRParen = SourceLocation();
2707     } else {
2708       // We still need the type.
2709       if (Tok.is(tok::l_paren)) {
2710         BalancedDelimiterTracker T(*this, tok::l_paren);
2711         T.consumeOpen();
2712         MaybeParseGNUAttributes(DeclaratorInfo);
2713         ParseSpecifierQualifierList(DS);
2714         DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2715         ParseDeclarator(DeclaratorInfo);
2716         T.consumeClose();
2717         TypeIdParens = T.getRange();
2718       } else {
2719         MaybeParseGNUAttributes(DeclaratorInfo);
2720         if (ParseCXXTypeSpecifierSeq(DS))
2721           DeclaratorInfo.setInvalidType(true);
2722         else {
2723           DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2724           ParseDeclaratorInternal(DeclaratorInfo,
2725                                   &Parser::ParseDirectNewDeclarator);
2726         }
2727       }
2728     }
2729   } else {
2730     // A new-type-id is a simplified type-id, where essentially the
2731     // direct-declarator is replaced by a direct-new-declarator.
2732     MaybeParseGNUAttributes(DeclaratorInfo);
2733     if (ParseCXXTypeSpecifierSeq(DS))
2734       DeclaratorInfo.setInvalidType(true);
2735     else {
2736       DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2737       ParseDeclaratorInternal(DeclaratorInfo,
2738                               &Parser::ParseDirectNewDeclarator);
2739     }
2740   }
2741   if (DeclaratorInfo.isInvalidType()) {
2742     SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2743     return ExprError();
2744   }
2745
2746   ExprResult Initializer;
2747
2748   if (Tok.is(tok::l_paren)) {
2749     SourceLocation ConstructorLParen, ConstructorRParen;
2750     ExprVector ConstructorArgs;
2751     BalancedDelimiterTracker T(*this, tok::l_paren);
2752     T.consumeOpen();
2753     ConstructorLParen = T.getOpenLocation();
2754     if (Tok.isNot(tok::r_paren)) {
2755       CommaLocsTy CommaLocs;
2756       if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
2757             ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(),
2758                                                        DeclaratorInfo).get();
2759             Actions.CodeCompleteConstructor(getCurScope(),
2760                                       TypeRep.get()->getCanonicalTypeInternal(),
2761                                             DeclaratorInfo.getLocEnd(),
2762                                             ConstructorArgs);
2763       })) {
2764         SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2765         return ExprError();
2766       }
2767     }
2768     T.consumeClose();
2769     ConstructorRParen = T.getCloseLocation();
2770     if (ConstructorRParen.isInvalid()) {
2771       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2772       return ExprError();
2773     }
2774     Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
2775                                              ConstructorRParen,
2776                                              ConstructorArgs);
2777   } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
2778     Diag(Tok.getLocation(),
2779          diag::warn_cxx98_compat_generalized_initializer_lists);
2780     Initializer = ParseBraceInitializer();
2781   }
2782   if (Initializer.isInvalid())
2783     return Initializer;
2784
2785   return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
2786                              PlacementArgs, PlacementRParen,
2787                              TypeIdParens, DeclaratorInfo, Initializer.get());
2788 }
2789
2790 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2791 /// passed to ParseDeclaratorInternal.
2792 ///
2793 ///        direct-new-declarator:
2794 ///                   '[' expression ']'
2795 ///                   direct-new-declarator '[' constant-expression ']'
2796 ///
2797 void Parser::ParseDirectNewDeclarator(Declarator &D) {
2798   // Parse the array dimensions.
2799   bool first = true;
2800   while (Tok.is(tok::l_square)) {
2801     // An array-size expression can't start with a lambda.
2802     if (CheckProhibitedCXX11Attribute())
2803       continue;
2804
2805     BalancedDelimiterTracker T(*this, tok::l_square);
2806     T.consumeOpen();
2807
2808     ExprResult Size(first ? ParseExpression()
2809                                 : ParseConstantExpression());
2810     if (Size.isInvalid()) {
2811       // Recover
2812       SkipUntil(tok::r_square, StopAtSemi);
2813       return;
2814     }
2815     first = false;
2816
2817     T.consumeClose();
2818
2819     // Attributes here appertain to the array type. C++11 [expr.new]p5.
2820     ParsedAttributes Attrs(AttrFactory);
2821     MaybeParseCXX11Attributes(Attrs);
2822
2823     D.AddTypeInfo(DeclaratorChunk::getArray(0,
2824                                             /*static=*/false, /*star=*/false,
2825                                             Size.get(),
2826                                             T.getOpenLocation(),
2827                                             T.getCloseLocation()),
2828                   Attrs, T.getCloseLocation());
2829
2830     if (T.getCloseLocation().isInvalid())
2831       return;
2832   }
2833 }
2834
2835 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2836 /// This ambiguity appears in the syntax of the C++ new operator.
2837 ///
2838 ///        new-expression:
2839 ///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2840 ///                                     new-initializer[opt]
2841 ///
2842 ///        new-placement:
2843 ///                   '(' expression-list ')'
2844 ///
2845 bool Parser::ParseExpressionListOrTypeId(
2846                                    SmallVectorImpl<Expr*> &PlacementArgs,
2847                                          Declarator &D) {
2848   // The '(' was already consumed.
2849   if (isTypeIdInParens()) {
2850     ParseSpecifierQualifierList(D.getMutableDeclSpec());
2851     D.SetSourceRange(D.getDeclSpec().getSourceRange());
2852     ParseDeclarator(D);
2853     return D.isInvalidType();
2854   }
2855
2856   // It's not a type, it has to be an expression list.
2857   // Discard the comma locations - ActOnCXXNew has enough parameters.
2858   CommaLocsTy CommaLocs;
2859   return ParseExpressionList(PlacementArgs, CommaLocs);
2860 }
2861
2862 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2863 /// to free memory allocated by new.
2864 ///
2865 /// This method is called to parse the 'delete' expression after the optional
2866 /// '::' has been already parsed.  If the '::' was present, "UseGlobal" is true
2867 /// and "Start" is its location.  Otherwise, "Start" is the location of the
2868 /// 'delete' token.
2869 ///
2870 ///        delete-expression:
2871 ///                   '::'[opt] 'delete' cast-expression
2872 ///                   '::'[opt] 'delete' '[' ']' cast-expression
2873 ExprResult
2874 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
2875   assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
2876   ConsumeToken(); // Consume 'delete'
2877
2878   // Array delete?
2879   bool ArrayDelete = false;
2880   if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
2881     // C++11 [expr.delete]p1:
2882     //   Whenever the delete keyword is followed by empty square brackets, it
2883     //   shall be interpreted as [array delete].
2884     //   [Footnote: A lambda expression with a lambda-introducer that consists
2885     //              of empty square brackets can follow the delete keyword if
2886     //              the lambda expression is enclosed in parentheses.]
2887     // FIXME: Produce a better diagnostic if the '[]' is unambiguously a
2888     //        lambda-introducer.
2889     ArrayDelete = true;
2890     BalancedDelimiterTracker T(*this, tok::l_square);
2891
2892     T.consumeOpen();
2893     T.consumeClose();
2894     if (T.getCloseLocation().isInvalid())
2895       return ExprError();
2896   }
2897
2898   ExprResult Operand(ParseCastExpression(false));
2899   if (Operand.isInvalid())
2900     return Operand;
2901
2902   return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
2903 }
2904
2905 static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
2906   switch (kind) {
2907   default: llvm_unreachable("Not a known type trait");
2908 #define TYPE_TRAIT_1(Spelling, Name, Key) \
2909 case tok::kw_ ## Spelling: return UTT_ ## Name;
2910 #define TYPE_TRAIT_2(Spelling, Name, Key) \
2911 case tok::kw_ ## Spelling: return BTT_ ## Name;
2912 #include "clang/Basic/TokenKinds.def"
2913 #define TYPE_TRAIT_N(Spelling, Name, Key) \
2914   case tok::kw_ ## Spelling: return TT_ ## Name;
2915 #include "clang/Basic/TokenKinds.def"
2916   }
2917 }
2918
2919 static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
2920   switch(kind) {
2921   default: llvm_unreachable("Not a known binary type trait");
2922   case tok::kw___array_rank:                 return ATT_ArrayRank;
2923   case tok::kw___array_extent:               return ATT_ArrayExtent;
2924   }
2925 }
2926
2927 static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
2928   switch(kind) {
2929   default: llvm_unreachable("Not a known unary expression trait.");
2930   case tok::kw___is_lvalue_expr:             return ET_IsLValueExpr;
2931   case tok::kw___is_rvalue_expr:             return ET_IsRValueExpr;
2932   }
2933 }
2934
2935 static unsigned TypeTraitArity(tok::TokenKind kind) {
2936   switch (kind) {
2937     default: llvm_unreachable("Not a known type trait");
2938 #define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
2939 #include "clang/Basic/TokenKinds.def"
2940   }
2941 }
2942
2943 /// \brief Parse the built-in type-trait pseudo-functions that allow
2944 /// implementation of the TR1/C++11 type traits templates.
2945 ///
2946 ///       primary-expression:
2947 ///          unary-type-trait '(' type-id ')'
2948 ///          binary-type-trait '(' type-id ',' type-id ')'
2949 ///          type-trait '(' type-id-seq ')'
2950 ///
2951 ///       type-id-seq:
2952 ///          type-id ...[opt] type-id-seq[opt]
2953 ///
2954 ExprResult Parser::ParseTypeTrait() {
2955   tok::TokenKind Kind = Tok.getKind();
2956   unsigned Arity = TypeTraitArity(Kind);
2957
2958   SourceLocation Loc = ConsumeToken();
2959
2960   BalancedDelimiterTracker Parens(*this, tok::l_paren);
2961   if (Parens.expectAndConsume())
2962     return ExprError();
2963
2964   SmallVector<ParsedType, 2> Args;
2965   do {
2966     // Parse the next type.
2967     TypeResult Ty = ParseTypeName();
2968     if (Ty.isInvalid()) {
2969       Parens.skipToEnd();
2970       return ExprError();
2971     }
2972
2973     // Parse the ellipsis, if present.
2974     if (Tok.is(tok::ellipsis)) {
2975       Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
2976       if (Ty.isInvalid()) {
2977         Parens.skipToEnd();
2978         return ExprError();
2979       }
2980     }
2981
2982     // Add this type to the list of arguments.
2983     Args.push_back(Ty.get());
2984   } while (TryConsumeToken(tok::comma));
2985
2986   if (Parens.consumeClose())
2987     return ExprError();
2988
2989   SourceLocation EndLoc = Parens.getCloseLocation();
2990
2991   if (Arity && Args.size() != Arity) {
2992     Diag(EndLoc, diag::err_type_trait_arity)
2993       << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
2994     return ExprError();
2995   }
2996
2997   if (!Arity && Args.empty()) {
2998     Diag(EndLoc, diag::err_type_trait_arity)
2999       << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
3000     return ExprError();
3001   }
3002
3003   return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
3004 }
3005
3006 /// ParseArrayTypeTrait - Parse the built-in array type-trait
3007 /// pseudo-functions.
3008 ///
3009 ///       primary-expression:
3010 /// [Embarcadero]     '__array_rank' '(' type-id ')'
3011 /// [Embarcadero]     '__array_extent' '(' type-id ',' expression ')'
3012 ///
3013 ExprResult Parser::ParseArrayTypeTrait() {
3014   ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
3015   SourceLocation Loc = ConsumeToken();
3016
3017   BalancedDelimiterTracker T(*this, tok::l_paren);
3018   if (T.expectAndConsume())
3019     return ExprError();
3020
3021   TypeResult Ty = ParseTypeName();
3022   if (Ty.isInvalid()) {
3023     SkipUntil(tok::comma, StopAtSemi);
3024     SkipUntil(tok::r_paren, StopAtSemi);
3025     return ExprError();
3026   }
3027
3028   switch (ATT) {
3029   case ATT_ArrayRank: {
3030     T.consumeClose();
3031     return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
3032                                        T.getCloseLocation());
3033   }
3034   case ATT_ArrayExtent: {
3035     if (ExpectAndConsume(tok::comma)) {
3036       SkipUntil(tok::r_paren, StopAtSemi);
3037       return ExprError();
3038     }
3039
3040     ExprResult DimExpr = ParseExpression();
3041     T.consumeClose();
3042
3043     return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
3044                                        T.getCloseLocation());
3045   }
3046   }
3047   llvm_unreachable("Invalid ArrayTypeTrait!");
3048 }
3049
3050 /// ParseExpressionTrait - Parse built-in expression-trait
3051 /// pseudo-functions like __is_lvalue_expr( xxx ).
3052 ///
3053 ///       primary-expression:
3054 /// [Embarcadero]     expression-trait '(' expression ')'
3055 ///
3056 ExprResult Parser::ParseExpressionTrait() {
3057   ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
3058   SourceLocation Loc = ConsumeToken();
3059
3060   BalancedDelimiterTracker T(*this, tok::l_paren);
3061   if (T.expectAndConsume())
3062     return ExprError();
3063
3064   ExprResult Expr = ParseExpression();
3065
3066   T.consumeClose();
3067
3068   return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
3069                                       T.getCloseLocation());
3070 }
3071
3072
3073 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3074 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3075 /// based on the context past the parens.
3076 ExprResult
3077 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3078                                          ParsedType &CastTy,
3079                                          BalancedDelimiterTracker &Tracker,
3080                                          ColonProtectionRAIIObject &ColonProt) {
3081   assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
3082   assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
3083   assert(isTypeIdInParens() && "Not a type-id!");
3084
3085   ExprResult Result(true);
3086   CastTy = nullptr;
3087
3088   // We need to disambiguate a very ugly part of the C++ syntax:
3089   //
3090   // (T())x;  - type-id
3091   // (T())*x; - type-id
3092   // (T())/x; - expression
3093   // (T());   - expression
3094   //
3095   // The bad news is that we cannot use the specialized tentative parser, since
3096   // it can only verify that the thing inside the parens can be parsed as
3097   // type-id, it is not useful for determining the context past the parens.
3098   //
3099   // The good news is that the parser can disambiguate this part without
3100   // making any unnecessary Action calls.
3101   //
3102   // It uses a scheme similar to parsing inline methods. The parenthesized
3103   // tokens are cached, the context that follows is determined (possibly by
3104   // parsing a cast-expression), and then we re-introduce the cached tokens
3105   // into the token stream and parse them appropriately.
3106
3107   ParenParseOption ParseAs;
3108   CachedTokens Toks;
3109
3110   // Store the tokens of the parentheses. We will parse them after we determine
3111   // the context that follows them.
3112   if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3113     // We didn't find the ')' we expected.
3114     Tracker.consumeClose();
3115     return ExprError();
3116   }
3117
3118   if (Tok.is(tok::l_brace)) {
3119     ParseAs = CompoundLiteral;
3120   } else {
3121     bool NotCastExpr;
3122     if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
3123       NotCastExpr = true;
3124     } else {
3125       // Try parsing the cast-expression that may follow.
3126       // If it is not a cast-expression, NotCastExpr will be true and no token
3127       // will be consumed.
3128       ColonProt.restore();
3129       Result = ParseCastExpression(false/*isUnaryExpression*/,
3130                                    false/*isAddressofOperand*/,
3131                                    NotCastExpr,
3132                                    // type-id has priority.
3133                                    IsTypeCast);
3134     }
3135
3136     // If we parsed a cast-expression, it's really a type-id, otherwise it's
3137     // an expression.
3138     ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
3139   }
3140
3141   // Create a fake EOF to mark end of Toks buffer.
3142   Token AttrEnd;
3143   AttrEnd.startToken();
3144   AttrEnd.setKind(tok::eof);
3145   AttrEnd.setLocation(Tok.getLocation());
3146   AttrEnd.setEofData(Toks.data());
3147   Toks.push_back(AttrEnd);
3148
3149   // The current token should go after the cached tokens.
3150   Toks.push_back(Tok);
3151   // Re-enter the stored parenthesized tokens into the token stream, so we may
3152   // parse them now.
3153   PP.EnterTokenStream(Toks, true /*DisableMacroExpansion*/);
3154   // Drop the current token and bring the first cached one. It's the same token
3155   // as when we entered this function.
3156   ConsumeAnyToken();
3157
3158   if (ParseAs >= CompoundLiteral) {
3159     // Parse the type declarator.
3160     DeclSpec DS(AttrFactory);
3161     Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
3162     {
3163       ColonProtectionRAIIObject InnerColonProtection(*this);
3164       ParseSpecifierQualifierList(DS);
3165       ParseDeclarator(DeclaratorInfo);
3166     }
3167
3168     // Match the ')'.
3169     Tracker.consumeClose();
3170     ColonProt.restore();
3171
3172     // Consume EOF marker for Toks buffer.
3173     assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3174     ConsumeAnyToken();
3175
3176     if (ParseAs == CompoundLiteral) {
3177       ExprType = CompoundLiteral;
3178       if (DeclaratorInfo.isInvalidType())
3179         return ExprError();
3180
3181       TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
3182       return ParseCompoundLiteralExpression(Ty.get(),
3183                                             Tracker.getOpenLocation(),
3184                                             Tracker.getCloseLocation());
3185     }
3186
3187     // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
3188     assert(ParseAs == CastExpr);
3189
3190     if (DeclaratorInfo.isInvalidType())
3191       return ExprError();
3192
3193     // Result is what ParseCastExpression returned earlier.
3194     if (!Result.isInvalid())
3195       Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
3196                                     DeclaratorInfo, CastTy,
3197                                     Tracker.getCloseLocation(), Result.get());
3198     return Result;
3199   }
3200
3201   // Not a compound literal, and not followed by a cast-expression.
3202   assert(ParseAs == SimpleExpr);
3203
3204   ExprType = SimpleExpr;
3205   Result = ParseExpression();
3206   if (!Result.isInvalid() && Tok.is(tok::r_paren))
3207     Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
3208                                     Tok.getLocation(), Result.get());
3209
3210   // Match the ')'.
3211   if (Result.isInvalid()) {
3212     while (Tok.isNot(tok::eof))
3213       ConsumeAnyToken();
3214     assert(Tok.getEofData() == AttrEnd.getEofData());
3215     ConsumeAnyToken();
3216     return ExprError();
3217   }
3218
3219   Tracker.consumeClose();
3220   // Consume EOF marker for Toks buffer.
3221   assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3222   ConsumeAnyToken();
3223   return Result;
3224 }