ParseTemplate.cpp revision 39a8de10c18365bde7062d8959b7ed525449c561
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" 19 20using namespace clang; 21 22/// \brief Parse a template declaration or an explicit specialization. 23/// 24/// Template declarations include one or more template parameter lists 25/// and either the function or class template declaration. Explicit 26/// specializations contain one or more 'template < >' prefixes 27/// followed by a (possibly templated) declaration. Since the 28/// syntactic form of both features is nearly identical, we parse all 29/// of the template headers together and let semantic analysis sort 30/// the declarations from the explicit specializations. 31/// 32/// template-declaration: [C++ temp] 33/// 'export'[opt] 'template' '<' template-parameter-list '>' declaration 34/// 35/// explicit-specialization: [ C++ temp.expl.spec] 36/// 'template' '<' '>' declaration 37Parser::DeclTy * 38Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context) { 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 0; 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); 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 (DeclTy* 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::DeclTy * 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::DeclTy *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 0; 233 } 234 235 DeclTy *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::DeclTy * 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 0; 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 0; 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 0; 295 } 296 297 TemplateParamsTy *ParamList = 298 Actions.ActOnTemplateParameterList(Depth, SourceLocation(), 299 TemplateLoc, LAngleLoc, 300 &TemplateParams[0], 301 TemplateParams.size(), 302 RAngleLoc); 303 304 Parser::DeclTy * 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::DeclTy * 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 0; 357 } 358 359 // Create the parameter. 360 DeclTy *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(DeclTy *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)) 435 return true; 436 437 // Determine the location of the '>'. Only consume this token if the 438 // caller asked us to. 439 RAngleLoc = Tok.getLocation(); 440 441 if (ConsumeLastToken) 442 ConsumeToken(); 443 444 return false; 445} 446 447/// \brief Replace the tokens that form a simple-template-id with an 448/// annotation token containing the complete template-id. 449/// 450/// The first token in the stream must be the name of a template that 451/// is followed by a '<'. This routine will parse the complete 452/// simple-template-id and replace the tokens with a single annotation 453/// token with one of two different kinds: if the template-id names a 454/// type (and \p AllowTypeAnnotation is true), the annotation token is 455/// a type annotation that includes the optional nested-name-specifier 456/// (\p SS). Otherwise, the annotation token is a template-id 457/// annotation that does not include the optional 458/// nested-name-specifier. 459/// 460/// \param Template the declaration of the template named by the first 461/// token (an identifier), as returned from \c Action::isTemplateName(). 462/// 463/// \param TemplateNameKind the kind of template that \p Template 464/// refers to, as returned from \c Action::isTemplateName(). 465/// 466/// \param SS if non-NULL, the nested-name-specifier that precedes 467/// this template name. 468/// 469/// \param TemplateKWLoc if valid, specifies that this template-id 470/// annotation was preceded by the 'template' keyword and gives the 471/// location of that keyword. If invalid (the default), then this 472/// template-id was not preceded by a 'template' keyword. 473/// 474/// \param AllowTypeAnnotation if true (the default), then a 475/// simple-template-id that refers to a class template, template 476/// template parameter, or other template that produces a type will be 477/// replaced with a type annotation token. Otherwise, the 478/// simple-template-id is always replaced with a template-id 479/// annotation token. 480void Parser::AnnotateTemplateIdToken(DeclTy *Template, TemplateNameKind TNK, 481 const CXXScopeSpec *SS, 482 SourceLocation TemplateKWLoc, 483 bool AllowTypeAnnotation) { 484 assert(getLang().CPlusPlus && "Can only annotate template-ids in C++"); 485 assert(Template && Tok.is(tok::identifier) && NextToken().is(tok::less) && 486 "Parser isn't at the beginning of a template-id"); 487 488 // Consume the template-name. 489 IdentifierInfo *Name = Tok.getIdentifierInfo(); 490 SourceLocation TemplateNameLoc = ConsumeToken(); 491 492 // Parse the enclosed template argument list. 493 SourceLocation LAngleLoc, RAngleLoc; 494 TemplateArgList TemplateArgs; 495 TemplateArgIsTypeList TemplateArgIsType; 496 TemplateArgLocationList TemplateArgLocations; 497 bool Invalid = ParseTemplateIdAfterTemplateName(Template, TemplateNameLoc, 498 SS, false, LAngleLoc, 499 TemplateArgs, 500 TemplateArgIsType, 501 TemplateArgLocations, 502 RAngleLoc); 503 504 ASTTemplateArgsPtr TemplateArgsPtr(Actions, &TemplateArgs[0], 505 &TemplateArgIsType[0], 506 TemplateArgs.size()); 507 508 if (Invalid) // FIXME: How to recover from a broken template-id? 509 return; 510 511 // Build the annotation token. 512 if (TNK == TNK_Class_template && AllowTypeAnnotation) { 513 Action::TypeResult Type 514 = Actions.ActOnClassTemplateId(Template, TemplateNameLoc, 515 LAngleLoc, TemplateArgsPtr, 516 &TemplateArgLocations[0], 517 RAngleLoc, SS); 518 if (Type.isInvalid()) // FIXME: better recovery? 519 return; 520 521 Tok.setKind(tok::annot_typename); 522 Tok.setAnnotationValue(Type.get()); 523 if (SS && SS->isNotEmpty()) 524 Tok.setLocation(SS->getBeginLoc()); 525 else if (TemplateKWLoc.isValid()) 526 Tok.setLocation(TemplateKWLoc); 527 else 528 Tok.setLocation(TemplateNameLoc); 529 } else { 530 // This is a function template. We'll be building a template-id 531 // annotation token. 532 Tok.setKind(tok::annot_template_id); 533 TemplateIdAnnotation *TemplateId 534 = TemplateIdAnnotation::Allocate(TemplateArgs.size()); 535 TemplateId->TemplateNameLoc = TemplateNameLoc; 536 TemplateId->Name = Name; 537 TemplateId->Template = Template; 538 TemplateId->Kind = TNK; 539 TemplateId->LAngleLoc = LAngleLoc; 540 TemplateId->RAngleLoc = RAngleLoc; 541 void **Args = TemplateId->getTemplateArgs(); 542 bool *ArgIsType = TemplateId->getTemplateArgIsType(); 543 SourceLocation *ArgLocs = TemplateId->getTemplateArgLocations(); 544 for (unsigned Arg = 0, ArgEnd = TemplateArgs.size(); Arg != ArgEnd; ++Arg) { 545 Args[Arg] = TemplateArgs[Arg]; 546 ArgIsType[Arg] = TemplateArgIsType[Arg]; 547 ArgLocs[Arg] = TemplateArgLocations[Arg]; 548 } 549 Tok.setAnnotationValue(TemplateId); 550 if (TemplateKWLoc.isValid()) 551 Tok.setLocation(TemplateKWLoc); 552 else 553 Tok.setLocation(TemplateNameLoc); 554 555 TemplateArgsPtr.release(); 556 } 557 558 // Common fields for the annotation token 559 Tok.setAnnotationEndLoc(RAngleLoc); 560 561 // In case the tokens were cached, have Preprocessor replace them with the 562 // annotation token. 563 PP.AnnotateCachedTokens(Tok); 564} 565 566/// \brief Replaces a template-id annotation token with a type 567/// annotation token. 568/// 569/// \returns true if there was an error, false otherwise. 570bool Parser::AnnotateTemplateIdTokenAsType(const CXXScopeSpec *SS) { 571 assert(Tok.is(tok::annot_template_id) && "Requires template-id tokens"); 572 573 TemplateIdAnnotation *TemplateId 574 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 575 assert(TemplateId->Kind == TNK_Class_template && 576 "Only works for class templates"); 577 578 ASTTemplateArgsPtr TemplateArgsPtr(Actions, 579 TemplateId->getTemplateArgs(), 580 TemplateId->getTemplateArgIsType(), 581 TemplateId->NumArgs); 582 583 Action::TypeResult Type 584 = Actions.ActOnClassTemplateId(TemplateId->Template, 585 TemplateId->TemplateNameLoc, 586 TemplateId->LAngleLoc, 587 TemplateArgsPtr, 588 TemplateId->getTemplateArgLocations(), 589 TemplateId->RAngleLoc, SS); 590 if (Type.isInvalid()) { 591 // FIXME: better recovery? 592 ConsumeToken(); 593 TemplateId->Destroy(); 594 return true; 595 } 596 597 // Create the new "type" annotation token. 598 Tok.setKind(tok::annot_typename); 599 Tok.setAnnotationValue(Type.get()); 600 if (SS && SS->isNotEmpty()) // it was a C++ qualified type name. 601 Tok.setLocation(SS->getBeginLoc()); 602 603 // We might be backtracking, in which case we need to replace the 604 // template-id annotation token with the type annotation within the 605 // set of cached tokens. That way, we won't try to form the same 606 // class template specialization again. 607 PP.ReplaceLastTokenWithAnnotation(Tok); 608 TemplateId->Destroy(); 609 610 return false; 611} 612 613/// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]). 614/// 615/// template-argument: [C++ 14.2] 616/// assignment-expression 617/// type-id 618/// id-expression 619void *Parser::ParseTemplateArgument(bool &ArgIsType) { 620 // C++ [temp.arg]p2: 621 // In a template-argument, an ambiguity between a type-id and an 622 // expression is resolved to a type-id, regardless of the form of 623 // the corresponding template-parameter. 624 // 625 // Therefore, we initially try to parse a type-id. 626 if (isCXXTypeId(TypeIdAsTemplateArgument)) { 627 ArgIsType = true; 628 TypeResult TypeArg = ParseTypeName(); 629 if (TypeArg.isInvalid()) 630 return 0; 631 return TypeArg.get(); 632 } 633 634 OwningExprResult ExprArg = ParseAssignmentExpression(); 635 if (ExprArg.isInvalid() || !ExprArg.get()) 636 return 0; 637 638 ArgIsType = false; 639 return ExprArg.release(); 640} 641 642/// ParseTemplateArgumentList - Parse a C++ template-argument-list 643/// (C++ [temp.names]). Returns true if there was an error. 644/// 645/// template-argument-list: [C++ 14.2] 646/// template-argument 647/// template-argument-list ',' template-argument 648bool 649Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs, 650 TemplateArgIsTypeList &TemplateArgIsType, 651 TemplateArgLocationList &TemplateArgLocations) { 652 while (true) { 653 bool IsType = false; 654 SourceLocation Loc = Tok.getLocation(); 655 void *Arg = ParseTemplateArgument(IsType); 656 if (Arg) { 657 TemplateArgs.push_back(Arg); 658 TemplateArgIsType.push_back(IsType); 659 TemplateArgLocations.push_back(Loc); 660 } else { 661 SkipUntil(tok::comma, tok::greater, true, true); 662 return true; 663 } 664 665 // If the next token is a comma, consume it and keep reading 666 // arguments. 667 if (Tok.isNot(tok::comma)) break; 668 669 // Consume the comma. 670 ConsumeToken(); 671 } 672 673 return Tok.isNot(tok::greater); 674} 675 676