ParseTemplate.cpp revision b28317a8e5e0e2953d1e5406d753d6c3c7f1e7d2
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 "clang/Parse/ParseDiagnostic.h" 16#include "clang/Parse/DeclSpec.h" 17#include "clang/Parse/Scope.h" 18#include "AstGuard.h" 19using namespace clang; 20 21/// \brief Parse a template declaration or an explicit specialization. 22/// 23/// Template declarations include one or more template parameter lists 24/// and either the function or class template declaration. Explicit 25/// specializations contain one or more 'template < >' prefixes 26/// followed by a (possibly templated) declaration. Since the 27/// syntactic form of both features is nearly identical, we parse all 28/// of the template headers together and let semantic analysis sort 29/// the declarations from the explicit specializations. 30/// 31/// template-declaration: [C++ temp] 32/// 'export'[opt] 'template' '<' template-parameter-list '>' declaration 33/// 34/// explicit-specialization: [ C++ temp.expl.spec] 35/// 'template' '<' '>' declaration 36Parser::DeclPtrTy 37Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context, 38 AccessSpecifier AS) { 39 assert((Tok.is(tok::kw_export) || Tok.is(tok::kw_template)) && 40 "Token does not start a template declaration."); 41 42 // Enter template-parameter scope. 43 ParseScope TemplateParmScope(this, Scope::TemplateParamScope); 44 45 // Parse multiple levels of template headers within this template 46 // parameter scope, e.g., 47 // 48 // template<typename T> 49 // template<typename U> 50 // class A<T>::B { ... }; 51 // 52 // We parse multiple levels non-recursively so that we can build a 53 // single data structure containing all of the template parameter 54 // lists to easily differentiate between the case above and: 55 // 56 // template<typename T> 57 // class A { 58 // template<typename U> class B; 59 // }; 60 // 61 // In the first case, the action for declaring A<T>::B receives 62 // both template parameter lists. In the second case, the action for 63 // defining A<T>::B receives just the inner template parameter list 64 // (and retrieves the outer template parameter list from its 65 // context). 66 TemplateParameterLists ParamLists; 67 do { 68 // Consume the 'export', if any. 69 SourceLocation ExportLoc; 70 if (Tok.is(tok::kw_export)) { 71 ExportLoc = ConsumeToken(); 72 } 73 74 // Consume the 'template', which should be here. 75 SourceLocation TemplateLoc; 76 if (Tok.is(tok::kw_template)) { 77 TemplateLoc = ConsumeToken(); 78 } else { 79 Diag(Tok.getLocation(), diag::err_expected_template); 80 return DeclPtrTy(); 81 } 82 83 // Parse the '<' template-parameter-list '>' 84 SourceLocation LAngleLoc, RAngleLoc; 85 TemplateParameterList TemplateParams; 86 ParseTemplateParameters(ParamLists.size(), TemplateParams, LAngleLoc, 87 RAngleLoc); 88 89 ParamLists.push_back( 90 Actions.ActOnTemplateParameterList(ParamLists.size(), ExportLoc, 91 TemplateLoc, LAngleLoc, 92 &TemplateParams[0], 93 TemplateParams.size(), RAngleLoc)); 94 } while (Tok.is(tok::kw_export) || Tok.is(tok::kw_template)); 95 96 // Parse the actual template declaration. 97 return ParseDeclarationOrFunctionDefinition(&ParamLists, AS); 98} 99 100/// ParseTemplateParameters - Parses a template-parameter-list enclosed in 101/// angle brackets. Depth is the depth of this template-parameter-list, which 102/// is the number of template headers directly enclosing this template header. 103/// TemplateParams is the current list of template parameters we're building. 104/// The template parameter we parse will be added to this list. LAngleLoc and 105/// RAngleLoc will receive the positions of the '<' and '>', respectively, 106/// that enclose this template parameter list. 107bool Parser::ParseTemplateParameters(unsigned Depth, 108 TemplateParameterList &TemplateParams, 109 SourceLocation &LAngleLoc, 110 SourceLocation &RAngleLoc) { 111 // Get the template parameter list. 112 if(!Tok.is(tok::less)) { 113 Diag(Tok.getLocation(), diag::err_expected_less_after) << "template"; 114 return false; 115 } 116 LAngleLoc = ConsumeToken(); 117 118 // Try to parse the template parameter list. 119 if (Tok.is(tok::greater)) 120 RAngleLoc = ConsumeToken(); 121 else if(ParseTemplateParameterList(Depth, TemplateParams)) { 122 if(!Tok.is(tok::greater)) { 123 Diag(Tok.getLocation(), diag::err_expected_greater); 124 return false; 125 } 126 RAngleLoc = ConsumeToken(); 127 } 128 return true; 129} 130 131/// ParseTemplateParameterList - Parse a template parameter list. If 132/// the parsing fails badly (i.e., closing bracket was left out), this 133/// will try to put the token stream in a reasonable position (closing 134/// a statement, etc.) and return false. 135/// 136/// template-parameter-list: [C++ temp] 137/// template-parameter 138/// template-parameter-list ',' template-parameter 139bool 140Parser::ParseTemplateParameterList(unsigned Depth, 141 TemplateParameterList &TemplateParams) { 142 while(1) { 143 if (DeclPtrTy TmpParam 144 = ParseTemplateParameter(Depth, TemplateParams.size())) { 145 TemplateParams.push_back(TmpParam); 146 } else { 147 // If we failed to parse a template parameter, skip until we find 148 // a comma or closing brace. 149 SkipUntil(tok::comma, tok::greater, true, true); 150 } 151 152 // Did we find a comma or the end of the template parmeter list? 153 if(Tok.is(tok::comma)) { 154 ConsumeToken(); 155 } else if(Tok.is(tok::greater)) { 156 // Don't consume this... that's done by template parser. 157 break; 158 } else { 159 // Somebody probably forgot to close the template. Skip ahead and 160 // try to get out of the expression. This error is currently 161 // subsumed by whatever goes on in ParseTemplateParameter. 162 // TODO: This could match >>, and it would be nice to avoid those 163 // silly errors with template <vec<T>>. 164 // Diag(Tok.getLocation(), diag::err_expected_comma_greater); 165 SkipUntil(tok::greater, true, true); 166 return false; 167 } 168 } 169 return true; 170} 171 172/// ParseTemplateParameter - Parse a template-parameter (C++ [temp.param]). 173/// 174/// template-parameter: [C++ temp.param] 175/// type-parameter 176/// parameter-declaration 177/// 178/// type-parameter: (see below) 179/// 'class' identifier[opt] 180/// 'class' identifier[opt] '=' type-id 181/// 'typename' identifier[opt] 182/// 'typename' identifier[opt] '=' type-id 183/// 'template' '<' template-parameter-list '>' 'class' identifier[opt] 184/// 'template' '<' template-parameter-list '>' 'class' identifier[opt] = id-expression 185Parser::DeclPtrTy 186Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) { 187 if(Tok.is(tok::kw_class) || 188 (Tok.is(tok::kw_typename) && 189 // FIXME: Next token has not been annotated! 190 NextToken().isNot(tok::annot_typename))) { 191 return ParseTypeParameter(Depth, Position); 192 } 193 194 if(Tok.is(tok::kw_template)) 195 return ParseTemplateTemplateParameter(Depth, Position); 196 197 // If it's none of the above, then it must be a parameter declaration. 198 // NOTE: This will pick up errors in the closure of the template parameter 199 // list (e.g., template < ; Check here to implement >> style closures. 200 return ParseNonTypeTemplateParameter(Depth, Position); 201} 202 203/// ParseTypeParameter - Parse a template type parameter (C++ [temp.param]). 204/// Other kinds of template parameters are parsed in 205/// ParseTemplateTemplateParameter and ParseNonTypeTemplateParameter. 206/// 207/// type-parameter: [C++ temp.param] 208/// 'class' identifier[opt] 209/// 'class' identifier[opt] '=' type-id 210/// 'typename' identifier[opt] 211/// 'typename' identifier[opt] '=' type-id 212Parser::DeclPtrTy Parser::ParseTypeParameter(unsigned Depth, unsigned Position){ 213 assert((Tok.is(tok::kw_class) || Tok.is(tok::kw_typename)) && 214 "A type-parameter starts with 'class' or 'typename'"); 215 216 // Consume the 'class' or 'typename' keyword. 217 bool TypenameKeyword = Tok.is(tok::kw_typename); 218 SourceLocation KeyLoc = ConsumeToken(); 219 220 // Grab the template parameter name (if given) 221 SourceLocation NameLoc; 222 IdentifierInfo* ParamName = 0; 223 if(Tok.is(tok::identifier)) { 224 ParamName = Tok.getIdentifierInfo(); 225 NameLoc = ConsumeToken(); 226 } else if(Tok.is(tok::equal) || Tok.is(tok::comma) || 227 Tok.is(tok::greater)) { 228 // Unnamed template parameter. Don't have to do anything here, just 229 // don't consume this token. 230 } else { 231 Diag(Tok.getLocation(), diag::err_expected_ident); 232 return DeclPtrTy(); 233 } 234 235 DeclPtrTy TypeParam = Actions.ActOnTypeParameter(CurScope, TypenameKeyword, 236 KeyLoc, ParamName, NameLoc, 237 Depth, Position); 238 239 // Grab a default type id (if given). 240 if(Tok.is(tok::equal)) { 241 SourceLocation EqualLoc = ConsumeToken(); 242 SourceLocation DefaultLoc = Tok.getLocation(); 243 TypeResult DefaultType = ParseTypeName(); 244 if (!DefaultType.isInvalid()) 245 Actions.ActOnTypeParameterDefault(TypeParam, EqualLoc, DefaultLoc, 246 DefaultType.get()); 247 } 248 249 return TypeParam; 250} 251 252/// ParseTemplateTemplateParameter - Handle the parsing of template 253/// template parameters. 254/// 255/// type-parameter: [C++ temp.param] 256/// 'template' '<' template-parameter-list '>' 'class' identifier[opt] 257/// 'template' '<' template-parameter-list '>' 'class' identifier[opt] = id-expression 258Parser::DeclPtrTy 259Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) { 260 assert(Tok.is(tok::kw_template) && "Expected 'template' keyword"); 261 262 // Handle the template <...> part. 263 SourceLocation TemplateLoc = ConsumeToken(); 264 TemplateParameterList TemplateParams; 265 SourceLocation LAngleLoc, RAngleLoc; 266 { 267 ParseScope TemplateParmScope(this, Scope::TemplateParamScope); 268 if(!ParseTemplateParameters(Depth + 1, TemplateParams, LAngleLoc, 269 RAngleLoc)) { 270 return DeclPtrTy(); 271 } 272 } 273 274 // Generate a meaningful error if the user forgot to put class before the 275 // identifier, comma, or greater. 276 if(!Tok.is(tok::kw_class)) { 277 Diag(Tok.getLocation(), diag::err_expected_class_before) 278 << PP.getSpelling(Tok); 279 return DeclPtrTy(); 280 } 281 SourceLocation ClassLoc = ConsumeToken(); 282 283 // Get the identifier, if given. 284 SourceLocation NameLoc; 285 IdentifierInfo* ParamName = 0; 286 if(Tok.is(tok::identifier)) { 287 ParamName = Tok.getIdentifierInfo(); 288 NameLoc = ConsumeToken(); 289 } else if(Tok.is(tok::equal) || Tok.is(tok::comma) || Tok.is(tok::greater)) { 290 // Unnamed template parameter. Don't have to do anything here, just 291 // don't consume this token. 292 } else { 293 Diag(Tok.getLocation(), diag::err_expected_ident); 294 return DeclPtrTy(); 295 } 296 297 TemplateParamsTy *ParamList = 298 Actions.ActOnTemplateParameterList(Depth, SourceLocation(), 299 TemplateLoc, LAngleLoc, 300 &TemplateParams[0], 301 TemplateParams.size(), 302 RAngleLoc); 303 304 Parser::DeclPtrTy Param 305 = Actions.ActOnTemplateTemplateParameter(CurScope, TemplateLoc, 306 ParamList, ParamName, 307 NameLoc, Depth, Position); 308 309 // Get the a default value, if given. 310 if (Tok.is(tok::equal)) { 311 SourceLocation EqualLoc = ConsumeToken(); 312 OwningExprResult DefaultExpr = ParseCXXIdExpression(); 313 if (DefaultExpr.isInvalid()) 314 return Param; 315 else if (Param) 316 Actions.ActOnTemplateTemplateParameterDefault(Param, EqualLoc, 317 move(DefaultExpr)); 318 } 319 320 return Param; 321} 322 323/// ParseNonTypeTemplateParameter - Handle the parsing of non-type 324/// template parameters (e.g., in "template<int Size> class array;"). 325/// 326/// template-parameter: 327/// ... 328/// parameter-declaration 329/// 330/// NOTE: It would be ideal to simply call out to ParseParameterDeclaration(), 331/// but that didn't work out to well. Instead, this tries to recrate the basic 332/// parsing of parameter declarations, but tries to constrain it for template 333/// parameters. 334/// FIXME: We need to make a ParseParameterDeclaration that works for 335/// non-type template parameters and normal function parameters. 336Parser::DeclPtrTy 337Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) { 338 SourceLocation StartLoc = Tok.getLocation(); 339 340 // Parse the declaration-specifiers (i.e., the type). 341 // FIXME: The type should probably be restricted in some way... Not all 342 // declarators (parts of declarators?) are accepted for parameters. 343 DeclSpec DS; 344 ParseDeclarationSpecifiers(DS); 345 346 // Parse this as a typename. 347 Declarator ParamDecl(DS, Declarator::TemplateParamContext); 348 ParseDeclarator(ParamDecl); 349 if (DS.getTypeSpecType() == DeclSpec::TST_unspecified && !DS.getTypeRep()) { 350 // This probably shouldn't happen - and it's more of a Sema thing, but 351 // basically we didn't parse the type name because we couldn't associate 352 // it with an AST node. we should just skip to the comma or greater. 353 // TODO: This is currently a placeholder for some kind of Sema Error. 354 Diag(Tok.getLocation(), diag::err_parse_error); 355 SkipUntil(tok::comma, tok::greater, true, true); 356 return DeclPtrTy(); 357 } 358 359 // Create the parameter. 360 DeclPtrTy Param = Actions.ActOnNonTypeTemplateParameter(CurScope, ParamDecl, 361 Depth, Position); 362 363 // If there is a default value, parse it. 364 if (Tok.is(tok::equal)) { 365 SourceLocation EqualLoc = ConsumeToken(); 366 367 // C++ [temp.param]p15: 368 // When parsing a default template-argument for a non-type 369 // template-parameter, the first non-nested > is taken as the 370 // end of the template-parameter-list rather than a greater-than 371 // operator. 372 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false); 373 374 OwningExprResult DefaultArg = ParseAssignmentExpression(); 375 if (DefaultArg.isInvalid()) 376 SkipUntil(tok::comma, tok::greater, true, true); 377 else if (Param) 378 Actions.ActOnNonTypeTemplateParameterDefault(Param, EqualLoc, 379 move(DefaultArg)); 380 } 381 382 return Param; 383} 384 385/// \brief Parses a template-id that after the template name has 386/// already been parsed. 387/// 388/// This routine takes care of parsing the enclosed template argument 389/// list ('<' template-parameter-list [opt] '>') and placing the 390/// results into a form that can be transferred to semantic analysis. 391/// 392/// \param Template the template declaration produced by isTemplateName 393/// 394/// \param TemplateNameLoc the source location of the template name 395/// 396/// \param SS if non-NULL, the nested-name-specifier preceding the 397/// template name. 398/// 399/// \param ConsumeLastToken if true, then we will consume the last 400/// token that forms the template-id. Otherwise, we will leave the 401/// last token in the stream (e.g., so that it can be replaced with an 402/// annotation token). 403bool 404Parser::ParseTemplateIdAfterTemplateName(DeclPtrTy Template, 405 SourceLocation TemplateNameLoc, 406 const CXXScopeSpec *SS, 407 bool ConsumeLastToken, 408 SourceLocation &LAngleLoc, 409 TemplateArgList &TemplateArgs, 410 TemplateArgIsTypeList &TemplateArgIsType, 411 TemplateArgLocationList &TemplateArgLocations, 412 SourceLocation &RAngleLoc) { 413 assert(Tok.is(tok::less) && "Must have already parsed the template-name"); 414 415 // Consume the '<'. 416 LAngleLoc = ConsumeToken(); 417 418 // Parse the optional template-argument-list. 419 bool Invalid = false; 420 { 421 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false); 422 if (Tok.isNot(tok::greater)) 423 Invalid = ParseTemplateArgumentList(TemplateArgs, TemplateArgIsType, 424 TemplateArgLocations); 425 426 if (Invalid) { 427 // Try to find the closing '>'. 428 SkipUntil(tok::greater, true, !ConsumeLastToken); 429 430 return true; 431 } 432 } 433 434 if (Tok.isNot(tok::greater) && Tok.isNot(tok::greatergreater)) 435 return true; 436 437 // Determine the location of the '>' or '>>'. Only consume this 438 // token if the caller asked us to. 439 RAngleLoc = Tok.getLocation(); 440 441 if (Tok.is(tok::greatergreater)) { 442 if (!getLang().CPlusPlus0x) { 443 const char *ReplaceStr = "> >"; 444 if (NextToken().is(tok::greater) || NextToken().is(tok::greatergreater)) 445 ReplaceStr = "> > "; 446 447 Diag(Tok.getLocation(), diag::err_two_right_angle_brackets_need_space) 448 << CodeModificationHint::CreateReplacement( 449 SourceRange(Tok.getLocation()), ReplaceStr); 450 } 451 452 Tok.setKind(tok::greater); 453 if (!ConsumeLastToken) { 454 // Since we're not supposed to consume the '>>' token, we need 455 // to insert a second '>' token after the first. 456 PP.EnterToken(Tok); 457 } 458 } else if (ConsumeLastToken) 459 ConsumeToken(); 460 461 return false; 462} 463 464/// \brief Replace the tokens that form a simple-template-id with an 465/// annotation token containing the complete template-id. 466/// 467/// The first token in the stream must be the name of a template that 468/// is followed by a '<'. This routine will parse the complete 469/// simple-template-id and replace the tokens with a single annotation 470/// token with one of two different kinds: if the template-id names a 471/// type (and \p AllowTypeAnnotation is true), the annotation token is 472/// a type annotation that includes the optional nested-name-specifier 473/// (\p SS). Otherwise, the annotation token is a template-id 474/// annotation that does not include the optional 475/// nested-name-specifier. 476/// 477/// \param Template the declaration of the template named by the first 478/// token (an identifier), as returned from \c Action::isTemplateName(). 479/// 480/// \param TemplateNameKind the kind of template that \p Template 481/// refers to, as returned from \c Action::isTemplateName(). 482/// 483/// \param SS if non-NULL, the nested-name-specifier that precedes 484/// this template name. 485/// 486/// \param TemplateKWLoc if valid, specifies that this template-id 487/// annotation was preceded by the 'template' keyword and gives the 488/// location of that keyword. If invalid (the default), then this 489/// template-id was not preceded by a 'template' keyword. 490/// 491/// \param AllowTypeAnnotation if true (the default), then a 492/// simple-template-id that refers to a class template, template 493/// template parameter, or other template that produces a type will be 494/// replaced with a type annotation token. Otherwise, the 495/// simple-template-id is always replaced with a template-id 496/// annotation token. 497void Parser::AnnotateTemplateIdToken(DeclPtrTy Template, TemplateNameKind TNK, 498 const CXXScopeSpec *SS, 499 SourceLocation TemplateKWLoc, 500 bool AllowTypeAnnotation) { 501 assert(getLang().CPlusPlus && "Can only annotate template-ids in C++"); 502 assert(Template && Tok.is(tok::identifier) && NextToken().is(tok::less) && 503 "Parser isn't at the beginning of a template-id"); 504 505 // Consume the template-name. 506 IdentifierInfo *Name = Tok.getIdentifierInfo(); 507 SourceLocation TemplateNameLoc = ConsumeToken(); 508 509 // Parse the enclosed template argument list. 510 SourceLocation LAngleLoc, RAngleLoc; 511 TemplateArgList TemplateArgs; 512 TemplateArgIsTypeList TemplateArgIsType; 513 TemplateArgLocationList TemplateArgLocations; 514 bool Invalid = ParseTemplateIdAfterTemplateName(Template, TemplateNameLoc, 515 SS, false, LAngleLoc, 516 TemplateArgs, 517 TemplateArgIsType, 518 TemplateArgLocations, 519 RAngleLoc); 520 521 ASTTemplateArgsPtr TemplateArgsPtr(Actions, &TemplateArgs[0], 522 &TemplateArgIsType[0], 523 TemplateArgs.size()); 524 525 if (Invalid) // FIXME: How to recover from a broken template-id? 526 return; 527 528 // Build the annotation token. 529 if (TNK == TNK_Class_template && AllowTypeAnnotation) { 530 Action::TypeResult Type 531 = Actions.ActOnClassTemplateId(Template, TemplateNameLoc, 532 LAngleLoc, TemplateArgsPtr, 533 &TemplateArgLocations[0], 534 RAngleLoc, SS); 535 if (Type.isInvalid()) // FIXME: better recovery? 536 return; 537 538 Tok.setKind(tok::annot_typename); 539 Tok.setAnnotationValue(Type.get()); 540 if (SS && SS->isNotEmpty()) 541 Tok.setLocation(SS->getBeginLoc()); 542 else if (TemplateKWLoc.isValid()) 543 Tok.setLocation(TemplateKWLoc); 544 else 545 Tok.setLocation(TemplateNameLoc); 546 } else { 547 // This is a function template. We'll be building a template-id 548 // annotation token. 549 Tok.setKind(tok::annot_template_id); 550 TemplateIdAnnotation *TemplateId 551 = TemplateIdAnnotation::Allocate(TemplateArgs.size()); 552 TemplateId->TemplateNameLoc = TemplateNameLoc; 553 TemplateId->Name = Name; 554 TemplateId->Template = Template.getAs<void*>(); 555 TemplateId->Kind = TNK; 556 TemplateId->LAngleLoc = LAngleLoc; 557 TemplateId->RAngleLoc = RAngleLoc; 558 void **Args = TemplateId->getTemplateArgs(); 559 bool *ArgIsType = TemplateId->getTemplateArgIsType(); 560 SourceLocation *ArgLocs = TemplateId->getTemplateArgLocations(); 561 for (unsigned Arg = 0, ArgEnd = TemplateArgs.size(); Arg != ArgEnd; ++Arg) { 562 Args[Arg] = TemplateArgs[Arg]; 563 ArgIsType[Arg] = TemplateArgIsType[Arg]; 564 ArgLocs[Arg] = TemplateArgLocations[Arg]; 565 } 566 Tok.setAnnotationValue(TemplateId); 567 if (TemplateKWLoc.isValid()) 568 Tok.setLocation(TemplateKWLoc); 569 else 570 Tok.setLocation(TemplateNameLoc); 571 572 TemplateArgsPtr.release(); 573 } 574 575 // Common fields for the annotation token 576 Tok.setAnnotationEndLoc(RAngleLoc); 577 578 // In case the tokens were cached, have Preprocessor replace them with the 579 // annotation token. 580 PP.AnnotateCachedTokens(Tok); 581} 582 583/// \brief Replaces a template-id annotation token with a type 584/// annotation token. 585/// 586/// \returns true if there was an error, false otherwise. 587bool Parser::AnnotateTemplateIdTokenAsType(const CXXScopeSpec *SS) { 588 assert(Tok.is(tok::annot_template_id) && "Requires template-id tokens"); 589 590 TemplateIdAnnotation *TemplateId 591 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 592 assert(TemplateId->Kind == TNK_Class_template && 593 "Only works for class templates"); 594 595 ASTTemplateArgsPtr TemplateArgsPtr(Actions, 596 TemplateId->getTemplateArgs(), 597 TemplateId->getTemplateArgIsType(), 598 TemplateId->NumArgs); 599 600 Action::TypeResult Type 601 = Actions.ActOnClassTemplateId(DeclPtrTy::make(TemplateId->Template), 602 TemplateId->TemplateNameLoc, 603 TemplateId->LAngleLoc, 604 TemplateArgsPtr, 605 TemplateId->getTemplateArgLocations(), 606 TemplateId->RAngleLoc, SS); 607 if (Type.isInvalid()) { 608 // FIXME: better recovery? 609 ConsumeToken(); 610 TemplateId->Destroy(); 611 return true; 612 } 613 614 // Create the new "type" annotation token. 615 Tok.setKind(tok::annot_typename); 616 Tok.setAnnotationValue(Type.get()); 617 if (SS && SS->isNotEmpty()) // it was a C++ qualified type name. 618 Tok.setLocation(SS->getBeginLoc()); 619 620 // We might be backtracking, in which case we need to replace the 621 // template-id annotation token with the type annotation within the 622 // set of cached tokens. That way, we won't try to form the same 623 // class template specialization again. 624 PP.ReplaceLastTokenWithAnnotation(Tok); 625 TemplateId->Destroy(); 626 627 return false; 628} 629 630/// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]). 631/// 632/// template-argument: [C++ 14.2] 633/// assignment-expression 634/// type-id 635/// id-expression 636void *Parser::ParseTemplateArgument(bool &ArgIsType) { 637 // C++ [temp.arg]p2: 638 // In a template-argument, an ambiguity between a type-id and an 639 // expression is resolved to a type-id, regardless of the form of 640 // the corresponding template-parameter. 641 // 642 // Therefore, we initially try to parse a type-id. 643 if (isCXXTypeId(TypeIdAsTemplateArgument)) { 644 ArgIsType = true; 645 TypeResult TypeArg = ParseTypeName(); 646 if (TypeArg.isInvalid()) 647 return 0; 648 return TypeArg.get(); 649 } 650 651 OwningExprResult ExprArg = ParseAssignmentExpression(); 652 if (ExprArg.isInvalid() || !ExprArg.get()) 653 return 0; 654 655 ArgIsType = false; 656 return ExprArg.release(); 657} 658 659/// ParseTemplateArgumentList - Parse a C++ template-argument-list 660/// (C++ [temp.names]). Returns true if there was an error. 661/// 662/// template-argument-list: [C++ 14.2] 663/// template-argument 664/// template-argument-list ',' template-argument 665bool 666Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs, 667 TemplateArgIsTypeList &TemplateArgIsType, 668 TemplateArgLocationList &TemplateArgLocations) { 669 while (true) { 670 bool IsType = false; 671 SourceLocation Loc = Tok.getLocation(); 672 void *Arg = ParseTemplateArgument(IsType); 673 if (Arg) { 674 TemplateArgs.push_back(Arg); 675 TemplateArgIsType.push_back(IsType); 676 TemplateArgLocations.push_back(Loc); 677 } else { 678 SkipUntil(tok::comma, tok::greater, true, true); 679 return true; 680 } 681 682 // If the next token is a comma, consume it and keep reading 683 // arguments. 684 if (Tok.isNot(tok::comma)) break; 685 686 // Consume the comma. 687 ConsumeToken(); 688 } 689 690 return Tok.isNot(tok::greater) && Tok.isNot(tok::greatergreater); 691} 692 693