blob: 32a78a73a89ab80cf9569edc9e2982a1802fa507 [file] [log] [blame]
Douglas Gregoradcac882008-12-01 23:54:00 +00001//===--- 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"
Chandler Carruth55fc8732012-12-04 09:13:33 +000015#include "RAIIObjectsForParser.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/DeclTemplate.h"
Chris Lattner500d3292009-01-29 05:15:15 +000018#include "clang/Parse/ParseDiagnostic.h"
John McCall19510852010-08-20 18:27:03 +000019#include "clang/Sema/DeclSpec.h"
20#include "clang/Sema/ParsedTemplate.h"
21#include "clang/Sema/Scope.h"
Douglas Gregoradcac882008-12-01 23:54:00 +000022using namespace clang;
23
Douglas Gregor4d9a16f2009-05-12 23:25:50 +000024/// \brief Parse a template declaration, explicit instantiation, or
25/// explicit specialization.
John McCalld226f652010-08-21 09:40:31 +000026Decl *
Douglas Gregor4d9a16f2009-05-12 23:25:50 +000027Parser::ParseDeclarationStartingWithTemplate(unsigned Context,
28 SourceLocation &DeclEnd,
Erik Verbruggen5f1c8222011-10-13 09:41:32 +000029 AccessSpecifier AS,
30 AttributeList *AccessAttrs) {
Fariborz Jahanian9735c5e2011-08-22 17:59:19 +000031 ObjCDeclContextSwitch ObjCDC(*this);
32
Fariborz Jahaniana28948f2011-08-22 15:54:49 +000033 if (Tok.is(tok::kw_template) && NextToken().isNot(tok::less)) {
Argyrios Kyrtzidis92410572011-12-23 02:16:45 +000034 return ParseExplicitInstantiation(Context,
35 SourceLocation(), ConsumeToken(),
36 DeclEnd, AS);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +000037 }
Erik Verbruggen5f1c8222011-10-13 09:41:32 +000038 return ParseTemplateDeclarationOrSpecialization(Context, DeclEnd, AS,
39 AccessAttrs);
Douglas Gregor4d9a16f2009-05-12 23:25:50 +000040}
41
Douglas Gregorc3058332009-08-24 23:03:25 +000042/// \brief RAII class that manages the template parameter depth.
43namespace {
Benjamin Kramer85b45212009-11-28 19:45:26 +000044 class TemplateParameterDepthCounter {
Douglas Gregorc3058332009-08-24 23:03:25 +000045 unsigned &Depth;
46 unsigned AddedLevels;
47
48 public:
Mike Stump1eb44332009-09-09 15:08:12 +000049 explicit TemplateParameterDepthCounter(unsigned &Depth)
Douglas Gregorc3058332009-08-24 23:03:25 +000050 : Depth(Depth), AddedLevels(0) { }
Mike Stump1eb44332009-09-09 15:08:12 +000051
Douglas Gregorc3058332009-08-24 23:03:25 +000052 ~TemplateParameterDepthCounter() {
53 Depth -= AddedLevels;
54 }
Mike Stump1eb44332009-09-09 15:08:12 +000055
56 void operator++() {
Douglas Gregorc3058332009-08-24 23:03:25 +000057 ++Depth;
58 ++AddedLevels;
59 }
Mike Stump1eb44332009-09-09 15:08:12 +000060
Douglas Gregorc3058332009-08-24 23:03:25 +000061 operator unsigned() const { return Depth; }
62 };
63}
64
Douglas Gregorcc636682009-02-17 23:15:12 +000065/// \brief Parse a template declaration or an explicit specialization.
66///
67/// Template declarations include one or more template parameter lists
68/// and either the function or class template declaration. Explicit
69/// specializations contain one or more 'template < >' prefixes
70/// followed by a (possibly templated) declaration. Since the
71/// syntactic form of both features is nearly identical, we parse all
72/// of the template headers together and let semantic analysis sort
73/// the declarations from the explicit specializations.
Douglas Gregoradcac882008-12-01 23:54:00 +000074///
75/// template-declaration: [C++ temp]
76/// 'export'[opt] 'template' '<' template-parameter-list '>' declaration
Douglas Gregorcc636682009-02-17 23:15:12 +000077///
78/// explicit-specialization: [ C++ temp.expl.spec]
79/// 'template' '<' '>' declaration
John McCalld226f652010-08-21 09:40:31 +000080Decl *
Anders Carlsson5aeccdb2009-03-26 00:52:18 +000081Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context,
Chris Lattner97144fc2009-04-02 04:16:50 +000082 SourceLocation &DeclEnd,
Erik Verbruggen5f1c8222011-10-13 09:41:32 +000083 AccessSpecifier AS,
84 AttributeList *AccessAttrs) {
Mike Stump1eb44332009-09-09 15:08:12 +000085 assert((Tok.is(tok::kw_export) || Tok.is(tok::kw_template)) &&
86 "Token does not start a template declaration.");
87
Douglas Gregor26236e82008-12-02 00:41:28 +000088 // Enter template-parameter scope.
Douglas Gregor8935b8b2008-12-10 06:34:36 +000089 ParseScope TemplateParmScope(this, Scope::TemplateParamScope);
Douglas Gregor26236e82008-12-02 00:41:28 +000090
John McCallc9068d72010-07-16 08:13:16 +000091 // Tell the action that names should be checked in the context of
92 // the declaration to come.
John McCall92576642012-05-07 06:16:41 +000093 ParsingDeclRAIIObject
94 ParsingTemplateParams(*this, ParsingDeclRAIIObject::NoParent);
John McCallc9068d72010-07-16 08:13:16 +000095
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +000096 // Parse multiple levels of template headers within this template
97 // parameter scope, e.g.,
98 //
99 // template<typename T>
100 // template<typename U>
101 // class A<T>::B { ... };
102 //
103 // We parse multiple levels non-recursively so that we can build a
104 // single data structure containing all of the template parameter
Douglas Gregorcc636682009-02-17 23:15:12 +0000105 // lists to easily differentiate between the case above and:
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000106 //
107 // template<typename T>
108 // class A {
109 // template<typename U> class B;
110 // };
111 //
112 // In the first case, the action for declaring A<T>::B receives
113 // both template parameter lists. In the second case, the action for
114 // defining A<T>::B receives just the inner template parameter list
115 // (and retrieves the outer template parameter list from its
116 // context).
Douglas Gregor0f499d92009-08-20 18:46:05 +0000117 bool isSpecialization = true;
Douglas Gregorc78c06d2009-10-30 22:09:44 +0000118 bool LastParamListWasEmpty = false;
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000119 TemplateParameterLists ParamLists;
Douglas Gregorc3058332009-08-24 23:03:25 +0000120 TemplateParameterDepthCounter Depth(TemplateParameterDepth);
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000121 do {
122 // Consume the 'export', if any.
123 SourceLocation ExportLoc;
124 if (Tok.is(tok::kw_export)) {
125 ExportLoc = ConsumeToken();
126 }
127
128 // Consume the 'template', which should be here.
129 SourceLocation TemplateLoc;
130 if (Tok.is(tok::kw_template)) {
131 TemplateLoc = ConsumeToken();
132 } else {
133 Diag(Tok.getLocation(), diag::err_expected_template);
John McCalld226f652010-08-21 09:40:31 +0000134 return 0;
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000135 }
Mike Stump1eb44332009-09-09 15:08:12 +0000136
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000137 // Parse the '<' template-parameter-list '>'
138 SourceLocation LAngleLoc, RAngleLoc;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000139 SmallVector<Decl*, 4> TemplateParams;
Mike Stump1eb44332009-09-09 15:08:12 +0000140 if (ParseTemplateParameters(Depth, TemplateParams, LAngleLoc,
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000141 RAngleLoc)) {
142 // Skip until the semi-colon or a }.
143 SkipUntil(tok::r_brace, true, true);
144 if (Tok.is(tok::semi))
145 ConsumeToken();
John McCalld226f652010-08-21 09:40:31 +0000146 return 0;
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000147 }
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000148
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000149 ParamLists.push_back(
Mike Stump1eb44332009-09-09 15:08:12 +0000150 Actions.ActOnTemplateParameterList(Depth, ExportLoc,
151 TemplateLoc, LAngleLoc,
Jay Foadbeaaccd2009-05-21 09:52:38 +0000152 TemplateParams.data(),
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000153 TemplateParams.size(), RAngleLoc));
Douglas Gregorc3058332009-08-24 23:03:25 +0000154
155 if (!TemplateParams.empty()) {
156 isSpecialization = false;
157 ++Depth;
Douglas Gregorc78c06d2009-10-30 22:09:44 +0000158 } else {
159 LastParamListWasEmpty = true;
Mike Stump1eb44332009-09-09 15:08:12 +0000160 }
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000161 } while (Tok.is(tok::kw_export) || Tok.is(tok::kw_template));
162
163 // Parse the actual template declaration.
Mike Stump1eb44332009-09-09 15:08:12 +0000164 return ParseSingleDeclarationAfterTemplate(Context,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000165 ParsedTemplateInfo(&ParamLists,
Douglas Gregorc78c06d2009-10-30 22:09:44 +0000166 isSpecialization,
167 LastParamListWasEmpty),
John McCallc9068d72010-07-16 08:13:16 +0000168 ParsingTemplateParams,
Erik Verbruggen5f1c8222011-10-13 09:41:32 +0000169 DeclEnd, AS, AccessAttrs);
Douglas Gregor1426e532009-05-12 21:31:51 +0000170}
Chris Lattner682bf922009-03-29 16:50:03 +0000171
Douglas Gregor1426e532009-05-12 21:31:51 +0000172/// \brief Parse a single declaration that declares a template,
173/// template specialization, or explicit instantiation of a template.
174///
Douglas Gregor1426e532009-05-12 21:31:51 +0000175/// \param DeclEnd will receive the source location of the last token
176/// within this declaration.
177///
178/// \param AS the access specifier associated with this
179/// declaration. Will be AS_none for namespace-scope declarations.
180///
181/// \returns the new declaration.
John McCalld226f652010-08-21 09:40:31 +0000182Decl *
Douglas Gregor1426e532009-05-12 21:31:51 +0000183Parser::ParseSingleDeclarationAfterTemplate(
184 unsigned Context,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000185 const ParsedTemplateInfo &TemplateInfo,
John McCallc9068d72010-07-16 08:13:16 +0000186 ParsingDeclRAIIObject &DiagsFromTParams,
Douglas Gregor1426e532009-05-12 21:31:51 +0000187 SourceLocation &DeclEnd,
Erik Verbruggen5f1c8222011-10-13 09:41:32 +0000188 AccessSpecifier AS,
189 AttributeList *AccessAttrs) {
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000190 assert(TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
191 "Template information required");
192
Douglas Gregor37b372b2009-08-20 22:52:58 +0000193 if (Context == Declarator::MemberContext) {
194 // We are parsing a member template.
Erik Verbruggen5f1c8222011-10-13 09:41:32 +0000195 ParseCXXClassMemberDeclaration(AS, AccessAttrs, TemplateInfo,
196 &DiagsFromTParams);
John McCalld226f652010-08-21 09:40:31 +0000197 return 0;
Douglas Gregor37b372b2009-08-20 22:52:58 +0000198 }
Mike Stump1eb44332009-09-09 15:08:12 +0000199
John McCall0b7e6782011-03-24 11:26:52 +0000200 ParsedAttributesWithRange prefixAttrs(AttrFactory);
Richard Smith4e24f0f2013-01-02 12:01:23 +0000201 MaybeParseCXX11Attributes(prefixAttrs);
John McCall78b81052010-11-10 02:40:36 +0000202
203 if (Tok.is(tok::kw_using))
204 return ParseUsingDirectiveOrDeclaration(Context, TemplateInfo, DeclEnd,
John McCall7f040a92010-12-24 02:08:15 +0000205 prefixAttrs);
John McCall78b81052010-11-10 02:40:36 +0000206
John McCall92576642012-05-07 06:16:41 +0000207 // Parse the declaration specifiers, stealing any diagnostics from
208 // the template parameters.
John McCall0b7e6782011-03-24 11:26:52 +0000209 ParsingDeclSpec DS(*this, &DiagsFromTParams);
Sean Huntbbd37c62009-11-21 08:43:09 +0000210
Douglas Gregor0efc2c12010-01-13 17:31:36 +0000211 ParseDeclarationSpecifiers(DS, TemplateInfo, AS,
212 getDeclSpecContextFromDeclaratorContext(Context));
Douglas Gregor1426e532009-05-12 21:31:51 +0000213
214 if (Tok.is(tok::semi)) {
Richard Smith68ea3ae2013-02-22 09:06:26 +0000215 ProhibitAttributes(prefixAttrs);
Douglas Gregor1426e532009-05-12 21:31:51 +0000216 DeclEnd = ConsumeToken();
John McCalld226f652010-08-21 09:40:31 +0000217 Decl *Decl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS, DS);
John McCall54abf7d2009-11-04 02:18:39 +0000218 DS.complete(Decl);
219 return Decl;
Douglas Gregor1426e532009-05-12 21:31:51 +0000220 }
221
Richard Smith68ea3ae2013-02-22 09:06:26 +0000222 // 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
Douglas Gregor1426e532009-05-12 21:31:51 +0000228 // Parse the declarator.
John McCall54abf7d2009-11-04 02:18:39 +0000229 ParsingDeclarator DeclaratorInfo(*this, DS, (Declarator::TheContext)Context);
Douglas Gregor1426e532009-05-12 21:31:51 +0000230 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, true, true);
235 if (Tok.is(tok::semi))
236 ConsumeToken();
John McCalld226f652010-08-21 09:40:31 +0000237 return 0;
Douglas Gregor1426e532009-05-12 21:31:51 +0000238 }
Mike Stump1eb44332009-09-09 15:08:12 +0000239
DeLesley Hutchins161db022012-11-02 21:44:32 +0000240 LateParsedAttrList LateParsedAttrs(true);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000241 if (DeclaratorInfo.isFunctionDeclarator())
242 MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);
243
Douglas Gregor1426e532009-05-12 21:31:51 +0000244 if (DeclaratorInfo.isFunctionDeclarator() &&
Chris Lattner004659a2010-07-11 22:42:07 +0000245 isStartOfFunctionDefinition(DeclaratorInfo)) {
Douglas Gregor1426e532009-05-12 21:31:51 +0000246 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
Richard Smith6e1fd332011-11-29 09:09:06 +0000247 // Recover by ignoring the 'typedef'. This was probably supposed to be
248 // the 'typename' keyword, which we should have already suggested adding
249 // if it's appropriate.
250 Diag(DS.getStorageClassSpecLoc(), diag::err_function_declared_typedef)
251 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
Richard Smith874d2532011-11-29 05:27:40 +0000252 DS.ClearStorageClassSpecs();
Douglas Gregor1426e532009-05-12 21:31:51 +0000253 }
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000254 return ParseFunctionDefinition(DeclaratorInfo, TemplateInfo,
255 &LateParsedAttrs);
Douglas Gregor1426e532009-05-12 21:31:51 +0000256 }
257
Richard Smithd3e723e2013-01-15 06:49:38 +0000258 // Parse this declaration.
259 Decl *ThisDecl = ParseDeclarationAfterDeclarator(DeclaratorInfo,
260 TemplateInfo);
261
262 if (Tok.is(tok::comma)) {
263 Diag(Tok, diag::err_multiple_template_declarators)
264 << (int)TemplateInfo.Kind;
265 SkipUntil(tok::semi, true, false);
266 return ThisDecl;
267 }
268
269 // Eat the semi colon after the declaration.
270 ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
271 if (LateParsedAttrs.size() > 0)
272 ParseLexedAttributeList(LateParsedAttrs, ThisDecl, true, false);
273 DeclaratorInfo.complete(ThisDecl);
274 return ThisDecl;
Douglas Gregoradcac882008-12-01 23:54:00 +0000275}
276
277/// ParseTemplateParameters - Parses a template-parameter-list enclosed in
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000278/// angle brackets. Depth is the depth of this template-parameter-list, which
279/// is the number of template headers directly enclosing this template header.
280/// TemplateParams is the current list of template parameters we're building.
281/// The template parameter we parse will be added to this list. LAngleLoc and
Mike Stump1eb44332009-09-09 15:08:12 +0000282/// RAngleLoc will receive the positions of the '<' and '>', respectively,
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000283/// that enclose this template parameter list.
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000284///
285/// \returns true if an error occurred, false otherwise.
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000286bool Parser::ParseTemplateParameters(unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000287 SmallVectorImpl<Decl*> &TemplateParams,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000288 SourceLocation &LAngleLoc,
289 SourceLocation &RAngleLoc) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000290 // Get the template parameter list.
Mike Stump1eb44332009-09-09 15:08:12 +0000291 if (!Tok.is(tok::less)) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000292 Diag(Tok.getLocation(), diag::err_expected_less_after) << "template";
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000293 return true;
Douglas Gregoradcac882008-12-01 23:54:00 +0000294 }
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000295 LAngleLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000296
Douglas Gregoradcac882008-12-01 23:54:00 +0000297 // Try to parse the template parameter list.
David Blaikieeb52f86a2012-04-09 16:37:11 +0000298 bool Failed = false;
299 if (!Tok.is(tok::greater) && !Tok.is(tok::greatergreater))
300 Failed = ParseTemplateParameterList(Depth, TemplateParams);
301
302 if (Tok.is(tok::greatergreater)) {
Richard Smith19a27022012-06-18 06:11:04 +0000303 // No diagnostic required here: a template-parameter-list can only be
304 // followed by a declaration or, for a template template parameter, the
305 // 'class' keyword. Therefore, the second '>' will be diagnosed later.
306 // This matters for elegant diagnosis of:
307 // template<template<typename>> struct S;
David Blaikieeb52f86a2012-04-09 16:37:11 +0000308 Tok.setKind(tok::greater);
309 RAngleLoc = Tok.getLocation();
310 Tok.setLocation(Tok.getLocation().getLocWithOffset(1));
311 } else if (Tok.is(tok::greater))
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000312 RAngleLoc = ConsumeToken();
David Blaikieeb52f86a2012-04-09 16:37:11 +0000313 else if (Failed) {
314 Diag(Tok.getLocation(), diag::err_expected_greater);
315 return true;
Douglas Gregoradcac882008-12-01 23:54:00 +0000316 }
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000317 return false;
Douglas Gregoradcac882008-12-01 23:54:00 +0000318}
319
320/// ParseTemplateParameterList - Parse a template parameter list. If
321/// the parsing fails badly (i.e., closing bracket was left out), this
322/// will try to put the token stream in a reasonable position (closing
Mike Stump1eb44332009-09-09 15:08:12 +0000323/// a statement, etc.) and return false.
Douglas Gregoradcac882008-12-01 23:54:00 +0000324///
325/// template-parameter-list: [C++ temp]
326/// template-parameter
327/// template-parameter-list ',' template-parameter
Mike Stump1eb44332009-09-09 15:08:12 +0000328bool
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000329Parser::ParseTemplateParameterList(unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000330 SmallVectorImpl<Decl*> &TemplateParams) {
Mike Stump1eb44332009-09-09 15:08:12 +0000331 while (1) {
John McCalld226f652010-08-21 09:40:31 +0000332 if (Decl *TmpParam
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000333 = ParseTemplateParameter(Depth, TemplateParams.size())) {
334 TemplateParams.push_back(TmpParam);
335 } else {
Douglas Gregoradcac882008-12-01 23:54:00 +0000336 // If we failed to parse a template parameter, skip until we find
337 // a comma or closing brace.
David Blaikie9df1b962012-04-06 05:26:43 +0000338 SkipUntil(tok::comma, tok::greater, tok::greatergreater, true, true);
Douglas Gregoradcac882008-12-01 23:54:00 +0000339 }
Mike Stump1eb44332009-09-09 15:08:12 +0000340
Nico Weber001397e2012-12-14 02:40:09 +0000341 // Did we find a comma or the end of the template parameter list?
Mike Stump1eb44332009-09-09 15:08:12 +0000342 if (Tok.is(tok::comma)) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000343 ConsumeToken();
David Blaikie9df1b962012-04-06 05:26:43 +0000344 } else if (Tok.is(tok::greater) || Tok.is(tok::greatergreater)) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000345 // Don't consume this... that's done by template parser.
346 break;
347 } else {
348 // Somebody probably forgot to close the template. Skip ahead and
349 // try to get out of the expression. This error is currently
350 // subsumed by whatever goes on in ParseTemplateParameter.
Douglas Gregor99ea7342010-10-15 01:15:58 +0000351 Diag(Tok.getLocation(), diag::err_expected_comma_greater);
David Blaikieeb52f86a2012-04-09 16:37:11 +0000352 SkipUntil(tok::comma, tok::greater, tok::greatergreater, true, true);
Douglas Gregoradcac882008-12-01 23:54:00 +0000353 return false;
354 }
355 }
356 return true;
357}
358
Douglas Gregor98440b42009-11-21 02:07:55 +0000359/// \brief Determine whether the parser is at the start of a template
360/// type parameter.
361bool Parser::isStartOfTemplateTypeParameter() {
Douglas Gregor7b6d25b2010-06-04 07:30:15 +0000362 if (Tok.is(tok::kw_class)) {
363 // "class" may be the start of an elaborated-type-specifier or a
364 // type-parameter. Per C++ [temp.param]p3, we prefer the type-parameter.
365 switch (NextToken().getKind()) {
366 case tok::equal:
367 case tok::comma:
368 case tok::greater:
369 case tok::greatergreater:
370 case tok::ellipsis:
371 return true;
372
373 case tok::identifier:
374 // This may be either a type-parameter or an elaborated-type-specifier.
375 // We have to look further.
376 break;
377
378 default:
379 return false;
380 }
381
382 switch (GetLookAheadToken(2).getKind()) {
383 case tok::equal:
384 case tok::comma:
385 case tok::greater:
386 case tok::greatergreater:
387 return true;
388
389 default:
390 return false;
391 }
392 }
Douglas Gregor98440b42009-11-21 02:07:55 +0000393
394 if (Tok.isNot(tok::kw_typename))
395 return false;
396
397 // C++ [temp.param]p2:
398 // There is no semantic difference between class and typename in a
399 // template-parameter. typename followed by an unqualified-id
400 // names a template type parameter. typename followed by a
401 // qualified-id denotes the type in a non-type
402 // parameter-declaration.
403 Token Next = NextToken();
404
405 // If we have an identifier, skip over it.
406 if (Next.getKind() == tok::identifier)
407 Next = GetLookAheadToken(2);
408
409 switch (Next.getKind()) {
410 case tok::equal:
411 case tok::comma:
412 case tok::greater:
413 case tok::greatergreater:
414 case tok::ellipsis:
415 return true;
416
417 default:
418 return false;
419 }
420}
421
Douglas Gregoradcac882008-12-01 23:54:00 +0000422/// ParseTemplateParameter - Parse a template-parameter (C++ [temp.param]).
423///
424/// template-parameter: [C++ temp.param]
425/// type-parameter
426/// parameter-declaration
427///
428/// type-parameter: (see below)
Douglas Gregor61c4d282011-01-05 15:48:55 +0000429/// 'class' ...[opt] identifier[opt]
Douglas Gregoradcac882008-12-01 23:54:00 +0000430/// 'class' identifier[opt] '=' type-id
Douglas Gregor61c4d282011-01-05 15:48:55 +0000431/// 'typename' ...[opt] identifier[opt]
Douglas Gregoradcac882008-12-01 23:54:00 +0000432/// 'typename' identifier[opt] '=' type-id
Douglas Gregor61c4d282011-01-05 15:48:55 +0000433/// 'template' '<' template-parameter-list '>'
434/// 'class' ...[opt] identifier[opt]
435/// 'template' '<' template-parameter-list '>' 'class' identifier[opt]
436/// = id-expression
John McCalld226f652010-08-21 09:40:31 +0000437Decl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) {
Douglas Gregor98440b42009-11-21 02:07:55 +0000438 if (isStartOfTemplateTypeParameter())
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000439 return ParseTypeParameter(Depth, Position);
Mike Stump1eb44332009-09-09 15:08:12 +0000440
441 if (Tok.is(tok::kw_template))
Chris Lattner532e19b2009-01-04 23:51:17 +0000442 return ParseTemplateTemplateParameter(Depth, Position);
443
444 // If it's none of the above, then it must be a parameter declaration.
445 // NOTE: This will pick up errors in the closure of the template parameter
446 // list (e.g., template < ; Check here to implement >> style closures.
447 return ParseNonTypeTemplateParameter(Depth, Position);
Douglas Gregoradcac882008-12-01 23:54:00 +0000448}
449
450/// ParseTypeParameter - Parse a template type parameter (C++ [temp.param]).
451/// Other kinds of template parameters are parsed in
452/// ParseTemplateTemplateParameter and ParseNonTypeTemplateParameter.
453///
454/// type-parameter: [C++ temp.param]
Anders Carlssonce5635a2009-06-12 23:09:56 +0000455/// 'class' ...[opt][C++0x] identifier[opt]
Douglas Gregoradcac882008-12-01 23:54:00 +0000456/// 'class' identifier[opt] '=' type-id
Anders Carlssonce5635a2009-06-12 23:09:56 +0000457/// 'typename' ...[opt][C++0x] identifier[opt]
Douglas Gregoradcac882008-12-01 23:54:00 +0000458/// 'typename' identifier[opt] '=' type-id
John McCalld226f652010-08-21 09:40:31 +0000459Decl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) {
Douglas Gregor26236e82008-12-02 00:41:28 +0000460 assert((Tok.is(tok::kw_class) || Tok.is(tok::kw_typename)) &&
Mike Stump1eb44332009-09-09 15:08:12 +0000461 "A type-parameter starts with 'class' or 'typename'");
Douglas Gregor26236e82008-12-02 00:41:28 +0000462
463 // Consume the 'class' or 'typename' keyword.
464 bool TypenameKeyword = Tok.is(tok::kw_typename);
465 SourceLocation KeyLoc = ConsumeToken();
Douglas Gregoradcac882008-12-01 23:54:00 +0000466
Anders Carlsson941df7d2009-06-12 19:58:00 +0000467 // Grab the ellipsis (if given).
468 bool Ellipsis = false;
469 SourceLocation EllipsisLoc;
Anders Carlssonce5635a2009-06-12 23:09:56 +0000470 if (Tok.is(tok::ellipsis)) {
Anders Carlsson941df7d2009-06-12 19:58:00 +0000471 Ellipsis = true;
472 EllipsisLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000473
Richard Smithe5acd132011-10-14 20:31:37 +0000474 Diag(EllipsisLoc,
Richard Smith80ad52f2013-01-02 11:42:31 +0000475 getLangOpts().CPlusPlus11
Richard Smithe5acd132011-10-14 20:31:37 +0000476 ? diag::warn_cxx98_compat_variadic_templates
477 : diag::ext_variadic_templates);
Anders Carlsson941df7d2009-06-12 19:58:00 +0000478 }
Mike Stump1eb44332009-09-09 15:08:12 +0000479
Douglas Gregoradcac882008-12-01 23:54:00 +0000480 // Grab the template parameter name (if given)
Douglas Gregor26236e82008-12-02 00:41:28 +0000481 SourceLocation NameLoc;
482 IdentifierInfo* ParamName = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000483 if (Tok.is(tok::identifier)) {
Douglas Gregor26236e82008-12-02 00:41:28 +0000484 ParamName = Tok.getIdentifierInfo();
485 NameLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000486 } else if (Tok.is(tok::equal) || Tok.is(tok::comma) ||
David Blaikie9df1b962012-04-06 05:26:43 +0000487 Tok.is(tok::greater) || Tok.is(tok::greatergreater)) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000488 // Unnamed template parameter. Don't have to do anything here, just
489 // don't consume this token.
490 } else {
491 Diag(Tok.getLocation(), diag::err_expected_ident);
John McCalld226f652010-08-21 09:40:31 +0000492 return 0;
Douglas Gregoradcac882008-12-01 23:54:00 +0000493 }
Mike Stump1eb44332009-09-09 15:08:12 +0000494
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000495 // Grab a default argument (if available).
496 // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
497 // we introduce the type parameter into the local scope.
498 SourceLocation EqualLoc;
John McCallb3d87482010-08-24 05:47:05 +0000499 ParsedType DefaultArg;
Mike Stump1eb44332009-09-09 15:08:12 +0000500 if (Tok.is(tok::equal)) {
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000501 EqualLoc = ConsumeToken();
Richard Smithd37b3602012-02-10 11:05:11 +0000502 DefaultArg = ParseTypeName(/*Range=*/0,
503 Declarator::TemplateTypeArgContext).get();
Douglas Gregoradcac882008-12-01 23:54:00 +0000504 }
Richard Smithd37b3602012-02-10 11:05:11 +0000505
Douglas Gregor23c94db2010-07-02 17:43:08 +0000506 return Actions.ActOnTypeParameter(getCurScope(), TypenameKeyword, Ellipsis,
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000507 EllipsisLoc, KeyLoc, ParamName, NameLoc,
508 Depth, Position, EqualLoc, DefaultArg);
Douglas Gregoradcac882008-12-01 23:54:00 +0000509}
510
511/// ParseTemplateTemplateParameter - Handle the parsing of template
Mike Stump1eb44332009-09-09 15:08:12 +0000512/// template parameters.
Douglas Gregoradcac882008-12-01 23:54:00 +0000513///
514/// type-parameter: [C++ temp.param]
Douglas Gregor61c4d282011-01-05 15:48:55 +0000515/// 'template' '<' template-parameter-list '>' 'class'
516/// ...[opt] identifier[opt]
517/// 'template' '<' template-parameter-list '>' 'class' identifier[opt]
518/// = id-expression
John McCalld226f652010-08-21 09:40:31 +0000519Decl *
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000520Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000521 assert(Tok.is(tok::kw_template) && "Expected 'template' keyword");
522
523 // Handle the template <...> part.
524 SourceLocation TemplateLoc = ConsumeToken();
Chris Lattner5f9e2722011-07-23 10:55:15 +0000525 SmallVector<Decl*,8> TemplateParams;
Douglas Gregorddc29e12009-02-06 22:42:48 +0000526 SourceLocation LAngleLoc, RAngleLoc;
Douglas Gregor68c69932009-02-10 19:52:54 +0000527 {
528 ParseScope TemplateParmScope(this, Scope::TemplateParamScope);
Mike Stump1eb44332009-09-09 15:08:12 +0000529 if (ParseTemplateParameters(Depth + 1, TemplateParams, LAngleLoc,
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000530 RAngleLoc)) {
John McCalld226f652010-08-21 09:40:31 +0000531 return 0;
Douglas Gregor68c69932009-02-10 19:52:54 +0000532 }
Douglas Gregoradcac882008-12-01 23:54:00 +0000533 }
534
535 // Generate a meaningful error if the user forgot to put class before the
David Blaikie9df1b962012-04-06 05:26:43 +0000536 // identifier, comma, or greater. Provide a fixit if the identifier, comma,
537 // or greater appear immediately or after 'typename' or 'struct'. In the
538 // latter case, replace the keyword with 'class'.
539 if (!Tok.is(tok::kw_class)) {
540 bool Replace = Tok.is(tok::kw_typename) || Tok.is(tok::kw_struct);
541 const Token& Next = Replace ? NextToken() : Tok;
542 if (Next.is(tok::identifier) || Next.is(tok::comma) ||
543 Next.is(tok::greater) || Next.is(tok::greatergreater) ||
544 Next.is(tok::ellipsis))
545 Diag(Tok.getLocation(), diag::err_class_on_template_template_param)
546 << (Replace ? FixItHint::CreateReplacement(Tok.getLocation(), "class")
547 : FixItHint::CreateInsertion(Tok.getLocation(), "class "));
548 else
549 Diag(Tok.getLocation(), diag::err_class_on_template_template_param);
550
551 if (Replace)
552 ConsumeToken();
553 } else
David Blaikie460ef132012-04-02 19:15:28 +0000554 ConsumeToken();
Douglas Gregoradcac882008-12-01 23:54:00 +0000555
Douglas Gregor61c4d282011-01-05 15:48:55 +0000556 // Parse the ellipsis, if given.
557 SourceLocation EllipsisLoc;
558 if (Tok.is(tok::ellipsis)) {
559 EllipsisLoc = ConsumeToken();
560
Richard Smithe5acd132011-10-14 20:31:37 +0000561 Diag(EllipsisLoc,
Richard Smith80ad52f2013-01-02 11:42:31 +0000562 getLangOpts().CPlusPlus11
Richard Smithe5acd132011-10-14 20:31:37 +0000563 ? diag::warn_cxx98_compat_variadic_templates
564 : diag::ext_variadic_templates);
Douglas Gregor61c4d282011-01-05 15:48:55 +0000565 }
566
Douglas Gregoradcac882008-12-01 23:54:00 +0000567 // Get the identifier, if given.
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000568 SourceLocation NameLoc;
569 IdentifierInfo* ParamName = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000570 if (Tok.is(tok::identifier)) {
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000571 ParamName = Tok.getIdentifierInfo();
572 NameLoc = ConsumeToken();
David Blaikie9df1b962012-04-06 05:26:43 +0000573 } else if (Tok.is(tok::equal) || Tok.is(tok::comma) ||
574 Tok.is(tok::greater) || Tok.is(tok::greatergreater)) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000575 // Unnamed template parameter. Don't have to do anything here, just
576 // don't consume this token.
577 } else {
578 Diag(Tok.getLocation(), diag::err_expected_ident);
John McCalld226f652010-08-21 09:40:31 +0000579 return 0;
Douglas Gregoradcac882008-12-01 23:54:00 +0000580 }
581
Richard Trieu90ab75b2011-09-09 03:18:59 +0000582 TemplateParameterList *ParamList =
Douglas Gregorddc29e12009-02-06 22:42:48 +0000583 Actions.ActOnTemplateParameterList(Depth, SourceLocation(),
584 TemplateLoc, LAngleLoc,
Douglas Gregor369ea272010-10-21 17:26:49 +0000585 TemplateParams.data(),
Douglas Gregorddc29e12009-02-06 22:42:48 +0000586 TemplateParams.size(),
587 RAngleLoc);
588
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000589 // Grab a default argument (if available).
590 // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
591 // we introduce the template parameter into the local scope.
592 SourceLocation EqualLoc;
593 ParsedTemplateArgument DefaultArg;
Douglas Gregord684b002009-02-10 19:49:53 +0000594 if (Tok.is(tok::equal)) {
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000595 EqualLoc = ConsumeToken();
596 DefaultArg = ParseTemplateTemplateArgument();
597 if (DefaultArg.isInvalid()) {
Douglas Gregor788cd062009-11-11 01:00:40 +0000598 Diag(Tok.getLocation(),
599 diag::err_default_template_template_parameter_not_template);
David Blaikieeb52f86a2012-04-09 16:37:11 +0000600 SkipUntil(tok::comma, tok::greater, tok::greatergreater, true, true);
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000601 }
Douglas Gregord684b002009-02-10 19:49:53 +0000602 }
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000603
Douglas Gregor23c94db2010-07-02 17:43:08 +0000604 return Actions.ActOnTemplateTemplateParameter(getCurScope(), TemplateLoc,
Douglas Gregor61c4d282011-01-05 15:48:55 +0000605 ParamList, EllipsisLoc,
606 ParamName, NameLoc, Depth,
607 Position, EqualLoc, DefaultArg);
Douglas Gregoradcac882008-12-01 23:54:00 +0000608}
609
610/// ParseNonTypeTemplateParameter - Handle the parsing of non-type
Mike Stump1eb44332009-09-09 15:08:12 +0000611/// template parameters (e.g., in "template<int Size> class array;").
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000612///
Douglas Gregoradcac882008-12-01 23:54:00 +0000613/// template-parameter:
614/// ...
615/// parameter-declaration
John McCalld226f652010-08-21 09:40:31 +0000616Decl *
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +0000617Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000618 // Parse the declaration-specifiers (i.e., the type).
Douglas Gregor26236e82008-12-02 00:41:28 +0000619 // FIXME: The type should probably be restricted in some way... Not all
Douglas Gregoradcac882008-12-01 23:54:00 +0000620 // declarators (parts of declarators?) are accepted for parameters.
John McCall0b7e6782011-03-24 11:26:52 +0000621 DeclSpec DS(AttrFactory);
Douglas Gregor26236e82008-12-02 00:41:28 +0000622 ParseDeclarationSpecifiers(DS);
Douglas Gregoradcac882008-12-01 23:54:00 +0000623
624 // Parse this as a typename.
Douglas Gregor26236e82008-12-02 00:41:28 +0000625 Declarator ParamDecl(DS, Declarator::TemplateParamContext);
626 ParseDeclarator(ParamDecl);
John McCallb3d87482010-08-24 05:47:05 +0000627 if (DS.getTypeSpecType() == DeclSpec::TST_unspecified) {
David Blaikieb031eab2012-04-06 23:33:59 +0000628 Diag(Tok.getLocation(), diag::err_expected_template_parameter);
John McCalld226f652010-08-21 09:40:31 +0000629 return 0;
Douglas Gregoradcac882008-12-01 23:54:00 +0000630 }
631
Douglas Gregord684b002009-02-10 19:49:53 +0000632 // If there is a default value, parse it.
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000633 // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
634 // we introduce the template parameter into the local scope.
635 SourceLocation EqualLoc;
John McCall60d7b3a2010-08-24 06:29:42 +0000636 ExprResult DefaultArg;
Chris Lattner7452c6f2009-01-05 01:24:05 +0000637 if (Tok.is(tok::equal)) {
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000638 EqualLoc = ConsumeToken();
Douglas Gregord684b002009-02-10 19:49:53 +0000639
640 // C++ [temp.param]p15:
641 // When parsing a default template-argument for a non-type
642 // template-parameter, the first non-nested > is taken as the
643 // end of the template-parameter-list rather than a greater-than
644 // operator.
Mike Stump1eb44332009-09-09 15:08:12 +0000645 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
Eli Friedman9b94cd12012-04-26 22:43:24 +0000646 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
Douglas Gregord684b002009-02-10 19:49:53 +0000647
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000648 DefaultArg = ParseAssignmentExpression();
Douglas Gregord684b002009-02-10 19:49:53 +0000649 if (DefaultArg.isInvalid())
650 SkipUntil(tok::comma, tok::greater, true, true);
Douglas Gregoradcac882008-12-01 23:54:00 +0000651 }
Mike Stump1eb44332009-09-09 15:08:12 +0000652
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000653 // Create the parameter.
Douglas Gregor23c94db2010-07-02 17:43:08 +0000654 return Actions.ActOnNonTypeTemplateParameter(getCurScope(), ParamDecl,
Douglas Gregorbb3310a2010-07-01 00:00:45 +0000655 Depth, Position, EqualLoc,
John McCall9ae2f072010-08-23 23:25:46 +0000656 DefaultArg.take());
Douglas Gregoradcac882008-12-01 23:54:00 +0000657}
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000658
Nico Weberb707a472012-12-14 18:22:38 +0000659/// \brief Parses a '>' at the end of a template list.
Douglas Gregorcc636682009-02-17 23:15:12 +0000660///
Nico Weberb707a472012-12-14 18:22:38 +0000661/// If this function encounters '>>', '>>>', '>=', or '>>=', it tries
662/// to determine if these tokens were supposed to be a '>' followed by
663/// '>', '>>', '>=', or '>='. It emits an appropriate diagnostic if necessary.
Douglas Gregorcc636682009-02-17 23:15:12 +0000664///
Nico Weberb707a472012-12-14 18:22:38 +0000665/// \param RAngleLoc the location of the consumed '>'.
Douglas Gregorcc636682009-02-17 23:15:12 +0000666///
Nico Weberb707a472012-12-14 18:22:38 +0000667/// \param ConsumeLastToken if true, the '>' is not consumed.
668bool Parser::ParseGreaterThanInTemplateList(SourceLocation &RAngleLoc,
669 bool ConsumeLastToken) {
Richard Smith19a27022012-06-18 06:11:04 +0000670 // What will be left once we've consumed the '>'.
671 tok::TokenKind RemainingToken;
672 const char *ReplacementStr = "> >";
673
674 switch (Tok.getKind()) {
675 default:
Eli Friedman64a4eb22009-12-27 22:31:18 +0000676 Diag(Tok.getLocation(), diag::err_expected_greater);
Douglas Gregorcc636682009-02-17 23:15:12 +0000677 return true;
Richard Smith19a27022012-06-18 06:11:04 +0000678
679 case tok::greater:
680 // Determine the location of the '>' token. Only consume this token
681 // if the caller asked us to.
682 RAngleLoc = Tok.getLocation();
683 if (ConsumeLastToken)
684 ConsumeToken();
685 return false;
686
687 case tok::greatergreater:
688 RemainingToken = tok::greater;
689 break;
690
691 case tok::greatergreatergreater:
692 RemainingToken = tok::greatergreater;
693 break;
694
695 case tok::greaterequal:
696 RemainingToken = tok::equal;
697 ReplacementStr = "> =";
698 break;
699
700 case tok::greatergreaterequal:
701 RemainingToken = tok::greaterequal;
702 break;
Eli Friedman64a4eb22009-12-27 22:31:18 +0000703 }
Douglas Gregorcc636682009-02-17 23:15:12 +0000704
Richard Smith19a27022012-06-18 06:11:04 +0000705 // This template-id is terminated by a token which starts with a '>'. Outside
706 // C++11, this is now error recovery, and in C++11, this is error recovery if
707 // the token isn't '>>'.
708
Douglas Gregorcc636682009-02-17 23:15:12 +0000709 RAngleLoc = Tok.getLocation();
710
Richard Smith19a27022012-06-18 06:11:04 +0000711 // The source range of the '>>' or '>=' at the start of the token.
712 CharSourceRange ReplacementRange =
713 CharSourceRange::getCharRange(RAngleLoc,
714 Lexer::AdvanceToTokenCharacter(RAngleLoc, 2, PP.getSourceManager(),
715 getLangOpts()));
Douglas Gregor4b2d3f72009-02-26 21:00:50 +0000716
Richard Smith19a27022012-06-18 06:11:04 +0000717 // A hint to put a space between the '>>'s. In order to make the hint as
718 // clear as possible, we include the characters either side of the space in
719 // the replacement, rather than just inserting a space at SecondCharLoc.
720 FixItHint Hint1 = FixItHint::CreateReplacement(ReplacementRange,
721 ReplacementStr);
Douglas Gregor3965b7b2009-02-25 23:02:36 +0000722
Richard Smith19a27022012-06-18 06:11:04 +0000723 // A hint to put another space after the token, if it would otherwise be
724 // lexed differently.
725 FixItHint Hint2;
726 Token Next = NextToken();
727 if ((RemainingToken == tok::greater ||
728 RemainingToken == tok::greatergreater) &&
729 (Next.is(tok::greater) || Next.is(tok::greatergreater) ||
730 Next.is(tok::greatergreatergreater) || Next.is(tok::equal) ||
731 Next.is(tok::greaterequal) || Next.is(tok::greatergreaterequal) ||
732 Next.is(tok::equalequal)) &&
733 areTokensAdjacent(Tok, Next))
734 Hint2 = FixItHint::CreateInsertion(Next.getLocation(), " ");
735
736 unsigned DiagId = diag::err_two_right_angle_brackets_need_space;
Richard Smith80ad52f2013-01-02 11:42:31 +0000737 if (getLangOpts().CPlusPlus11 && Tok.is(tok::greatergreater))
Richard Smith19a27022012-06-18 06:11:04 +0000738 DiagId = diag::warn_cxx98_compat_two_right_angle_brackets;
739 else if (Tok.is(tok::greaterequal))
740 DiagId = diag::err_right_angle_bracket_equal_needs_space;
741 Diag(Tok.getLocation(), DiagId) << Hint1 << Hint2;
742
743 // Strip the initial '>' from the token.
744 if (RemainingToken == tok::equal && Next.is(tok::equal) &&
745 areTokensAdjacent(Tok, Next)) {
746 // Join two adjacent '=' tokens into one, for cases like:
747 // void (*p)() = f<int>;
748 // return f<int>==p;
Douglas Gregorcc636682009-02-17 23:15:12 +0000749 ConsumeToken();
Richard Smith19a27022012-06-18 06:11:04 +0000750 Tok.setKind(tok::equalequal);
751 Tok.setLength(Tok.getLength() + 1);
752 } else {
753 Tok.setKind(RemainingToken);
754 Tok.setLength(Tok.getLength() - 1);
755 }
756 Tok.setLocation(Lexer::AdvanceToTokenCharacter(RAngleLoc, 1,
757 PP.getSourceManager(),
758 getLangOpts()));
759
760 if (!ConsumeLastToken) {
761 // Since we're not supposed to consume the '>' token, we need to push
762 // this token and revert the current token back to the '>'.
763 PP.EnterToken(Tok);
764 Tok.setKind(tok::greater);
765 Tok.setLength(1);
766 Tok.setLocation(RAngleLoc);
767 }
Douglas Gregorcc636682009-02-17 23:15:12 +0000768 return false;
769}
Mike Stump1eb44332009-09-09 15:08:12 +0000770
Nico Weberb707a472012-12-14 18:22:38 +0000771
772/// \brief Parses a template-id that after the template name has
773/// already been parsed.
774///
775/// This routine takes care of parsing the enclosed template argument
776/// list ('<' template-parameter-list [opt] '>') and placing the
777/// results into a form that can be transferred to semantic analysis.
778///
779/// \param Template the template declaration produced by isTemplateName
780///
781/// \param TemplateNameLoc the source location of the template name
782///
783/// \param SS if non-NULL, the nested-name-specifier preceding the
784/// template name.
785///
786/// \param ConsumeLastToken if true, then we will consume the last
787/// token that forms the template-id. Otherwise, we will leave the
788/// last token in the stream (e.g., so that it can be replaced with an
789/// annotation token).
790bool
791Parser::ParseTemplateIdAfterTemplateName(TemplateTy Template,
792 SourceLocation TemplateNameLoc,
793 const CXXScopeSpec &SS,
794 bool ConsumeLastToken,
795 SourceLocation &LAngleLoc,
796 TemplateArgList &TemplateArgs,
797 SourceLocation &RAngleLoc) {
798 assert(Tok.is(tok::less) && "Must have already parsed the template-name");
799
800 // Consume the '<'.
801 LAngleLoc = ConsumeToken();
802
803 // Parse the optional template-argument-list.
804 bool Invalid = false;
805 {
806 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
807 if (Tok.isNot(tok::greater) && Tok.isNot(tok::greatergreater))
808 Invalid = ParseTemplateArgumentList(TemplateArgs);
809
810 if (Invalid) {
811 // Try to find the closing '>'.
812 SkipUntil(tok::greater, true, !ConsumeLastToken);
813
814 return true;
815 }
816 }
817
818 return ParseGreaterThanInTemplateList(RAngleLoc, ConsumeLastToken);
819}
820
Douglas Gregor39a8de12009-02-25 19:37:18 +0000821/// \brief Replace the tokens that form a simple-template-id with an
822/// annotation token containing the complete template-id.
823///
824/// The first token in the stream must be the name of a template that
825/// is followed by a '<'. This routine will parse the complete
826/// simple-template-id and replace the tokens with a single annotation
827/// token with one of two different kinds: if the template-id names a
828/// type (and \p AllowTypeAnnotation is true), the annotation token is
829/// a type annotation that includes the optional nested-name-specifier
830/// (\p SS). Otherwise, the annotation token is a template-id
831/// annotation that does not include the optional
832/// nested-name-specifier.
833///
834/// \param Template the declaration of the template named by the first
835/// token (an identifier), as returned from \c Action::isTemplateName().
836///
NAKAMURA Takumi384d3fc2012-11-14 02:21:42 +0000837/// \param TNK the kind of template that \p Template
Douglas Gregor39a8de12009-02-25 19:37:18 +0000838/// refers to, as returned from \c Action::isTemplateName().
839///
840/// \param SS if non-NULL, the nested-name-specifier that precedes
841/// this template name.
842///
843/// \param TemplateKWLoc if valid, specifies that this template-id
844/// annotation was preceded by the 'template' keyword and gives the
845/// location of that keyword. If invalid (the default), then this
846/// template-id was not preceded by a 'template' keyword.
847///
848/// \param AllowTypeAnnotation if true (the default), then a
849/// simple-template-id that refers to a class template, template
850/// template parameter, or other template that produces a type will be
851/// replaced with a type annotation token. Otherwise, the
852/// simple-template-id is always replaced with a template-id
853/// annotation token.
Chris Lattnerc8e27cc2009-06-26 04:27:47 +0000854///
855/// If an unrecoverable parse error occurs and no annotation token can be
856/// formed, this function returns true.
857///
858bool Parser::AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
Douglas Gregor059101f2011-03-02 00:47:37 +0000859 CXXScopeSpec &SS,
Douglas Gregor39a8de12009-02-25 19:37:18 +0000860 SourceLocation TemplateKWLoc,
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000861 UnqualifiedId &TemplateName,
Douglas Gregor39a8de12009-02-25 19:37:18 +0000862 bool AllowTypeAnnotation) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000863 assert(getLangOpts().CPlusPlus && "Can only annotate template-ids in C++");
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000864 assert(Template && Tok.is(tok::less) &&
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000865 "Parser isn't at the beginning of a template-id");
866
867 // Consume the template-name.
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000868 SourceLocation TemplateNameLoc = TemplateName.getSourceRange().getBegin();
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000869
Douglas Gregorcc636682009-02-17 23:15:12 +0000870 // Parse the enclosed template argument list.
871 SourceLocation LAngleLoc, RAngleLoc;
Douglas Gregor5908e9f2009-02-09 19:34:22 +0000872 TemplateArgList TemplateArgs;
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000873 bool Invalid = ParseTemplateIdAfterTemplateName(Template,
874 TemplateNameLoc,
Mike Stump1eb44332009-09-09 15:08:12 +0000875 SS, false, LAngleLoc,
876 TemplateArgs,
Douglas Gregorcc636682009-02-17 23:15:12 +0000877 RAngleLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000878
Chris Lattnerc8e27cc2009-06-26 04:27:47 +0000879 if (Invalid) {
880 // If we failed to parse the template ID but skipped ahead to a >, we're not
881 // going to be able to form a token annotation. Eat the '>' if present.
882 if (Tok.is(tok::greater))
883 ConsumeToken();
884 return true;
885 }
Douglas Gregorc15cb382009-02-09 23:23:08 +0000886
Benjamin Kramer5354e772012-08-23 23:38:35 +0000887 ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
Douglas Gregorf02da892009-02-09 21:04:56 +0000888
Douglas Gregor55f6b142009-02-09 18:46:07 +0000889 // Build the annotation token.
Douglas Gregorc45c2322009-03-31 00:43:58 +0000890 if (TNK == TNK_Type_template && AllowTypeAnnotation) {
John McCallf312b1e2010-08-26 23:41:50 +0000891 TypeResult Type
Abramo Bagnara55d23c92012-02-06 14:41:24 +0000892 = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
Douglas Gregor059101f2011-03-02 00:47:37 +0000893 Template, TemplateNameLoc,
Abramo Bagnara55d23c92012-02-06 14:41:24 +0000894 LAngleLoc, TemplateArgsPtr, RAngleLoc);
Chris Lattnerc8e27cc2009-06-26 04:27:47 +0000895 if (Type.isInvalid()) {
896 // If we failed to parse the template ID but skipped ahead to a >, we're not
897 // going to be able to form a token annotation. Eat the '>' if present.
898 if (Tok.is(tok::greater))
899 ConsumeToken();
900 return true;
901 }
Douglas Gregorcc636682009-02-17 23:15:12 +0000902
903 Tok.setKind(tok::annot_typename);
John McCallb3d87482010-08-24 05:47:05 +0000904 setTypeAnnotation(Tok, Type.get());
Douglas Gregor059101f2011-03-02 00:47:37 +0000905 if (SS.isNotEmpty())
906 Tok.setLocation(SS.getBeginLoc());
Douglas Gregor39a8de12009-02-25 19:37:18 +0000907 else if (TemplateKWLoc.isValid())
908 Tok.setLocation(TemplateKWLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000909 else
Douglas Gregor39a8de12009-02-25 19:37:18 +0000910 Tok.setLocation(TemplateNameLoc);
Douglas Gregorcc636682009-02-17 23:15:12 +0000911 } else {
Douglas Gregorc45c2322009-03-31 00:43:58 +0000912 // Build a template-id annotation token that can be processed
913 // later.
Douglas Gregor39a8de12009-02-25 19:37:18 +0000914 Tok.setKind(tok::annot_template_id);
Mike Stump1eb44332009-09-09 15:08:12 +0000915 TemplateIdAnnotation *TemplateId
Benjamin Kramer13bb7012012-04-14 12:14:03 +0000916 = TemplateIdAnnotation::Allocate(TemplateArgs.size(), TemplateIds);
Douglas Gregor55f6b142009-02-09 18:46:07 +0000917 TemplateId->TemplateNameLoc = TemplateNameLoc;
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000918 if (TemplateName.getKind() == UnqualifiedId::IK_Identifier) {
919 TemplateId->Name = TemplateName.Identifier;
920 TemplateId->Operator = OO_None;
921 } else {
922 TemplateId->Name = 0;
923 TemplateId->Operator = TemplateName.OperatorFunctionId.Operator;
924 }
Douglas Gregor059101f2011-03-02 00:47:37 +0000925 TemplateId->SS = SS;
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000926 TemplateId->TemplateKWLoc = TemplateKWLoc;
John McCall2b5289b2010-08-23 07:28:44 +0000927 TemplateId->Template = Template;
Douglas Gregor39a8de12009-02-25 19:37:18 +0000928 TemplateId->Kind = TNK;
Douglas Gregor55f6b142009-02-09 18:46:07 +0000929 TemplateId->LAngleLoc = LAngleLoc;
Douglas Gregor39a8de12009-02-25 19:37:18 +0000930 TemplateId->RAngleLoc = RAngleLoc;
Douglas Gregor314b97f2009-11-10 19:49:08 +0000931 ParsedTemplateArgument *Args = TemplateId->getTemplateArgs();
932 for (unsigned Arg = 0, ArgEnd = TemplateArgs.size(); Arg != ArgEnd; ++Arg)
Douglas Gregorc34348a2011-02-24 17:54:50 +0000933 Args[Arg] = ParsedTemplateArgument(TemplateArgs[Arg]);
Douglas Gregor55f6b142009-02-09 18:46:07 +0000934 Tok.setAnnotationValue(TemplateId);
Douglas Gregor39a8de12009-02-25 19:37:18 +0000935 if (TemplateKWLoc.isValid())
936 Tok.setLocation(TemplateKWLoc);
937 else
938 Tok.setLocation(TemplateNameLoc);
Douglas Gregor55f6b142009-02-09 18:46:07 +0000939 }
940
941 // Common fields for the annotation token
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000942 Tok.setAnnotationEndLoc(RAngleLoc);
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000943
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000944 // In case the tokens were cached, have Preprocessor replace them with the
945 // annotation token.
946 PP.AnnotateCachedTokens(Tok);
Chris Lattnerc8e27cc2009-06-26 04:27:47 +0000947 return false;
Douglas Gregord6fb7ef2008-12-18 19:37:40 +0000948}
949
Douglas Gregor39a8de12009-02-25 19:37:18 +0000950/// \brief Replaces a template-id annotation token with a type
951/// annotation token.
952///
Douglas Gregor31a19b62009-04-01 21:51:26 +0000953/// If there was a failure when forming the type from the template-id,
954/// a type annotation token will still be created, but will have a
955/// NULL type pointer to signify an error.
Douglas Gregor059101f2011-03-02 00:47:37 +0000956void Parser::AnnotateTemplateIdTokenAsType() {
Douglas Gregor39a8de12009-02-25 19:37:18 +0000957 assert(Tok.is(tok::annot_template_id) && "Requires template-id tokens");
958
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +0000959 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregorc45c2322009-03-31 00:43:58 +0000960 assert((TemplateId->Kind == TNK_Type_template ||
961 TemplateId->Kind == TNK_Dependent_template_name) &&
962 "Only works for type and dependent templates");
Mike Stump1eb44332009-09-09 15:08:12 +0000963
Benjamin Kramer5354e772012-08-23 23:38:35 +0000964 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Douglas Gregor39a8de12009-02-25 19:37:18 +0000965 TemplateId->NumArgs);
966
John McCallf312b1e2010-08-26 23:41:50 +0000967 TypeResult Type
Douglas Gregor059101f2011-03-02 00:47:37 +0000968 = Actions.ActOnTemplateIdType(TemplateId->SS,
Abramo Bagnara55d23c92012-02-06 14:41:24 +0000969 TemplateId->TemplateKWLoc,
Douglas Gregor059101f2011-03-02 00:47:37 +0000970 TemplateId->Template,
Douglas Gregor7532dc62009-03-30 22:58:21 +0000971 TemplateId->TemplateNameLoc,
Mike Stump1eb44332009-09-09 15:08:12 +0000972 TemplateId->LAngleLoc,
Douglas Gregor7532dc62009-03-30 22:58:21 +0000973 TemplateArgsPtr,
Douglas Gregor7532dc62009-03-30 22:58:21 +0000974 TemplateId->RAngleLoc);
Douglas Gregor39a8de12009-02-25 19:37:18 +0000975 // Create the new "type" annotation token.
976 Tok.setKind(tok::annot_typename);
John McCallb3d87482010-08-24 05:47:05 +0000977 setTypeAnnotation(Tok, Type.isInvalid() ? ParsedType() : Type.get());
Douglas Gregor059101f2011-03-02 00:47:37 +0000978 if (TemplateId->SS.isNotEmpty()) // it was a C++ qualified type name.
979 Tok.setLocation(TemplateId->SS.getBeginLoc());
Sebastian Redl39d67112010-02-08 19:35:18 +0000980 // End location stays the same
Douglas Gregor39a8de12009-02-25 19:37:18 +0000981
Douglas Gregor86235412009-11-04 18:18:19 +0000982 // Replace the template-id annotation token, and possible the scope-specifier
983 // that precedes it, with the typename annotation token.
984 PP.AnnotateCachedTokens(Tok);
Douglas Gregor39a8de12009-02-25 19:37:18 +0000985}
986
Douglas Gregor314b97f2009-11-10 19:49:08 +0000987/// \brief Determine whether the given token can end a template argument.
Benjamin Kramer3a4a2b32009-11-10 21:29:56 +0000988static bool isEndOfTemplateArgument(Token Tok) {
Douglas Gregor314b97f2009-11-10 19:49:08 +0000989 return Tok.is(tok::comma) || Tok.is(tok::greater) ||
990 Tok.is(tok::greatergreater);
991}
992
Douglas Gregor788cd062009-11-11 01:00:40 +0000993/// \brief Parse a C++ template template argument.
994ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
995 if (!Tok.is(tok::identifier) && !Tok.is(tok::coloncolon) &&
996 !Tok.is(tok::annot_cxxscope))
997 return ParsedTemplateArgument();
998
999 // C++0x [temp.arg.template]p1:
1000 // A template-argument for a template template-parameter shall be the name
Richard Smith3e4c6c42011-05-05 21:57:07 +00001001 // of a class template or an alias template, expressed as id-expression.
Douglas Gregor788cd062009-11-11 01:00:40 +00001002 //
Richard Smith3e4c6c42011-05-05 21:57:07 +00001003 // We parse an id-expression that refers to a class template or alias
1004 // template. The grammar we parse is:
Douglas Gregor788cd062009-11-11 01:00:40 +00001005 //
Douglas Gregorec5e6962011-01-05 17:33:50 +00001006 // nested-name-specifier[opt] template[opt] identifier ...[opt]
Douglas Gregor788cd062009-11-11 01:00:40 +00001007 //
1008 // followed by a token that terminates a template argument, such as ',',
1009 // '>', or (in some cases) '>>'.
Douglas Gregor788cd062009-11-11 01:00:40 +00001010 CXXScopeSpec SS; // nested-name-specifier, if present
John McCallb3d87482010-08-24 05:47:05 +00001011 ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
Douglas Gregor788cd062009-11-11 01:00:40 +00001012 /*EnteringContext=*/false);
1013
Douglas Gregorec5e6962011-01-05 17:33:50 +00001014 ParsedTemplateArgument Result;
1015 SourceLocation EllipsisLoc;
Douglas Gregor788cd062009-11-11 01:00:40 +00001016 if (SS.isSet() && Tok.is(tok::kw_template)) {
1017 // Parse the optional 'template' keyword following the
1018 // nested-name-specifier.
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001019 SourceLocation TemplateKWLoc = ConsumeToken();
Douglas Gregor788cd062009-11-11 01:00:40 +00001020
1021 if (Tok.is(tok::identifier)) {
1022 // We appear to have a dependent template name.
1023 UnqualifiedId Name;
1024 Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1025 ConsumeToken(); // the identifier
1026
Douglas Gregorec5e6962011-01-05 17:33:50 +00001027 // Parse the ellipsis.
1028 if (Tok.is(tok::ellipsis))
1029 EllipsisLoc = ConsumeToken();
1030
Douglas Gregor788cd062009-11-11 01:00:40 +00001031 // If the next token signals the end of a template argument,
1032 // then we have a dependent template name that could be a template
1033 // template argument.
Douglas Gregord6ab2322010-06-16 23:00:59 +00001034 TemplateTy Template;
1035 if (isEndOfTemplateArgument(Tok) &&
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001036 Actions.ActOnDependentTemplateName(getCurScope(),
1037 SS, TemplateKWLoc, Name,
John McCallb3d87482010-08-24 05:47:05 +00001038 /*ObjectType=*/ ParsedType(),
Douglas Gregord6ab2322010-06-16 23:00:59 +00001039 /*EnteringContext=*/false,
1040 Template))
Douglas Gregorec5e6962011-01-05 17:33:50 +00001041 Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
Douglas Gregord6ab2322010-06-16 23:00:59 +00001042 }
Douglas Gregor788cd062009-11-11 01:00:40 +00001043 } else if (Tok.is(tok::identifier)) {
1044 // We may have a (non-dependent) template name.
1045 TemplateTy Template;
1046 UnqualifiedId Name;
1047 Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1048 ConsumeToken(); // the identifier
1049
Douglas Gregorec5e6962011-01-05 17:33:50 +00001050 // Parse the ellipsis.
1051 if (Tok.is(tok::ellipsis))
1052 EllipsisLoc = ConsumeToken();
1053
Douglas Gregor788cd062009-11-11 01:00:40 +00001054 if (isEndOfTemplateArgument(Tok)) {
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001055 bool MemberOfUnknownSpecialization;
Abramo Bagnara7c153532010-08-06 12:11:11 +00001056 TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
1057 /*hasTemplateKeyword=*/false,
1058 Name,
John McCallb3d87482010-08-24 05:47:05 +00001059 /*ObjectType=*/ ParsedType(),
Douglas Gregor788cd062009-11-11 01:00:40 +00001060 /*EnteringContext=*/false,
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001061 Template,
1062 MemberOfUnknownSpecialization);
Douglas Gregor788cd062009-11-11 01:00:40 +00001063 if (TNK == TNK_Dependent_template_name || TNK == TNK_Type_template) {
1064 // We have an id-expression that refers to a class template or
Richard Smith3e4c6c42011-05-05 21:57:07 +00001065 // (C++0x) alias template.
Douglas Gregorec5e6962011-01-05 17:33:50 +00001066 Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
Douglas Gregor788cd062009-11-11 01:00:40 +00001067 }
1068 }
1069 }
1070
Douglas Gregorec5e6962011-01-05 17:33:50 +00001071 // If this is a pack expansion, build it as such.
1072 if (EllipsisLoc.isValid() && !Result.isInvalid())
1073 Result = Actions.ActOnPackExpansion(Result, EllipsisLoc);
1074
1075 return Result;
Douglas Gregor788cd062009-11-11 01:00:40 +00001076}
1077
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001078/// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]).
1079///
1080/// template-argument: [C++ 14.2]
Douglas Gregorac7610d2009-06-22 20:57:11 +00001081/// constant-expression
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001082/// type-id
1083/// id-expression
Douglas Gregor314b97f2009-11-10 19:49:08 +00001084ParsedTemplateArgument Parser::ParseTemplateArgument() {
Douglas Gregor55f6b142009-02-09 18:46:07 +00001085 // C++ [temp.arg]p2:
1086 // In a template-argument, an ambiguity between a type-id and an
1087 // expression is resolved to a type-id, regardless of the form of
1088 // the corresponding template-parameter.
1089 //
Douglas Gregor314b97f2009-11-10 19:49:08 +00001090 // Therefore, we initially try to parse a type-id.
Douglas Gregor8b642592009-02-10 00:53:15 +00001091 if (isCXXTypeId(TypeIdAsTemplateArgument)) {
Douglas Gregor314b97f2009-11-10 19:49:08 +00001092 SourceLocation Loc = Tok.getLocation();
Douglas Gregor683a81f2011-01-31 16:09:46 +00001093 TypeResult TypeArg = ParseTypeName(/*Range=*/0,
1094 Declarator::TemplateTypeArgContext);
Douglas Gregor809070a2009-02-18 17:45:20 +00001095 if (TypeArg.isInvalid())
Douglas Gregor314b97f2009-11-10 19:49:08 +00001096 return ParsedTemplateArgument();
1097
John McCallb3d87482010-08-24 05:47:05 +00001098 return ParsedTemplateArgument(ParsedTemplateArgument::Type,
1099 TypeArg.get().getAsOpaquePtr(),
Douglas Gregor314b97f2009-11-10 19:49:08 +00001100 Loc);
Douglas Gregor55f6b142009-02-09 18:46:07 +00001101 }
Douglas Gregor788cd062009-11-11 01:00:40 +00001102
1103 // Try to parse a template template argument.
Douglas Gregoreaf75f42009-11-12 00:03:40 +00001104 {
1105 TentativeParsingAction TPA(*this);
1106
1107 ParsedTemplateArgument TemplateTemplateArgument
1108 = ParseTemplateTemplateArgument();
1109 if (!TemplateTemplateArgument.isInvalid()) {
1110 TPA.Commit();
1111 return TemplateTemplateArgument;
1112 }
1113
1114 // Revert this tentative parse to parse a non-type template argument.
1115 TPA.Revert();
1116 }
Douglas Gregor314b97f2009-11-10 19:49:08 +00001117
1118 // Parse a non-type template argument.
1119 SourceLocation Loc = Tok.getLocation();
Kaelyn Uhraine43fe992012-02-22 01:03:07 +00001120 ExprResult ExprArg = ParseConstantExpression(MaybeTypeCast);
Douglas Gregorc15cb382009-02-09 23:23:08 +00001121 if (ExprArg.isInvalid() || !ExprArg.get())
Douglas Gregor314b97f2009-11-10 19:49:08 +00001122 return ParsedTemplateArgument();
Douglas Gregor55f6b142009-02-09 18:46:07 +00001123
Douglas Gregor314b97f2009-11-10 19:49:08 +00001124 return ParsedTemplateArgument(ParsedTemplateArgument::NonType,
1125 ExprArg.release(), Loc);
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001126}
1127
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001128/// \brief Determine whether the current tokens can only be parsed as a
1129/// template argument list (starting with the '<') and never as a '<'
1130/// expression.
Douglas Gregord5ab9b02010-05-21 23:43:39 +00001131bool Parser::IsTemplateArgumentList(unsigned Skip) {
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001132 struct AlwaysRevertAction : TentativeParsingAction {
1133 AlwaysRevertAction(Parser &P) : TentativeParsingAction(P) { }
1134 ~AlwaysRevertAction() { Revert(); }
1135 } Tentative(*this);
1136
Douglas Gregord5ab9b02010-05-21 23:43:39 +00001137 while (Skip) {
1138 ConsumeToken();
1139 --Skip;
1140 }
1141
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001142 // '<'
1143 if (!Tok.is(tok::less))
1144 return false;
1145 ConsumeToken();
1146
1147 // An empty template argument list.
1148 if (Tok.is(tok::greater))
1149 return true;
1150
1151 // See whether we have declaration specifiers, which indicate a type.
1152 while (isCXXDeclarationSpecifier() == TPResult::True())
1153 ConsumeToken();
1154
1155 // If we have a '>' or a ',' then this is a template argument list.
1156 return Tok.is(tok::greater) || Tok.is(tok::comma);
1157}
1158
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001159/// ParseTemplateArgumentList - Parse a C++ template-argument-list
1160/// (C++ [temp.names]). Returns true if there was an error.
1161///
1162/// template-argument-list: [C++ 14.2]
1163/// template-argument
1164/// template-argument-list ',' template-argument
Mike Stump1eb44332009-09-09 15:08:12 +00001165bool
Douglas Gregor314b97f2009-11-10 19:49:08 +00001166Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs) {
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001167 while (true) {
Douglas Gregor314b97f2009-11-10 19:49:08 +00001168 ParsedTemplateArgument Arg = ParseTemplateArgument();
Douglas Gregor7536dd52010-12-20 02:24:11 +00001169 if (Tok.is(tok::ellipsis)) {
1170 SourceLocation EllipsisLoc = ConsumeToken();
1171 Arg = Actions.ActOnPackExpansion(Arg, EllipsisLoc);
1172 }
1173
Douglas Gregor314b97f2009-11-10 19:49:08 +00001174 if (Arg.isInvalid()) {
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001175 SkipUntil(tok::comma, tok::greater, true, true);
1176 return true;
1177 }
Douglas Gregor5908e9f2009-02-09 19:34:22 +00001178
Douglas Gregor314b97f2009-11-10 19:49:08 +00001179 // Save this template argument.
1180 TemplateArgs.push_back(Arg);
1181
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001182 // If the next token is a comma, consume it and keep reading
1183 // arguments.
1184 if (Tok.isNot(tok::comma)) break;
1185
1186 // Consume the comma.
1187 ConsumeToken();
1188 }
1189
Eli Friedman64a4eb22009-12-27 22:31:18 +00001190 return false;
Douglas Gregord6fb7ef2008-12-18 19:37:40 +00001191}
1192
Mike Stump1eb44332009-09-09 15:08:12 +00001193/// \brief Parse a C++ explicit template instantiation
Douglas Gregor1426e532009-05-12 21:31:51 +00001194/// (C++ [temp.explicit]).
1195///
1196/// explicit-instantiation:
Douglas Gregor45f96552009-09-04 06:33:52 +00001197/// 'extern' [opt] 'template' declaration
1198///
1199/// Note that the 'extern' is a GNU extension and C++0x feature.
Argyrios Kyrtzidis92410572011-12-23 02:16:45 +00001200Decl *Parser::ParseExplicitInstantiation(unsigned Context,
1201 SourceLocation ExternLoc,
John McCalld226f652010-08-21 09:40:31 +00001202 SourceLocation TemplateLoc,
Argyrios Kyrtzidis92410572011-12-23 02:16:45 +00001203 SourceLocation &DeclEnd,
1204 AccessSpecifier AS) {
John McCallc9068d72010-07-16 08:13:16 +00001205 // This isn't really required here.
John McCall92576642012-05-07 06:16:41 +00001206 ParsingDeclRAIIObject
1207 ParsingTemplateParams(*this, ParsingDeclRAIIObject::NoParent);
John McCallc9068d72010-07-16 08:13:16 +00001208
Argyrios Kyrtzidis92410572011-12-23 02:16:45 +00001209 return ParseSingleDeclarationAfterTemplate(Context,
Douglas Gregor45f96552009-09-04 06:33:52 +00001210 ParsedTemplateInfo(ExternLoc,
1211 TemplateLoc),
John McCallc9068d72010-07-16 08:13:16 +00001212 ParsingTemplateParams,
Argyrios Kyrtzidis92410572011-12-23 02:16:45 +00001213 DeclEnd, AS);
Douglas Gregor1426e532009-05-12 21:31:51 +00001214}
John McCall78b81052010-11-10 02:40:36 +00001215
1216SourceRange Parser::ParsedTemplateInfo::getSourceRange() const {
1217 if (TemplateParams)
1218 return getTemplateParamsRange(TemplateParams->data(),
1219 TemplateParams->size());
1220
1221 SourceRange R(TemplateLoc);
1222 if (ExternLoc.isValid())
1223 R.setBegin(ExternLoc);
1224 return R;
1225}
Francois Pichet8387e2a2011-04-22 22:18:13 +00001226
Francois Pichet4a47e8d2011-04-23 11:52:20 +00001227void Parser::LateTemplateParserCallback(void *P, const FunctionDecl *FD) {
Francois Pichet8387e2a2011-04-22 22:18:13 +00001228 ((Parser*)P)->LateTemplateParser(FD);
1229}
1230
1231
Francois Pichet4a47e8d2011-04-23 11:52:20 +00001232void Parser::LateTemplateParser(const FunctionDecl *FD) {
Francois Pichet8387e2a2011-04-22 22:18:13 +00001233 LateParsedTemplatedFunction *LPT = LateParsedTemplateMap[FD];
1234 if (LPT) {
1235 ParseLateTemplatedFuncDef(*LPT);
1236 return;
1237 }
1238
1239 llvm_unreachable("Late templated function without associated lexed tokens");
1240}
David Blaikie219c2e22012-04-02 20:59:49 +00001241
1242/// \brief Late parse a C++ function template in Microsoft mode.
1243void Parser::ParseLateTemplatedFuncDef(LateParsedTemplatedFunction &LMT) {
1244 if(!LMT.D)
1245 return;
1246
1247 // Get the FunctionDecl.
1248 FunctionDecl *FD = 0;
1249 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(LMT.D))
1250 FD = FunTmpl->getTemplatedDecl();
1251 else
1252 FD = cast<FunctionDecl>(LMT.D);
1253
Francois Pichetd77177a2012-02-22 08:25:53 +00001254 // To restore the context after late parsing.
David Blaikie219c2e22012-04-02 20:59:49 +00001255 Sema::ContextRAII GlobalSavedContext(Actions, Actions.CurContext);
1256
1257 SmallVector<ParseScope*, 4> TemplateParamScopeStack;
1258 DeclaratorDecl* Declarator = dyn_cast<DeclaratorDecl>(FD);
1259 if (Declarator && Declarator->getNumTemplateParameterLists() != 0) {
1260 TemplateParamScopeStack.push_back(new ParseScope(this, Scope::TemplateParamScope));
1261 Actions.ActOnReenterDeclaratorTemplateScope(getCurScope(), Declarator);
1262 Actions.ActOnReenterTemplateScope(getCurScope(), LMT.D);
1263 } else {
1264 // Get the list of DeclContext to reenter.
1265 SmallVector<DeclContext*, 4> DeclContextToReenter;
1266 DeclContext *DD = FD->getLexicalParent();
1267 while (DD && !DD->isTranslationUnit()) {
1268 DeclContextToReenter.push_back(DD);
1269 DD = DD->getLexicalParent();
1270 }
1271
1272 // Reenter template scopes from outmost to innermost.
1273 SmallVector<DeclContext*, 4>::reverse_iterator II =
1274 DeclContextToReenter.rbegin();
1275 for (; II != DeclContextToReenter.rend(); ++II) {
1276 if (ClassTemplatePartialSpecializationDecl* MD =
1277 dyn_cast_or_null<ClassTemplatePartialSpecializationDecl>(*II)) {
1278 TemplateParamScopeStack.push_back(new ParseScope(this,
1279 Scope::TemplateParamScope));
1280 Actions.ActOnReenterTemplateScope(getCurScope(), MD);
1281 } else if (CXXRecordDecl* MD = dyn_cast_or_null<CXXRecordDecl>(*II)) {
1282 TemplateParamScopeStack.push_back(new ParseScope(this,
1283 Scope::TemplateParamScope,
1284 MD->getDescribedClassTemplate() != 0 ));
1285 Actions.ActOnReenterTemplateScope(getCurScope(),
1286 MD->getDescribedClassTemplate());
1287 }
1288 TemplateParamScopeStack.push_back(new ParseScope(this, Scope::DeclScope));
1289 Actions.PushDeclContext(Actions.getCurScope(), *II);
1290 }
1291 TemplateParamScopeStack.push_back(new ParseScope(this,
1292 Scope::TemplateParamScope));
1293 Actions.ActOnReenterTemplateScope(getCurScope(), LMT.D);
1294 }
1295
1296 assert(!LMT.Toks.empty() && "Empty body!");
1297
1298 // Append the current token at the end of the new token stream so that it
1299 // doesn't get lost.
1300 LMT.Toks.push_back(Tok);
1301 PP.EnterTokenStream(LMT.Toks.data(), LMT.Toks.size(), true, false);
1302
1303 // Consume the previously pushed token.
1304 ConsumeAnyToken();
1305 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try))
1306 && "Inline method not starting with '{', ':' or 'try'");
1307
1308 // Parse the method body. Function body parsing code is similar enough
1309 // to be re-used for method bodies as well.
1310 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope);
1311
1312 // Recreate the containing function DeclContext.
1313 Sema::ContextRAII FunctionSavedContext(Actions, Actions.getContainingDC(FD));
1314
1315 if (FunctionTemplateDecl *FunctionTemplate
1316 = dyn_cast_or_null<FunctionTemplateDecl>(LMT.D))
1317 Actions.ActOnStartOfFunctionDef(getCurScope(),
1318 FunctionTemplate->getTemplatedDecl());
1319 if (FunctionDecl *Function = dyn_cast_or_null<FunctionDecl>(LMT.D))
1320 Actions.ActOnStartOfFunctionDef(getCurScope(), Function);
1321
1322
1323 if (Tok.is(tok::kw_try)) {
1324 ParseFunctionTryBlock(LMT.D, FnScope);
1325 } else {
1326 if (Tok.is(tok::colon))
1327 ParseConstructorInitializer(LMT.D);
1328 else
1329 Actions.ActOnDefaultCtorInitializers(LMT.D);
1330
1331 if (Tok.is(tok::l_brace)) {
1332 ParseFunctionStatementBody(LMT.D, FnScope);
1333 Actions.MarkAsLateParsedTemplate(FD, false);
1334 } else
1335 Actions.ActOnFinishFunctionBody(LMT.D, 0);
1336 }
1337
1338 // Exit scopes.
Francois Pichetfdde4702011-09-22 22:14:56 +00001339 FnScope.Exit();
David Blaikie219c2e22012-04-02 20:59:49 +00001340 SmallVector<ParseScope*, 4>::reverse_iterator I =
1341 TemplateParamScopeStack.rbegin();
1342 for (; I != TemplateParamScopeStack.rend(); ++I)
1343 delete *I;
1344
1345 DeclGroupPtrTy grp = Actions.ConvertDeclToDeclGroup(LMT.D);
1346 if (grp)
1347 Actions.getASTConsumer().HandleTopLevelDecl(grp.get());
Francois Pichet8387e2a2011-04-22 22:18:13 +00001348}
1349
1350/// \brief Lex a delayed template function for late parsing.
1351void Parser::LexTemplateFunctionForLateParsing(CachedTokens &Toks) {
1352 tok::TokenKind kind = Tok.getKind();
Sebastian Redla891a322011-09-30 08:32:17 +00001353 if (!ConsumeAndStoreFunctionPrologue(Toks)) {
1354 // Consume everything up to (and including) the matching right brace.
1355 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
Francois Pichet8387e2a2011-04-22 22:18:13 +00001356 }
Francois Pichet8387e2a2011-04-22 22:18:13 +00001357
1358 // If we're in a function-try-block, we need to store all the catch blocks.
1359 if (kind == tok::kw_try) {
1360 while (Tok.is(tok::kw_catch)) {
1361 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
1362 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
1363 }
1364 }
1365}