contrib/llvm/tools/clang/lib/Parse/ParseTemplate.cpp

   1 //===--- ParseTemplate.cpp - Template 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 parsing of C++ templates.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Parse/Parser.h"
  15 #include "RAIIObjectsForParser.h"
  16 #include "clang/AST/ASTConsumer.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/Parse/ParseDiagnostic.h"
  20 #include "clang/Sema/DeclSpec.h"
  21 #include "clang/Sema/ParsedTemplate.h"
  22 #include "clang/Sema/Scope.h"
  23 using namespace clang;
  24
  25 /// \brief Parse a template declaration, explicit instantiation, or
  26 /// explicit specialization.
  27 Decl *
  28 Parser::ParseDeclarationStartingWithTemplate(unsigned Context,
  29                                              SourceLocation &DeclEnd,
  30                                              AccessSpecifier AS,
  31                                              AttributeList *AccessAttrs) {
  32   ObjCDeclContextSwitch ObjCDC(*this);
  33
  34   if (Tok.is(tok::kw_template) && NextToken().isNot(tok::less)) {
  35     return ParseExplicitInstantiation(Context,
  36                                       SourceLocation(), ConsumeToken(),
  37                                       DeclEnd, AS);
  38   }
  39   return ParseTemplateDeclarationOrSpecialization(Context, DeclEnd, AS,
  40                                                   AccessAttrs);
  41 }
  42
  43
  44
  45 /// \brief Parse a template declaration or an explicit specialization.
  46 ///
  47 /// Template declarations include one or more template parameter lists
  48 /// and either the function or class template declaration. Explicit
  49 /// specializations contain one or more 'template < >' prefixes
  50 /// followed by a (possibly templated) declaration. Since the
  51 /// syntactic form of both features is nearly identical, we parse all
  52 /// of the template headers together and let semantic analysis sort
  53 /// the declarations from the explicit specializations.
  54 ///
  55 ///       template-declaration: [C++ temp]
  56 ///         'export'[opt] 'template' '<' template-parameter-list '>' declaration
  57 ///
  58 ///       explicit-specialization: [ C++ temp.expl.spec]
  59 ///         'template' '<' '>' declaration
  60 Decl *
  61 Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context,
  62                                                  SourceLocation &DeclEnd,
  63                                                  AccessSpecifier AS,
  64                                                  AttributeList *AccessAttrs) {
  65   assert(Tok.isOneOf(tok::kw_export, tok::kw_template) &&
  66          "Token does not start a template declaration.");
  67
  68   // Enter template-parameter scope.
  69   ParseScope TemplateParmScope(this, Scope::TemplateParamScope);
  70
  71   // Tell the action that names should be checked in the context of
  72   // the declaration to come.
  73   ParsingDeclRAIIObject
  74     ParsingTemplateParams(*this, ParsingDeclRAIIObject::NoParent);
  75
  76   // Parse multiple levels of template headers within this template
  77   // parameter scope, e.g.,
  78   //
  79   //   template<typename T>
  80   //     template<typename U>
  81   //       class A<T>::B { ... };
  82   //
  83   // We parse multiple levels non-recursively so that we can build a
  84   // single data structure containing all of the template parameter
  85   // lists to easily differentiate between the case above and:
  86   //
  87   //   template<typename T>
  88   //   class A {
  89   //     template<typename U> class B;
  90   //   };
  91   //
  92   // In the first case, the action for declaring A<T>::B receives
  93   // both template parameter lists. In the second case, the action for
  94   // defining A<T>::B receives just the inner template parameter list
  95   // (and retrieves the outer template parameter list from its
  96   // context).
  97   bool isSpecialization = true;
  98   bool LastParamListWasEmpty = false;
  99   TemplateParameterLists ParamLists;
 100   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
 101
 102   do {
 103     // Consume the 'export', if any.
 104     SourceLocation ExportLoc;
 105     TryConsumeToken(tok::kw_export, ExportLoc);
 106
 107     // Consume the 'template', which should be here.
 108     SourceLocation TemplateLoc;
 109     if (!TryConsumeToken(tok::kw_template, TemplateLoc)) {
 110       Diag(Tok.getLocation(), diag::err_expected_template);
 111       return nullptr;
 112     }
 113
 114     // Parse the '<' template-parameter-list '>'
 115     SourceLocation LAngleLoc, RAngleLoc;
 116     SmallVector<Decl*, 4> TemplateParams;
 117     if (ParseTemplateParameters(CurTemplateDepthTracker.getDepth(),
 118                                 TemplateParams, LAngleLoc, RAngleLoc)) {
 119       // Skip until the semi-colon or a '}'.
 120       SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
 121       TryConsumeToken(tok::semi);
 122       return nullptr;
 123     }
 124
 125     ParamLists.push_back(
 126       Actions.ActOnTemplateParameterList(CurTemplateDepthTracker.getDepth(),
 127                                          ExportLoc,
 128                                          TemplateLoc, LAngleLoc,
 129                                          TemplateParams.data(),
 130                                          TemplateParams.size(), RAngleLoc));
 131
 132     if (!TemplateParams.empty()) {
 133       isSpecialization = false;
 134       ++CurTemplateDepthTracker;
 135
 136       if (TryConsumeToken(tok::kw_requires)) {
 137         ExprResult ER =
 138             Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression());
 139         if (!ER.isUsable()) {
 140           // Skip until the semi-colon or a '}'.
 141           SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
 142           TryConsumeToken(tok::semi);
 143           return nullptr;
 144         }
 145       }
 146     } else {
 147       LastParamListWasEmpty = true;
 148     }
 149   } while (Tok.isOneOf(tok::kw_export, tok::kw_template));
 150
 151   // Parse the actual template declaration.
 152   return ParseSingleDeclarationAfterTemplate(Context,
 153                                              ParsedTemplateInfo(&ParamLists,
 154                                                              isSpecialization,
 155                                                          LastParamListWasEmpty),
 156                                              ParsingTemplateParams,
 157                                              DeclEnd, AS, AccessAttrs);
 158 }
 159
 160 /// \brief Parse a single declaration that declares a template,
 161 /// template specialization, or explicit instantiation of a template.
 162 ///
 163 /// \param DeclEnd will receive the source location of the last token
 164 /// within this declaration.
 165 ///
 166 /// \param AS the access specifier associated with this
 167 /// declaration. Will be AS_none for namespace-scope declarations.
 168 ///
 169 /// \returns the new declaration.
 170 Decl *
 171 Parser::ParseSingleDeclarationAfterTemplate(
 172                                        unsigned Context,
 173                                        const ParsedTemplateInfo &TemplateInfo,
 174                                        ParsingDeclRAIIObject &DiagsFromTParams,
 175                                        SourceLocation &DeclEnd,
 176                                        AccessSpecifier AS,
 177                                        AttributeList *AccessAttrs) {
 178   assert(TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
 179          "Template information required");
 180
 181   if (Tok.is(tok::kw_static_assert)) {
 182     // A static_assert declaration may not be templated.
 183     Diag(Tok.getLocation(), diag::err_templated_invalid_declaration)
 184       << TemplateInfo.getSourceRange();
 185     // Parse the static_assert declaration to improve error recovery.
 186     return ParseStaticAssertDeclaration(DeclEnd);
 187   }
 188
 189   if (Context == Declarator::MemberContext) {
 190     // We are parsing a member template.
 191     ParseCXXClassMemberDeclaration(AS, AccessAttrs, TemplateInfo,
 192                                    &DiagsFromTParams);
 193     return nullptr;
 194   }
 195
 196   ParsedAttributesWithRange prefixAttrs(AttrFactory);
 197   MaybeParseCXX11Attributes(prefixAttrs);
 198
 199   if (Tok.is(tok::kw_using))
 200     return ParseUsingDirectiveOrDeclaration(Context, TemplateInfo, DeclEnd,
 201                                             prefixAttrs);
 202
 203   // Parse the declaration specifiers, stealing any diagnostics from
 204   // the template parameters.
 205   ParsingDeclSpec DS(*this, &DiagsFromTParams);
 206
 207   ParseDeclarationSpecifiers(DS, TemplateInfo, AS,
 208                              getDeclSpecContextFromDeclaratorContext(Context));
 209
 210   if (Tok.is(tok::semi)) {
 211     ProhibitAttributes(prefixAttrs);
 212     DeclEnd = ConsumeToken();
 213     Decl *Decl = Actions.ParsedFreeStandingDeclSpec(
 214         getCurScope(), AS, DS,
 215         TemplateInfo.TemplateParams ? *TemplateInfo.TemplateParams
 216                                     : MultiTemplateParamsArg(),
 217         TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation);
 218     DS.complete(Decl);
 219     return Decl;
 220   }
 221
 222   // Move the attributes from the prefix into the DS.
 223   if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
 224     ProhibitAttributes(prefixAttrs);
 225   else
 226     DS.takeAttributesFrom(prefixAttrs);
 227
 228   // Parse the declarator.
 229   ParsingDeclarator DeclaratorInfo(*this, DS, (Declarator::TheContext)Context);
 230   ParseDeclarator(DeclaratorInfo);
 231   // Error parsing the declarator?
 232   if (!DeclaratorInfo.hasName()) {
 233     // If so, skip until the semi-colon or a }.
 234     SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
 235     if (Tok.is(tok::semi))
 236       ConsumeToken();
 237     return nullptr;
 238   }
 239
 240   LateParsedAttrList LateParsedAttrs(true);
 241   if (DeclaratorInfo.isFunctionDeclarator())
 242     MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);
 243
 244   if (DeclaratorInfo.isFunctionDeclarator() &&
 245       isStartOfFunctionDefinition(DeclaratorInfo)) {
 246
 247     // Function definitions are only allowed at file scope and in C++ classes.
 248     // The C++ inline method definition case is handled elsewhere, so we only
 249     // need to handle the file scope definition case.
 250     if (Context != Declarator::FileContext) {
 251       Diag(Tok, diag::err_function_definition_not_allowed);
 252       SkipMalformedDecl();
 253       return nullptr;
 254     }
 255
 256     if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
 257       // Recover by ignoring the 'typedef'. This was probably supposed to be
 258       // the 'typename' keyword, which we should have already suggested adding
 259       // if it's appropriate.
 260       Diag(DS.getStorageClassSpecLoc(), diag::err_function_declared_typedef)
 261         << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
 262       DS.ClearStorageClassSpecs();
 263     }
 264
 265     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
 266       if (DeclaratorInfo.getName().getKind() != UnqualifiedId::IK_TemplateId) {
 267         // If the declarator-id is not a template-id, issue a diagnostic and
 268         // recover by ignoring the 'template' keyword.
 269         Diag(Tok, diag::err_template_defn_explicit_instantiation) << 0;
 270         return ParseFunctionDefinition(DeclaratorInfo, ParsedTemplateInfo(),
 271                                        &LateParsedAttrs);
 272       } else {
 273         SourceLocation LAngleLoc
 274           = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
 275         Diag(DeclaratorInfo.getIdentifierLoc(),
 276              diag::err_explicit_instantiation_with_definition)
 277             << SourceRange(TemplateInfo.TemplateLoc)
 278             << FixItHint::CreateInsertion(LAngleLoc, "<>");
 279
 280         // Recover as if it were an explicit specialization.
 281         TemplateParameterLists FakedParamLists;
 282         FakedParamLists.push_back(Actions.ActOnTemplateParameterList(
 283             0, SourceLocation(), TemplateInfo.TemplateLoc, LAngleLoc, nullptr,
 284             0, LAngleLoc));
 285
 286         return ParseFunctionDefinition(
 287             DeclaratorInfo, ParsedTemplateInfo(&FakedParamLists,
 288                                                /*isSpecialization=*/true,
 289                                                /*LastParamListWasEmpty=*/true),
 290             &LateParsedAttrs);
 291       }
 292     }
 293     return ParseFunctionDefinition(DeclaratorInfo, TemplateInfo,
 294                                    &LateParsedAttrs);
 295   }
 296
 297   // Parse this declaration.
 298   Decl *ThisDecl = ParseDeclarationAfterDeclarator(DeclaratorInfo,
 299                                                    TemplateInfo);
 300
 301   if (Tok.is(tok::comma)) {
 302     Diag(Tok, diag::err_multiple_template_declarators)
 303       << (int)TemplateInfo.Kind;
 304     SkipUntil(tok::semi);
 305     return ThisDecl;
 306   }
 307
 308   // Eat the semi colon after the declaration.
 309   ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
 310   if (LateParsedAttrs.size() > 0)
 311     ParseLexedAttributeList(LateParsedAttrs, ThisDecl, true, false);
 312   DeclaratorInfo.complete(ThisDecl);
 313   return ThisDecl;
 314 }
 315
 316 /// ParseTemplateParameters - Parses a template-parameter-list enclosed in
 317 /// angle brackets. Depth is the depth of this template-parameter-list, which
 318 /// is the number of template headers directly enclosing this template header.
 319 /// TemplateParams is the current list of template parameters we're building.
 320 /// The template parameter we parse will be added to this list. LAngleLoc and
 321 /// RAngleLoc will receive the positions of the '<' and '>', respectively,
 322 /// that enclose this template parameter list.
 323 ///
 324 /// \returns true if an error occurred, false otherwise.
 325 bool Parser::ParseTemplateParameters(unsigned Depth,
 326                                SmallVectorImpl<Decl*> &TemplateParams,
 327                                      SourceLocation &LAngleLoc,
 328                                      SourceLocation &RAngleLoc) {
 329   // Get the template parameter list.
 330   if (!TryConsumeToken(tok::less, LAngleLoc)) {
 331     Diag(Tok.getLocation(), diag::err_expected_less_after) << "template";
 332     return true;
 333   }
 334
 335   // Try to parse the template parameter list.
 336   bool Failed = false;
 337   if (!Tok.is(tok::greater) && !Tok.is(tok::greatergreater))
 338     Failed = ParseTemplateParameterList(Depth, TemplateParams);
 339
 340   if (Tok.is(tok::greatergreater)) {
 341     // No diagnostic required here: a template-parameter-list can only be
 342     // followed by a declaration or, for a template template parameter, the
 343     // 'class' keyword. Therefore, the second '>' will be diagnosed later.
 344     // This matters for elegant diagnosis of:
 345     //   template<template<typename>> struct S;
 346     Tok.setKind(tok::greater);
 347     RAngleLoc = Tok.getLocation();
 348     Tok.setLocation(Tok.getLocation().getLocWithOffset(1));
 349   } else if (!TryConsumeToken(tok::greater, RAngleLoc) && Failed) {
 350     Diag(Tok.getLocation(), diag::err_expected) << tok::greater;
 351     return true;
 352   }
 353   return false;
 354 }
 355
 356 /// ParseTemplateParameterList - Parse a template parameter list. If
 357 /// the parsing fails badly (i.e., closing bracket was left out), this
 358 /// will try to put the token stream in a reasonable position (closing
 359 /// a statement, etc.) and return false.
 360 ///
 361 ///       template-parameter-list:    [C++ temp]
 362 ///         template-parameter
 363 ///         template-parameter-list ',' template-parameter
 364 bool
 365 Parser::ParseTemplateParameterList(unsigned Depth,
 366                              SmallVectorImpl<Decl*> &TemplateParams) {
 367   while (1) {
 368     if (Decl *TmpParam
 369           = ParseTemplateParameter(Depth, TemplateParams.size())) {
 370       TemplateParams.push_back(TmpParam);
 371     } else {
 372       // If we failed to parse a template parameter, skip until we find
 373       // a comma or closing brace.
 374       SkipUntil(tok::comma, tok::greater, tok::greatergreater,
 375                 StopAtSemi | StopBeforeMatch);
 376     }
 377
 378     // Did we find a comma or the end of the template parameter list?
 379     if (Tok.is(tok::comma)) {
 380       ConsumeToken();
 381     } else if (Tok.isOneOf(tok::greater, tok::greatergreater)) {
 382       // Don't consume this... that's done by template parser.
 383       break;
 384     } else {
 385       // Somebody probably forgot to close the template. Skip ahead and
 386       // try to get out of the expression. This error is currently
 387       // subsumed by whatever goes on in ParseTemplateParameter.
 388       Diag(Tok.getLocation(), diag::err_expected_comma_greater);
 389       SkipUntil(tok::comma, tok::greater, tok::greatergreater,
 390                 StopAtSemi | StopBeforeMatch);
 391       return false;
 392     }
 393   }
 394   return true;
 395 }
 396
 397 /// \brief Determine whether the parser is at the start of a template
 398 /// type parameter.
 399 bool Parser::isStartOfTemplateTypeParameter() {
 400   if (Tok.is(tok::kw_class)) {
 401     // "class" may be the start of an elaborated-type-specifier or a
 402     // type-parameter. Per C++ [temp.param]p3, we prefer the type-parameter.
 403     switch (NextToken().getKind()) {
 404     case tok::equal:
 405     case tok::comma:
 406     case tok::greater:
 407     case tok::greatergreater:
 408     case tok::ellipsis:
 409       return true;
 410
 411     case tok::identifier:
 412       // This may be either a type-parameter or an elaborated-type-specifier.
 413       // We have to look further.
 414       break;
 415
 416     default:
 417       return false;
 418     }
 419
 420     switch (GetLookAheadToken(2).getKind()) {
 421     case tok::equal:
 422     case tok::comma:
 423     case tok::greater:
 424     case tok::greatergreater:
 425       return true;
 426
 427     default:
 428       return false;
 429     }
 430   }
 431
 432   if (Tok.isNot(tok::kw_typename))
 433     return false;
 434
 435   // C++ [temp.param]p2:
 436   //   There is no semantic difference between class and typename in a
 437   //   template-parameter. typename followed by an unqualified-id
 438   //   names a template type parameter. typename followed by a
 439   //   qualified-id denotes the type in a non-type
 440   //   parameter-declaration.
 441   Token Next = NextToken();
 442
 443   // If we have an identifier, skip over it.
 444   if (Next.getKind() == tok::identifier)
 445     Next = GetLookAheadToken(2);
 446
 447   switch (Next.getKind()) {
 448   case tok::equal:
 449   case tok::comma:
 450   case tok::greater:
 451   case tok::greatergreater:
 452   case tok::ellipsis:
 453     return true;
 454
 455   default:
 456     return false;
 457   }
 458 }
 459
 460 /// ParseTemplateParameter - Parse a template-parameter (C++ [temp.param]).
 461 ///
 462 ///       template-parameter: [C++ temp.param]
 463 ///         type-parameter
 464 ///         parameter-declaration
 465 ///
 466 ///       type-parameter: (see below)
 467 ///         'class' ...[opt] identifier[opt]
 468 ///         'class' identifier[opt] '=' type-id
 469 ///         'typename' ...[opt] identifier[opt]
 470 ///         'typename' identifier[opt] '=' type-id
 471 ///         'template' '<' template-parameter-list '>'
 472 ///               'class' ...[opt] identifier[opt]
 473 ///         'template' '<' template-parameter-list '>' 'class' identifier[opt]
 474 ///               = id-expression
 475 Decl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) {
 476   if (isStartOfTemplateTypeParameter())
 477     return ParseTypeParameter(Depth, Position);
 478
 479   if (Tok.is(tok::kw_template))
 480     return ParseTemplateTemplateParameter(Depth, Position);
 481
 482   // If it's none of the above, then it must be a parameter declaration.
 483   // NOTE: This will pick up errors in the closure of the template parameter
 484   // list (e.g., template < ; Check here to implement >> style closures.
 485   return ParseNonTypeTemplateParameter(Depth, Position);
 486 }
 487
 488 /// ParseTypeParameter - Parse a template type parameter (C++ [temp.param]).
 489 /// Other kinds of template parameters are parsed in
 490 /// ParseTemplateTemplateParameter and ParseNonTypeTemplateParameter.
 491 ///
 492 ///       type-parameter:     [C++ temp.param]
 493 ///         'class' ...[opt][C++0x] identifier[opt]
 494 ///         'class' identifier[opt] '=' type-id
 495 ///         'typename' ...[opt][C++0x] identifier[opt]
 496 ///         'typename' identifier[opt] '=' type-id
 497 Decl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) {
 498   assert(Tok.isOneOf(tok::kw_class, tok::kw_typename) &&
 499          "A type-parameter starts with 'class' or 'typename'");
 500
 501   // Consume the 'class' or 'typename' keyword.
 502   bool TypenameKeyword = Tok.is(tok::kw_typename);
 503   SourceLocation KeyLoc = ConsumeToken();
 504
 505   // Grab the ellipsis (if given).
 506   SourceLocation EllipsisLoc;
 507   if (TryConsumeToken(tok::ellipsis, EllipsisLoc)) {
 508     Diag(EllipsisLoc,
 509          getLangOpts().CPlusPlus11
 510            ? diag::warn_cxx98_compat_variadic_templates
 511            : diag::ext_variadic_templates);
 512   }
 513
 514   // Grab the template parameter name (if given)
 515   SourceLocation NameLoc;
 516   IdentifierInfo *ParamName = nullptr;
 517   if (Tok.is(tok::identifier)) {
 518     ParamName = Tok.getIdentifierInfo();
 519     NameLoc = ConsumeToken();
 520   } else if (Tok.isOneOf(tok::equal, tok::comma, tok::greater,
 521                          tok::greatergreater)) {
 522     // Unnamed template parameter. Don't have to do anything here, just
 523     // don't consume this token.
 524   } else {
 525     Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
 526     return nullptr;
 527   }
 528
 529   // Recover from misplaced ellipsis.
 530   bool AlreadyHasEllipsis = EllipsisLoc.isValid();
 531   if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
 532     DiagnoseMisplacedEllipsis(EllipsisLoc, NameLoc, AlreadyHasEllipsis, true);
 533
 534   // Grab a default argument (if available).
 535   // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
 536   // we introduce the type parameter into the local scope.
 537   SourceLocation EqualLoc;
 538   ParsedType DefaultArg;
 539   if (TryConsumeToken(tok::equal, EqualLoc))
 540     DefaultArg = ParseTypeName(/*Range=*/nullptr,
 541                                Declarator::TemplateTypeArgContext).get();
 542
 543   return Actions.ActOnTypeParameter(getCurScope(), TypenameKeyword, EllipsisLoc,
 544                                     KeyLoc, ParamName, NameLoc, Depth, Position,
 545                                     EqualLoc, DefaultArg);
 546 }
 547
 548 /// ParseTemplateTemplateParameter - Handle the parsing of template
 549 /// template parameters.
 550 ///
 551 ///       type-parameter:    [C++ temp.param]
 552 ///         'template' '<' template-parameter-list '>' type-parameter-key
 553 ///                  ...[opt] identifier[opt]
 554 ///         'template' '<' template-parameter-list '>' type-parameter-key
 555 ///                  identifier[opt] = id-expression
 556 ///       type-parameter-key:
 557 ///         'class'
 558 ///         'typename'       [C++1z]
 559 Decl *
 560 Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) {
 561   assert(Tok.is(tok::kw_template) && "Expected 'template' keyword");
 562
 563   // Handle the template <...> part.
 564   SourceLocation TemplateLoc = ConsumeToken();
 565   SmallVector<Decl*,8> TemplateParams;
 566   SourceLocation LAngleLoc, RAngleLoc;
 567   {
 568     ParseScope TemplateParmScope(this, Scope::TemplateParamScope);
 569     if (ParseTemplateParameters(Depth + 1, TemplateParams, LAngleLoc,
 570                                RAngleLoc)) {
 571       return nullptr;
 572     }
 573   }
 574
 575   // Provide an ExtWarn if the C++1z feature of using 'typename' here is used.
 576   // Generate a meaningful error if the user forgot to put class before the
 577   // identifier, comma, or greater. Provide a fixit if the identifier, comma,
 578   // or greater appear immediately or after 'struct'. In the latter case,
 579   // replace the keyword with 'class'.
 580   if (!TryConsumeToken(tok::kw_class)) {
 581     bool Replace = Tok.isOneOf(tok::kw_typename, tok::kw_struct);
 582     const Token &Next = Tok.is(tok::kw_struct) ? NextToken() : Tok;
 583     if (Tok.is(tok::kw_typename)) {
 584       Diag(Tok.getLocation(),
 585            getLangOpts().CPlusPlus1z
 586                ? diag::warn_cxx14_compat_template_template_param_typename
 587                : diag::ext_template_template_param_typename)
 588         << (!getLangOpts().CPlusPlus1z
 589                 ? FixItHint::CreateReplacement(Tok.getLocation(), "class")
 590                 : FixItHint());
 591     } else if (Next.isOneOf(tok::identifier, tok::comma, tok::greater,
 592                             tok::greatergreater, tok::ellipsis)) {
 593       Diag(Tok.getLocation(), diag::err_class_on_template_template_param)
 594         << (Replace ? FixItHint::CreateReplacement(Tok.getLocation(), "class")
 595                     : FixItHint::CreateInsertion(Tok.getLocation(), "class "));
 596     } else
 597       Diag(Tok.getLocation(), diag::err_class_on_template_template_param);
 598
 599     if (Replace)
 600       ConsumeToken();
 601   }
 602
 603   // Parse the ellipsis, if given.
 604   SourceLocation EllipsisLoc;
 605   if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
 606     Diag(EllipsisLoc,
 607          getLangOpts().CPlusPlus11
 608            ? diag::warn_cxx98_compat_variadic_templates
 609            : diag::ext_variadic_templates);
 610
 611   // Get the identifier, if given.
 612   SourceLocation NameLoc;
 613   IdentifierInfo *ParamName = nullptr;
 614   if (Tok.is(tok::identifier)) {
 615     ParamName = Tok.getIdentifierInfo();
 616     NameLoc = ConsumeToken();
 617   } else if (Tok.isOneOf(tok::equal, tok::comma, tok::greater,
 618                          tok::greatergreater)) {
 619     // Unnamed template parameter. Don't have to do anything here, just
 620     // don't consume this token.
 621   } else {
 622     Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
 623     return nullptr;
 624   }
 625
 626   // Recover from misplaced ellipsis.
 627   bool AlreadyHasEllipsis = EllipsisLoc.isValid();
 628   if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
 629     DiagnoseMisplacedEllipsis(EllipsisLoc, NameLoc, AlreadyHasEllipsis, true);
 630
 631   TemplateParameterList *ParamList =
 632     Actions.ActOnTemplateParameterList(Depth, SourceLocation(),
 633                                        TemplateLoc, LAngleLoc,
 634                                        TemplateParams.data(),
 635                                        TemplateParams.size(),
 636                                        RAngleLoc);
 637
 638   // Grab a default argument (if available).
 639   // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
 640   // we introduce the template parameter into the local scope.
 641   SourceLocation EqualLoc;
 642   ParsedTemplateArgument DefaultArg;
 643   if (TryConsumeToken(tok::equal, EqualLoc)) {
 644     DefaultArg = ParseTemplateTemplateArgument();
 645     if (DefaultArg.isInvalid()) {
 646       Diag(Tok.getLocation(),
 647            diag::err_default_template_template_parameter_not_template);
 648       SkipUntil(tok::comma, tok::greater, tok::greatergreater,
 649                 StopAtSemi | StopBeforeMatch);
 650     }
 651   }
 652
 653   return Actions.ActOnTemplateTemplateParameter(getCurScope(), TemplateLoc,
 654                                                 ParamList, EllipsisLoc,
 655                                                 ParamName, NameLoc, Depth,
 656                                                 Position, EqualLoc, DefaultArg);
 657 }
 658
 659 /// ParseNonTypeTemplateParameter - Handle the parsing of non-type
 660 /// template parameters (e.g., in "template<int Size> class array;").
 661 ///
 662 ///       template-parameter:
 663 ///         ...
 664 ///         parameter-declaration
 665 Decl *
 666 Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) {
 667   // Parse the declaration-specifiers (i.e., the type).
 668   // FIXME: The type should probably be restricted in some way... Not all
 669   // declarators (parts of declarators?) are accepted for parameters.
 670   DeclSpec DS(AttrFactory);
 671   ParseDeclarationSpecifiers(DS);
 672
 673   // Parse this as a typename.
 674   Declarator ParamDecl(DS, Declarator::TemplateParamContext);
 675   ParseDeclarator(ParamDecl);
 676   if (DS.getTypeSpecType() == DeclSpec::TST_unspecified) {
 677     Diag(Tok.getLocation(), diag::err_expected_template_parameter);
 678     return nullptr;
 679   }
 680
 681   // Recover from misplaced ellipsis.
 682   SourceLocation EllipsisLoc;
 683   if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
 684     DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, ParamDecl);
 685
 686   // If there is a default value, parse it.
 687   // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
 688   // we introduce the template parameter into the local scope.
 689   SourceLocation EqualLoc;
 690   ExprResult DefaultArg;
 691   if (TryConsumeToken(tok::equal, EqualLoc)) {
 692     // C++ [temp.param]p15:
 693     //   When parsing a default template-argument for a non-type
 694     //   template-parameter, the first non-nested > is taken as the
 695     //   end of the template-parameter-list rather than a greater-than
 696     //   operator.
 697     GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
 698     EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
 699
 700     DefaultArg = Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
 701     if (DefaultArg.isInvalid())
 702       SkipUntil(tok::comma, tok::greater, StopAtSemi | StopBeforeMatch);
 703   }
 704
 705   // Create the parameter.
 706   return Actions.ActOnNonTypeTemplateParameter(getCurScope(), ParamDecl,
 707                                                Depth, Position, EqualLoc,
 708                                                DefaultArg.get());
 709 }
 710
 711 void Parser::DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
 712                                        SourceLocation CorrectLoc,
 713                                        bool AlreadyHasEllipsis,
 714                                        bool IdentifierHasName) {
 715   FixItHint Insertion;
 716   if (!AlreadyHasEllipsis)
 717     Insertion = FixItHint::CreateInsertion(CorrectLoc, "...");
 718   Diag(EllipsisLoc, diag::err_misplaced_ellipsis_in_declaration)
 719       << FixItHint::CreateRemoval(EllipsisLoc) << Insertion
 720       << !IdentifierHasName;
 721 }
 722
 723 void Parser::DiagnoseMisplacedEllipsisInDeclarator(SourceLocation EllipsisLoc,
 724                                                    Declarator &D) {
 725   assert(EllipsisLoc.isValid());
 726   bool AlreadyHasEllipsis = D.getEllipsisLoc().isValid();
 727   if (!AlreadyHasEllipsis)
 728     D.setEllipsisLoc(EllipsisLoc);
 729   DiagnoseMisplacedEllipsis(EllipsisLoc, D.getIdentifierLoc(),
 730                             AlreadyHasEllipsis, D.hasName());
 731 }
 732
 733 /// \brief Parses a '>' at the end of a template list.
 734 ///
 735 /// If this function encounters '>>', '>>>', '>=', or '>>=', it tries
 736 /// to determine if these tokens were supposed to be a '>' followed by
 737 /// '>', '>>', '>=', or '>='. It emits an appropriate diagnostic if necessary.
 738 ///
 739 /// \param RAngleLoc the location of the consumed '>'.
 740 ///
 741 /// \param ConsumeLastToken if true, the '>' is consumed.
 742 ///
 743 /// \param ObjCGenericList if true, this is the '>' closing an Objective-C
 744 /// type parameter or type argument list, rather than a C++ template parameter
 745 /// or argument list.
 746 ///
 747 /// \returns true, if current token does not start with '>', false otherwise.
 748 bool Parser::ParseGreaterThanInTemplateList(SourceLocation &RAngleLoc,
 749                                             bool ConsumeLastToken,
 750                                             bool ObjCGenericList) {
 751   // What will be left once we've consumed the '>'.
 752   tok::TokenKind RemainingToken;
 753   const char *ReplacementStr = "> >";
 754
 755   switch (Tok.getKind()) {
 756   default:
 757     Diag(Tok.getLocation(), diag::err_expected) << tok::greater;
 758     return true;
 759
 760   case tok::greater:
 761     // Determine the location of the '>' token. Only consume this token
 762     // if the caller asked us to.
 763     RAngleLoc = Tok.getLocation();
 764     if (ConsumeLastToken)
 765       ConsumeToken();
 766     return false;
 767
 768   case tok::greatergreater:
 769     RemainingToken = tok::greater;
 770     break;
 771
 772   case tok::greatergreatergreater:
 773     RemainingToken = tok::greatergreater;
 774     break;
 775
 776   case tok::greaterequal:
 777     RemainingToken = tok::equal;
 778     ReplacementStr = "> =";
 779     break;
 780
 781   case tok::greatergreaterequal:
 782     RemainingToken = tok::greaterequal;
 783     break;
 784   }
 785
 786   // This template-id is terminated by a token which starts with a '>'. Outside
 787   // C++11, this is now error recovery, and in C++11, this is error recovery if
 788   // the token isn't '>>' or '>>>'.
 789   // '>>>' is for CUDA, where this sequence of characters is parsed into
 790   // tok::greatergreatergreater, rather than two separate tokens.
 791   //
 792   // We always allow this for Objective-C type parameter and type argument
 793   // lists.
 794   RAngleLoc = Tok.getLocation();
 795   Token Next = NextToken();
 796   if (!ObjCGenericList) {
 797     // The source range of the '>>' or '>=' at the start of the token.
 798     CharSourceRange ReplacementRange =
 799         CharSourceRange::getCharRange(RAngleLoc,
 800             Lexer::AdvanceToTokenCharacter(RAngleLoc, 2, PP.getSourceManager(),
 801                                            getLangOpts()));
 802
 803     // A hint to put a space between the '>>'s. In order to make the hint as
 804     // clear as possible, we include the characters either side of the space in
 805     // the replacement, rather than just inserting a space at SecondCharLoc.
 806     FixItHint Hint1 = FixItHint::CreateReplacement(ReplacementRange,
 807                                                    ReplacementStr);
 808
 809     // A hint to put another space after the token, if it would otherwise be
 810     // lexed differently.
 811     FixItHint Hint2;
 812     if ((RemainingToken == tok::greater ||
 813          RemainingToken == tok::greatergreater) &&
 814         (Next.isOneOf(tok::greater, tok::greatergreater,
 815                       tok::greatergreatergreater, tok::equal,
 816                       tok::greaterequal, tok::greatergreaterequal,
 817                       tok::equalequal)) &&
 818         areTokensAdjacent(Tok, Next))
 819       Hint2 = FixItHint::CreateInsertion(Next.getLocation(), " ");
 820
 821     unsigned DiagId = diag::err_two_right_angle_brackets_need_space;
 822     if (getLangOpts().CPlusPlus11 &&
 823         (Tok.is(tok::greatergreater) || Tok.is(tok::greatergreatergreater)))
 824       DiagId = diag::warn_cxx98_compat_two_right_angle_brackets;
 825     else if (Tok.is(tok::greaterequal))
 826       DiagId = diag::err_right_angle_bracket_equal_needs_space;
 827     Diag(Tok.getLocation(), DiagId) << Hint1 << Hint2;
 828   }
 829
 830   // Strip the initial '>' from the token.
 831   if (RemainingToken == tok::equal && Next.is(tok::equal) &&
 832       areTokensAdjacent(Tok, Next)) {
 833     // Join two adjacent '=' tokens into one, for cases like:
 834     //   void (*p)() = f<int>;
 835     //   return f<int>==p;
 836     ConsumeToken();
 837     Tok.setKind(tok::equalequal);
 838     Tok.setLength(Tok.getLength() + 1);
 839   } else {
 840     Tok.setKind(RemainingToken);
 841     Tok.setLength(Tok.getLength() - 1);
 842   }
 843   Tok.setLocation(Lexer::AdvanceToTokenCharacter(RAngleLoc, 1,
 844                                                  PP.getSourceManager(),
 845                                                  getLangOpts()));
 846
 847   if (!ConsumeLastToken) {
 848     // Since we're not supposed to consume the '>' token, we need to push
 849     // this token and revert the current token back to the '>'.
 850     PP.EnterToken(Tok);
 851     Tok.setKind(tok::greater);
 852     Tok.setLength(1);
 853     Tok.setLocation(RAngleLoc);
 854   }
 855   return false;
 856 }
 857
 858
 859 /// \brief Parses a template-id that after the template name has
 860 /// already been parsed.
 861 ///
 862 /// This routine takes care of parsing the enclosed template argument
 863 /// list ('<' template-parameter-list [opt] '>') and placing the
 864 /// results into a form that can be transferred to semantic analysis.
 865 ///
 866 /// \param Template the template declaration produced by isTemplateName
 867 ///
 868 /// \param TemplateNameLoc the source location of the template name
 869 ///
 870 /// \param SS if non-NULL, the nested-name-specifier preceding the
 871 /// template name.
 872 ///
 873 /// \param ConsumeLastToken if true, then we will consume the last
 874 /// token that forms the template-id. Otherwise, we will leave the
 875 /// last token in the stream (e.g., so that it can be replaced with an
 876 /// annotation token).
 877 bool
 878 Parser::ParseTemplateIdAfterTemplateName(TemplateTy Template,
 879                                          SourceLocation TemplateNameLoc,
 880                                          const CXXScopeSpec &SS,
 881                                          bool ConsumeLastToken,
 882                                          SourceLocation &LAngleLoc,
 883                                          TemplateArgList &TemplateArgs,
 884                                          SourceLocation &RAngleLoc) {
 885   assert(Tok.is(tok::less) && "Must have already parsed the template-name");
 886
 887   // Consume the '<'.
 888   LAngleLoc = ConsumeToken();
 889
 890   // Parse the optional template-argument-list.
 891   bool Invalid = false;
 892   {
 893     GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
 894     if (Tok.isNot(tok::greater) && Tok.isNot(tok::greatergreater))
 895       Invalid = ParseTemplateArgumentList(TemplateArgs);
 896
 897     if (Invalid) {
 898       // Try to find the closing '>'.
 899       if (ConsumeLastToken)
 900         SkipUntil(tok::greater, StopAtSemi);
 901       else
 902         SkipUntil(tok::greater, StopAtSemi | StopBeforeMatch);
 903       return true;
 904     }
 905   }
 906
 907   return ParseGreaterThanInTemplateList(RAngleLoc, ConsumeLastToken,
 908                                         /*ObjCGenericList=*/false);
 909 }
 910
 911 /// \brief Replace the tokens that form a simple-template-id with an
 912 /// annotation token containing the complete template-id.
 913 ///
 914 /// The first token in the stream must be the name of a template that
 915 /// is followed by a '<'. This routine will parse the complete
 916 /// simple-template-id and replace the tokens with a single annotation
 917 /// token with one of two different kinds: if the template-id names a
 918 /// type (and \p AllowTypeAnnotation is true), the annotation token is
 919 /// a type annotation that includes the optional nested-name-specifier
 920 /// (\p SS). Otherwise, the annotation token is a template-id
 921 /// annotation that does not include the optional
 922 /// nested-name-specifier.
 923 ///
 924 /// \param Template  the declaration of the template named by the first
 925 /// token (an identifier), as returned from \c Action::isTemplateName().
 926 ///
 927 /// \param TNK the kind of template that \p Template
 928 /// refers to, as returned from \c Action::isTemplateName().
 929 ///
 930 /// \param SS if non-NULL, the nested-name-specifier that precedes
 931 /// this template name.
 932 ///
 933 /// \param TemplateKWLoc if valid, specifies that this template-id
 934 /// annotation was preceded by the 'template' keyword and gives the
 935 /// location of that keyword. If invalid (the default), then this
 936 /// template-id was not preceded by a 'template' keyword.
 937 ///
 938 /// \param AllowTypeAnnotation if true (the default), then a
 939 /// simple-template-id that refers to a class template, template
 940 /// template parameter, or other template that produces a type will be
 941 /// replaced with a type annotation token. Otherwise, the
 942 /// simple-template-id is always replaced with a template-id
 943 /// annotation token.
 944 ///
 945 /// If an unrecoverable parse error occurs and no annotation token can be
 946 /// formed, this function returns true.
 947 ///
 948 bool Parser::AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
 949                                      CXXScopeSpec &SS,
 950                                      SourceLocation TemplateKWLoc,
 951                                      UnqualifiedId &TemplateName,
 952                                      bool AllowTypeAnnotation) {
 953   assert(getLangOpts().CPlusPlus && "Can only annotate template-ids in C++");
 954   assert(Template && Tok.is(tok::less) &&
 955          "Parser isn't at the beginning of a template-id");
 956
 957   // Consume the template-name.
 958   SourceLocation TemplateNameLoc = TemplateName.getSourceRange().getBegin();
 959
 960   // Parse the enclosed template argument list.
 961   SourceLocation LAngleLoc, RAngleLoc;
 962   TemplateArgList TemplateArgs;
 963   bool Invalid = ParseTemplateIdAfterTemplateName(Template,
 964                                                   TemplateNameLoc,
 965                                                   SS, false, LAngleLoc,
 966                                                   TemplateArgs,
 967                                                   RAngleLoc);
 968
 969   if (Invalid) {
 970     // If we failed to parse the template ID but skipped ahead to a >, we're not
 971     // going to be able to form a token annotation.  Eat the '>' if present.
 972     TryConsumeToken(tok::greater);
 973     return true;
 974   }
 975
 976   ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
 977
 978   // Build the annotation token.
 979   if (TNK == TNK_Type_template && AllowTypeAnnotation) {
 980     TypeResult Type
 981       = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
 982                                     Template, TemplateNameLoc,
 983                                     LAngleLoc, TemplateArgsPtr, RAngleLoc);
 984     if (Type.isInvalid()) {
 985       // If we failed to parse the template ID but skipped ahead to a >, we're not
 986       // going to be able to form a token annotation.  Eat the '>' if present.
 987       TryConsumeToken(tok::greater);
 988       return true;
 989     }
 990
 991     Tok.setKind(tok::annot_typename);
 992     setTypeAnnotation(Tok, Type.get());
 993     if (SS.isNotEmpty())
 994       Tok.setLocation(SS.getBeginLoc());
 995     else if (TemplateKWLoc.isValid())
 996       Tok.setLocation(TemplateKWLoc);
 997     else
 998       Tok.setLocation(TemplateNameLoc);
 999   } else {
1000     // Build a template-id annotation token that can be processed
1001     // later.
1002     Tok.setKind(tok::annot_template_id);
1003     TemplateIdAnnotation *TemplateId
1004       = TemplateIdAnnotation::Allocate(TemplateArgs.size(), TemplateIds);
1005     TemplateId->TemplateNameLoc = TemplateNameLoc;
1006     if (TemplateName.getKind() == UnqualifiedId::IK_Identifier) {
1007       TemplateId->Name = TemplateName.Identifier;
1008       TemplateId->Operator = OO_None;
1009     } else {
1010       TemplateId->Name = nullptr;
1011       TemplateId->Operator = TemplateName.OperatorFunctionId.Operator;
1012     }
1013     TemplateId->SS = SS;
1014     TemplateId->TemplateKWLoc = TemplateKWLoc;
1015     TemplateId->Template = Template;
1016     TemplateId->Kind = TNK;
1017     TemplateId->LAngleLoc = LAngleLoc;
1018     TemplateId->RAngleLoc = RAngleLoc;
1019     ParsedTemplateArgument *Args = TemplateId->getTemplateArgs();
1020     for (unsigned Arg = 0, ArgEnd = TemplateArgs.size(); Arg != ArgEnd; ++Arg)
1021       Args[Arg] = ParsedTemplateArgument(TemplateArgs[Arg]);
1022     Tok.setAnnotationValue(TemplateId);
1023     if (TemplateKWLoc.isValid())
1024       Tok.setLocation(TemplateKWLoc);
1025     else
1026       Tok.setLocation(TemplateNameLoc);
1027   }
1028
1029   // Common fields for the annotation token
1030   Tok.setAnnotationEndLoc(RAngleLoc);
1031
1032   // In case the tokens were cached, have Preprocessor replace them with the
1033   // annotation token.
1034   PP.AnnotateCachedTokens(Tok);
1035   return false;
1036 }
1037
1038 /// \brief Replaces a template-id annotation token with a type
1039 /// annotation token.
1040 ///
1041 /// If there was a failure when forming the type from the template-id,
1042 /// a type annotation token will still be created, but will have a
1043 /// NULL type pointer to signify an error.
1044 void Parser::AnnotateTemplateIdTokenAsType() {
1045   assert(Tok.is(tok::annot_template_id) && "Requires template-id tokens");
1046
1047   TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1048   assert((TemplateId->Kind == TNK_Type_template ||
1049           TemplateId->Kind == TNK_Dependent_template_name) &&
1050          "Only works for type and dependent templates");
1051
1052   ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
1053                                      TemplateId->NumArgs);
1054
1055   TypeResult Type
1056     = Actions.ActOnTemplateIdType(TemplateId->SS,
1057                                   TemplateId->TemplateKWLoc,
1058                                   TemplateId->Template,
1059                                   TemplateId->TemplateNameLoc,
1060                                   TemplateId->LAngleLoc,
1061                                   TemplateArgsPtr,
1062                                   TemplateId->RAngleLoc);
1063   // Create the new "type" annotation token.
1064   Tok.setKind(tok::annot_typename);
1065   setTypeAnnotation(Tok, Type.isInvalid() ? ParsedType() : Type.get());
1066   if (TemplateId->SS.isNotEmpty()) // it was a C++ qualified type name.
1067     Tok.setLocation(TemplateId->SS.getBeginLoc());
1068   // End location stays the same
1069
1070   // Replace the template-id annotation token, and possible the scope-specifier
1071   // that precedes it, with the typename annotation token.
1072   PP.AnnotateCachedTokens(Tok);
1073 }
1074
1075 /// \brief Determine whether the given token can end a template argument.
1076 static bool isEndOfTemplateArgument(Token Tok) {
1077   return Tok.isOneOf(tok::comma, tok::greater, tok::greatergreater);
1078 }
1079
1080 /// \brief Parse a C++ template template argument.
1081 ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
1082   if (!Tok.is(tok::identifier) && !Tok.is(tok::coloncolon) &&
1083       !Tok.is(tok::annot_cxxscope))
1084     return ParsedTemplateArgument();
1085
1086   // C++0x [temp.arg.template]p1:
1087   //   A template-argument for a template template-parameter shall be the name
1088   //   of a class template or an alias template, expressed as id-expression.
1089   //
1090   // We parse an id-expression that refers to a class template or alias
1091   // template. The grammar we parse is:
1092   //
1093   //   nested-name-specifier[opt] template[opt] identifier ...[opt]
1094   //
1095   // followed by a token that terminates a template argument, such as ',',
1096   // '>', or (in some cases) '>>'.
1097   CXXScopeSpec SS; // nested-name-specifier, if present
1098   ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
1099                                  /*EnteringContext=*/false);
1100
1101   ParsedTemplateArgument Result;
1102   SourceLocation EllipsisLoc;
1103   if (SS.isSet() && Tok.is(tok::kw_template)) {
1104     // Parse the optional 'template' keyword following the
1105     // nested-name-specifier.
1106     SourceLocation TemplateKWLoc = ConsumeToken();
1107
1108     if (Tok.is(tok::identifier)) {
1109       // We appear to have a dependent template name.
1110       UnqualifiedId Name;
1111       Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1112       ConsumeToken(); // the identifier
1113
1114       TryConsumeToken(tok::ellipsis, EllipsisLoc);
1115
1116       // If the next token signals the end of a template argument,
1117       // then we have a dependent template name that could be a template
1118       // template argument.
1119       TemplateTy Template;
1120       if (isEndOfTemplateArgument(Tok) &&
1121           Actions.ActOnDependentTemplateName(getCurScope(),
1122                                              SS, TemplateKWLoc, Name,
1123                                              /*ObjectType=*/ ParsedType(),
1124                                              /*EnteringContext=*/false,
1125                                              Template))
1126         Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
1127     }
1128   } else if (Tok.is(tok::identifier)) {
1129     // We may have a (non-dependent) template name.
1130     TemplateTy Template;
1131     UnqualifiedId Name;
1132     Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1133     ConsumeToken(); // the identifier
1134
1135     TryConsumeToken(tok::ellipsis, EllipsisLoc);
1136
1137     if (isEndOfTemplateArgument(Tok)) {
1138       bool MemberOfUnknownSpecialization;
1139       TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
1140                                                /*hasTemplateKeyword=*/false,
1141                                                     Name,
1142                                                /*ObjectType=*/ ParsedType(),
1143                                                     /*EnteringContext=*/false,
1144                                                     Template,
1145                                                 MemberOfUnknownSpecialization);
1146       if (TNK == TNK_Dependent_template_name || TNK == TNK_Type_template) {
1147         // We have an id-expression that refers to a class template or
1148         // (C++0x) alias template.
1149         Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
1150       }
1151     }
1152   }
1153
1154   // If this is a pack expansion, build it as such.
1155   if (EllipsisLoc.isValid() && !Result.isInvalid())
1156     Result = Actions.ActOnPackExpansion(Result, EllipsisLoc);
1157
1158   return Result;
1159 }
1160
1161 /// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]).
1162 ///
1163 ///       template-argument: [C++ 14.2]
1164 ///         constant-expression
1165 ///         type-id
1166 ///         id-expression
1167 ParsedTemplateArgument Parser::ParseTemplateArgument() {
1168   // C++ [temp.arg]p2:
1169   //   In a template-argument, an ambiguity between a type-id and an
1170   //   expression is resolved to a type-id, regardless of the form of
1171   //   the corresponding template-parameter.
1172   //
1173   // Therefore, we initially try to parse a type-id.
1174   if (isCXXTypeId(TypeIdAsTemplateArgument)) {
1175     SourceLocation Loc = Tok.getLocation();
1176     TypeResult TypeArg = ParseTypeName(/*Range=*/nullptr,
1177                                        Declarator::TemplateTypeArgContext);
1178     if (TypeArg.isInvalid())
1179       return ParsedTemplateArgument();
1180
1181     return ParsedTemplateArgument(ParsedTemplateArgument::Type,
1182                                   TypeArg.get().getAsOpaquePtr(),
1183                                   Loc);
1184   }
1185
1186   // Try to parse a template template argument.
1187   {
1188     TentativeParsingAction TPA(*this);
1189
1190     ParsedTemplateArgument TemplateTemplateArgument
1191       = ParseTemplateTemplateArgument();
1192     if (!TemplateTemplateArgument.isInvalid()) {
1193       TPA.Commit();
1194       return TemplateTemplateArgument;
1195     }
1196
1197     // Revert this tentative parse to parse a non-type template argument.
1198     TPA.Revert();
1199   }
1200
1201   // Parse a non-type template argument.
1202   SourceLocation Loc = Tok.getLocation();
1203   ExprResult ExprArg = ParseConstantExpression(MaybeTypeCast);
1204   if (ExprArg.isInvalid() || !ExprArg.get())
1205     return ParsedTemplateArgument();
1206
1207   return ParsedTemplateArgument(ParsedTemplateArgument::NonType,
1208                                 ExprArg.get(), Loc);
1209 }
1210
1211 /// \brief Determine whether the current tokens can only be parsed as a
1212 /// template argument list (starting with the '<') and never as a '<'
1213 /// expression.
1214 bool Parser::IsTemplateArgumentList(unsigned Skip) {
1215   struct AlwaysRevertAction : TentativeParsingAction {
1216     AlwaysRevertAction(Parser &P) : TentativeParsingAction(P) { }
1217     ~AlwaysRevertAction() { Revert(); }
1218   } Tentative(*this);
1219
1220   while (Skip) {
1221     ConsumeToken();
1222     --Skip;
1223   }
1224
1225   // '<'
1226   if (!TryConsumeToken(tok::less))
1227     return false;
1228
1229   // An empty template argument list.
1230   if (Tok.is(tok::greater))
1231     return true;
1232
1233   // See whether we have declaration specifiers, which indicate a type.
1234   while (isCXXDeclarationSpecifier() == TPResult::True)
1235     ConsumeToken();
1236
1237   // If we have a '>' or a ',' then this is a template argument list.
1238   return Tok.isOneOf(tok::greater, tok::comma);
1239 }
1240
1241 /// ParseTemplateArgumentList - Parse a C++ template-argument-list
1242 /// (C++ [temp.names]). Returns true if there was an error.
1243 ///
1244 ///       template-argument-list: [C++ 14.2]
1245 ///         template-argument
1246 ///         template-argument-list ',' template-argument
1247 bool
1248 Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs) {
1249   // Template argument lists are constant-evaluation contexts.
1250   EnterExpressionEvaluationContext EvalContext(Actions,Sema::ConstantEvaluated);
1251   ColonProtectionRAIIObject ColonProtection(*this, false);
1252
1253   do {
1254     ParsedTemplateArgument Arg = ParseTemplateArgument();
1255     SourceLocation EllipsisLoc;
1256     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
1257       Arg = Actions.ActOnPackExpansion(Arg, EllipsisLoc);
1258
1259     if (Arg.isInvalid()) {
1260       SkipUntil(tok::comma, tok::greater, StopAtSemi | StopBeforeMatch);
1261       return true;
1262     }
1263
1264     // Save this template argument.
1265     TemplateArgs.push_back(Arg);
1266
1267     // If the next token is a comma, consume it and keep reading
1268     // arguments.
1269   } while (TryConsumeToken(tok::comma));
1270
1271   return false;
1272 }
1273
1274 /// \brief Parse a C++ explicit template instantiation
1275 /// (C++ [temp.explicit]).
1276 ///
1277 ///       explicit-instantiation:
1278 ///         'extern' [opt] 'template' declaration
1279 ///
1280 /// Note that the 'extern' is a GNU extension and C++11 feature.
1281 Decl *Parser::ParseExplicitInstantiation(unsigned Context,
1282                                          SourceLocation ExternLoc,
1283                                          SourceLocation TemplateLoc,
1284                                          SourceLocation &DeclEnd,
1285                                          AccessSpecifier AS) {
1286   // This isn't really required here.
1287   ParsingDeclRAIIObject
1288     ParsingTemplateParams(*this, ParsingDeclRAIIObject::NoParent);
1289
1290   return ParseSingleDeclarationAfterTemplate(Context,
1291                                              ParsedTemplateInfo(ExternLoc,
1292                                                                 TemplateLoc),
1293                                              ParsingTemplateParams,
1294                                              DeclEnd, AS);
1295 }
1296
1297 SourceRange Parser::ParsedTemplateInfo::getSourceRange() const {
1298   if (TemplateParams)
1299     return getTemplateParamsRange(TemplateParams->data(),
1300                                   TemplateParams->size());
1301
1302   SourceRange R(TemplateLoc);
1303   if (ExternLoc.isValid())
1304     R.setBegin(ExternLoc);
1305   return R;
1306 }
1307
1308 void Parser::LateTemplateParserCallback(void *P, LateParsedTemplate &LPT) {
1309   ((Parser *)P)->ParseLateTemplatedFuncDef(LPT);
1310 }
1311
1312 /// \brief Late parse a C++ function template in Microsoft mode.
1313 void Parser::ParseLateTemplatedFuncDef(LateParsedTemplate &LPT) {
1314   if (!LPT.D)
1315      return;
1316
1317   // Get the FunctionDecl.
1318   FunctionDecl *FunD = LPT.D->getAsFunction();
1319   // Track template parameter depth.
1320   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1321
1322   // To restore the context after late parsing.
1323   Sema::ContextRAII GlobalSavedContext(
1324       Actions, Actions.Context.getTranslationUnitDecl());
1325
1326   SmallVector<ParseScope*, 4> TemplateParamScopeStack;
1327
1328   // Get the list of DeclContexts to reenter.
1329   SmallVector<DeclContext*, 4> DeclContextsToReenter;
1330   DeclContext *DD = FunD;
1331   while (DD && !DD->isTranslationUnit()) {
1332     DeclContextsToReenter.push_back(DD);
1333     DD = DD->getLexicalParent();
1334   }
1335
1336   // Reenter template scopes from outermost to innermost.
1337   SmallVectorImpl<DeclContext *>::reverse_iterator II =
1338       DeclContextsToReenter.rbegin();
1339   for (; II != DeclContextsToReenter.rend(); ++II) {
1340     TemplateParamScopeStack.push_back(new ParseScope(this,
1341           Scope::TemplateParamScope));
1342     unsigned NumParamLists =
1343       Actions.ActOnReenterTemplateScope(getCurScope(), cast<Decl>(*II));
1344     CurTemplateDepthTracker.addDepth(NumParamLists);
1345     if (*II != FunD) {
1346       TemplateParamScopeStack.push_back(new ParseScope(this, Scope::DeclScope));
1347       Actions.PushDeclContext(Actions.getCurScope(), *II);
1348     }
1349   }
1350
1351   assert(!LPT.Toks.empty() && "Empty body!");
1352
1353   // Append the current token at the end of the new token stream so that it
1354   // doesn't get lost.
1355   LPT.Toks.push_back(Tok);
1356   PP.EnterTokenStream(LPT.Toks.data(), LPT.Toks.size(), true, false);
1357
1358   // Consume the previously pushed token.
1359   ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
1360   assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try) &&
1361          "Inline method not starting with '{', ':' or 'try'");
1362
1363   // Parse the method body. Function body parsing code is similar enough
1364   // to be re-used for method bodies as well.
1365   ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope);
1366
1367   // Recreate the containing function DeclContext.
1368   Sema::ContextRAII FunctionSavedContext(Actions,
1369                                          Actions.getContainingDC(FunD));
1370
1371   Actions.ActOnStartOfFunctionDef(getCurScope(), FunD);
1372
1373   if (Tok.is(tok::kw_try)) {
1374     ParseFunctionTryBlock(LPT.D, FnScope);
1375   } else {
1376     if (Tok.is(tok::colon))
1377       ParseConstructorInitializer(LPT.D);
1378     else
1379       Actions.ActOnDefaultCtorInitializers(LPT.D);
1380
1381     if (Tok.is(tok::l_brace)) {
1382       assert((!isa<FunctionTemplateDecl>(LPT.D) ||
1383               cast<FunctionTemplateDecl>(LPT.D)
1384                       ->getTemplateParameters()
1385                       ->getDepth() == TemplateParameterDepth - 1) &&
1386              "TemplateParameterDepth should be greater than the depth of "
1387              "current template being instantiated!");
1388       ParseFunctionStatementBody(LPT.D, FnScope);
1389       Actions.UnmarkAsLateParsedTemplate(FunD);
1390     } else
1391       Actions.ActOnFinishFunctionBody(LPT.D, nullptr);
1392   }
1393
1394   // Exit scopes.
1395   FnScope.Exit();
1396   SmallVectorImpl<ParseScope *>::reverse_iterator I =
1397    TemplateParamScopeStack.rbegin();
1398   for (; I != TemplateParamScopeStack.rend(); ++I)
1399     delete *I;
1400 }
1401
1402 /// \brief Lex a delayed template function for late parsing.
1403 void Parser::LexTemplateFunctionForLateParsing(CachedTokens &Toks) {
1404   tok::TokenKind kind = Tok.getKind();
1405   if (!ConsumeAndStoreFunctionPrologue(Toks)) {
1406     // Consume everything up to (and including) the matching right brace.
1407     ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
1408   }
1409
1410   // If we're in a function-try-block, we need to store all the catch blocks.
1411   if (kind == tok::kw_try) {
1412     while (Tok.is(tok::kw_catch)) {
1413       ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
1414       ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
1415     }
1416   }
1417 }