Ultrasimplistic sketch for the parsing of C++ template-ids. This won't
become useful or correct until we (1) parse template arguments
correctly, (2) have some way to turn template-ids into types,
declarators, etc., and (3) have a real representation of templates.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@61208 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Parse/MinimalAction.cpp b/lib/Parse/MinimalAction.cpp
index 5837810..c4e7ecc 100644
--- a/lib/Parse/MinimalAction.cpp
+++ b/lib/Parse/MinimalAction.cpp
@@ -73,6 +73,16 @@
return false;
}
+ /// isTemplateName - Determines whether the identifier II is a
+ /// template name in the current scope, and returns the template
+ /// declaration if II names a template. An optional CXXScope can be
+ /// passed to indicate the C++ scope in which the identifier will be
+ /// found.
+Action::DeclTy *MinimalAction::isTemplateName(IdentifierInfo &II, Scope *S,
+ const CXXScopeSpec *SS ) {
+ return 0;
+}
+
/// ActOnDeclarator - If this is a typedef declarator, we modify the
/// IdentifierInfo::FETokenInfo field to keep track of this fact, until S is
/// popped.
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 407aa9c..16e7e77 100644
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -1452,13 +1452,27 @@
if (Tok.is(tok::identifier)) {
assert(Tok.getIdentifierInfo() && "Not an identifier?");
- // Determine whether this identifier is a C++ constructor name or
- // a normal identifier.
- if (Actions.isCurrentClassName(*Tok.getIdentifierInfo(), CurScope)) {
+
+ // If this identifier is followed by a '<', we may have a template-id.
+ DeclTy *Template;
+ if (getLang().CPlusPlus && NextToken().is(tok::less) &&
+ (Template = Actions.isTemplateName(*Tok.getIdentifierInfo(),
+ CurScope))) {
+ IdentifierInfo *II = Tok.getIdentifierInfo();
+ AnnotateTemplateIdToken(Template, 0);
+ // FIXME: Set the declarator to a template-id. How? I don't
+ // know... for now, just use the identifier.
+ D.SetIdentifier(II, Tok.getLocation());
+ }
+ // If this identifier is the name of the current class, it's a
+ // constructor name.
+ else if (getLang().CPlusPlus &&
+ Actions.isCurrentClassName(*Tok.getIdentifierInfo(), CurScope))
D.setConstructor(Actions.isTypeName(*Tok.getIdentifierInfo(),
CurScope),
Tok.getLocation());
- } else
+ // This is a normal identifier.
+ else
D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
ConsumeToken();
goto PastIdentifier;
diff --git a/lib/Parse/ParseTemplate.cpp b/lib/Parse/ParseTemplate.cpp
index d21dc4a..5d0c4b5 100644
--- a/lib/Parse/ParseTemplate.cpp
+++ b/lib/Parse/ParseTemplate.cpp
@@ -46,8 +46,19 @@
// Try to parse the template parameters, and the declaration if
// successful.
DeclTy *TemplateDecl = 0;
- if(ParseTemplateParameters(0))
+ if (Tok.is(tok::less) && NextToken().is(tok::greater)) {
+ // This is a template specialization. Just consume the angle
+ // brackets and parse the declaration or function definition that
+ // follows.
+ // FIXME: Record somehow that we're in an explicit specialization.
+ ConsumeToken();
+ ConsumeToken();
+ TemplateParmScope.Exit();
TemplateDecl = ParseDeclarationOrFunctionDefinition();
+ } else {
+ if(ParseTemplateParameters(0))
+ TemplateDecl = ParseDeclarationOrFunctionDefinition();
+ }
return TemplateDecl;
}
@@ -243,7 +254,7 @@
/// ParseNonTypeTemplateParameter - Handle the parsing of non-type
/// template parameters (e.g., in "template<int Size> class array;").
-
+///
/// template-parameter:
/// ...
/// parameter-declaration
@@ -289,3 +300,96 @@
return Param;
}
+
+/// AnnotateTemplateIdToken - The current token is an identifier that
+/// refers to the template declaration Template, and is followed by a
+/// '<'. Turn this template-id into a template-id annotation token.
+void Parser::AnnotateTemplateIdToken(DeclTy *Template, const CXXScopeSpec *SS) {
+ assert(getLang().CPlusPlus && "Can only annotate template-ids in C++");
+ assert(Template && Tok.is(tok::identifier) && NextToken().is(tok::less) &&
+ "Parser isn't at the beginning of a template-id");
+
+ // Consume the template-name.
+ SourceLocation TemplateNameLoc = ConsumeToken();
+
+ // Consume the '<'.
+ SourceLocation LAngleLoc = ConsumeToken();
+
+ // Parse the optional template-argument-list.
+ TemplateArgList TemplateArgs;
+ if (Tok.isNot(tok::greater) && ParseTemplateArgumentList(TemplateArgs)) {
+ // Try to find the closing '>'.
+ SkipUntil(tok::greater, true, true);
+
+ // FIXME: What's our recovery strategy for failed template-argument-lists?
+ return;
+ }
+
+ if (Tok.isNot(tok::greater))
+ return;
+
+ // Determine the location of the '>'. We won't actually consume this
+ // token, because we'll be replacing it with the template-id.
+ SourceLocation RAngleLoc = Tok.getLocation();
+
+ Tok.setKind(tok::annot_template_id);
+ Tok.setAnnotationEndLoc(RAngleLoc);
+ Tok.setLocation(TemplateNameLoc);
+ if (SS && SS->isNotEmpty())
+ Tok.setLocation(SS->getBeginLoc());
+
+ TemplateIdAnnotation *TemplateId
+ = (TemplateIdAnnotation *)malloc(sizeof(TemplateIdAnnotation) +
+ sizeof(TemplateArgTy*) * TemplateArgs.size());
+ TemplateId->TemplateNameLoc = TemplateNameLoc;
+ TemplateId->Template = Template;
+ TemplateId->LAngleLoc = LAngleLoc;
+ TemplateId->NumArgs = TemplateArgs.size();
+ TemplateArgTy **Args = (TemplateArgTy**)(TemplateId + 1);
+ for (unsigned Arg = 0, ArgEnd = TemplateArgs.size(); Arg != ArgEnd; ++Arg)
+ Args[Arg] = TemplateArgs[Arg];
+ Tok.setAnnotationValue(TemplateId);
+
+ // In case the tokens were cached, have Preprocessor replace them with the
+ // annotation token.
+ PP.AnnotateCachedTokens(Tok);
+}
+
+/// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]).
+///
+/// template-argument: [C++ 14.2]
+/// assignment-expression
+/// type-id
+/// id-expression
+Parser::OwningTemplateArgResult Parser::ParseTemplateArgument() {
+ // FIXME: Implement this!
+ return TemplateArgError();
+}
+
+/// ParseTemplateArgumentList - Parse a C++ template-argument-list
+/// (C++ [temp.names]). Returns true if there was an error.
+///
+/// template-argument-list: [C++ 14.2]
+/// template-argument
+/// template-argument-list ',' template-argument
+bool Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs) {
+ while (true) {
+ OwningTemplateArgResult Arg = ParseTemplateArgument();
+ if (Arg.isInvalid()) {
+ SkipUntil(tok::comma, tok::greater, true, true);
+ return true;
+ }
+ else
+ TemplateArgs.push_back(Arg.release());
+
+ // If the next token is a comma, consume it and keep reading
+ // arguments.
+ if (Tok.isNot(tok::comma)) break;
+
+ // Consume the comma.
+ ConsumeToken();
+ }
+
+ return Tok.isNot(tok::greater);
+}
+
diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
index 058182e..48b0d5f 100644
--- a/lib/Parse/Parser.cpp
+++ b/lib/Parse/Parser.cpp
@@ -722,6 +722,7 @@
/// specifier, and another one to get the actual type inside
/// ParseDeclarationSpecifiers).
void Parser::TryAnnotateTypeOrScopeToken() {
+ // FIXME: what about template-ids?
if (Tok.is(tok::annot_qualtypename) || Tok.is(tok::annot_cxxscope))
return;
@@ -730,23 +731,39 @@
MaybeParseCXXScopeSpecifier(SS);
if (Tok.is(tok::identifier)) {
- TypeTy *Ty = Actions.isTypeName(*Tok.getIdentifierInfo(), CurScope, &SS);
- if (Ty) {
- // This is a typename. Replace the current token in-place with an
- // annotation type token.
- Tok.setKind(tok::annot_qualtypename);
- Tok.setAnnotationValue(Ty);
- Tok.setAnnotationEndLoc(Tok.getLocation());
- if (SS.isNotEmpty()) // it was a C++ qualified type name.
- Tok.setLocation(SS.getBeginLoc());
-
- // In case the tokens were cached, have Preprocessor replace them with the
- // annotation token.
- PP.AnnotateCachedTokens(Tok);
- return;
+ DeclTy *Template = 0;
+ // If this is a template-id, annotate the template-id token.
+ if (getLang().CPlusPlus && NextToken().is(tok::less) &&
+ (Template = Actions.isTemplateName(*Tok.getIdentifierInfo(), CurScope,
+ &SS)))
+ AnnotateTemplateIdToken(Template, &SS);
+ else {
+ // Determine whether the identifier is a type name.
+ TypeTy *Ty = Actions.isTypeName(*Tok.getIdentifierInfo(), CurScope, &SS);
+ if (Ty) {
+ // This is a typename. Replace the current token in-place with an
+ // annotation type token.
+ Tok.setKind(tok::annot_qualtypename);
+ Tok.setAnnotationValue(Ty);
+ Tok.setAnnotationEndLoc(Tok.getLocation());
+ if (SS.isNotEmpty()) // it was a C++ qualified type name.
+ Tok.setLocation(SS.getBeginLoc());
+
+ // In case the tokens were cached, have Preprocessor replace
+ // them with the annotation token.
+ PP.AnnotateCachedTokens(Tok);
+ return;
+ }
}
+
+ // We either have an identifier that is not a type name or we have
+ // just created a template-id that might be a type name. Both
+ // cases will be handled below.
}
+ // FIXME: check for a template-id token here, and look it up if it
+ // names a type.
+
if (SS.isNotEmpty()) {
// A C++ scope specifier that isn't followed by a typename.
// Push the current token back into the token stream (or revert it if it is