clang 19.0.0git
ParseTemplate.cpp
Go to the documentation of this file.
1//===--- ParseTemplate.cpp - Template Parsing -----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements parsing of C++ templates.
10//
11//===----------------------------------------------------------------------===//
12
15#include "clang/AST/ExprCXX.h"
17#include "clang/Parse/Parser.h"
19#include "clang/Sema/DeclSpec.h"
22#include "clang/Sema/Scope.h"
24#include "llvm/Support/TimeProfiler.h"
25using namespace clang;
26
27/// Re-enter a possible template scope, creating as many template parameter
28/// scopes as necessary.
29/// \return The number of template parameter scopes entered.
31 return Actions.ActOnReenterTemplateScope(D, [&] {
33 return Actions.getCurScope();
34 });
35}
36
37/// Parse a template declaration, explicit instantiation, or
38/// explicit specialization.
40Parser::ParseDeclarationStartingWithTemplate(DeclaratorContext Context,
41 SourceLocation &DeclEnd,
42 ParsedAttributes &AccessAttrs) {
43 ObjCDeclContextSwitch ObjCDC(*this);
44
45 if (Tok.is(tok::kw_template) && NextToken().isNot(tok::less)) {
46 return ParseExplicitInstantiation(Context, SourceLocation(), ConsumeToken(),
47 DeclEnd, AccessAttrs,
49 }
50 return ParseTemplateDeclarationOrSpecialization(Context, DeclEnd, AccessAttrs,
52}
53
54/// Parse a template declaration or an explicit specialization.
55///
56/// Template declarations include one or more template parameter lists
57/// and either the function or class template declaration. Explicit
58/// specializations contain one or more 'template < >' prefixes
59/// followed by a (possibly templated) declaration. Since the
60/// syntactic form of both features is nearly identical, we parse all
61/// of the template headers together and let semantic analysis sort
62/// the declarations from the explicit specializations.
63///
64/// template-declaration: [C++ temp]
65/// 'export'[opt] 'template' '<' template-parameter-list '>' declaration
66///
67/// template-declaration: [C++2a]
68/// template-head declaration
69/// template-head concept-definition
70///
71/// TODO: requires-clause
72/// template-head: [C++2a]
73/// 'template' '<' template-parameter-list '>'
74/// requires-clause[opt]
75///
76/// explicit-specialization: [ C++ temp.expl.spec]
77/// 'template' '<' '>' declaration
78Parser::DeclGroupPtrTy Parser::ParseTemplateDeclarationOrSpecialization(
79 DeclaratorContext Context, SourceLocation &DeclEnd,
80 ParsedAttributes &AccessAttrs, AccessSpecifier AS) {
81 assert(Tok.isOneOf(tok::kw_export, tok::kw_template) &&
82 "Token does not start a template declaration.");
83
84 MultiParseScope TemplateParamScopes(*this);
85
86 // Tell the action that names should be checked in the context of
87 // the declaration to come.
89 ParsingTemplateParams(*this, ParsingDeclRAIIObject::NoParent);
90
91 // Parse multiple levels of template headers within this template
92 // parameter scope, e.g.,
93 //
94 // template<typename T>
95 // template<typename U>
96 // class A<T>::B { ... };
97 //
98 // We parse multiple levels non-recursively so that we can build a
99 // single data structure containing all of the template parameter
100 // lists to easily differentiate between the case above and:
101 //
102 // template<typename T>
103 // class A {
104 // template<typename U> class B;
105 // };
106 //
107 // In the first case, the action for declaring A<T>::B receives
108 // both template parameter lists. In the second case, the action for
109 // defining A<T>::B receives just the inner template parameter list
110 // (and retrieves the outer template parameter list from its
111 // context).
112 bool isSpecialization = true;
113 bool LastParamListWasEmpty = false;
114 TemplateParameterLists ParamLists;
115 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
116
117 do {
118 // Consume the 'export', if any.
119 SourceLocation ExportLoc;
120 TryConsumeToken(tok::kw_export, ExportLoc);
121
122 // Consume the 'template', which should be here.
123 SourceLocation TemplateLoc;
124 if (!TryConsumeToken(tok::kw_template, TemplateLoc)) {
125 Diag(Tok.getLocation(), diag::err_expected_template);
126 return nullptr;
127 }
128
129 // Parse the '<' template-parameter-list '>'
130 SourceLocation LAngleLoc, RAngleLoc;
131 SmallVector<NamedDecl*, 4> TemplateParams;
132 if (ParseTemplateParameters(TemplateParamScopes,
133 CurTemplateDepthTracker.getDepth(),
134 TemplateParams, LAngleLoc, RAngleLoc)) {
135 // Skip until the semi-colon or a '}'.
136 SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
137 TryConsumeToken(tok::semi);
138 return nullptr;
139 }
140
141 ExprResult OptionalRequiresClauseConstraintER;
142 if (!TemplateParams.empty()) {
143 isSpecialization = false;
144 ++CurTemplateDepthTracker;
145
146 if (TryConsumeToken(tok::kw_requires)) {
147 OptionalRequiresClauseConstraintER =
149 /*IsTrailingRequiresClause=*/false));
150 if (!OptionalRequiresClauseConstraintER.isUsable()) {
151 // Skip until the semi-colon or a '}'.
152 SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
153 TryConsumeToken(tok::semi);
154 return nullptr;
155 }
156 }
157 } else {
158 LastParamListWasEmpty = true;
159 }
160
161 ParamLists.push_back(Actions.ActOnTemplateParameterList(
162 CurTemplateDepthTracker.getDepth(), ExportLoc, TemplateLoc, LAngleLoc,
163 TemplateParams, RAngleLoc, OptionalRequiresClauseConstraintER.get()));
164 } while (Tok.isOneOf(tok::kw_export, tok::kw_template));
165
166 ParsedTemplateInfo TemplateInfo(&ParamLists, isSpecialization,
167 LastParamListWasEmpty);
168
169 // Parse the actual template declaration.
170 if (Tok.is(tok::kw_concept)) {
171 Decl *ConceptDecl = ParseConceptDefinition(TemplateInfo, DeclEnd);
172 // We need to explicitly pass ConceptDecl to ParsingDeclRAIIObject, so that
173 // delayed diagnostics (e.g. warn_deprecated) have a Decl to work with.
174 ParsingTemplateParams.complete(ConceptDecl);
175 return Actions.ConvertDeclToDeclGroup(ConceptDecl);
176 }
177
178 return ParseDeclarationAfterTemplate(
179 Context, TemplateInfo, ParsingTemplateParams, DeclEnd, AccessAttrs, AS);
180}
181
182/// Parse a single declaration that declares a template,
183/// template specialization, or explicit instantiation of a template.
184///
185/// \param DeclEnd will receive the source location of the last token
186/// within this declaration.
187///
188/// \param AS the access specifier associated with this
189/// declaration. Will be AS_none for namespace-scope declarations.
190///
191/// \returns the new declaration.
192Parser::DeclGroupPtrTy Parser::ParseDeclarationAfterTemplate(
193 DeclaratorContext Context, ParsedTemplateInfo &TemplateInfo,
194 ParsingDeclRAIIObject &DiagsFromTParams, SourceLocation &DeclEnd,
195 ParsedAttributes &AccessAttrs, AccessSpecifier AS) {
196 assert(TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
197 "Template information required");
198
199 if (Tok.is(tok::kw_static_assert)) {
200 // A static_assert declaration may not be templated.
201 Diag(Tok.getLocation(), diag::err_templated_invalid_declaration)
202 << TemplateInfo.getSourceRange();
203 // Parse the static_assert declaration to improve error recovery.
204 return Actions.ConvertDeclToDeclGroup(
205 ParseStaticAssertDeclaration(DeclEnd));
206 }
207
208 // We are parsing a member template.
209 if (Context == DeclaratorContext::Member)
210 return ParseCXXClassMemberDeclaration(AS, AccessAttrs, TemplateInfo,
211 &DiagsFromTParams);
212
213 ParsedAttributes DeclAttrs(AttrFactory);
214 ParsedAttributes DeclSpecAttrs(AttrFactory);
215
216 // GNU attributes are applied to the declaration specification while the
217 // standard attributes are applied to the declaration. We parse the two
218 // attribute sets into different containters so we can apply them during
219 // the regular parsing process.
220 while (MaybeParseCXX11Attributes(DeclAttrs) ||
221 MaybeParseGNUAttributes(DeclSpecAttrs))
222 ;
223
224 if (Tok.is(tok::kw_using))
225 return ParseUsingDirectiveOrDeclaration(Context, TemplateInfo, DeclEnd,
226 DeclAttrs);
227
228 // Parse the declaration specifiers, stealing any diagnostics from
229 // the template parameters.
230 ParsingDeclSpec DS(*this, &DiagsFromTParams);
231 DS.SetRangeStart(DeclSpecAttrs.Range.getBegin());
232 DS.SetRangeEnd(DeclSpecAttrs.Range.getEnd());
233 DS.takeAttributesFrom(DeclSpecAttrs);
234
235 ParseDeclarationSpecifiers(DS, TemplateInfo, AS,
236 getDeclSpecContextFromDeclaratorContext(Context));
237
238 if (Tok.is(tok::semi)) {
239 ProhibitAttributes(DeclAttrs);
240 DeclEnd = ConsumeToken();
241 RecordDecl *AnonRecord = nullptr;
244 TemplateInfo.TemplateParams ? *TemplateInfo.TemplateParams
246 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation,
247 AnonRecord);
249 assert(!AnonRecord &&
250 "Anonymous unions/structs should not be valid with template");
251 DS.complete(Decl);
252 return Actions.ConvertDeclToDeclGroup(Decl);
253 }
254
255 if (DS.hasTagDefinition())
256 Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
257
258 // Move the attributes from the prefix into the DS.
259 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
260 ProhibitAttributes(DeclAttrs);
261
262 return ParseDeclGroup(DS, Context, DeclAttrs, TemplateInfo, &DeclEnd);
263}
264
265/// \brief Parse a single declaration that declares a concept.
266///
267/// \param DeclEnd will receive the source location of the last token
268/// within this declaration.
269///
270/// \returns the new declaration.
271Decl *
272Parser::ParseConceptDefinition(const ParsedTemplateInfo &TemplateInfo,
273 SourceLocation &DeclEnd) {
274 assert(TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
275 "Template information required");
276 assert(Tok.is(tok::kw_concept) &&
277 "ParseConceptDefinition must be called when at a 'concept' keyword");
278
279 ConsumeToken(); // Consume 'concept'
280
281 SourceLocation BoolKWLoc;
282 if (TryConsumeToken(tok::kw_bool, BoolKWLoc))
283 Diag(Tok.getLocation(), diag::err_concept_legacy_bool_keyword) <<
285
286 DiagnoseAndSkipCXX11Attributes();
287
288 CXXScopeSpec SS;
289 if (ParseOptionalCXXScopeSpecifier(
290 SS, /*ObjectType=*/nullptr,
291 /*ObjectHasErrors=*/false, /*EnteringContext=*/false,
292 /*MayBePseudoDestructor=*/nullptr,
293 /*IsTypename=*/false, /*LastII=*/nullptr, /*OnlyNamespace=*/true) ||
294 SS.isInvalid()) {
295 SkipUntil(tok::semi);
296 return nullptr;
297 }
298
299 if (SS.isNotEmpty())
300 Diag(SS.getBeginLoc(),
301 diag::err_concept_definition_not_identifier);
302
304 if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
305 /*ObjectHadErrors=*/false, /*EnteringContext=*/false,
306 /*AllowDestructorName=*/false,
307 /*AllowConstructorName=*/false,
308 /*AllowDeductionGuide=*/false,
309 /*TemplateKWLoc=*/nullptr, Result)) {
310 SkipUntil(tok::semi);
311 return nullptr;
312 }
313
314 if (Result.getKind() != UnqualifiedIdKind::IK_Identifier) {
315 Diag(Result.getBeginLoc(), diag::err_concept_definition_not_identifier);
316 SkipUntil(tok::semi);
317 return nullptr;
318 }
319
320 const IdentifierInfo *Id = Result.Identifier;
321 SourceLocation IdLoc = Result.getBeginLoc();
322
323 ParsedAttributes Attrs(AttrFactory);
324 MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs);
325
326 if (!TryConsumeToken(tok::equal)) {
327 Diag(Tok.getLocation(), diag::err_expected) << tok::equal;
328 SkipUntil(tok::semi);
329 return nullptr;
330 }
331
332 ExprResult ConstraintExprResult =
334 if (ConstraintExprResult.isInvalid()) {
335 SkipUntil(tok::semi);
336 return nullptr;
337 }
338
339 DeclEnd = Tok.getLocation();
340 ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
341 Expr *ConstraintExpr = ConstraintExprResult.get();
342 return Actions.ActOnConceptDefinition(getCurScope(),
343 *TemplateInfo.TemplateParams, Id, IdLoc,
344 ConstraintExpr, Attrs);
345}
346
347/// ParseTemplateParameters - Parses a template-parameter-list enclosed in
348/// angle brackets. Depth is the depth of this template-parameter-list, which
349/// is the number of template headers directly enclosing this template header.
350/// TemplateParams is the current list of template parameters we're building.
351/// The template parameter we parse will be added to this list. LAngleLoc and
352/// RAngleLoc will receive the positions of the '<' and '>', respectively,
353/// that enclose this template parameter list.
354///
355/// \returns true if an error occurred, false otherwise.
356bool Parser::ParseTemplateParameters(
357 MultiParseScope &TemplateScopes, unsigned Depth,
358 SmallVectorImpl<NamedDecl *> &TemplateParams, SourceLocation &LAngleLoc,
359 SourceLocation &RAngleLoc) {
360 // Get the template parameter list.
361 if (!TryConsumeToken(tok::less, LAngleLoc)) {
362 Diag(Tok.getLocation(), diag::err_expected_less_after) << "template";
363 return true;
364 }
365
366 // Try to parse the template parameter list.
367 bool Failed = false;
368 // FIXME: Missing greatergreatergreater support.
369 if (!Tok.is(tok::greater) && !Tok.is(tok::greatergreater)) {
370 TemplateScopes.Enter(Scope::TemplateParamScope);
371 Failed = ParseTemplateParameterList(Depth, TemplateParams);
372 }
373
374 if (Tok.is(tok::greatergreater)) {
375 // No diagnostic required here: a template-parameter-list can only be
376 // followed by a declaration or, for a template template parameter, the
377 // 'class' keyword. Therefore, the second '>' will be diagnosed later.
378 // This matters for elegant diagnosis of:
379 // template<template<typename>> struct S;
380 Tok.setKind(tok::greater);
381 RAngleLoc = Tok.getLocation();
383 } else if (!TryConsumeToken(tok::greater, RAngleLoc) && Failed) {
384 Diag(Tok.getLocation(), diag::err_expected) << tok::greater;
385 return true;
386 }
387 return false;
388}
389
390/// ParseTemplateParameterList - Parse a template parameter list. If
391/// the parsing fails badly (i.e., closing bracket was left out), this
392/// will try to put the token stream in a reasonable position (closing
393/// a statement, etc.) and return false.
394///
395/// template-parameter-list: [C++ temp]
396/// template-parameter
397/// template-parameter-list ',' template-parameter
398bool
399Parser::ParseTemplateParameterList(const unsigned Depth,
400 SmallVectorImpl<NamedDecl*> &TemplateParams) {
401 while (true) {
402
403 if (NamedDecl *TmpParam
404 = ParseTemplateParameter(Depth, TemplateParams.size())) {
405 TemplateParams.push_back(TmpParam);
406 } else {
407 // If we failed to parse a template parameter, skip until we find
408 // a comma or closing brace.
409 SkipUntil(tok::comma, tok::greater, tok::greatergreater,
411 }
412
413 // Did we find a comma or the end of the template parameter list?
414 if (Tok.is(tok::comma)) {
415 ConsumeToken();
416 } else if (Tok.isOneOf(tok::greater, tok::greatergreater)) {
417 // Don't consume this... that's done by template parser.
418 break;
419 } else {
420 // Somebody probably forgot to close the template. Skip ahead and
421 // try to get out of the expression. This error is currently
422 // subsumed by whatever goes on in ParseTemplateParameter.
423 Diag(Tok.getLocation(), diag::err_expected_comma_greater);
424 SkipUntil(tok::comma, tok::greater, tok::greatergreater,
426 return false;
427 }
428 }
429 return true;
430}
431
432/// Determine whether the parser is at the start of a template
433/// type parameter.
434Parser::TPResult Parser::isStartOfTemplateTypeParameter() {
435 if (Tok.is(tok::kw_class)) {
436 // "class" may be the start of an elaborated-type-specifier or a
437 // type-parameter. Per C++ [temp.param]p3, we prefer the type-parameter.
438 switch (NextToken().getKind()) {
439 case tok::equal:
440 case tok::comma:
441 case tok::greater:
442 case tok::greatergreater:
443 case tok::ellipsis:
444 return TPResult::True;
445
446 case tok::identifier:
447 // This may be either a type-parameter or an elaborated-type-specifier.
448 // We have to look further.
449 break;
450
451 default:
452 return TPResult::False;
453 }
454
455 switch (GetLookAheadToken(2).getKind()) {
456 case tok::equal:
457 case tok::comma:
458 case tok::greater:
459 case tok::greatergreater:
460 return TPResult::True;
461
462 default:
463 return TPResult::False;
464 }
465 }
466
467 if (TryAnnotateTypeConstraint())
468 return TPResult::Error;
469
470 if (isTypeConstraintAnnotation() &&
471 // Next token might be 'auto' or 'decltype', indicating that this
472 // type-constraint is in fact part of a placeholder-type-specifier of a
473 // non-type template parameter.
474 !GetLookAheadToken(Tok.is(tok::annot_cxxscope) ? 2 : 1)
475 .isOneOf(tok::kw_auto, tok::kw_decltype))
476 return TPResult::True;
477
478 // 'typedef' is a reasonably-common typo/thinko for 'typename', and is
479 // ill-formed otherwise.
480 if (Tok.isNot(tok::kw_typename) && Tok.isNot(tok::kw_typedef))
481 return TPResult::False;
482
483 // C++ [temp.param]p2:
484 // There is no semantic difference between class and typename in a
485 // template-parameter. typename followed by an unqualified-id
486 // names a template type parameter. typename followed by a
487 // qualified-id denotes the type in a non-type
488 // parameter-declaration.
489 Token Next = NextToken();
490
491 // If we have an identifier, skip over it.
492 if (Next.getKind() == tok::identifier)
493 Next = GetLookAheadToken(2);
494
495 switch (Next.getKind()) {
496 case tok::equal:
497 case tok::comma:
498 case tok::greater:
499 case tok::greatergreater:
500 case tok::ellipsis:
501 return TPResult::True;
502
503 case tok::kw_typename:
504 case tok::kw_typedef:
505 case tok::kw_class:
506 // These indicate that a comma was missed after a type parameter, not that
507 // we have found a non-type parameter.
508 return TPResult::True;
509
510 default:
511 return TPResult::False;
512 }
513}
514
515/// ParseTemplateParameter - Parse a template-parameter (C++ [temp.param]).
516///
517/// template-parameter: [C++ temp.param]
518/// type-parameter
519/// parameter-declaration
520///
521/// type-parameter: (See below)
522/// type-parameter-key ...[opt] identifier[opt]
523/// type-parameter-key identifier[opt] = type-id
524/// (C++2a) type-constraint ...[opt] identifier[opt]
525/// (C++2a) type-constraint identifier[opt] = type-id
526/// 'template' '<' template-parameter-list '>' type-parameter-key
527/// ...[opt] identifier[opt]
528/// 'template' '<' template-parameter-list '>' type-parameter-key
529/// identifier[opt] '=' id-expression
530///
531/// type-parameter-key:
532/// class
533/// typename
534///
535NamedDecl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) {
536
537 switch (isStartOfTemplateTypeParameter()) {
538 case TPResult::True:
539 // Is there just a typo in the input code? ('typedef' instead of
540 // 'typename')
541 if (Tok.is(tok::kw_typedef)) {
542 Diag(Tok.getLocation(), diag::err_expected_template_parameter);
543
544 Diag(Tok.getLocation(), diag::note_meant_to_use_typename)
546 Tok.getLocation(),
547 Tok.getEndLoc()),
548 "typename");
549
550 Tok.setKind(tok::kw_typename);
551 }
552
553 return ParseTypeParameter(Depth, Position);
554 case TPResult::False:
555 break;
556
557 case TPResult::Error: {
558 // We return an invalid parameter as opposed to null to avoid having bogus
559 // diagnostics about an empty template parameter list.
560 // FIXME: Fix ParseTemplateParameterList to better handle nullptr results
561 // from here.
562 // Return a NTTP as if there was an error in a scope specifier, the user
563 // probably meant to write the type of a NTTP.
565 DS.SetTypeSpecError();
568 D.SetIdentifier(nullptr, Tok.getLocation());
569 D.setInvalidType(true);
570 NamedDecl *ErrorParam = Actions.ActOnNonTypeTemplateParameter(
571 getCurScope(), D, Depth, Position, /*EqualLoc=*/SourceLocation(),
572 /*DefaultArg=*/nullptr);
573 ErrorParam->setInvalidDecl(true);
574 SkipUntil(tok::comma, tok::greater, tok::greatergreater,
576 return ErrorParam;
577 }
578
579 case TPResult::Ambiguous:
580 llvm_unreachable("template param classification can't be ambiguous");
581 }
582
583 if (Tok.is(tok::kw_template))
584 return ParseTemplateTemplateParameter(Depth, Position);
585
586 // If it's none of the above, then it must be a parameter declaration.
587 // NOTE: This will pick up errors in the closure of the template parameter
588 // list (e.g., template < ; Check here to implement >> style closures.
589 return ParseNonTypeTemplateParameter(Depth, Position);
590}
591
592/// Check whether the current token is a template-id annotation denoting a
593/// type-constraint.
594bool Parser::isTypeConstraintAnnotation() {
595 const Token &T = Tok.is(tok::annot_cxxscope) ? NextToken() : Tok;
596 if (T.isNot(tok::annot_template_id))
597 return false;
598 const auto *ExistingAnnot =
599 static_cast<TemplateIdAnnotation *>(T.getAnnotationValue());
600 return ExistingAnnot->Kind == TNK_Concept_template;
601}
602
603/// Try parsing a type-constraint at the current location.
604///
605/// type-constraint:
606/// nested-name-specifier[opt] concept-name
607/// nested-name-specifier[opt] concept-name
608/// '<' template-argument-list[opt] '>'[opt]
609///
610/// \returns true if an error occurred, and false otherwise.
611bool Parser::TryAnnotateTypeConstraint() {
613 return false;
614 CXXScopeSpec SS;
615 bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope);
616 if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
617 /*ObjectHasErrors=*/false,
618 /*EnteringContext=*/false,
619 /*MayBePseudoDestructor=*/nullptr,
620 // If this is not a type-constraint, then
621 // this scope-spec is part of the typename
622 // of a non-type template parameter
623 /*IsTypename=*/true, /*LastII=*/nullptr,
624 // We won't find concepts in
625 // non-namespaces anyway, so might as well
626 // parse this correctly for possible type
627 // names.
628 /*OnlyNamespace=*/false))
629 return true;
630
631 if (Tok.is(tok::identifier)) {
632 UnqualifiedId PossibleConceptName;
633 PossibleConceptName.setIdentifier(Tok.getIdentifierInfo(),
634 Tok.getLocation());
635
636 TemplateTy PossibleConcept;
637 bool MemberOfUnknownSpecialization = false;
638 auto TNK = Actions.isTemplateName(getCurScope(), SS,
639 /*hasTemplateKeyword=*/false,
640 PossibleConceptName,
641 /*ObjectType=*/ParsedType(),
642 /*EnteringContext=*/false,
643 PossibleConcept,
644 MemberOfUnknownSpecialization,
645 /*Disambiguation=*/true);
646 if (MemberOfUnknownSpecialization || !PossibleConcept ||
647 TNK != TNK_Concept_template) {
648 if (SS.isNotEmpty())
649 AnnotateScopeToken(SS, !WasScopeAnnotation);
650 return false;
651 }
652
653 // At this point we're sure we're dealing with a constrained parameter. It
654 // may or may not have a template parameter list following the concept
655 // name.
656 if (AnnotateTemplateIdToken(PossibleConcept, TNK, SS,
657 /*TemplateKWLoc=*/SourceLocation(),
658 PossibleConceptName,
659 /*AllowTypeAnnotation=*/false,
660 /*TypeConstraint=*/true))
661 return true;
662 }
663
664 if (SS.isNotEmpty())
665 AnnotateScopeToken(SS, !WasScopeAnnotation);
666 return false;
667}
668
669/// ParseTypeParameter - Parse a template type parameter (C++ [temp.param]).
670/// Other kinds of template parameters are parsed in
671/// ParseTemplateTemplateParameter and ParseNonTypeTemplateParameter.
672///
673/// type-parameter: [C++ temp.param]
674/// 'class' ...[opt][C++0x] identifier[opt]
675/// 'class' identifier[opt] '=' type-id
676/// 'typename' ...[opt][C++0x] identifier[opt]
677/// 'typename' identifier[opt] '=' type-id
678NamedDecl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) {
679 assert((Tok.isOneOf(tok::kw_class, tok::kw_typename) ||
680 isTypeConstraintAnnotation()) &&
681 "A type-parameter starts with 'class', 'typename' or a "
682 "type-constraint");
683
684 CXXScopeSpec TypeConstraintSS;
686 bool TypenameKeyword = false;
687 SourceLocation KeyLoc;
688 ParseOptionalCXXScopeSpecifier(TypeConstraintSS, /*ObjectType=*/nullptr,
689 /*ObjectHasErrors=*/false,
690 /*EnteringContext*/ false);
691 if (Tok.is(tok::annot_template_id)) {
692 // Consume the 'type-constraint'.
694 static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
695 assert(TypeConstraint->Kind == TNK_Concept_template &&
696 "stray non-concept template-id annotation");
697 KeyLoc = ConsumeAnnotationToken();
698 } else {
699 assert(TypeConstraintSS.isEmpty() &&
700 "expected type constraint after scope specifier");
701
702 // Consume the 'class' or 'typename' keyword.
703 TypenameKeyword = Tok.is(tok::kw_typename);
704 KeyLoc = ConsumeToken();
705 }
706
707 // Grab the ellipsis (if given).
708 SourceLocation EllipsisLoc;
709 if (TryConsumeToken(tok::ellipsis, EllipsisLoc)) {
710 Diag(EllipsisLoc,
712 ? diag::warn_cxx98_compat_variadic_templates
713 : diag::ext_variadic_templates);
714 }
715
716 // Grab the template parameter name (if given)
717 SourceLocation NameLoc = Tok.getLocation();
718 IdentifierInfo *ParamName = nullptr;
719 if (Tok.is(tok::identifier)) {
720 ParamName = Tok.getIdentifierInfo();
721 ConsumeToken();
722 } else if (Tok.isOneOf(tok::equal, tok::comma, tok::greater,
723 tok::greatergreater)) {
724 // Unnamed template parameter. Don't have to do anything here, just
725 // don't consume this token.
726 } else {
727 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
728 return nullptr;
729 }
730
731 // Recover from misplaced ellipsis.
732 bool AlreadyHasEllipsis = EllipsisLoc.isValid();
733 if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
734 DiagnoseMisplacedEllipsis(EllipsisLoc, NameLoc, AlreadyHasEllipsis, true);
735
736 // Grab a default argument (if available).
737 // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
738 // we introduce the type parameter into the local scope.
739 SourceLocation EqualLoc;
740 ParsedType DefaultArg;
741 std::optional<DelayTemplateIdDestructionRAII> DontDestructTemplateIds;
742 if (TryConsumeToken(tok::equal, EqualLoc)) {
743 // The default argument might contain a lambda declaration; avoid destroying
744 // parsed template ids at the end of that declaration because they can be
745 // used in a type constraint later.
746 DontDestructTemplateIds.emplace(*this, /*DelayTemplateIdDestruction=*/true);
747 // The default argument may declare template parameters, notably
748 // if it contains a generic lambda, so we need to increase
749 // the template depth as these parameters would not be instantiated
750 // at the current level.
751 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
752 ++CurTemplateDepthTracker;
753 DefaultArg =
755 .get();
756 }
757
758 NamedDecl *NewDecl = Actions.ActOnTypeParameter(getCurScope(),
759 TypenameKeyword, EllipsisLoc,
760 KeyLoc, ParamName, NameLoc,
761 Depth, Position, EqualLoc,
762 DefaultArg,
763 TypeConstraint != nullptr);
764
765 if (TypeConstraint) {
766 Actions.ActOnTypeConstraint(TypeConstraintSS, TypeConstraint,
767 cast<TemplateTypeParmDecl>(NewDecl),
768 EllipsisLoc);
769 }
770
771 return NewDecl;
772}
773
774/// ParseTemplateTemplateParameter - Handle the parsing of template
775/// template parameters.
776///
777/// type-parameter: [C++ temp.param]
778/// template-head type-parameter-key ...[opt] identifier[opt]
779/// template-head type-parameter-key identifier[opt] = id-expression
780/// type-parameter-key:
781/// 'class'
782/// 'typename' [C++1z]
783/// template-head: [C++2a]
784/// 'template' '<' template-parameter-list '>'
785/// requires-clause[opt]
786NamedDecl *Parser::ParseTemplateTemplateParameter(unsigned Depth,
787 unsigned Position) {
788 assert(Tok.is(tok::kw_template) && "Expected 'template' keyword");
789
790 // Handle the template <...> part.
791 SourceLocation TemplateLoc = ConsumeToken();
792 SmallVector<NamedDecl*,8> TemplateParams;
793 SourceLocation LAngleLoc, RAngleLoc;
794 ExprResult OptionalRequiresClauseConstraintER;
795 {
796 MultiParseScope TemplateParmScope(*this);
797 if (ParseTemplateParameters(TemplateParmScope, Depth + 1, TemplateParams,
798 LAngleLoc, RAngleLoc)) {
799 return nullptr;
800 }
801 if (TryConsumeToken(tok::kw_requires)) {
802 OptionalRequiresClauseConstraintER =
804 /*IsTrailingRequiresClause=*/false));
805 if (!OptionalRequiresClauseConstraintER.isUsable()) {
806 SkipUntil(tok::comma, tok::greater, tok::greatergreater,
808 return nullptr;
809 }
810 }
811 }
812
813 // Provide an ExtWarn if the C++1z feature of using 'typename' here is used.
814 // Generate a meaningful error if the user forgot to put class before the
815 // identifier, comma, or greater. Provide a fixit if the identifier, comma,
816 // or greater appear immediately or after 'struct'. In the latter case,
817 // replace the keyword with 'class'.
818 bool TypenameKeyword = false;
819 if (!TryConsumeToken(tok::kw_class)) {
820 bool Replace = Tok.isOneOf(tok::kw_typename, tok::kw_struct);
821 const Token &Next = Tok.is(tok::kw_struct) ? NextToken() : Tok;
822 if (Tok.is(tok::kw_typename)) {
823 TypenameKeyword = true;
824 Diag(Tok.getLocation(),
826 ? diag::warn_cxx14_compat_template_template_param_typename
827 : diag::ext_template_template_param_typename)
828 << (!getLangOpts().CPlusPlus17
830 : FixItHint());
831 } else if (Next.isOneOf(tok::identifier, tok::comma, tok::greater,
832 tok::greatergreater, tok::ellipsis)) {
833 Diag(Tok.getLocation(), diag::err_class_on_template_template_param)
834 << getLangOpts().CPlusPlus17
835 << (Replace
837 : FixItHint::CreateInsertion(Tok.getLocation(), "class "));
838 } else
839 Diag(Tok.getLocation(), diag::err_class_on_template_template_param)
840 << getLangOpts().CPlusPlus17;
841
842 if (Replace)
843 ConsumeToken();
844 }
845
846 // Parse the ellipsis, if given.
847 SourceLocation EllipsisLoc;
848 if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
849 Diag(EllipsisLoc,
851 ? diag::warn_cxx98_compat_variadic_templates
852 : diag::ext_variadic_templates);
853
854 // Get the identifier, if given.
855 SourceLocation NameLoc = Tok.getLocation();
856 IdentifierInfo *ParamName = nullptr;
857 if (Tok.is(tok::identifier)) {
858 ParamName = Tok.getIdentifierInfo();
859 ConsumeToken();
860 } else if (Tok.isOneOf(tok::equal, tok::comma, tok::greater,
861 tok::greatergreater)) {
862 // Unnamed template parameter. Don't have to do anything here, just
863 // don't consume this token.
864 } else {
865 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
866 return nullptr;
867 }
868
869 // Recover from misplaced ellipsis.
870 bool AlreadyHasEllipsis = EllipsisLoc.isValid();
871 if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
872 DiagnoseMisplacedEllipsis(EllipsisLoc, NameLoc, AlreadyHasEllipsis, true);
873
875 Depth, SourceLocation(), TemplateLoc, LAngleLoc, TemplateParams,
876 RAngleLoc, OptionalRequiresClauseConstraintER.get());
877
878 // Grab a default argument (if available).
879 // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
880 // we introduce the template parameter into the local scope.
881 SourceLocation EqualLoc;
882 ParsedTemplateArgument DefaultArg;
883 if (TryConsumeToken(tok::equal, EqualLoc)) {
884 DefaultArg = ParseTemplateTemplateArgument();
885 if (DefaultArg.isInvalid()) {
886 Diag(Tok.getLocation(),
887 diag::err_default_template_template_parameter_not_template);
888 SkipUntil(tok::comma, tok::greater, tok::greatergreater,
890 }
891 }
892
893 return Actions.ActOnTemplateTemplateParameter(
894 getCurScope(), TemplateLoc, ParamList, TypenameKeyword, EllipsisLoc,
895 ParamName, NameLoc, Depth, Position, EqualLoc, DefaultArg);
896}
897
898/// ParseNonTypeTemplateParameter - Handle the parsing of non-type
899/// template parameters (e.g., in "template<int Size> class array;").
900///
901/// template-parameter:
902/// ...
903/// parameter-declaration
904NamedDecl *
905Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) {
906 // Parse the declaration-specifiers (i.e., the type).
907 // FIXME: The type should probably be restricted in some way... Not all
908 // declarators (parts of declarators?) are accepted for parameters.
909 DeclSpec DS(AttrFactory);
910 ParsedTemplateInfo TemplateInfo;
911 ParseDeclarationSpecifiers(DS, TemplateInfo, AS_none,
912 DeclSpecContext::DSC_template_param);
913
914 // Parse this as a typename.
917 ParseDeclarator(ParamDecl);
918 if (DS.getTypeSpecType() == DeclSpec::TST_unspecified) {
919 Diag(Tok.getLocation(), diag::err_expected_template_parameter);
920 return nullptr;
921 }
922
923 // Recover from misplaced ellipsis.
924 SourceLocation EllipsisLoc;
925 if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
926 DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, ParamDecl);
927
928 // If there is a default value, parse it.
929 // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
930 // we introduce the template parameter into the local scope.
931 SourceLocation EqualLoc;
932 ExprResult DefaultArg;
933 if (TryConsumeToken(tok::equal, EqualLoc)) {
934 if (Tok.is(tok::l_paren) && NextToken().is(tok::l_brace)) {
935 Diag(Tok.getLocation(), diag::err_stmt_expr_in_default_arg) << 1;
936 SkipUntil(tok::comma, tok::greater, StopAtSemi | StopBeforeMatch);
937 } else {
938 // C++ [temp.param]p15:
939 // When parsing a default template-argument for a non-type
940 // template-parameter, the first non-nested > is taken as the
941 // end of the template-parameter-list rather than a greater-than
942 // operator.
943 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
944
945 // The default argument may declare template parameters, notably
946 // if it contains a generic lambda, so we need to increase
947 // the template depth as these parameters would not be instantiated
948 // at the current level.
949 TemplateParameterDepthRAII CurTemplateDepthTracker(
950 TemplateParameterDepth);
951 ++CurTemplateDepthTracker;
952 EnterExpressionEvaluationContext ConstantEvaluated(
954 DefaultArg = Actions.CorrectDelayedTyposInExpr(ParseInitializer());
955 if (DefaultArg.isInvalid())
956 SkipUntil(tok::comma, tok::greater, StopAtSemi | StopBeforeMatch);
957 }
958 }
959
960 // Create the parameter.
961 return Actions.ActOnNonTypeTemplateParameter(getCurScope(), ParamDecl,
962 Depth, Position, EqualLoc,
963 DefaultArg.get());
964}
965
966void Parser::DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
967 SourceLocation CorrectLoc,
968 bool AlreadyHasEllipsis,
969 bool IdentifierHasName) {
970 FixItHint Insertion;
971 if (!AlreadyHasEllipsis)
972 Insertion = FixItHint::CreateInsertion(CorrectLoc, "...");
973 Diag(EllipsisLoc, diag::err_misplaced_ellipsis_in_declaration)
974 << FixItHint::CreateRemoval(EllipsisLoc) << Insertion
975 << !IdentifierHasName;
976}
977
978void Parser::DiagnoseMisplacedEllipsisInDeclarator(SourceLocation EllipsisLoc,
979 Declarator &D) {
980 assert(EllipsisLoc.isValid());
981 bool AlreadyHasEllipsis = D.getEllipsisLoc().isValid();
982 if (!AlreadyHasEllipsis)
983 D.setEllipsisLoc(EllipsisLoc);
984 DiagnoseMisplacedEllipsis(EllipsisLoc, D.getIdentifierLoc(),
985 AlreadyHasEllipsis, D.hasName());
986}
987
988/// Parses a '>' at the end of a template list.
989///
990/// If this function encounters '>>', '>>>', '>=', or '>>=', it tries
991/// to determine if these tokens were supposed to be a '>' followed by
992/// '>', '>>', '>=', or '>='. It emits an appropriate diagnostic if necessary.
993///
994/// \param RAngleLoc the location of the consumed '>'.
995///
996/// \param ConsumeLastToken if true, the '>' is consumed.
997///
998/// \param ObjCGenericList if true, this is the '>' closing an Objective-C
999/// type parameter or type argument list, rather than a C++ template parameter
1000/// or argument list.
1001///
1002/// \returns true, if current token does not start with '>', false otherwise.
1003bool Parser::ParseGreaterThanInTemplateList(SourceLocation LAngleLoc,
1004 SourceLocation &RAngleLoc,
1005 bool ConsumeLastToken,
1006 bool ObjCGenericList) {
1007 // What will be left once we've consumed the '>'.
1008 tok::TokenKind RemainingToken;
1009 const char *ReplacementStr = "> >";
1010 bool MergeWithNextToken = false;
1011
1012 switch (Tok.getKind()) {
1013 default:
1014 Diag(getEndOfPreviousToken(), diag::err_expected) << tok::greater;
1015 Diag(LAngleLoc, diag::note_matching) << tok::less;
1016 return true;
1017
1018 case tok::greater:
1019 // Determine the location of the '>' token. Only consume this token
1020 // if the caller asked us to.
1021 RAngleLoc = Tok.getLocation();
1022 if (ConsumeLastToken)
1023 ConsumeToken();
1024 return false;
1025
1026 case tok::greatergreater:
1027 RemainingToken = tok::greater;
1028 break;
1029
1030 case tok::greatergreatergreater:
1031 RemainingToken = tok::greatergreater;
1032 break;
1033
1034 case tok::greaterequal:
1035 RemainingToken = tok::equal;
1036 ReplacementStr = "> =";
1037
1038 // Join two adjacent '=' tokens into one, for cases like:
1039 // void (*p)() = f<int>;
1040 // return f<int>==p;
1041 if (NextToken().is(tok::equal) &&
1042 areTokensAdjacent(Tok, NextToken())) {
1043 RemainingToken = tok::equalequal;
1044 MergeWithNextToken = true;
1045 }
1046 break;
1047
1048 case tok::greatergreaterequal:
1049 RemainingToken = tok::greaterequal;
1050 break;
1051 }
1052
1053 // This template-id is terminated by a token that starts with a '>'.
1054 // Outside C++11 and Objective-C, this is now error recovery.
1055 //
1056 // C++11 allows this when the token is '>>', and in CUDA + C++11 mode, we
1057 // extend that treatment to also apply to the '>>>' token.
1058 //
1059 // Objective-C allows this in its type parameter / argument lists.
1060
1061 SourceLocation TokBeforeGreaterLoc = PrevTokLocation;
1062 SourceLocation TokLoc = Tok.getLocation();
1063 Token Next = NextToken();
1064
1065 // Whether splitting the current token after the '>' would undesirably result
1066 // in the remaining token pasting with the token after it. This excludes the
1067 // MergeWithNextToken cases, which we've already handled.
1068 bool PreventMergeWithNextToken =
1069 (RemainingToken == tok::greater ||
1070 RemainingToken == tok::greatergreater) &&
1071 (Next.isOneOf(tok::greater, tok::greatergreater,
1072 tok::greatergreatergreater, tok::equal, tok::greaterequal,
1073 tok::greatergreaterequal, tok::equalequal)) &&
1074 areTokensAdjacent(Tok, Next);
1075
1076 // Diagnose this situation as appropriate.
1077 if (!ObjCGenericList) {
1078 // The source range of the replaced token(s).
1080 TokLoc, Lexer::AdvanceToTokenCharacter(TokLoc, 2, PP.getSourceManager(),
1081 getLangOpts()));
1082
1083 // A hint to put a space between the '>>'s. In order to make the hint as
1084 // clear as possible, we include the characters either side of the space in
1085 // the replacement, rather than just inserting a space at SecondCharLoc.
1086 FixItHint Hint1 = FixItHint::CreateReplacement(ReplacementRange,
1087 ReplacementStr);
1088
1089 // A hint to put another space after the token, if it would otherwise be
1090 // lexed differently.
1091 FixItHint Hint2;
1092 if (PreventMergeWithNextToken)
1093 Hint2 = FixItHint::CreateInsertion(Next.getLocation(), " ");
1094
1095 unsigned DiagId = diag::err_two_right_angle_brackets_need_space;
1096 if (getLangOpts().CPlusPlus11 &&
1097 (Tok.is(tok::greatergreater) || Tok.is(tok::greatergreatergreater)))
1098 DiagId = diag::warn_cxx98_compat_two_right_angle_brackets;
1099 else if (Tok.is(tok::greaterequal))
1100 DiagId = diag::err_right_angle_bracket_equal_needs_space;
1101 Diag(TokLoc, DiagId) << Hint1 << Hint2;
1102 }
1103
1104 // Find the "length" of the resulting '>' token. This is not always 1, as it
1105 // can contain escaped newlines.
1106 unsigned GreaterLength = Lexer::getTokenPrefixLength(
1107 TokLoc, 1, PP.getSourceManager(), getLangOpts());
1108
1109 // Annotate the source buffer to indicate that we split the token after the
1110 // '>'. This allows us to properly find the end of, and extract the spelling
1111 // of, the '>' token later.
1112 RAngleLoc = PP.SplitToken(TokLoc, GreaterLength);
1113
1114 // Strip the initial '>' from the token.
1115 bool CachingTokens = PP.IsPreviousCachedToken(Tok);
1116
1117 Token Greater = Tok;
1118 Greater.setLocation(RAngleLoc);
1119 Greater.setKind(tok::greater);
1120 Greater.setLength(GreaterLength);
1121
1122 unsigned OldLength = Tok.getLength();
1123 if (MergeWithNextToken) {
1124 ConsumeToken();
1125 OldLength += Tok.getLength();
1126 }
1127
1128 Tok.setKind(RemainingToken);
1129 Tok.setLength(OldLength - GreaterLength);
1130
1131 // Split the second token if lexing it normally would lex a different token
1132 // (eg, the fifth token in 'A<B>>>' should re-lex as '>', not '>>').
1133 SourceLocation AfterGreaterLoc = TokLoc.getLocWithOffset(GreaterLength);
1134 if (PreventMergeWithNextToken)
1135 AfterGreaterLoc = PP.SplitToken(AfterGreaterLoc, Tok.getLength());
1136 Tok.setLocation(AfterGreaterLoc);
1137
1138 // Update the token cache to match what we just did if necessary.
1139 if (CachingTokens) {
1140 // If the previous cached token is being merged, delete it.
1141 if (MergeWithNextToken)
1143
1144 if (ConsumeLastToken)
1146 else
1148 }
1149
1150 if (ConsumeLastToken) {
1151 PrevTokLocation = RAngleLoc;
1152 } else {
1153 PrevTokLocation = TokBeforeGreaterLoc;
1154 PP.EnterToken(Tok, /*IsReinject=*/true);
1155 Tok = Greater;
1156 }
1157
1158 return false;
1159}
1160
1161/// Parses a template-id that after the template name has
1162/// already been parsed.
1163///
1164/// This routine takes care of parsing the enclosed template argument
1165/// list ('<' template-parameter-list [opt] '>') and placing the
1166/// results into a form that can be transferred to semantic analysis.
1167///
1168/// \param ConsumeLastToken if true, then we will consume the last
1169/// token that forms the template-id. Otherwise, we will leave the
1170/// last token in the stream (e.g., so that it can be replaced with an
1171/// annotation token).
1172bool Parser::ParseTemplateIdAfterTemplateName(bool ConsumeLastToken,
1173 SourceLocation &LAngleLoc,
1174 TemplateArgList &TemplateArgs,
1175 SourceLocation &RAngleLoc,
1176 TemplateTy Template) {
1177 assert(Tok.is(tok::less) && "Must have already parsed the template-name");
1178
1179 // Consume the '<'.
1180 LAngleLoc = ConsumeToken();
1181
1182 // Parse the optional template-argument-list.
1183 bool Invalid = false;
1184 {
1185 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
1186 if (!Tok.isOneOf(tok::greater, tok::greatergreater,
1187 tok::greatergreatergreater, tok::greaterequal,
1188 tok::greatergreaterequal))
1189 Invalid = ParseTemplateArgumentList(TemplateArgs, Template, LAngleLoc);
1190
1191 if (Invalid) {
1192 // Try to find the closing '>'.
1194 SkipUntil(tok::greater, tok::greatergreater,
1195 tok::greatergreatergreater, StopAtSemi | StopBeforeMatch);
1196 else
1197 SkipUntil(tok::greater, StopAtSemi | StopBeforeMatch);
1198 }
1199 }
1200
1201 return ParseGreaterThanInTemplateList(LAngleLoc, RAngleLoc, ConsumeLastToken,
1202 /*ObjCGenericList=*/false) ||
1203 Invalid;
1204}
1205
1206/// Replace the tokens that form a simple-template-id with an
1207/// annotation token containing the complete template-id.
1208///
1209/// The first token in the stream must be the name of a template that
1210/// is followed by a '<'. This routine will parse the complete
1211/// simple-template-id and replace the tokens with a single annotation
1212/// token with one of two different kinds: if the template-id names a
1213/// type (and \p AllowTypeAnnotation is true), the annotation token is
1214/// a type annotation that includes the optional nested-name-specifier
1215/// (\p SS). Otherwise, the annotation token is a template-id
1216/// annotation that does not include the optional
1217/// nested-name-specifier.
1218///
1219/// \param Template the declaration of the template named by the first
1220/// token (an identifier), as returned from \c Action::isTemplateName().
1221///
1222/// \param TNK the kind of template that \p Template
1223/// refers to, as returned from \c Action::isTemplateName().
1224///
1225/// \param SS if non-NULL, the nested-name-specifier that precedes
1226/// this template name.
1227///
1228/// \param TemplateKWLoc if valid, specifies that this template-id
1229/// annotation was preceded by the 'template' keyword and gives the
1230/// location of that keyword. If invalid (the default), then this
1231/// template-id was not preceded by a 'template' keyword.
1232///
1233/// \param AllowTypeAnnotation if true (the default), then a
1234/// simple-template-id that refers to a class template, template
1235/// template parameter, or other template that produces a type will be
1236/// replaced with a type annotation token. Otherwise, the
1237/// simple-template-id is always replaced with a template-id
1238/// annotation token.
1239///
1240/// \param TypeConstraint if true, then this is actually a type-constraint,
1241/// meaning that the template argument list can be omitted (and the template in
1242/// question must be a concept).
1243///
1244/// If an unrecoverable parse error occurs and no annotation token can be
1245/// formed, this function returns true.
1246///
1247bool Parser::AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
1248 CXXScopeSpec &SS,
1249 SourceLocation TemplateKWLoc,
1251 bool AllowTypeAnnotation,
1252 bool TypeConstraint) {
1253 assert(getLangOpts().CPlusPlus && "Can only annotate template-ids in C++");
1254 assert((Tok.is(tok::less) || TypeConstraint) &&
1255 "Parser isn't at the beginning of a template-id");
1256 assert(!(TypeConstraint && AllowTypeAnnotation) && "type-constraint can't be "
1257 "a type annotation");
1258 assert((!TypeConstraint || TNK == TNK_Concept_template) && "type-constraint "
1259 "must accompany a concept name");
1260 assert((Template || TNK == TNK_Non_template) && "missing template name");
1261
1262 // Consume the template-name.
1263 SourceLocation TemplateNameLoc = TemplateName.getSourceRange().getBegin();
1264
1265 // Parse the enclosed template argument list.
1266 SourceLocation LAngleLoc, RAngleLoc;
1267 TemplateArgList TemplateArgs;
1268 bool ArgsInvalid = false;
1269 if (!TypeConstraint || Tok.is(tok::less)) {
1270 ArgsInvalid = ParseTemplateIdAfterTemplateName(
1271 false, LAngleLoc, TemplateArgs, RAngleLoc, Template);
1272 // If we couldn't recover from invalid arguments, don't form an annotation
1273 // token -- we don't know how much to annotate.
1274 // FIXME: This can lead to duplicate diagnostics if we retry parsing this
1275 // template-id in another context. Try to annotate anyway?
1276 if (RAngleLoc.isInvalid())
1277 return true;
1278 }
1279
1280 ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
1281
1282 // Build the annotation token.
1283 if (TNK == TNK_Type_template && AllowTypeAnnotation) {
1284 TypeResult Type = ArgsInvalid
1285 ? TypeError()
1286 : Actions.ActOnTemplateIdType(
1287 getCurScope(), SS, TemplateKWLoc, Template,
1288 TemplateName.Identifier, TemplateNameLoc,
1289 LAngleLoc, TemplateArgsPtr, RAngleLoc);
1290
1291 Tok.setKind(tok::annot_typename);
1292 setTypeAnnotation(Tok, Type);
1293 if (SS.isNotEmpty())
1294 Tok.setLocation(SS.getBeginLoc());
1295 else if (TemplateKWLoc.isValid())
1296 Tok.setLocation(TemplateKWLoc);
1297 else
1298 Tok.setLocation(TemplateNameLoc);
1299 } else {
1300 // Build a template-id annotation token that can be processed
1301 // later.
1302 Tok.setKind(tok::annot_template_id);
1303
1304 const IdentifierInfo *TemplateII =
1306 ? TemplateName.Identifier
1307 : nullptr;
1308
1309 OverloadedOperatorKind OpKind =
1311 ? OO_None
1312 : TemplateName.OperatorFunctionId.Operator;
1313
1315 TemplateKWLoc, TemplateNameLoc, TemplateII, OpKind, Template, TNK,
1316 LAngleLoc, RAngleLoc, TemplateArgs, ArgsInvalid, TemplateIds);
1317
1318 Tok.setAnnotationValue(TemplateId);
1319 if (TemplateKWLoc.isValid())
1320 Tok.setLocation(TemplateKWLoc);
1321 else
1322 Tok.setLocation(TemplateNameLoc);
1323 }
1324
1325 // Common fields for the annotation token
1326 Tok.setAnnotationEndLoc(RAngleLoc);
1327
1328 // In case the tokens were cached, have Preprocessor replace them with the
1329 // annotation token.
1330 PP.AnnotateCachedTokens(Tok);
1331 return false;
1332}
1333
1334/// Replaces a template-id annotation token with a type
1335/// annotation token.
1336///
1337/// If there was a failure when forming the type from the template-id,
1338/// a type annotation token will still be created, but will have a
1339/// NULL type pointer to signify an error.
1340///
1341/// \param SS The scope specifier appearing before the template-id, if any.
1342///
1343/// \param AllowImplicitTypename whether this is a context where T::type
1344/// denotes a dependent type.
1345/// \param IsClassName Is this template-id appearing in a context where we
1346/// know it names a class, such as in an elaborated-type-specifier or
1347/// base-specifier? ('typename' and 'template' are unneeded and disallowed
1348/// in those contexts.)
1349void Parser::AnnotateTemplateIdTokenAsType(
1350 CXXScopeSpec &SS, ImplicitTypenameContext AllowImplicitTypename,
1351 bool IsClassName) {
1352 assert(Tok.is(tok::annot_template_id) && "Requires template-id tokens");
1353
1354 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1355 assert(TemplateId->mightBeType() &&
1356 "Only works for type and dependent templates");
1357
1358 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
1359 TemplateId->NumArgs);
1360
1362 TemplateId->isInvalid()
1363 ? TypeError()
1364 : Actions.ActOnTemplateIdType(
1365 getCurScope(), SS, TemplateId->TemplateKWLoc,
1366 TemplateId->Template, TemplateId->Name,
1367 TemplateId->TemplateNameLoc, TemplateId->LAngleLoc,
1368 TemplateArgsPtr, TemplateId->RAngleLoc,
1369 /*IsCtorOrDtorName=*/false, IsClassName, AllowImplicitTypename);
1370 // Create the new "type" annotation token.
1371 Tok.setKind(tok::annot_typename);
1372 setTypeAnnotation(Tok, Type);
1373 if (SS.isNotEmpty()) // it was a C++ qualified type name.
1374 Tok.setLocation(SS.getBeginLoc());
1375 // End location stays the same
1376
1377 // Replace the template-id annotation token, and possible the scope-specifier
1378 // that precedes it, with the typename annotation token.
1379 PP.AnnotateCachedTokens(Tok);
1380}
1381
1382/// Determine whether the given token can end a template argument.
1384 // FIXME: Handle '>>>'.
1385 return Tok.isOneOf(tok::comma, tok::greater, tok::greatergreater,
1386 tok::greatergreatergreater);
1387}
1388
1389/// Parse a C++ template template argument.
1390ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
1391 if (!Tok.is(tok::identifier) && !Tok.is(tok::coloncolon) &&
1392 !Tok.is(tok::annot_cxxscope))
1393 return ParsedTemplateArgument();
1394
1395 // C++0x [temp.arg.template]p1:
1396 // A template-argument for a template template-parameter shall be the name
1397 // of a class template or an alias template, expressed as id-expression.
1398 //
1399 // We parse an id-expression that refers to a class template or alias
1400 // template. The grammar we parse is:
1401 //
1402 // nested-name-specifier[opt] template[opt] identifier ...[opt]
1403 //
1404 // followed by a token that terminates a template argument, such as ',',
1405 // '>', or (in some cases) '>>'.
1406 CXXScopeSpec SS; // nested-name-specifier, if present
1407 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
1408 /*ObjectHasErrors=*/false,
1409 /*EnteringContext=*/false);
1410
1412 SourceLocation EllipsisLoc;
1413 if (SS.isSet() && Tok.is(tok::kw_template)) {
1414 // Parse the optional 'template' keyword following the
1415 // nested-name-specifier.
1416 SourceLocation TemplateKWLoc = ConsumeToken();
1417
1418 if (Tok.is(tok::identifier)) {
1419 // We appear to have a dependent template name.
1420 UnqualifiedId Name;
1421 Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1422 ConsumeToken(); // the identifier
1423
1424 TryConsumeToken(tok::ellipsis, EllipsisLoc);
1425
1426 // If the next token signals the end of a template argument, then we have
1427 // a (possibly-dependent) template name that could be a template template
1428 // argument.
1429 TemplateTy Template;
1430 if (isEndOfTemplateArgument(Tok) &&
1431 Actions.ActOnTemplateName(getCurScope(), SS, TemplateKWLoc, Name,
1432 /*ObjectType=*/nullptr,
1433 /*EnteringContext=*/false, Template))
1434 Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
1435 }
1436 } else if (Tok.is(tok::identifier)) {
1437 // We may have a (non-dependent) template name.
1438 TemplateTy Template;
1439 UnqualifiedId Name;
1440 Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1441 ConsumeToken(); // the identifier
1442
1443 TryConsumeToken(tok::ellipsis, EllipsisLoc);
1444
1445 if (isEndOfTemplateArgument(Tok)) {
1446 bool MemberOfUnknownSpecialization;
1447 TemplateNameKind TNK = Actions.isTemplateName(
1448 getCurScope(), SS,
1449 /*hasTemplateKeyword=*/false, Name,
1450 /*ObjectType=*/nullptr,
1451 /*EnteringContext=*/false, Template, MemberOfUnknownSpecialization);
1452 if (TNK == TNK_Dependent_template_name || TNK == TNK_Type_template) {
1453 // We have an id-expression that refers to a class template or
1454 // (C++0x) alias template.
1455 Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
1456 }
1457 }
1458 }
1459
1460 // If this is a pack expansion, build it as such.
1461 if (EllipsisLoc.isValid() && !Result.isInvalid())
1462 Result = Actions.ActOnPackExpansion(Result, EllipsisLoc);
1463
1464 return Result;
1465}
1466
1467/// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]).
1468///
1469/// template-argument: [C++ 14.2]
1470/// constant-expression
1471/// type-id
1472/// id-expression
1473/// braced-init-list [C++26, DR]
1474///
1475ParsedTemplateArgument Parser::ParseTemplateArgument() {
1476 // C++ [temp.arg]p2:
1477 // In a template-argument, an ambiguity between a type-id and an
1478 // expression is resolved to a type-id, regardless of the form of
1479 // the corresponding template-parameter.
1480 //
1481 // Therefore, we initially try to parse a type-id - and isCXXTypeId might look
1482 // up and annotate an identifier as an id-expression during disambiguation,
1483 // so enter the appropriate context for a constant expression template
1484 // argument before trying to disambiguate.
1485
1486 EnterExpressionEvaluationContext EnterConstantEvaluated(
1488 /*LambdaContextDecl=*/nullptr,
1490 if (isCXXTypeId(TypeIdAsTemplateArgument)) {
1491 TypeResult TypeArg = ParseTypeName(
1492 /*Range=*/nullptr, DeclaratorContext::TemplateArg);
1493 return Actions.ActOnTemplateTypeArgument(TypeArg);
1494 }
1495
1496 // Try to parse a template template argument.
1497 {
1498 TentativeParsingAction TPA(*this);
1499
1500 ParsedTemplateArgument TemplateTemplateArgument
1501 = ParseTemplateTemplateArgument();
1502 if (!TemplateTemplateArgument.isInvalid()) {
1503 TPA.Commit();
1504 return TemplateTemplateArgument;
1505 }
1506
1507 // Revert this tentative parse to parse a non-type template argument.
1508 TPA.Revert();
1509 }
1510
1511 // Parse a non-type template argument.
1512 ExprResult ExprArg;
1514 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
1515 ExprArg = ParseBraceInitializer();
1516 else
1518 if (ExprArg.isInvalid() || !ExprArg.get()) {
1519 return ParsedTemplateArgument();
1520 }
1521
1523 ExprArg.get(), Loc);
1524}
1525
1526/// ParseTemplateArgumentList - Parse a C++ template-argument-list
1527/// (C++ [temp.names]). Returns true if there was an error.
1528///
1529/// template-argument-list: [C++ 14.2]
1530/// template-argument
1531/// template-argument-list ',' template-argument
1532///
1533/// \param Template is only used for code completion, and may be null.
1534bool Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs,
1535 TemplateTy Template,
1536 SourceLocation OpenLoc) {
1537
1538 ColonProtectionRAIIObject ColonProtection(*this, false);
1539
1540 auto RunSignatureHelp = [&] {
1541 if (!Template)
1542 return QualType();
1543 CalledSignatureHelp = true;
1545 Template, TemplateArgs, OpenLoc);
1546 };
1547
1548 do {
1549 PreferredType.enterFunctionArgument(Tok.getLocation(), RunSignatureHelp);
1550 ParsedTemplateArgument Arg = ParseTemplateArgument();
1551 SourceLocation EllipsisLoc;
1552 if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
1553 Arg = Actions.ActOnPackExpansion(Arg, EllipsisLoc);
1554
1555 if (Arg.isInvalid()) {
1556 if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
1557 RunSignatureHelp();
1558 return true;
1559 }
1560
1561 // Save this template argument.
1562 TemplateArgs.push_back(Arg);
1563
1564 // If the next token is a comma, consume it and keep reading
1565 // arguments.
1566 } while (TryConsumeToken(tok::comma));
1567
1568 return false;
1569}
1570
1571/// Parse a C++ explicit template instantiation
1572/// (C++ [temp.explicit]).
1573///
1574/// explicit-instantiation:
1575/// 'extern' [opt] 'template' declaration
1576///
1577/// Note that the 'extern' is a GNU extension and C++11 feature.
1578Parser::DeclGroupPtrTy Parser::ParseExplicitInstantiation(
1579 DeclaratorContext Context, SourceLocation ExternLoc,
1580 SourceLocation TemplateLoc, SourceLocation &DeclEnd,
1581 ParsedAttributes &AccessAttrs, AccessSpecifier AS) {
1582 // This isn't really required here.
1584 ParsingTemplateParams(*this, ParsingDeclRAIIObject::NoParent);
1585 ParsedTemplateInfo TemplateInfo(ExternLoc, TemplateLoc);
1586 return ParseDeclarationAfterTemplate(
1587 Context, TemplateInfo, ParsingTemplateParams, DeclEnd, AccessAttrs, AS);
1588}
1589
1590SourceRange Parser::ParsedTemplateInfo::getSourceRange() const {
1591 if (TemplateParams)
1592 return getTemplateParamsRange(TemplateParams->data(),
1593 TemplateParams->size());
1594
1595 SourceRange R(TemplateLoc);
1596 if (ExternLoc.isValid())
1597 R.setBegin(ExternLoc);
1598 return R;
1599}
1600
1601void Parser::LateTemplateParserCallback(void *P, LateParsedTemplate &LPT) {
1602 ((Parser *)P)->ParseLateTemplatedFuncDef(LPT);
1603}
1604
1605/// Late parse a C++ function template in Microsoft mode.
1606void Parser::ParseLateTemplatedFuncDef(LateParsedTemplate &LPT) {
1607 if (!LPT.D)
1608 return;
1609
1610 // Destroy TemplateIdAnnotations when we're done, if possible.
1611 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*this);
1612
1613 // Get the FunctionDecl.
1614 FunctionDecl *FunD = LPT.D->getAsFunction();
1615 // Track template parameter depth.
1616 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1617
1618 // To restore the context after late parsing.
1619 Sema::ContextRAII GlobalSavedContext(
1620 Actions, Actions.Context.getTranslationUnitDecl());
1621
1622 MultiParseScope Scopes(*this);
1623
1624 // Get the list of DeclContexts to reenter.
1625 SmallVector<DeclContext*, 4> DeclContextsToReenter;
1626 for (DeclContext *DC = FunD; DC && !DC->isTranslationUnit();
1627 DC = DC->getLexicalParent())
1628 DeclContextsToReenter.push_back(DC);
1629
1630 // Reenter scopes from outermost to innermost.
1631 for (DeclContext *DC : reverse(DeclContextsToReenter)) {
1632 CurTemplateDepthTracker.addDepth(
1633 ReenterTemplateScopes(Scopes, cast<Decl>(DC)));
1634 Scopes.Enter(Scope::DeclScope);
1635 // We'll reenter the function context itself below.
1636 if (DC != FunD)
1637 Actions.PushDeclContext(Actions.getCurScope(), DC);
1638 }
1639
1640 // Parsing should occur with empty FP pragma stack and FP options used in the
1641 // point of the template definition.
1642 Sema::FpPragmaStackSaveRAII SavedStack(Actions);
1643 Actions.resetFPOptions(LPT.FPO);
1644
1645 assert(!LPT.Toks.empty() && "Empty body!");
1646
1647 // Append the current token at the end of the new token stream so that it
1648 // doesn't get lost.
1649 LPT.Toks.push_back(Tok);
1650 PP.EnterTokenStream(LPT.Toks, true, /*IsReinject*/true);
1651
1652 // Consume the previously pushed token.
1653 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
1654 assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try) &&
1655 "Inline method not starting with '{', ':' or 'try'");
1656
1657 // Parse the method body. Function body parsing code is similar enough
1658 // to be re-used for method bodies as well.
1659 ParseScope FnScope(this, Scope::FnScope | Scope::DeclScope |
1661
1662 // Recreate the containing function DeclContext.
1663 Sema::ContextRAII FunctionSavedContext(Actions, FunD->getLexicalParent());
1664
1665 Actions.ActOnStartOfFunctionDef(getCurScope(), FunD);
1666
1667 if (Tok.is(tok::kw_try)) {
1668 ParseFunctionTryBlock(LPT.D, FnScope);
1669 } else {
1670 if (Tok.is(tok::colon))
1671 ParseConstructorInitializer(LPT.D);
1672 else
1673 Actions.ActOnDefaultCtorInitializers(LPT.D);
1674
1675 if (Tok.is(tok::l_brace)) {
1676 assert((!isa<FunctionTemplateDecl>(LPT.D) ||
1677 cast<FunctionTemplateDecl>(LPT.D)
1678 ->getTemplateParameters()
1679 ->getDepth() == TemplateParameterDepth - 1) &&
1680 "TemplateParameterDepth should be greater than the depth of "
1681 "current template being instantiated!");
1682 ParseFunctionStatementBody(LPT.D, FnScope);
1683 Actions.UnmarkAsLateParsedTemplate(FunD);
1684 } else
1685 Actions.ActOnFinishFunctionBody(LPT.D, nullptr);
1686 }
1687}
1688
1689/// Lex a delayed template function for late parsing.
1690void Parser::LexTemplateFunctionForLateParsing(CachedTokens &Toks) {
1691 tok::TokenKind kind = Tok.getKind();
1692 if (!ConsumeAndStoreFunctionPrologue(Toks)) {
1693 // Consume everything up to (and including) the matching right brace.
1694 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
1695 }
1696
1697 // If we're in a function-try-block, we need to store all the catch blocks.
1698 if (kind == tok::kw_try) {
1699 while (Tok.is(tok::kw_catch)) {
1700 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
1701 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
1702 }
1703 }
1704}
1705
1706/// We've parsed something that could plausibly be intended to be a template
1707/// name (\p LHS) followed by a '<' token, and the following code can't possibly
1708/// be an expression. Determine if this is likely to be a template-id and if so,
1709/// diagnose it.
1710bool Parser::diagnoseUnknownTemplateId(ExprResult LHS, SourceLocation Less) {
1711 TentativeParsingAction TPA(*this);
1712 // FIXME: We could look at the token sequence in a lot more detail here.
1713 if (SkipUntil(tok::greater, tok::greatergreater, tok::greatergreatergreater,
1715 TPA.Commit();
1716
1718 ParseGreaterThanInTemplateList(Less, Greater, true, false);
1720 Less, Greater);
1721 return true;
1722 }
1723
1724 // There's no matching '>' token, this probably isn't supposed to be
1725 // interpreted as a template-id. Parse it as an (ill-formed) comparison.
1726 TPA.Revert();
1727 return false;
1728}
1729
1730void Parser::checkPotentialAngleBracket(ExprResult &PotentialTemplateName) {
1731 assert(Tok.is(tok::less) && "not at a potential angle bracket");
1732
1733 bool DependentTemplateName = false;
1734 if (!Actions.mightBeIntendedToBeTemplateName(PotentialTemplateName,
1736 return;
1737
1738 // OK, this might be a name that the user intended to be parsed as a
1739 // template-name, followed by a '<' token. Check for some easy cases.
1740
1741 // If we have potential_template<>, then it's supposed to be a template-name.
1742 if (NextToken().is(tok::greater) ||
1744 NextToken().isOneOf(tok::greatergreater, tok::greatergreatergreater))) {
1747 ParseGreaterThanInTemplateList(Less, Greater, true, false);
1749 getCurScope(), PotentialTemplateName, Less, Greater);
1750 // FIXME: Perform error recovery.
1751 PotentialTemplateName = ExprError();
1752 return;
1753 }
1754
1755 // If we have 'potential_template<type-id', assume it's supposed to be a
1756 // template-name if there's a matching '>' later on.
1757 {
1758 // FIXME: Avoid the tentative parse when NextToken() can't begin a type.
1759 TentativeParsingAction TPA(*this);
1761 if (isTypeIdUnambiguously() &&
1762 diagnoseUnknownTemplateId(PotentialTemplateName, Less)) {
1763 TPA.Commit();
1764 // FIXME: Perform error recovery.
1765 PotentialTemplateName = ExprError();
1766 return;
1767 }
1768 TPA.Revert();
1769 }
1770
1771 // Otherwise, remember that we saw this in case we see a potentially-matching
1772 // '>' token later on.
1773 AngleBracketTracker::Priority Priority =
1774 (DependentTemplateName ? AngleBracketTracker::DependentName
1775 : AngleBracketTracker::PotentialTypo) |
1776 (Tok.hasLeadingSpace() ? AngleBracketTracker::SpaceBeforeLess
1777 : AngleBracketTracker::NoSpaceBeforeLess);
1778 AngleBrackets.add(*this, PotentialTemplateName.get(), Tok.getLocation(),
1779 Priority);
1780}
1781
1782bool Parser::checkPotentialAngleBracketDelimiter(
1783 const AngleBracketTracker::Loc &LAngle, const Token &OpToken) {
1784 // If a comma in an expression context is followed by a type that can be a
1785 // template argument and cannot be an expression, then this is ill-formed,
1786 // but might be intended to be part of a template-id.
1787 if (OpToken.is(tok::comma) && isTypeIdUnambiguously() &&
1788 diagnoseUnknownTemplateId(LAngle.TemplateName, LAngle.LessLoc)) {
1789 AngleBrackets.clear(*this);
1790 return true;
1791 }
1792
1793 // If a context that looks like a template-id is followed by '()', then
1794 // this is ill-formed, but might be intended to be a template-id
1795 // followed by '()'.
1796 if (OpToken.is(tok::greater) && Tok.is(tok::l_paren) &&
1797 NextToken().is(tok::r_paren)) {
1799 getCurScope(), LAngle.TemplateName, LAngle.LessLoc,
1800 OpToken.getLocation());
1801 AngleBrackets.clear(*this);
1802 return true;
1803 }
1804
1805 // After a '>' (etc), we're no longer potentially in a construct that's
1806 // intended to be treated as a template-id.
1807 if (OpToken.is(tok::greater) ||
1809 OpToken.isOneOf(tok::greatergreater, tok::greatergreatergreater)))
1810 AngleBrackets.clear(*this);
1811 return false;
1812}
Defines the clang::ASTContext interface.
StringRef P
const Decl * D
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:1152
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
int Priority
Definition: Format.cpp:2993
StringRef Identifier
Definition: Format.cpp:2997
static bool isEndOfTemplateArgument(Token Tok)
Determine whether the given token can end a template argument.
static constexpr bool isOneOf()
uint32_t Id
Definition: SemaARM.cpp:1143
SourceLocation Loc
Definition: SemaObjC.cpp:758
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1094
PtrTy get() const
Definition: Ownership.h:170
bool isInvalid() const
Definition: Ownership.h:166
bool isUsable() const
Definition: Ownership.h:168
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:74
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:210
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:84
bool isSet() const
Deprecated.
Definition: DeclSpec.h:228
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:213
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:208
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed.
Declaration of a C++20 concept.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1425
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:2095
bool isTranslationUnit() const
Definition: DeclBase.h:2155
Captures information about "declaration specifiers".
Definition: DeclSpec.h:247
static const TST TST_unspecified
Definition: DeclSpec.h:278
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:154
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:249
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1900
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:491
RAII object that enters a new expression evaluation context.
This represents one expression.
Definition: Expr.h:110
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:71
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition: Diagnostic.h:134
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:123
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:97
Represents a function declaration or definition.
Definition: Decl.h:1932
RAII object that makes '>' behave either as an operator or as the closing angle bracket for a templat...
One of these records is kept for each identifier that is lexed.
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token,...
Definition: Lexer.h:399
static unsigned getTokenPrefixLength(SourceLocation TokStart, unsigned CharNo, const SourceManager &SM, const LangOptions &LangOpts)
Get the physical length (including trigraphs and escaped newlines) of the first Characters characters...
Definition: Lexer.cpp:791
This represents a decl that may have a name.
Definition: Decl.h:249
Wrapper for void* pointer.
Definition: Ownership.h:50
static const ParsedAttributesView & none()
Definition: ParsedAttr.h:838
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:958
Represents the parsed form of a C++ template argument.
@ NonType
A non-type template parameter, stored as an expression.
bool isInvalid() const
Determine whether the given template argument is invalid.
Introduces zero or more scopes for parsing.
Definition: Parser.h:1209
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:58
TypeResult ParseTypeName(SourceRange *Range=nullptr, DeclaratorContext Context=DeclaratorContext::TypeName, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)
ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].
Definition: ParseDecl.cpp:50
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:81
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:548
AttributeFactory & getAttrFactory()
Definition: Parser.h:499
ExprResult ParseConstraintLogicalOrExpression(bool IsTrailingRequiresClause)
Parse a constraint-logical-or-expression.
Definition: ParseExpr.cpp:380
bool ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, SourceLocation *TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type.
Definition: Parser.h:576
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:556
Scope * getCurScope() const
Definition: Parser.h:502
SourceLocation getEndOfPreviousToken()
Definition: Parser.h:594
OpaquePtr< TemplateName > TemplateTy
Definition: Parser.h:514
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Definition: Parser.h:1294
ExprResult ParseConstantExpressionInExprEvalContext(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:223
const LangOptions & getLangOpts() const
Definition: Parser.h:495
@ StopBeforeMatch
Stop skipping at specified token, but don't skip the token itself.
Definition: Parser.h:1275
@ StopAtSemi
Stop skipping at semicolon.
Definition: Parser.h:1273
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:872
ExprResult ParseConstraintExpression()
Parse a constraint-expression.
Definition: ParseExpr.cpp:266
SmallVector< TemplateParameterList *, 4 > TemplateParameterLists
Definition: Parser.h:516
unsigned ReenterTemplateScopes(MultiParseScope &S, Decl *D)
Re-enter the template scopes for a declaration that might be a template.
RAII object used to inform the actions that we're currently parsing a declaration.
A class for parsing a DeclSpec.
void enterFunctionArgument(SourceLocation Tok, llvm::function_ref< QualType()> ComputeType)
Computing a type for the function argument may require running overloading, so we postpone its comput...
void EnterToken(const Token &Tok, bool IsReinject)
Enters a token in the token stream to be lexed next.
bool IsPreviousCachedToken(const Token &Tok) const
Whether Tok is the most recent token (CachedLexPos - 1) in CachedTokens.
Definition: PPCaching.cpp:139
void AnnotateCachedTokens(const Token &Tok)
We notify the Preprocessor that if it is caching tokens (because backtrack is enabled) it should repl...
SourceManager & getSourceManager() const
SourceLocation SplitToken(SourceLocation TokLoc, unsigned Length)
Split the first Length characters out of the token starting at TokLoc and return a location pointing ...
void ReplacePreviousCachedToken(ArrayRef< Token > NewToks)
Replace token in CachedLexPos - 1 in CachedTokens by the tokens in NewToks.
Definition: PPCaching.cpp:157
bool isCodeCompletionReached() const
Returns true if code-completion is enabled and we have hit the code-completion point.
A (possibly-)qualified type.
Definition: Type.h:941
Represents a struct/union/class.
Definition: Decl.h:4141
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:81
@ CompoundStmtScope
This is a compound statement scope.
Definition: Scope.h:134
@ FnScope
This indicates that the scope corresponds to a function, which means that labels are set here.
Definition: Scope.h:51
@ DeclScope
This is a scope that can contain a declaration.
Definition: Scope.h:63
QualType ProduceTemplateArgumentSignatureHelp(TemplateTy, ArrayRef< ParsedTemplateArgument >, SourceLocation LAngleLoc)
A RAII object to temporarily push a declaration context.
Definition: Sema.h:3010
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:803
void ActOnDefinedDeclarationSpecifier(Decl *D)
Called once it is known whether a tag declaration is an anonymous union or struct.
Definition: SemaDecl.cpp:5290
TemplateParameterList * ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ActOnTemplateParameterList - Builds a TemplateParameterList, optionally constrained by RequiresClause...
NamedDecl * ActOnTemplateTemplateParameter(Scope *S, SourceLocation TmpLoc, TemplateParameterList *Params, bool Typename, SourceLocation EllipsisLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedTemplateArgument DefaultArg)
ActOnTemplateTemplateParameter - Called when a C++ template template parameter (e....
bool ActOnTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Decl * ActOnConceptDefinition(Scope *S, MultiTemplateParamsArg TemplateParameterLists, const IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr, const ParsedAttributesView &Attrs)
void UnmarkAsLateParsedTemplate(FunctionDecl *FD)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType)
Convert a parsed type into a parsed template argument.
ASTContext & Context
Definition: Sema.h:1002
void resetFPOptions(FPOptions FPO)
Definition: Sema.h:11039
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:71
NamedDecl * ActOnTypeParameter(Scope *S, bool Typename, SourceLocation EllipsisLoc, SourceLocation KeyLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedType DefaultArg, bool HasTypeConstraint)
ActOnTypeParameter - Called when a C++ template type parameter (e.g., "typename T") has been parsed.
SemaCodeCompletion & CodeCompletion()
Definition: Sema.h:1159
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
Definition: SemaDecl.cpp:15176
bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent)
Determine whether it's plausible that E was intended to be a template-name.
Definition: Sema.h:3389
TemplateNameKind ActOnTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)
Form a template name from a name that is syntactically required to name a template,...
unsigned ActOnReenterTemplateScope(Decl *Template, llvm::function_ref< Scope *()> EnterScope)
void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName, SourceLocation Less, SourceLocation Greater)
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
Definition: SemaDecl.cpp:15692
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion.
ExprResult ActOnRequiresClause(ExprResult ConstraintExpr)
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e....
Definition: SemaDecl.cpp:4776
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1306
NamedDecl * ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, unsigned Depth, unsigned Position, SourceLocation EqualLoc, Expr *DefaultArg)
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
A trivial tuple used to represent a source range.
Represents a C++ template name within the type system.
Definition: TemplateName.h:203
NameKind getKind() const
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
Token - This structure provides full information about a lexed token.
Definition: Token.h:36
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:187
SourceLocation getEndLoc() const
Definition: Token.h:159
void setAnnotationEndLoc(SourceLocation L)
Definition: Token.h:150
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:132
unsigned getLength() const
Definition: Token.h:135
void setLength(unsigned Len)
Definition: Token.h:141
void setKind(tok::TokenKind K)
Definition: Token.h:95
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
Definition: Token.h:99
void * getAnnotationValue() const
Definition: Token.h:234
tok::TokenKind getKind() const
Definition: Token.h:94
bool hasLeadingSpace() const
Return true if this token has whitespace before it.
Definition: Token.h:280
void setLocation(SourceLocation L)
Definition: Token.h:140
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:101
bool isNot(tok::TokenKind K) const
Definition: Token.h:100
void setAnnotationValue(void *val)
Definition: Token.h:238
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
Definition: ASTConcept.h:228
The base class of the type hierarchy.
Definition: Type.h:1829
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:1025
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:1113
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:68
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
The JSON file list parser is used to communicate input to InstallAPI.
ImplicitTypenameContext
Definition: DeclSpec.h:1883
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
@ OO_None
Not an overloaded operator.
Definition: OperatorKinds.h:22
@ CPlusPlus20
Definition: LangStandard.h:60
@ CPlusPlus
Definition: LangStandard.h:56
@ CPlusPlus11
Definition: LangStandard.h:57
@ CPlusPlus17
Definition: LangStandard.h:59
@ IK_Identifier
An identifier.
TypeResult TypeError()
Definition: Ownership.h:266
DeclaratorContext
Definition: DeclSpec.h:1850
@ Result
The result type of a method or function.
ExprResult ExprError()
Definition: Ownership.h:264
SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params, unsigned NumParams)
Retrieves the range of the given template parameter lists.
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
Definition: TemplateKinds.h:20
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
@ TNK_Dependent_template_name
The name refers to a dependent template name:
Definition: TemplateKinds.h:46
@ TNK_Concept_template
The name refers to a concept.
Definition: TemplateKinds.h:52
@ TNK_Non_template
The name does not refer to a template.
Definition: TemplateKinds.h:22
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
Definition: Ownership.h:229
const FunctionProtoType * T
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:120
@ AS_none
Definition: Specifiers.h:124
#define false
Definition: stdbool.h:26
Contains a late templated function.
Definition: Sema.h:15062
CachedTokens Toks
Definition: Sema.h:15063
FPOptions FPO
Floating-point options in the point of definition.
Definition: Sema.h:15067
Decl * D
The template function declaration to be late parsed.
Definition: Sema.h:15065
Information about a template-id annotation token.
TemplateNameKind Kind
The kind of template that Template refers to.
unsigned NumArgs
NumArgs - The number of template arguments.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
bool mightBeType() const
Determine whether this might be a type template.
static TemplateIdAnnotation * Create(SourceLocation TemplateKWLoc, SourceLocation TemplateNameLoc, const IdentifierInfo *Name, OverloadedOperatorKind OperatorKind, ParsedTemplateTy OpaqueTemplateName, TemplateNameKind TemplateKind, SourceLocation LAngleLoc, SourceLocation RAngleLoc, ArrayRef< ParsedTemplateArgument > TemplateArgs, bool ArgsInvalid, SmallVectorImpl< TemplateIdAnnotation * > &CleanupList)
Creates a new TemplateIdAnnotation with NumArgs arguments and appends it to List.