2007-07-11 21:01:13 +04:00
|
|
|
//===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 22:59:25 +03:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-07-11 21:01:13 +04:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the Expression parsing implementation for C++.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-01-29 08:15:15 +03:00
|
|
|
#include "clang/Parse/ParseDiagnostic.h"
|
2007-07-11 21:01:13 +04:00
|
|
|
#include "clang/Parse/Parser.h"
|
2008-08-22 19:38:55 +04:00
|
|
|
#include "clang/Parse/DeclSpec.h"
|
2009-11-03 04:35:08 +03:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
|
2007-07-11 21:01:13 +04:00
|
|
|
using namespace clang;
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \brief Parse global scope or nested-name-specifier if present.
|
2009-09-03 02:59:36 +04:00
|
|
|
///
|
|
|
|
/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
|
2009-09-09 19:08:12 +04:00
|
|
|
/// may be preceded by '::'). Note that this routine will not parse ::new or
|
2009-09-03 02:59:36 +04:00
|
|
|
/// ::delete; it will just leave them in the token stream.
|
2008-11-08 19:45:02 +03:00
|
|
|
///
|
|
|
|
/// '::'[opt] nested-name-specifier
|
|
|
|
/// '::'
|
|
|
|
///
|
|
|
|
/// nested-name-specifier:
|
|
|
|
/// type-name '::'
|
|
|
|
/// namespace-name '::'
|
|
|
|
/// nested-name-specifier identifier '::'
|
2009-09-03 02:59:36 +04:00
|
|
|
/// nested-name-specifier 'template'[opt] simple-template-id '::'
|
|
|
|
///
|
|
|
|
///
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \param SS the scope specifier that will be set to the parsed
|
2009-09-03 02:59:36 +04:00
|
|
|
/// nested-name-specifier (or empty)
|
|
|
|
///
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \param ObjectType if this nested-name-specifier is being parsed following
|
2009-09-03 02:59:36 +04:00
|
|
|
/// the "." or "->" of a member access expression, this parameter provides the
|
|
|
|
/// type of the object whose members are being accessed.
|
2008-11-08 19:45:02 +03:00
|
|
|
///
|
2009-09-03 02:59:36 +04:00
|
|
|
/// \param EnteringContext whether we will be entering into the context of
|
|
|
|
/// the nested-name-specifier after parsing it.
|
|
|
|
///
|
|
|
|
/// \returns true if a scope specifier was parsed.
|
Improve support for out-of-line definitions of nested templates and
their members, including member class template, member function
templates, and member classes and functions of member templates.
To actually parse the nested-name-specifiers that qualify the name of
an out-of-line definition of a member template, e.g.,
template<typename X> template<typename Y>
X Outer<X>::Inner1<Y>::foo(Y) {
return X();
}
we need to look for the template names (e.g., "Inner1") as a member of
the current instantiation (Outer<X>), even before we have entered the
scope of the current instantiation. Since we can't do this in general
(i.e., we should not be looking into all dependent
nested-name-specifiers as if they were the current instantiation), we
rely on the parser to tell us when it is parsing a declaration
specifier sequence, and, therefore, when we should consider the
current scope specifier to be a current instantiation.
Printing of complicated, dependent nested-name-specifiers may be
somewhat broken by this commit; I'll add tests for this issue and fix
the problem (if it still exists) in a subsequent commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@80044 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-26 02:51:20 +04:00
|
|
|
bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
|
2009-09-03 02:59:36 +04:00
|
|
|
Action::TypeTy *ObjectType,
|
Improve support for out-of-line definitions of nested templates and
their members, including member class template, member function
templates, and member classes and functions of member templates.
To actually parse the nested-name-specifiers that qualify the name of
an out-of-line definition of a member template, e.g.,
template<typename X> template<typename Y>
X Outer<X>::Inner1<Y>::foo(Y) {
return X();
}
we need to look for the template names (e.g., "Inner1") as a member of
the current instantiation (Outer<X>), even before we have entered the
scope of the current instantiation. Since we can't do this in general
(i.e., we should not be looking into all dependent
nested-name-specifiers as if they were the current instantiation), we
rely on the parser to tell us when it is parsing a declaration
specifier sequence, and, therefore, when we should consider the
current scope specifier to be a current instantiation.
Printing of complicated, dependent nested-name-specifiers may be
somewhat broken by this commit; I'll add tests for this issue and fix
the problem (if it still exists) in a subsequent commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@80044 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-26 02:51:20 +04:00
|
|
|
bool EnteringContext) {
|
2008-11-27 00:41:52 +03:00
|
|
|
assert(getLang().CPlusPlus &&
|
2009-01-05 04:24:05 +03:00
|
|
|
"Call sites of this function should be guarded by checking for C++");
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2008-11-08 19:45:02 +03:00
|
|
|
if (Tok.is(tok::annot_cxxscope)) {
|
2009-03-27 02:56:24 +03:00
|
|
|
SS.setScopeRep(Tok.getAnnotationValue());
|
2008-11-08 19:45:02 +03:00
|
|
|
SS.setRange(Tok.getAnnotationRange());
|
|
|
|
ConsumeToken();
|
2008-11-27 00:41:52 +03:00
|
|
|
return true;
|
2008-11-08 19:45:02 +03:00
|
|
|
}
|
2009-01-05 00:14:15 +03:00
|
|
|
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
bool HasScopeSpecifier = false;
|
|
|
|
|
2009-01-05 06:55:46 +03:00
|
|
|
if (Tok.is(tok::coloncolon)) {
|
|
|
|
// ::new and ::delete aren't nested-name-specifiers.
|
|
|
|
tok::TokenKind NextKind = NextToken().getKind();
|
|
|
|
if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
|
|
|
|
return false;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-01-05 03:13:00 +03:00
|
|
|
// '::' - Global scope qualifier.
|
2009-01-05 05:07:19 +03:00
|
|
|
SourceLocation CCLoc = ConsumeToken();
|
|
|
|
SS.setBeginLoc(CCLoc);
|
2009-03-27 02:56:24 +03:00
|
|
|
SS.setScopeRep(Actions.ActOnCXXGlobalScopeSpecifier(CurScope, CCLoc));
|
2009-01-05 05:07:19 +03:00
|
|
|
SS.setEndLoc(CCLoc);
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
HasScopeSpecifier = true;
|
2008-11-08 19:45:02 +03:00
|
|
|
}
|
|
|
|
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
while (true) {
|
2009-09-03 02:59:36 +04:00
|
|
|
if (HasScopeSpecifier) {
|
|
|
|
// C++ [basic.lookup.classref]p5:
|
|
|
|
// If the qualified-id has the form
|
2009-09-09 04:23:06 +04:00
|
|
|
//
|
2009-09-03 02:59:36 +04:00
|
|
|
// ::class-name-or-namespace-name::...
|
2009-09-09 04:23:06 +04:00
|
|
|
//
|
2009-09-03 02:59:36 +04:00
|
|
|
// the class-name-or-namespace-name is looked up in global scope as a
|
|
|
|
// class-name or namespace-name.
|
|
|
|
//
|
|
|
|
// To implement this, we clear out the object type as soon as we've
|
|
|
|
// seen a leading '::' or part of a nested-name-specifier.
|
|
|
|
ObjectType = 0;
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@82166 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-18 01:32:03 +04:00
|
|
|
|
|
|
|
if (Tok.is(tok::code_completion)) {
|
|
|
|
// Code completion for a nested-name-specifier, where the code
|
|
|
|
// code completion token follows the '::'.
|
|
|
|
Actions.CodeCompleteQualifiedId(CurScope, SS, EnteringContext);
|
|
|
|
ConsumeToken();
|
|
|
|
}
|
2009-09-03 02:59:36 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:47:46 +04:00
|
|
|
// nested-name-specifier:
|
|
|
|
// nested-name-specifier 'template'[opt] simple-template-id '::'
|
|
|
|
|
|
|
|
// Parse the optional 'template' keyword, then make sure we have
|
|
|
|
// 'identifier <' after it.
|
|
|
|
if (Tok.is(tok::kw_template)) {
|
2009-09-03 02:59:36 +04:00
|
|
|
// If we don't have a scope specifier or an object type, this isn't a
|
2009-08-29 08:08:08 +04:00
|
|
|
// nested-name-specifier, since they aren't allowed to start with
|
|
|
|
// 'template'.
|
2009-09-03 02:59:36 +04:00
|
|
|
if (!HasScopeSpecifier && !ObjectType)
|
2009-08-29 08:08:08 +04:00
|
|
|
break;
|
|
|
|
|
2009-06-26 07:47:46 +04:00
|
|
|
SourceLocation TemplateKWLoc = ConsumeToken();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:47:46 +04:00
|
|
|
if (Tok.isNot(tok::identifier)) {
|
2009-09-09 19:08:12 +04:00
|
|
|
Diag(Tok.getLocation(),
|
2009-06-26 07:47:46 +04:00
|
|
|
diag::err_id_after_template_in_nested_name_spec)
|
|
|
|
<< SourceRange(TemplateKWLoc);
|
|
|
|
break;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:47:46 +04:00
|
|
|
if (NextToken().isNot(tok::less)) {
|
|
|
|
Diag(NextToken().getLocation(),
|
|
|
|
diag::err_less_after_template_name_in_nested_name_spec)
|
|
|
|
<< Tok.getIdentifierInfo()->getName()
|
|
|
|
<< SourceRange(TemplateKWLoc, Tok.getLocation());
|
|
|
|
break;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
TemplateTy Template
|
2009-06-26 07:47:46 +04:00
|
|
|
= Actions.ActOnDependentTemplateName(TemplateKWLoc,
|
|
|
|
*Tok.getIdentifierInfo(),
|
2009-09-03 02:59:36 +04:00
|
|
|
Tok.getLocation(), SS,
|
|
|
|
ObjectType);
|
2009-08-29 08:08:08 +04:00
|
|
|
if (!Template)
|
|
|
|
break;
|
2009-06-26 08:27:47 +04:00
|
|
|
if (AnnotateTemplateIdToken(Template, TNK_Dependent_template_name,
|
|
|
|
&SS, TemplateKWLoc, false))
|
|
|
|
break;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:47:46 +04:00
|
|
|
continue;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
|
2009-09-09 19:08:12 +04:00
|
|
|
// We have
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
//
|
|
|
|
// simple-template-id '::'
|
|
|
|
//
|
|
|
|
// So we need to check whether the simple-template-id is of the
|
2009-03-31 04:43:58 +04:00
|
|
|
// right kind (it should name a type or be dependent), and then
|
|
|
|
// convert it into a type within the nested-name-specifier.
|
2009-09-09 19:08:12 +04:00
|
|
|
TemplateIdAnnotation *TemplateId
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
= static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
|
2008-11-27 00:41:52 +03:00
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
if (TemplateId->Kind == TNK_Type_template ||
|
2009-03-31 04:43:58 +04:00
|
|
|
TemplateId->Kind == TNK_Dependent_template_name) {
|
2009-04-02 01:51:26 +04:00
|
|
|
AnnotateTemplateIdTokenAsType(&SS);
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
assert(Tok.is(tok::annot_typename) &&
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
"AnnotateTemplateIdTokenAsType isn't working");
|
|
|
|
Token TypeToken = Tok;
|
|
|
|
ConsumeToken();
|
|
|
|
assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
|
|
|
|
SourceLocation CCLoc = ConsumeToken();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
if (!HasScopeSpecifier) {
|
|
|
|
SS.setBeginLoc(TypeToken.getLocation());
|
|
|
|
HasScopeSpecifier = true;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-04-02 01:51:26 +04:00
|
|
|
if (TypeToken.getAnnotationValue())
|
|
|
|
SS.setScopeRep(
|
2009-09-09 19:08:12 +04:00
|
|
|
Actions.ActOnCXXNestedNameSpecifier(CurScope, SS,
|
2009-04-02 01:51:26 +04:00
|
|
|
TypeToken.getAnnotationValue(),
|
|
|
|
TypeToken.getAnnotationRange(),
|
|
|
|
CCLoc));
|
|
|
|
else
|
|
|
|
SS.setScopeRep(0);
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
SS.setEndLoc(CCLoc);
|
|
|
|
continue;
|
2009-06-26 07:45:46 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:45:46 +04:00
|
|
|
assert(false && "FIXME: Only type template names supported here");
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
}
|
|
|
|
|
2009-06-26 07:52:38 +04:00
|
|
|
|
|
|
|
// The rest of the nested-name-specifier possibilities start with
|
|
|
|
// tok::identifier.
|
|
|
|
if (Tok.isNot(tok::identifier))
|
|
|
|
break;
|
|
|
|
|
|
|
|
IdentifierInfo &II = *Tok.getIdentifierInfo();
|
|
|
|
|
|
|
|
// nested-name-specifier:
|
|
|
|
// type-name '::'
|
|
|
|
// namespace-name '::'
|
|
|
|
// nested-name-specifier identifier '::'
|
|
|
|
Token Next = NextToken();
|
|
|
|
if (Next.is(tok::coloncolon)) {
|
|
|
|
// We have an identifier followed by a '::'. Lookup this name
|
|
|
|
// as the name in a nested-name-specifier.
|
|
|
|
SourceLocation IdLoc = ConsumeToken();
|
|
|
|
assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
|
|
|
|
SourceLocation CCLoc = ConsumeToken();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:52:38 +04:00
|
|
|
if (!HasScopeSpecifier) {
|
|
|
|
SS.setBeginLoc(IdLoc);
|
|
|
|
HasScopeSpecifier = true;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:52:38 +04:00
|
|
|
if (SS.isInvalid())
|
|
|
|
continue;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:52:38 +04:00
|
|
|
SS.setScopeRep(
|
Improve support for out-of-line definitions of nested templates and
their members, including member class template, member function
templates, and member classes and functions of member templates.
To actually parse the nested-name-specifiers that qualify the name of
an out-of-line definition of a member template, e.g.,
template<typename X> template<typename Y>
X Outer<X>::Inner1<Y>::foo(Y) {
return X();
}
we need to look for the template names (e.g., "Inner1") as a member of
the current instantiation (Outer<X>), even before we have entered the
scope of the current instantiation. Since we can't do this in general
(i.e., we should not be looking into all dependent
nested-name-specifiers as if they were the current instantiation), we
rely on the parser to tell us when it is parsing a declaration
specifier sequence, and, therefore, when we should consider the
current scope specifier to be a current instantiation.
Printing of complicated, dependent nested-name-specifiers may be
somewhat broken by this commit; I'll add tests for this issue and fix
the problem (if it still exists) in a subsequent commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@80044 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-26 02:51:20 +04:00
|
|
|
Actions.ActOnCXXNestedNameSpecifier(CurScope, SS, IdLoc, CCLoc, II,
|
2009-09-03 02:59:36 +04:00
|
|
|
ObjectType, EnteringContext));
|
2009-06-26 07:52:38 +04:00
|
|
|
SS.setEndLoc(CCLoc);
|
|
|
|
continue;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-26 07:52:38 +04:00
|
|
|
// nested-name-specifier:
|
|
|
|
// type-name '<'
|
|
|
|
if (Next.is(tok::less)) {
|
|
|
|
TemplateTy Template;
|
2009-09-03 02:59:36 +04:00
|
|
|
if (TemplateNameKind TNK = Actions.isTemplateName(CurScope, II,
|
|
|
|
Tok.getLocation(),
|
|
|
|
&SS,
|
|
|
|
ObjectType,
|
Improve support for out-of-line definitions of nested templates and
their members, including member class template, member function
templates, and member classes and functions of member templates.
To actually parse the nested-name-specifiers that qualify the name of
an out-of-line definition of a member template, e.g.,
template<typename X> template<typename Y>
X Outer<X>::Inner1<Y>::foo(Y) {
return X();
}
we need to look for the template names (e.g., "Inner1") as a member of
the current instantiation (Outer<X>), even before we have entered the
scope of the current instantiation. Since we can't do this in general
(i.e., we should not be looking into all dependent
nested-name-specifiers as if they were the current instantiation), we
rely on the parser to tell us when it is parsing a declaration
specifier sequence, and, therefore, when we should consider the
current scope specifier to be a current instantiation.
Printing of complicated, dependent nested-name-specifiers may be
somewhat broken by this commit; I'll add tests for this issue and fix
the problem (if it still exists) in a subsequent commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@80044 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-26 02:51:20 +04:00
|
|
|
EnteringContext,
|
|
|
|
Template)) {
|
2009-06-26 07:52:38 +04:00
|
|
|
// We have found a template name, so annotate this this token
|
|
|
|
// with a template-id annotation. We do not permit the
|
|
|
|
// template-id to be translated into a type annotation,
|
|
|
|
// because some clients (e.g., the parsing of class template
|
|
|
|
// specializations) still want to see the original template-id
|
|
|
|
// token.
|
2009-06-26 08:27:47 +04:00
|
|
|
if (AnnotateTemplateIdToken(Template, TNK, &SS, SourceLocation(),
|
|
|
|
false))
|
|
|
|
break;
|
2009-06-26 07:52:38 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
// We don't have any tokens that form the beginning of a
|
|
|
|
// nested-name-specifier, so we're done.
|
|
|
|
break;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65467 91177308-0d34-0410-b5e6-96231b3b80d8
2009-02-25 22:37:18 +03:00
|
|
|
return HasScopeSpecifier;
|
2008-11-08 19:45:02 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/// ParseCXXIdExpression - Handle id-expression.
|
|
|
|
///
|
|
|
|
/// id-expression:
|
|
|
|
/// unqualified-id
|
|
|
|
/// qualified-id
|
|
|
|
///
|
|
|
|
/// unqualified-id:
|
|
|
|
/// identifier
|
|
|
|
/// operator-function-id
|
|
|
|
/// conversion-function-id [TODO]
|
|
|
|
/// '~' class-name [TODO]
|
2009-07-01 02:34:41 +04:00
|
|
|
/// template-id
|
2008-11-08 19:45:02 +03:00
|
|
|
///
|
|
|
|
/// qualified-id:
|
|
|
|
/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
|
|
|
|
/// '::' identifier
|
|
|
|
/// '::' operator-function-id
|
2009-07-01 02:34:41 +04:00
|
|
|
/// '::' template-id
|
2008-11-08 19:45:02 +03:00
|
|
|
///
|
|
|
|
/// nested-name-specifier:
|
|
|
|
/// type-name '::'
|
|
|
|
/// namespace-name '::'
|
|
|
|
/// nested-name-specifier identifier '::'
|
|
|
|
/// nested-name-specifier 'template'[opt] simple-template-id '::' [TODO]
|
|
|
|
///
|
|
|
|
/// NOTE: The standard specifies that, for qualified-id, the parser does not
|
|
|
|
/// expect:
|
|
|
|
///
|
|
|
|
/// '::' conversion-function-id
|
|
|
|
/// '::' '~' class-name
|
|
|
|
///
|
|
|
|
/// This may cause a slight inconsistency on diagnostics:
|
|
|
|
///
|
|
|
|
/// class C {};
|
|
|
|
/// namespace A {}
|
|
|
|
/// void f() {
|
|
|
|
/// :: A :: ~ C(); // Some Sema error about using destructor with a
|
|
|
|
/// // namespace.
|
|
|
|
/// :: ~ C(); // Some Parser error like 'unexpected ~'.
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// We simplify the parser a bit and make it work like:
|
|
|
|
///
|
|
|
|
/// qualified-id:
|
|
|
|
/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
|
|
|
|
/// '::' unqualified-id
|
|
|
|
///
|
|
|
|
/// That way Sema can handle and report similar errors for namespaces and the
|
|
|
|
/// global scope.
|
|
|
|
///
|
2009-02-03 23:19:35 +03:00
|
|
|
/// The isAddressOfOperand parameter indicates that this id-expression is a
|
|
|
|
/// direct operand of the address-of operator. This is, besides member contexts,
|
|
|
|
/// the only place where a qualified-id naming a non-static class member may
|
|
|
|
/// appear.
|
|
|
|
///
|
|
|
|
Parser::OwningExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
|
2008-11-08 19:45:02 +03:00
|
|
|
// qualified-id:
|
|
|
|
// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
|
|
|
|
// '::' unqualified-id
|
|
|
|
//
|
|
|
|
CXXScopeSpec SS;
|
2009-09-03 02:59:36 +04:00
|
|
|
ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false);
|
2009-11-03 19:56:39 +03:00
|
|
|
|
|
|
|
UnqualifiedId Name;
|
|
|
|
if (ParseUnqualifiedId(SS,
|
|
|
|
/*EnteringContext=*/false,
|
|
|
|
/*AllowDestructorName=*/false,
|
|
|
|
/*AllowConstructorName=*/false,
|
2009-11-03 22:44:04 +03:00
|
|
|
/*ObjectType=*/0,
|
2009-11-03 19:56:39 +03:00
|
|
|
Name))
|
|
|
|
return ExprError();
|
|
|
|
|
|
|
|
return Actions.ActOnIdExpression(CurScope, SS, Name, Tok.is(tok::l_paren),
|
|
|
|
isAddressOfOperand);
|
|
|
|
|
2008-11-08 19:45:02 +03:00
|
|
|
}
|
|
|
|
|
2007-07-11 21:01:13 +04:00
|
|
|
/// ParseCXXCasts - This handles the various ways to cast expressions to another
|
|
|
|
/// type.
|
|
|
|
///
|
|
|
|
/// postfix-expression: [C++ 5.2p1]
|
|
|
|
/// 'dynamic_cast' '<' type-name '>' '(' expression ')'
|
|
|
|
/// 'static_cast' '<' type-name '>' '(' expression ')'
|
|
|
|
/// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
|
|
|
|
/// 'const_cast' '<' type-name '>' '(' expression ')'
|
|
|
|
///
|
2008-12-12 01:51:44 +03:00
|
|
|
Parser::OwningExprResult Parser::ParseCXXCasts() {
|
2007-07-11 21:01:13 +04:00
|
|
|
tok::TokenKind Kind = Tok.getKind();
|
|
|
|
const char *CastName = 0; // For error messages
|
|
|
|
|
|
|
|
switch (Kind) {
|
|
|
|
default: assert(0 && "Unknown C++ cast!"); abort();
|
|
|
|
case tok::kw_const_cast: CastName = "const_cast"; break;
|
|
|
|
case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
|
|
|
|
case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
|
|
|
|
case tok::kw_static_cast: CastName = "static_cast"; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
SourceLocation OpLoc = ConsumeToken();
|
|
|
|
SourceLocation LAngleBracketLoc = Tok.getLocation();
|
|
|
|
|
|
|
|
if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2007-07-11 21:01:13 +04:00
|
|
|
|
2009-02-18 20:45:20 +03:00
|
|
|
TypeResult CastTy = ParseTypeName();
|
2007-07-11 21:01:13 +04:00
|
|
|
SourceLocation RAngleBracketLoc = Tok.getLocation();
|
|
|
|
|
2008-11-18 10:48:38 +03:00
|
|
|
if (ExpectAndConsume(tok::greater, diag::err_expected_greater))
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << "<");
|
2007-07-11 21:01:13 +04:00
|
|
|
|
|
|
|
SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
|
|
|
|
|
2009-05-22 14:23:16 +04:00
|
|
|
if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, CastName))
|
|
|
|
return ExprError();
|
2007-07-11 21:01:13 +04:00
|
|
|
|
2009-05-22 14:23:16 +04:00
|
|
|
OwningExprResult Result = ParseExpression();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-05-22 14:23:16 +04:00
|
|
|
// Match the ')'.
|
|
|
|
if (Result.isInvalid())
|
|
|
|
SkipUntil(tok::r_paren);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-05-22 14:23:16 +04:00
|
|
|
if (Tok.is(tok::r_paren))
|
|
|
|
RParenLoc = ConsumeParen();
|
|
|
|
else
|
|
|
|
MatchRHSPunctuation(tok::r_paren, LParenLoc);
|
2007-07-11 21:01:13 +04:00
|
|
|
|
2009-02-18 20:45:20 +03:00
|
|
|
if (!Result.isInvalid() && !CastTy.isInvalid())
|
2008-10-27 22:41:14 +03:00
|
|
|
Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
|
2009-03-15 20:47:39 +03:00
|
|
|
LAngleBracketLoc, CastTy.get(),
|
2009-02-18 20:45:20 +03:00
|
|
|
RAngleBracketLoc,
|
2009-03-15 20:47:39 +03:00
|
|
|
LParenLoc, move(Result), RParenLoc);
|
2007-07-11 21:01:13 +04:00
|
|
|
|
2008-12-12 01:51:44 +03:00
|
|
|
return move(Result);
|
2007-07-11 21:01:13 +04:00
|
|
|
}
|
|
|
|
|
2008-11-11 14:37:55 +03:00
|
|
|
/// ParseCXXTypeid - This handles the C++ typeid expression.
|
|
|
|
///
|
|
|
|
/// postfix-expression: [C++ 5.2p1]
|
|
|
|
/// 'typeid' '(' expression ')'
|
|
|
|
/// 'typeid' '(' type-id ')'
|
|
|
|
///
|
2008-12-12 01:51:44 +03:00
|
|
|
Parser::OwningExprResult Parser::ParseCXXTypeid() {
|
2008-11-11 14:37:55 +03:00
|
|
|
assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
|
|
|
|
|
|
|
|
SourceLocation OpLoc = ConsumeToken();
|
|
|
|
SourceLocation LParenLoc = Tok.getLocation();
|
|
|
|
SourceLocation RParenLoc;
|
|
|
|
|
|
|
|
// typeid expressions are always parenthesized.
|
|
|
|
if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
|
|
|
|
"typeid"))
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-11-11 14:37:55 +03:00
|
|
|
|
2008-12-09 23:22:58 +03:00
|
|
|
OwningExprResult Result(Actions);
|
2008-11-11 14:37:55 +03:00
|
|
|
|
|
|
|
if (isTypeIdInParens()) {
|
2009-02-18 20:45:20 +03:00
|
|
|
TypeResult Ty = ParseTypeName();
|
2008-11-11 14:37:55 +03:00
|
|
|
|
|
|
|
// Match the ')'.
|
|
|
|
MatchRHSPunctuation(tok::r_paren, LParenLoc);
|
|
|
|
|
2009-02-18 20:45:20 +03:00
|
|
|
if (Ty.isInvalid())
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-11-11 14:37:55 +03:00
|
|
|
|
|
|
|
Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
|
2009-02-18 20:45:20 +03:00
|
|
|
Ty.get(), RParenLoc);
|
2008-11-11 14:37:55 +03:00
|
|
|
} else {
|
2009-06-20 03:52:42 +04:00
|
|
|
// C++0x [expr.typeid]p3:
|
2009-09-09 19:08:12 +04:00
|
|
|
// When typeid is applied to an expression other than an lvalue of a
|
|
|
|
// polymorphic class type [...] The expression is an unevaluated
|
2009-06-20 03:52:42 +04:00
|
|
|
// operand (Clause 5).
|
|
|
|
//
|
2009-09-09 19:08:12 +04:00
|
|
|
// Note that we can't tell whether the expression is an lvalue of a
|
2009-06-20 03:52:42 +04:00
|
|
|
// polymorphic class type until after we've parsed the expression, so
|
2009-06-23 00:57:11 +04:00
|
|
|
// we the expression is potentially potentially evaluated.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(Actions,
|
|
|
|
Action::PotentiallyPotentiallyEvaluated);
|
2008-11-11 14:37:55 +03:00
|
|
|
Result = ParseExpression();
|
|
|
|
|
|
|
|
// Match the ')'.
|
2008-12-09 16:15:23 +03:00
|
|
|
if (Result.isInvalid())
|
2008-11-11 14:37:55 +03:00
|
|
|
SkipUntil(tok::r_paren);
|
|
|
|
else {
|
|
|
|
MatchRHSPunctuation(tok::r_paren, LParenLoc);
|
|
|
|
|
|
|
|
Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
|
2008-12-10 03:02:53 +03:00
|
|
|
Result.release(), RParenLoc);
|
2008-11-11 14:37:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-12 01:51:44 +03:00
|
|
|
return move(Result);
|
2008-11-11 14:37:55 +03:00
|
|
|
}
|
|
|
|
|
2007-07-11 21:01:13 +04:00
|
|
|
/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
|
|
|
|
///
|
|
|
|
/// boolean-literal: [C++ 2.13.5]
|
|
|
|
/// 'true'
|
|
|
|
/// 'false'
|
2008-12-12 01:51:44 +03:00
|
|
|
Parser::OwningExprResult Parser::ParseCXXBoolLiteral() {
|
2007-07-11 21:01:13 +04:00
|
|
|
tok::TokenKind Kind = Tok.getKind();
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
|
2007-07-11 21:01:13 +04:00
|
|
|
}
|
2008-02-26 03:51:44 +03:00
|
|
|
|
|
|
|
/// ParseThrowExpression - This handles the C++ throw expression.
|
|
|
|
///
|
|
|
|
/// throw-expression: [C++ 15]
|
|
|
|
/// 'throw' assignment-expression[opt]
|
2008-12-12 01:51:44 +03:00
|
|
|
Parser::OwningExprResult Parser::ParseThrowExpression() {
|
2008-02-26 03:51:44 +03:00
|
|
|
assert(Tok.is(tok::kw_throw) && "Not throw!");
|
|
|
|
SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
|
2008-12-12 01:51:44 +03:00
|
|
|
|
2008-04-06 10:02:23 +04:00
|
|
|
// If the current token isn't the start of an assignment-expression,
|
|
|
|
// then the expression is not present. This handles things like:
|
|
|
|
// "C ? throw : (void)42", which is crazy but legal.
|
|
|
|
switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
|
|
|
|
case tok::semi:
|
|
|
|
case tok::r_paren:
|
|
|
|
case tok::r_square:
|
|
|
|
case tok::r_brace:
|
|
|
|
case tok::colon:
|
|
|
|
case tok::comma:
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXThrow(ThrowLoc, ExprArg(Actions));
|
2008-02-26 03:51:44 +03:00
|
|
|
|
2008-04-06 10:02:23 +04:00
|
|
|
default:
|
2008-12-12 00:36:32 +03:00
|
|
|
OwningExprResult Expr(ParseAssignmentExpression());
|
2008-12-12 01:51:44 +03:00
|
|
|
if (Expr.isInvalid()) return move(Expr);
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXThrow(ThrowLoc, move(Expr));
|
2008-04-06 10:02:23 +04:00
|
|
|
}
|
2008-02-26 03:51:44 +03:00
|
|
|
}
|
2008-06-25 02:12:16 +04:00
|
|
|
|
|
|
|
/// ParseCXXThis - This handles the C++ 'this' pointer.
|
|
|
|
///
|
|
|
|
/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
|
|
|
|
/// a non-lvalue expression whose value is the address of the object for which
|
|
|
|
/// the function is called.
|
2008-12-12 01:51:44 +03:00
|
|
|
Parser::OwningExprResult Parser::ParseCXXThis() {
|
2008-06-25 02:12:16 +04:00
|
|
|
assert(Tok.is(tok::kw_this) && "Not 'this'!");
|
|
|
|
SourceLocation ThisLoc = ConsumeToken();
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXThis(ThisLoc);
|
2008-06-25 02:12:16 +04:00
|
|
|
}
|
2008-08-22 19:38:55 +04:00
|
|
|
|
|
|
|
/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
|
|
|
|
/// Can be interpreted either as function-style casting ("int(x)")
|
|
|
|
/// or class type construction ("ClassType(x,y,z)")
|
|
|
|
/// or creation of a value-initialized type ("int()").
|
|
|
|
///
|
|
|
|
/// postfix-expression: [C++ 5.2p1]
|
|
|
|
/// simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
|
|
|
|
/// typename-specifier '(' expression-list[opt] ')' [TODO]
|
|
|
|
///
|
2008-12-12 01:51:44 +03:00
|
|
|
Parser::OwningExprResult
|
|
|
|
Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
|
2008-08-22 19:38:55 +04:00
|
|
|
Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
|
2009-01-27 01:44:13 +03:00
|
|
|
TypeTy *TypeRep = Actions.ActOnTypeName(CurScope, DeclaratorInfo).get();
|
2008-08-22 19:38:55 +04:00
|
|
|
|
|
|
|
assert(Tok.is(tok::l_paren) && "Expected '('!");
|
|
|
|
SourceLocation LParenLoc = ConsumeParen();
|
|
|
|
|
2008-11-26 01:21:31 +03:00
|
|
|
ExprVector Exprs(Actions);
|
2008-08-22 19:38:55 +04:00
|
|
|
CommaLocsTy CommaLocs;
|
|
|
|
|
|
|
|
if (Tok.isNot(tok::r_paren)) {
|
|
|
|
if (ParseExpressionList(Exprs, CommaLocs)) {
|
|
|
|
SkipUntil(tok::r_paren);
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-08-22 19:38:55 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Match the ')'.
|
|
|
|
SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
|
|
|
|
|
2009-07-29 17:50:23 +04:00
|
|
|
// TypeRep could be null, if it references an invalid typedef.
|
|
|
|
if (!TypeRep)
|
|
|
|
return ExprError();
|
|
|
|
|
2008-08-22 19:38:55 +04:00
|
|
|
assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
|
|
|
|
"Unexpected number of commas!");
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXTypeConstructExpr(DS.getSourceRange(), TypeRep,
|
|
|
|
LParenLoc, move_arg(Exprs),
|
2009-05-21 13:52:38 +04:00
|
|
|
CommaLocs.data(), RParenLoc);
|
2008-08-22 19:38:55 +04:00
|
|
|
}
|
|
|
|
|
2008-09-10 00:38:47 +04:00
|
|
|
/// ParseCXXCondition - if/switch/while/for condition expression.
|
|
|
|
///
|
|
|
|
/// condition:
|
|
|
|
/// expression
|
|
|
|
/// type-specifier-seq declarator '=' assignment-expression
|
|
|
|
/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
|
|
|
|
/// '=' assignment-expression
|
|
|
|
///
|
2008-12-12 00:36:32 +03:00
|
|
|
Parser::OwningExprResult Parser::ParseCXXCondition() {
|
2008-10-05 19:03:47 +04:00
|
|
|
if (!isCXXConditionDeclaration())
|
2008-09-10 00:38:47 +04:00
|
|
|
return ParseExpression(); // expression
|
|
|
|
|
|
|
|
SourceLocation StartLoc = Tok.getLocation();
|
|
|
|
|
|
|
|
// type-specifier-seq
|
|
|
|
DeclSpec DS;
|
|
|
|
ParseSpecifierQualifierList(DS);
|
|
|
|
|
|
|
|
// declarator
|
|
|
|
Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
|
|
|
|
ParseDeclarator(DeclaratorInfo);
|
|
|
|
|
|
|
|
// simple-asm-expr[opt]
|
|
|
|
if (Tok.is(tok::kw_asm)) {
|
2009-02-09 21:23:29 +03:00
|
|
|
SourceLocation Loc;
|
|
|
|
OwningExprResult AsmLabel(ParseSimpleAsm(&Loc));
|
2008-12-09 16:15:23 +03:00
|
|
|
if (AsmLabel.isInvalid()) {
|
2008-09-10 00:38:47 +04:00
|
|
|
SkipUntil(tok::semi);
|
2008-12-12 00:36:32 +03:00
|
|
|
return ExprError();
|
2008-09-10 00:38:47 +04:00
|
|
|
}
|
2008-12-10 03:02:53 +03:00
|
|
|
DeclaratorInfo.setAsmLabel(AsmLabel.release());
|
2009-02-09 21:23:29 +03:00
|
|
|
DeclaratorInfo.SetRangeEnd(Loc);
|
2008-09-10 00:38:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// If attributes are present, parse them.
|
2009-02-09 21:23:29 +03:00
|
|
|
if (Tok.is(tok::kw___attribute)) {
|
|
|
|
SourceLocation Loc;
|
|
|
|
AttributeList *AttrList = ParseAttributes(&Loc);
|
|
|
|
DeclaratorInfo.AddAttributes(AttrList, Loc);
|
|
|
|
}
|
2008-09-10 00:38:47 +04:00
|
|
|
|
|
|
|
// '=' assignment-expression
|
|
|
|
if (Tok.isNot(tok::equal))
|
2008-12-12 00:36:32 +03:00
|
|
|
return ExprError(Diag(Tok, diag::err_expected_equal_after_declarator));
|
2008-09-10 00:38:47 +04:00
|
|
|
SourceLocation EqualLoc = ConsumeToken();
|
2008-12-12 00:36:32 +03:00
|
|
|
OwningExprResult AssignExpr(ParseAssignmentExpression());
|
2008-12-09 16:15:23 +03:00
|
|
|
if (AssignExpr.isInvalid())
|
2008-12-12 00:36:32 +03:00
|
|
|
return ExprError();
|
|
|
|
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXConditionDeclarationExpr(CurScope, StartLoc,
|
|
|
|
DeclaratorInfo,EqualLoc,
|
|
|
|
move(AssignExpr));
|
2008-09-10 00:38:47 +04:00
|
|
|
}
|
|
|
|
|
2008-08-22 19:38:55 +04:00
|
|
|
/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
|
|
|
|
/// This should only be called when the current token is known to be part of
|
|
|
|
/// simple-type-specifier.
|
|
|
|
///
|
|
|
|
/// simple-type-specifier:
|
2008-11-08 19:45:02 +03:00
|
|
|
/// '::'[opt] nested-name-specifier[opt] type-name
|
2008-08-22 19:38:55 +04:00
|
|
|
/// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
|
|
|
|
/// char
|
|
|
|
/// wchar_t
|
|
|
|
/// bool
|
|
|
|
/// short
|
|
|
|
/// int
|
|
|
|
/// long
|
|
|
|
/// signed
|
|
|
|
/// unsigned
|
|
|
|
/// float
|
|
|
|
/// double
|
|
|
|
/// void
|
|
|
|
/// [GNU] typeof-specifier
|
|
|
|
/// [C++0x] auto [TODO]
|
|
|
|
///
|
|
|
|
/// type-name:
|
|
|
|
/// class-name
|
|
|
|
/// enum-name
|
|
|
|
/// typedef-name
|
|
|
|
///
|
|
|
|
void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
|
|
|
|
DS.SetRangeStart(Tok.getLocation());
|
|
|
|
const char *PrevSpec;
|
2009-08-04 00:12:06 +04:00
|
|
|
unsigned DiagID;
|
2008-08-22 19:38:55 +04:00
|
|
|
SourceLocation Loc = Tok.getLocation();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2008-08-22 19:38:55 +04:00
|
|
|
switch (Tok.getKind()) {
|
2009-01-05 03:13:00 +03:00
|
|
|
case tok::identifier: // foo::bar
|
|
|
|
case tok::coloncolon: // ::foo::bar
|
|
|
|
assert(0 && "Annotation token should already be formed!");
|
2009-09-09 19:08:12 +04:00
|
|
|
default:
|
2008-08-22 19:38:55 +04:00
|
|
|
assert(0 && "Not a simple-type-specifier token!");
|
|
|
|
abort();
|
2009-01-05 03:13:00 +03:00
|
|
|
|
2008-08-22 19:38:55 +04:00
|
|
|
// type-name
|
2009-01-06 08:06:21 +03:00
|
|
|
case tok::annot_typename: {
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
|
2008-11-08 19:45:02 +03:00
|
|
|
Tok.getAnnotationValue());
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2008-08-22 19:38:55 +04:00
|
|
|
// builtin types
|
|
|
|
case tok::kw_short:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_long:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_signed:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_unsigned:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_void:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_char:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_int:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_float:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_double:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_wchar_t:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
2009-07-14 10:30:34 +04:00
|
|
|
case tok::kw_char16_t:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID);
|
2009-07-14 10:30:34 +04:00
|
|
|
break;
|
|
|
|
case tok::kw_char32_t:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID);
|
2009-07-14 10:30:34 +04:00
|
|
|
break;
|
2008-08-22 19:38:55 +04:00
|
|
|
case tok::kw_bool:
|
2009-08-04 00:12:06 +04:00
|
|
|
DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
|
2008-08-22 19:38:55 +04:00
|
|
|
break;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2008-08-22 19:38:55 +04:00
|
|
|
// GNU typeof support.
|
|
|
|
case tok::kw_typeof:
|
|
|
|
ParseTypeofSpecifier(DS);
|
2009-04-02 02:41:11 +04:00
|
|
|
DS.Finish(Diags, PP);
|
2008-08-22 19:38:55 +04:00
|
|
|
return;
|
|
|
|
}
|
2009-01-06 08:06:21 +03:00
|
|
|
if (Tok.is(tok::annot_typename))
|
2008-11-08 19:45:02 +03:00
|
|
|
DS.SetRangeEnd(Tok.getAnnotationEndLoc());
|
|
|
|
else
|
|
|
|
DS.SetRangeEnd(Tok.getLocation());
|
2008-08-22 19:38:55 +04:00
|
|
|
ConsumeToken();
|
2009-04-02 02:41:11 +04:00
|
|
|
DS.Finish(Diags, PP);
|
2008-08-22 19:38:55 +04:00
|
|
|
}
|
2008-11-07 01:13:31 +03:00
|
|
|
|
2008-11-07 23:08:42 +03:00
|
|
|
/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
|
|
|
|
/// [dcl.name]), which is a non-empty sequence of type-specifiers,
|
|
|
|
/// e.g., "const short int". Note that the DeclSpec is *not* finished
|
|
|
|
/// by parsing the type-specifier-seq, because these sequences are
|
|
|
|
/// typically followed by some form of declarator. Returns true and
|
|
|
|
/// emits diagnostics if this is not a type-specifier-seq, false
|
|
|
|
/// otherwise.
|
|
|
|
///
|
|
|
|
/// type-specifier-seq: [C++ 8.1]
|
|
|
|
/// type-specifier type-specifier-seq[opt]
|
|
|
|
///
|
|
|
|
bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
|
|
|
|
DS.SetRangeStart(Tok.getLocation());
|
|
|
|
const char *PrevSpec = 0;
|
2009-08-04 00:12:06 +04:00
|
|
|
unsigned DiagID;
|
|
|
|
bool isInvalid = 0;
|
2008-11-07 23:08:42 +03:00
|
|
|
|
|
|
|
// Parse one or more of the type specifiers.
|
2009-08-04 00:12:06 +04:00
|
|
|
if (!ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID)) {
|
2008-11-18 10:48:38 +03:00
|
|
|
Diag(Tok, diag::err_operator_missing_type_specifier);
|
2008-11-07 23:08:42 +03:00
|
|
|
return true;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-08-04 00:12:06 +04:00
|
|
|
while (ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID)) ;
|
2008-11-07 23:08:42 +03:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-11-03 04:35:08 +03:00
|
|
|
/// \brief Finish parsing a C++ unqualified-id that is a template-id of
|
|
|
|
/// some form.
|
|
|
|
///
|
|
|
|
/// This routine is invoked when a '<' is encountered after an identifier or
|
|
|
|
/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
|
|
|
|
/// whether the unqualified-id is actually a template-id. This routine will
|
|
|
|
/// then parse the template arguments and form the appropriate template-id to
|
|
|
|
/// return to the caller.
|
|
|
|
///
|
|
|
|
/// \param SS the nested-name-specifier that precedes this template-id, if
|
|
|
|
/// we're actually parsing a qualified-id.
|
|
|
|
///
|
|
|
|
/// \param Name for constructor and destructor names, this is the actual
|
|
|
|
/// identifier that may be a template-name.
|
|
|
|
///
|
|
|
|
/// \param NameLoc the location of the class-name in a constructor or
|
|
|
|
/// destructor.
|
|
|
|
///
|
|
|
|
/// \param EnteringContext whether we're entering the scope of the
|
|
|
|
/// nested-name-specifier.
|
|
|
|
///
|
|
|
|
/// \param Id as input, describes the template-name or operator-function-id
|
|
|
|
/// that precedes the '<'. If template arguments were parsed successfully,
|
|
|
|
/// will be updated with the template-id.
|
|
|
|
///
|
|
|
|
/// \returns true if a parse error occurred, false otherwise.
|
|
|
|
bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
|
|
|
|
IdentifierInfo *Name,
|
|
|
|
SourceLocation NameLoc,
|
|
|
|
bool EnteringContext,
|
2009-11-03 22:44:04 +03:00
|
|
|
TypeTy *ObjectType,
|
2009-11-03 04:35:08 +03:00
|
|
|
UnqualifiedId &Id) {
|
|
|
|
assert(Tok.is(tok::less) && "Expected '<' to finish parsing a template-id");
|
|
|
|
|
|
|
|
TemplateTy Template;
|
|
|
|
TemplateNameKind TNK = TNK_Non_template;
|
|
|
|
switch (Id.getKind()) {
|
|
|
|
case UnqualifiedId::IK_Identifier:
|
|
|
|
TNK = Actions.isTemplateName(CurScope, *Id.Identifier, Id.StartLocation,
|
2009-11-03 22:44:04 +03:00
|
|
|
&SS, ObjectType, EnteringContext, Template);
|
2009-11-03 04:35:08 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UnqualifiedId::IK_OperatorFunctionId: {
|
|
|
|
// FIXME: Temporary hack: warn that we are completely ignoring the
|
|
|
|
// template arguments for now.
|
2009-11-03 22:44:04 +03:00
|
|
|
// Parse the enclosed template argument list and throw it away.
|
2009-11-03 04:35:08 +03:00
|
|
|
SourceLocation LAngleLoc, RAngleLoc;
|
|
|
|
TemplateArgList TemplateArgs;
|
|
|
|
TemplateArgIsTypeList TemplateArgIsType;
|
|
|
|
TemplateArgLocationList TemplateArgLocations;
|
|
|
|
if (ParseTemplateIdAfterTemplateName(Template, Id.StartLocation,
|
|
|
|
&SS, true, LAngleLoc,
|
|
|
|
TemplateArgs,
|
|
|
|
TemplateArgIsType,
|
|
|
|
TemplateArgLocations,
|
|
|
|
RAngleLoc))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Diag(Id.StartLocation, diag::warn_operator_template_id_ignores_args)
|
|
|
|
<< SourceRange(LAngleLoc, RAngleLoc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case UnqualifiedId::IK_ConstructorName:
|
2009-11-03 22:44:04 +03:00
|
|
|
TNK = Actions.isTemplateName(CurScope, *Name, NameLoc, &SS, ObjectType,
|
|
|
|
EnteringContext, Template);
|
2009-11-03 04:35:08 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UnqualifiedId::IK_DestructorName:
|
2009-11-03 22:44:04 +03:00
|
|
|
if (ObjectType) {
|
|
|
|
Template = Actions.ActOnDependentTemplateName(SourceLocation(), *Name,
|
|
|
|
NameLoc, SS, ObjectType);
|
|
|
|
TNK = TNK_Dependent_template_name;
|
|
|
|
if (!Template.get())
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
TNK = Actions.isTemplateName(CurScope, *Name, NameLoc, &SS, ObjectType,
|
|
|
|
EnteringContext, Template);
|
|
|
|
|
|
|
|
if (TNK == TNK_Non_template && Id.DestructorName == 0) {
|
|
|
|
// The identifier following the destructor did not refer to a template
|
|
|
|
// or to a type. Complain.
|
|
|
|
if (ObjectType)
|
|
|
|
Diag(NameLoc, diag::err_ident_in_pseudo_dtor_not_a_type)
|
|
|
|
<< Name;
|
|
|
|
else
|
|
|
|
Diag(NameLoc, diag::err_destructor_class_name);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2009-11-03 04:35:08 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TNK == TNK_Non_template)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Parse the enclosed template argument list.
|
|
|
|
SourceLocation LAngleLoc, RAngleLoc;
|
|
|
|
TemplateArgList TemplateArgs;
|
|
|
|
TemplateArgIsTypeList TemplateArgIsType;
|
|
|
|
TemplateArgLocationList TemplateArgLocations;
|
|
|
|
if (ParseTemplateIdAfterTemplateName(Template, Id.StartLocation,
|
|
|
|
&SS, true, LAngleLoc,
|
|
|
|
TemplateArgs,
|
|
|
|
TemplateArgIsType,
|
|
|
|
TemplateArgLocations,
|
|
|
|
RAngleLoc))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (Id.getKind() == UnqualifiedId::IK_Identifier ||
|
|
|
|
Id.getKind() == UnqualifiedId::IK_OperatorFunctionId) {
|
|
|
|
// Form a parsed representation of the template-id to be stored in the
|
|
|
|
// UnqualifiedId.
|
|
|
|
TemplateIdAnnotation *TemplateId
|
|
|
|
= TemplateIdAnnotation::Allocate(TemplateArgs.size());
|
|
|
|
|
|
|
|
if (Id.getKind() == UnqualifiedId::IK_Identifier) {
|
|
|
|
TemplateId->Name = Id.Identifier;
|
|
|
|
TemplateId->TemplateNameLoc = Id.StartLocation;
|
|
|
|
} else {
|
|
|
|
// FIXME: Handle IK_OperatorFunctionId
|
|
|
|
}
|
|
|
|
|
|
|
|
TemplateId->Template = Template.getAs<void*>();
|
|
|
|
TemplateId->Kind = TNK;
|
|
|
|
TemplateId->LAngleLoc = LAngleLoc;
|
|
|
|
TemplateId->RAngleLoc = RAngleLoc;
|
|
|
|
void **Args = TemplateId->getTemplateArgs();
|
|
|
|
bool *ArgIsType = TemplateId->getTemplateArgIsType();
|
|
|
|
SourceLocation *ArgLocs = TemplateId->getTemplateArgLocations();
|
|
|
|
for (unsigned Arg = 0, ArgEnd = TemplateArgs.size();
|
|
|
|
Arg != ArgEnd; ++Arg) {
|
|
|
|
Args[Arg] = TemplateArgs[Arg];
|
|
|
|
ArgIsType[Arg] = TemplateArgIsType[Arg];
|
|
|
|
ArgLocs[Arg] = TemplateArgLocations[Arg];
|
|
|
|
}
|
|
|
|
|
|
|
|
Id.setTemplateId(TemplateId);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bundle the template arguments together.
|
|
|
|
ASTTemplateArgsPtr TemplateArgsPtr(Actions, TemplateArgs.data(),
|
|
|
|
TemplateArgIsType.data(),
|
|
|
|
TemplateArgs.size());
|
|
|
|
|
|
|
|
// Constructor and destructor names.
|
|
|
|
Action::TypeResult Type
|
|
|
|
= Actions.ActOnTemplateIdType(Template, NameLoc,
|
|
|
|
LAngleLoc, TemplateArgsPtr,
|
|
|
|
&TemplateArgLocations[0],
|
|
|
|
RAngleLoc);
|
|
|
|
if (Type.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (Id.getKind() == UnqualifiedId::IK_ConstructorName)
|
|
|
|
Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
|
|
|
|
else
|
|
|
|
Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
|
|
|
|
/// name of an entity.
|
|
|
|
///
|
|
|
|
/// \code
|
|
|
|
/// unqualified-id: [C++ expr.prim.general]
|
|
|
|
/// identifier
|
|
|
|
/// operator-function-id
|
|
|
|
/// conversion-function-id
|
|
|
|
/// [C++0x] literal-operator-id [TODO]
|
|
|
|
/// ~ class-name
|
|
|
|
/// template-id
|
|
|
|
///
|
|
|
|
/// operator-function-id: [C++ 13.5]
|
|
|
|
/// 'operator' operator
|
|
|
|
///
|
|
|
|
/// operator: one of
|
|
|
|
/// new delete new[] delete[]
|
|
|
|
/// + - * / % ^ & | ~
|
|
|
|
/// ! = < > += -= *= /= %=
|
|
|
|
/// ^= &= |= << >> >>= <<= == !=
|
|
|
|
/// <= >= && || ++ -- , ->* ->
|
|
|
|
/// () []
|
|
|
|
///
|
|
|
|
/// conversion-function-id: [C++ 12.3.2]
|
|
|
|
/// operator conversion-type-id
|
|
|
|
///
|
|
|
|
/// conversion-type-id:
|
|
|
|
/// type-specifier-seq conversion-declarator[opt]
|
|
|
|
///
|
|
|
|
/// conversion-declarator:
|
|
|
|
/// ptr-operator conversion-declarator[opt]
|
|
|
|
/// \endcode
|
|
|
|
///
|
|
|
|
/// \param The nested-name-specifier that preceded this unqualified-id. If
|
|
|
|
/// non-empty, then we are parsing the unqualified-id of a qualified-id.
|
|
|
|
///
|
|
|
|
/// \param EnteringContext whether we are entering the scope of the
|
|
|
|
/// nested-name-specifier.
|
|
|
|
///
|
|
|
|
/// \param AllowDestructorName whether we allow parsing of a destructor name.
|
|
|
|
///
|
|
|
|
/// \param AllowConstructorName whether we allow parsing a constructor name.
|
|
|
|
///
|
|
|
|
/// \param Result on a successful parse, contains the parsed unqualified-id.
|
|
|
|
///
|
|
|
|
/// \returns true if parsing fails, false otherwise.
|
|
|
|
bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
|
|
|
|
bool AllowDestructorName,
|
|
|
|
bool AllowConstructorName,
|
2009-11-03 22:44:04 +03:00
|
|
|
TypeTy *ObjectType,
|
2009-11-03 04:35:08 +03:00
|
|
|
UnqualifiedId &Result) {
|
|
|
|
// unqualified-id:
|
|
|
|
// identifier
|
|
|
|
// template-id (when it hasn't already been annotated)
|
|
|
|
if (Tok.is(tok::identifier)) {
|
|
|
|
// Consume the identifier.
|
|
|
|
IdentifierInfo *Id = Tok.getIdentifierInfo();
|
|
|
|
SourceLocation IdLoc = ConsumeToken();
|
|
|
|
|
|
|
|
if (AllowConstructorName &&
|
|
|
|
Actions.isCurrentClassName(*Id, CurScope, &SS)) {
|
|
|
|
// We have parsed a constructor name.
|
|
|
|
Result.setConstructorName(Actions.getTypeName(*Id, IdLoc, CurScope,
|
|
|
|
&SS, false),
|
|
|
|
IdLoc, IdLoc);
|
|
|
|
} else {
|
|
|
|
// We have parsed an identifier.
|
|
|
|
Result.setIdentifier(Id, IdLoc);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the next token is a '<', we may have a template.
|
|
|
|
if (Tok.is(tok::less))
|
|
|
|
return ParseUnqualifiedIdTemplateId(SS, Id, IdLoc, EnteringContext,
|
2009-11-03 22:44:04 +03:00
|
|
|
ObjectType, Result);
|
2009-11-03 04:35:08 +03:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// unqualified-id:
|
|
|
|
// template-id (already parsed and annotated)
|
|
|
|
if (Tok.is(tok::annot_template_id)) {
|
|
|
|
// FIXME: Could this be a constructor name???
|
|
|
|
|
|
|
|
// We have already parsed a template-id; consume the annotation token as
|
|
|
|
// our unqualified-id.
|
|
|
|
Result.setTemplateId(
|
|
|
|
static_cast<TemplateIdAnnotation*>(Tok.getAnnotationValue()));
|
|
|
|
ConsumeToken();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// unqualified-id:
|
|
|
|
// operator-function-id
|
|
|
|
// conversion-function-id
|
|
|
|
if (Tok.is(tok::kw_operator)) {
|
|
|
|
// Consume the 'operator' keyword.
|
|
|
|
SourceLocation KeywordLoc = ConsumeToken();
|
|
|
|
|
|
|
|
// Determine what kind of operator name we have.
|
|
|
|
unsigned SymbolIdx = 0;
|
|
|
|
SourceLocation SymbolLocations[3];
|
|
|
|
OverloadedOperatorKind Op = OO_None;
|
|
|
|
switch (Tok.getKind()) {
|
|
|
|
case tok::kw_new:
|
|
|
|
case tok::kw_delete: {
|
|
|
|
bool isNew = Tok.getKind() == tok::kw_new;
|
|
|
|
// Consume the 'new' or 'delete'.
|
|
|
|
SymbolLocations[SymbolIdx++] = ConsumeToken();
|
|
|
|
if (Tok.is(tok::l_square)) {
|
|
|
|
// Consume the '['.
|
|
|
|
SourceLocation LBracketLoc = ConsumeBracket();
|
|
|
|
// Consume the ']'.
|
|
|
|
SourceLocation RBracketLoc = MatchRHSPunctuation(tok::r_square,
|
|
|
|
LBracketLoc);
|
|
|
|
if (RBracketLoc.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
SymbolLocations[SymbolIdx++] = LBracketLoc;
|
|
|
|
SymbolLocations[SymbolIdx++] = RBracketLoc;
|
|
|
|
Op = isNew? OO_Array_New : OO_Array_Delete;
|
|
|
|
} else {
|
|
|
|
Op = isNew? OO_New : OO_Delete;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
|
|
|
|
case tok::Token: \
|
|
|
|
SymbolLocations[SymbolIdx++] = ConsumeToken(); \
|
|
|
|
Op = OO_##Name; \
|
|
|
|
break;
|
|
|
|
#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
|
|
|
|
#include "clang/Basic/OperatorKinds.def"
|
|
|
|
|
|
|
|
case tok::l_paren: {
|
|
|
|
// Consume the '('.
|
|
|
|
SourceLocation LParenLoc = ConsumeParen();
|
|
|
|
// Consume the ')'.
|
|
|
|
SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren,
|
|
|
|
LParenLoc);
|
|
|
|
if (RParenLoc.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
SymbolLocations[SymbolIdx++] = LParenLoc;
|
|
|
|
SymbolLocations[SymbolIdx++] = RParenLoc;
|
|
|
|
Op = OO_Call;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case tok::l_square: {
|
|
|
|
// Consume the '['.
|
|
|
|
SourceLocation LBracketLoc = ConsumeBracket();
|
|
|
|
// Consume the ']'.
|
|
|
|
SourceLocation RBracketLoc = MatchRHSPunctuation(tok::r_square,
|
|
|
|
LBracketLoc);
|
|
|
|
if (RBracketLoc.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
SymbolLocations[SymbolIdx++] = LBracketLoc;
|
|
|
|
SymbolLocations[SymbolIdx++] = RBracketLoc;
|
|
|
|
Op = OO_Subscript;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case tok::code_completion: {
|
|
|
|
// Code completion for the operator name.
|
|
|
|
Actions.CodeCompleteOperatorName(CurScope);
|
|
|
|
|
|
|
|
// Consume the operator token.
|
|
|
|
ConsumeToken();
|
|
|
|
|
|
|
|
// Don't try to parse any further.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Op != OO_None) {
|
|
|
|
// We have parsed an operator-function-id.
|
|
|
|
Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
|
|
|
|
|
|
|
|
// If the next token is a '<', we may have a template.
|
|
|
|
if (Tok.is(tok::less))
|
|
|
|
return ParseUnqualifiedIdTemplateId(SS, 0, SourceLocation(),
|
2009-11-03 22:44:04 +03:00
|
|
|
EnteringContext, ObjectType,
|
|
|
|
Result);
|
2009-11-03 04:35:08 +03:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Parse a conversion-function-id.
|
|
|
|
//
|
|
|
|
// conversion-function-id: [C++ 12.3.2]
|
|
|
|
// operator conversion-type-id
|
|
|
|
//
|
|
|
|
// conversion-type-id:
|
|
|
|
// type-specifier-seq conversion-declarator[opt]
|
|
|
|
//
|
|
|
|
// conversion-declarator:
|
|
|
|
// ptr-operator conversion-declarator[opt]
|
|
|
|
|
|
|
|
// Parse the type-specifier-seq.
|
|
|
|
DeclSpec DS;
|
|
|
|
if (ParseCXXTypeSpecifierSeq(DS))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Parse the conversion-declarator, which is merely a sequence of
|
|
|
|
// ptr-operators.
|
|
|
|
Declarator D(DS, Declarator::TypeNameContext);
|
|
|
|
ParseDeclaratorInternal(D, /*DirectDeclParser=*/0);
|
|
|
|
|
|
|
|
// Finish up the type.
|
|
|
|
Action::TypeResult Ty = Actions.ActOnTypeName(CurScope, D);
|
|
|
|
if (Ty.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Note that this is a conversion-function-id.
|
|
|
|
Result.setConversionFunctionId(KeywordLoc, Ty.get(),
|
|
|
|
D.getSourceRange().getEnd());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
|
|
|
|
// C++ [expr.unary.op]p10:
|
|
|
|
// There is an ambiguity in the unary-expression ~X(), where X is a
|
|
|
|
// class-name. The ambiguity is resolved in favor of treating ~ as a
|
|
|
|
// unary complement rather than treating ~X as referring to a destructor.
|
|
|
|
|
|
|
|
// Parse the '~'.
|
|
|
|
SourceLocation TildeLoc = ConsumeToken();
|
|
|
|
|
|
|
|
// Parse the class-name.
|
|
|
|
if (Tok.isNot(tok::identifier)) {
|
|
|
|
Diag(Tok, diag::err_destructor_class_name);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Parse the class-name (or template-name in a simple-template-id).
|
|
|
|
IdentifierInfo *ClassName = Tok.getIdentifierInfo();
|
|
|
|
SourceLocation ClassNameLoc = ConsumeToken();
|
|
|
|
|
2009-11-03 22:44:04 +03:00
|
|
|
if (Tok.is(tok::less)) {
|
|
|
|
Result.setDestructorName(TildeLoc, 0, ClassNameLoc);
|
|
|
|
return ParseUnqualifiedIdTemplateId(SS, ClassName, ClassNameLoc,
|
|
|
|
EnteringContext, ObjectType, Result);
|
|
|
|
}
|
|
|
|
|
2009-11-03 04:35:08 +03:00
|
|
|
// Note that this is a destructor name.
|
|
|
|
Action::TypeTy *Ty = Actions.getTypeName(*ClassName, ClassNameLoc,
|
|
|
|
CurScope, &SS);
|
|
|
|
if (!Ty) {
|
2009-11-03 22:44:04 +03:00
|
|
|
if (ObjectType)
|
|
|
|
Diag(ClassNameLoc, diag::err_ident_in_pseudo_dtor_not_a_type)
|
|
|
|
<< ClassName;
|
|
|
|
else
|
|
|
|
Diag(ClassNameLoc, diag::err_destructor_class_name);
|
2009-11-03 04:35:08 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-11-03 22:44:04 +03:00
|
|
|
Diag(Tok, diag::err_expected_unqualified_id)
|
|
|
|
<< getLang().CPlusPlus;
|
2009-11-03 04:35:08 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-11-17 19:14:12 +03:00
|
|
|
/// TryParseOperatorFunctionId - Attempts to parse a C++ overloaded
|
2008-11-07 01:13:31 +03:00
|
|
|
/// operator name (C++ [over.oper]). If successful, returns the
|
|
|
|
/// predefined identifier that corresponds to that overloaded
|
|
|
|
/// operator. Otherwise, returns NULL and does not consume any tokens.
|
|
|
|
///
|
|
|
|
/// operator-function-id: [C++ 13.5]
|
|
|
|
/// 'operator' operator
|
|
|
|
///
|
|
|
|
/// operator: one of
|
|
|
|
/// new delete new[] delete[]
|
|
|
|
/// + - * / % ^ & | ~
|
|
|
|
/// ! = < > += -= *= /= %=
|
|
|
|
/// ^= &= |= << >> >>= <<= == !=
|
|
|
|
/// <= >= && || ++ -- , ->* ->
|
|
|
|
/// () []
|
2009-02-09 21:23:29 +03:00
|
|
|
OverloadedOperatorKind
|
|
|
|
Parser::TryParseOperatorFunctionId(SourceLocation *EndLoc) {
|
2008-11-07 18:54:02 +03:00
|
|
|
assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
|
2009-02-09 21:23:29 +03:00
|
|
|
SourceLocation Loc;
|
2008-11-07 01:13:31 +03:00
|
|
|
|
|
|
|
OverloadedOperatorKind Op = OO_None;
|
|
|
|
switch (NextToken().getKind()) {
|
|
|
|
case tok::kw_new:
|
|
|
|
ConsumeToken(); // 'operator'
|
2009-02-09 21:23:29 +03:00
|
|
|
Loc = ConsumeToken(); // 'new'
|
2008-11-07 01:13:31 +03:00
|
|
|
if (Tok.is(tok::l_square)) {
|
|
|
|
ConsumeBracket(); // '['
|
2009-02-09 21:23:29 +03:00
|
|
|
Loc = Tok.getLocation();
|
2008-11-07 01:13:31 +03:00
|
|
|
ExpectAndConsume(tok::r_square, diag::err_expected_rsquare); // ']'
|
|
|
|
Op = OO_Array_New;
|
|
|
|
} else {
|
|
|
|
Op = OO_New;
|
|
|
|
}
|
2009-02-09 21:23:29 +03:00
|
|
|
if (EndLoc)
|
|
|
|
*EndLoc = Loc;
|
Extend DeclarationName to support C++ overloaded operators, e.g.,
operator+, directly, using the same mechanism as all other special
names.
Removed the "special" identifiers for the overloaded operators from
the identifier table and IdentifierInfo data structure. IdentifierInfo
is back to representing only real identifiers.
Added a new Action, ActOnOperatorFunctionIdExpr, that builds an
expression from an parsed operator-function-id (e.g., "operator
+"). ActOnIdentifierExpr used to do this job, but
operator-function-ids are no longer represented by IdentifierInfo's.
Extended Declarator to store overloaded operator names.
Sema::GetNameForDeclarator now knows how to turn the operator
name into a DeclarationName for the overloaded operator.
Except for (perhaps) consolidating the functionality of
ActOnIdentifier, ActOnOperatorFunctionIdExpr, and
ActOnConversionFunctionExpr into a common routine that builds an
appropriate DeclRefExpr by looking up a DeclarationName, all of the
work on normalizing declaration names should be complete with this
commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59526 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 17:39:36 +03:00
|
|
|
return Op;
|
2008-11-07 01:13:31 +03:00
|
|
|
|
|
|
|
case tok::kw_delete:
|
|
|
|
ConsumeToken(); // 'operator'
|
2009-02-09 21:23:29 +03:00
|
|
|
Loc = ConsumeToken(); // 'delete'
|
2008-11-07 01:13:31 +03:00
|
|
|
if (Tok.is(tok::l_square)) {
|
|
|
|
ConsumeBracket(); // '['
|
2009-02-09 21:23:29 +03:00
|
|
|
Loc = Tok.getLocation();
|
2008-11-07 01:13:31 +03:00
|
|
|
ExpectAndConsume(tok::r_square, diag::err_expected_rsquare); // ']'
|
|
|
|
Op = OO_Array_Delete;
|
|
|
|
} else {
|
|
|
|
Op = OO_Delete;
|
|
|
|
}
|
2009-02-09 21:23:29 +03:00
|
|
|
if (EndLoc)
|
|
|
|
*EndLoc = Loc;
|
Extend DeclarationName to support C++ overloaded operators, e.g.,
operator+, directly, using the same mechanism as all other special
names.
Removed the "special" identifiers for the overloaded operators from
the identifier table and IdentifierInfo data structure. IdentifierInfo
is back to representing only real identifiers.
Added a new Action, ActOnOperatorFunctionIdExpr, that builds an
expression from an parsed operator-function-id (e.g., "operator
+"). ActOnIdentifierExpr used to do this job, but
operator-function-ids are no longer represented by IdentifierInfo's.
Extended Declarator to store overloaded operator names.
Sema::GetNameForDeclarator now knows how to turn the operator
name into a DeclarationName for the overloaded operator.
Except for (perhaps) consolidating the functionality of
ActOnIdentifier, ActOnOperatorFunctionIdExpr, and
ActOnConversionFunctionExpr into a common routine that builds an
appropriate DeclRefExpr by looking up a DeclarationName, all of the
work on normalizing declaration names should be complete with this
commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59526 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 17:39:36 +03:00
|
|
|
return Op;
|
2008-11-07 01:13:31 +03:00
|
|
|
|
2008-11-10 16:38:07 +03:00
|
|
|
#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
|
2008-11-07 01:13:31 +03:00
|
|
|
case tok::Token: Op = OO_##Name; break;
|
2008-11-10 16:38:07 +03:00
|
|
|
#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
|
2008-11-07 01:13:31 +03:00
|
|
|
#include "clang/Basic/OperatorKinds.def"
|
|
|
|
|
|
|
|
case tok::l_paren:
|
|
|
|
ConsumeToken(); // 'operator'
|
|
|
|
ConsumeParen(); // '('
|
2009-02-09 21:23:29 +03:00
|
|
|
Loc = Tok.getLocation();
|
2008-11-07 01:13:31 +03:00
|
|
|
ExpectAndConsume(tok::r_paren, diag::err_expected_rparen); // ')'
|
2009-02-09 21:23:29 +03:00
|
|
|
if (EndLoc)
|
|
|
|
*EndLoc = Loc;
|
Extend DeclarationName to support C++ overloaded operators, e.g.,
operator+, directly, using the same mechanism as all other special
names.
Removed the "special" identifiers for the overloaded operators from
the identifier table and IdentifierInfo data structure. IdentifierInfo
is back to representing only real identifiers.
Added a new Action, ActOnOperatorFunctionIdExpr, that builds an
expression from an parsed operator-function-id (e.g., "operator
+"). ActOnIdentifierExpr used to do this job, but
operator-function-ids are no longer represented by IdentifierInfo's.
Extended Declarator to store overloaded operator names.
Sema::GetNameForDeclarator now knows how to turn the operator
name into a DeclarationName for the overloaded operator.
Except for (perhaps) consolidating the functionality of
ActOnIdentifier, ActOnOperatorFunctionIdExpr, and
ActOnConversionFunctionExpr into a common routine that builds an
appropriate DeclRefExpr by looking up a DeclarationName, all of the
work on normalizing declaration names should be complete with this
commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59526 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 17:39:36 +03:00
|
|
|
return OO_Call;
|
2008-11-07 01:13:31 +03:00
|
|
|
|
|
|
|
case tok::l_square:
|
|
|
|
ConsumeToken(); // 'operator'
|
|
|
|
ConsumeBracket(); // '['
|
2009-02-09 21:23:29 +03:00
|
|
|
Loc = Tok.getLocation();
|
2008-11-07 01:13:31 +03:00
|
|
|
ExpectAndConsume(tok::r_square, diag::err_expected_rsquare); // ']'
|
2009-02-09 21:23:29 +03:00
|
|
|
if (EndLoc)
|
|
|
|
*EndLoc = Loc;
|
Extend DeclarationName to support C++ overloaded operators, e.g.,
operator+, directly, using the same mechanism as all other special
names.
Removed the "special" identifiers for the overloaded operators from
the identifier table and IdentifierInfo data structure. IdentifierInfo
is back to representing only real identifiers.
Added a new Action, ActOnOperatorFunctionIdExpr, that builds an
expression from an parsed operator-function-id (e.g., "operator
+"). ActOnIdentifierExpr used to do this job, but
operator-function-ids are no longer represented by IdentifierInfo's.
Extended Declarator to store overloaded operator names.
Sema::GetNameForDeclarator now knows how to turn the operator
name into a DeclarationName for the overloaded operator.
Except for (perhaps) consolidating the functionality of
ActOnIdentifier, ActOnOperatorFunctionIdExpr, and
ActOnConversionFunctionExpr into a common routine that builds an
appropriate DeclRefExpr by looking up a DeclarationName, all of the
work on normalizing declaration names should be complete with this
commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59526 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 17:39:36 +03:00
|
|
|
return OO_Subscript;
|
2008-11-07 01:13:31 +03:00
|
|
|
|
2009-09-19 00:05:18 +04:00
|
|
|
case tok::code_completion: {
|
|
|
|
// Code completion for the operator name.
|
|
|
|
Actions.CodeCompleteOperatorName(CurScope);
|
|
|
|
|
|
|
|
// Consume the 'operator' token, then replace the code-completion token
|
|
|
|
// with an 'operator' token and try again.
|
|
|
|
SourceLocation OperatorLoc = ConsumeToken();
|
|
|
|
Tok.setLocation(OperatorLoc);
|
|
|
|
Tok.setKind(tok::kw_operator);
|
|
|
|
return TryParseOperatorFunctionId(EndLoc);
|
|
|
|
}
|
|
|
|
|
2008-11-07 01:13:31 +03:00
|
|
|
default:
|
Extend DeclarationName to support C++ overloaded operators, e.g.,
operator+, directly, using the same mechanism as all other special
names.
Removed the "special" identifiers for the overloaded operators from
the identifier table and IdentifierInfo data structure. IdentifierInfo
is back to representing only real identifiers.
Added a new Action, ActOnOperatorFunctionIdExpr, that builds an
expression from an parsed operator-function-id (e.g., "operator
+"). ActOnIdentifierExpr used to do this job, but
operator-function-ids are no longer represented by IdentifierInfo's.
Extended Declarator to store overloaded operator names.
Sema::GetNameForDeclarator now knows how to turn the operator
name into a DeclarationName for the overloaded operator.
Except for (perhaps) consolidating the functionality of
ActOnIdentifier, ActOnOperatorFunctionIdExpr, and
ActOnConversionFunctionExpr into a common routine that builds an
appropriate DeclRefExpr by looking up a DeclarationName, all of the
work on normalizing declaration names should be complete with this
commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59526 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 17:39:36 +03:00
|
|
|
return OO_None;
|
2008-11-07 01:13:31 +03:00
|
|
|
}
|
2008-11-17 19:14:12 +03:00
|
|
|
|
|
|
|
ConsumeToken(); // 'operator'
|
2009-02-09 21:23:29 +03:00
|
|
|
Loc = ConsumeAnyToken(); // the operator itself
|
|
|
|
if (EndLoc)
|
|
|
|
*EndLoc = Loc;
|
Extend DeclarationName to support C++ overloaded operators, e.g.,
operator+, directly, using the same mechanism as all other special
names.
Removed the "special" identifiers for the overloaded operators from
the identifier table and IdentifierInfo data structure. IdentifierInfo
is back to representing only real identifiers.
Added a new Action, ActOnOperatorFunctionIdExpr, that builds an
expression from an parsed operator-function-id (e.g., "operator
+"). ActOnIdentifierExpr used to do this job, but
operator-function-ids are no longer represented by IdentifierInfo's.
Extended Declarator to store overloaded operator names.
Sema::GetNameForDeclarator now knows how to turn the operator
name into a DeclarationName for the overloaded operator.
Except for (perhaps) consolidating the functionality of
ActOnIdentifier, ActOnOperatorFunctionIdExpr, and
ActOnConversionFunctionExpr into a common routine that builds an
appropriate DeclRefExpr by looking up a DeclarationName, all of the
work on normalizing declaration names should be complete with this
commit.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59526 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 17:39:36 +03:00
|
|
|
return Op;
|
2008-11-07 01:13:31 +03:00
|
|
|
}
|
2008-11-07 23:08:42 +03:00
|
|
|
|
|
|
|
/// ParseConversionFunctionId - Parse a C++ conversion-function-id,
|
|
|
|
/// which expresses the name of a user-defined conversion operator
|
|
|
|
/// (C++ [class.conv.fct]p1). Returns the type that this operator is
|
|
|
|
/// specifying a conversion for, or NULL if there was an error.
|
|
|
|
///
|
|
|
|
/// conversion-function-id: [C++ 12.3.2]
|
|
|
|
/// operator conversion-type-id
|
|
|
|
///
|
|
|
|
/// conversion-type-id:
|
|
|
|
/// type-specifier-seq conversion-declarator[opt]
|
|
|
|
///
|
|
|
|
/// conversion-declarator:
|
|
|
|
/// ptr-operator conversion-declarator[opt]
|
2009-02-09 21:23:29 +03:00
|
|
|
Parser::TypeTy *Parser::ParseConversionFunctionId(SourceLocation *EndLoc) {
|
2008-11-07 23:08:42 +03:00
|
|
|
assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
|
|
|
|
ConsumeToken(); // 'operator'
|
|
|
|
|
|
|
|
// Parse the type-specifier-seq.
|
|
|
|
DeclSpec DS;
|
|
|
|
if (ParseCXXTypeSpecifierSeq(DS))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Parse the conversion-declarator, which is merely a sequence of
|
|
|
|
// ptr-operators.
|
|
|
|
Declarator D(DS, Declarator::TypeNameContext);
|
2008-11-21 22:14:01 +03:00
|
|
|
ParseDeclaratorInternal(D, /*DirectDeclParser=*/0);
|
2009-02-09 21:23:29 +03:00
|
|
|
if (EndLoc)
|
|
|
|
*EndLoc = D.getSourceRange().getEnd();
|
2008-11-07 23:08:42 +03:00
|
|
|
|
|
|
|
// Finish up the type.
|
|
|
|
Action::TypeResult Result = Actions.ActOnTypeName(CurScope, D);
|
2009-01-27 01:44:13 +03:00
|
|
|
if (Result.isInvalid())
|
2008-11-07 23:08:42 +03:00
|
|
|
return 0;
|
|
|
|
else
|
2009-01-27 01:44:13 +03:00
|
|
|
return Result.get();
|
2008-11-07 23:08:42 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
|
|
|
|
/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
|
|
|
|
/// memory in a typesafe manner and call constructors.
|
2009-09-09 19:08:12 +04:00
|
|
|
///
|
2009-01-05 00:25:24 +03:00
|
|
|
/// This method is called to parse the new expression after the optional :: has
|
|
|
|
/// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
|
|
|
|
/// is its location. Otherwise, "Start" is the location of the 'new' token.
|
2008-11-21 22:14:01 +03:00
|
|
|
///
|
|
|
|
/// new-expression:
|
|
|
|
/// '::'[opt] 'new' new-placement[opt] new-type-id
|
|
|
|
/// new-initializer[opt]
|
|
|
|
/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
|
|
|
|
/// new-initializer[opt]
|
|
|
|
///
|
|
|
|
/// new-placement:
|
|
|
|
/// '(' expression-list ')'
|
|
|
|
///
|
2008-12-02 17:43:59 +03:00
|
|
|
/// new-type-id:
|
|
|
|
/// type-specifier-seq new-declarator[opt]
|
|
|
|
///
|
|
|
|
/// new-declarator:
|
|
|
|
/// ptr-operator new-declarator[opt]
|
|
|
|
/// direct-new-declarator
|
|
|
|
///
|
2008-11-21 22:14:01 +03:00
|
|
|
/// new-initializer:
|
|
|
|
/// '(' expression-list[opt] ')'
|
|
|
|
/// [C++0x] braced-init-list [TODO]
|
|
|
|
///
|
2009-01-05 00:25:24 +03:00
|
|
|
Parser::OwningExprResult
|
|
|
|
Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
|
|
|
|
assert(Tok.is(tok::kw_new) && "expected 'new' token");
|
|
|
|
ConsumeToken(); // Consume 'new'
|
2008-11-21 22:14:01 +03:00
|
|
|
|
|
|
|
// A '(' now can be a new-placement or the '(' wrapping the type-id in the
|
|
|
|
// second form of new-expression. It can't be a new-type-id.
|
|
|
|
|
2008-11-26 01:21:31 +03:00
|
|
|
ExprVector PlacementArgs(Actions);
|
2008-11-21 22:14:01 +03:00
|
|
|
SourceLocation PlacementLParen, PlacementRParen;
|
|
|
|
|
|
|
|
bool ParenTypeId;
|
2008-12-02 17:43:59 +03:00
|
|
|
DeclSpec DS;
|
|
|
|
Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
|
2008-11-21 22:14:01 +03:00
|
|
|
if (Tok.is(tok::l_paren)) {
|
|
|
|
// If it turns out to be a placement, we change the type location.
|
|
|
|
PlacementLParen = ConsumeParen();
|
2008-12-02 17:43:59 +03:00
|
|
|
if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
|
|
|
|
SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-12-02 17:43:59 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
|
|
|
|
PlacementRParen = MatchRHSPunctuation(tok::r_paren, PlacementLParen);
|
2008-12-02 17:43:59 +03:00
|
|
|
if (PlacementRParen.isInvalid()) {
|
|
|
|
SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-12-02 17:43:59 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
|
2008-12-02 17:43:59 +03:00
|
|
|
if (PlacementArgs.empty()) {
|
2008-11-21 22:14:01 +03:00
|
|
|
// Reset the placement locations. There was no placement.
|
|
|
|
PlacementLParen = PlacementRParen = SourceLocation();
|
|
|
|
ParenTypeId = true;
|
|
|
|
} else {
|
|
|
|
// We still need the type.
|
|
|
|
if (Tok.is(tok::l_paren)) {
|
2008-12-02 17:43:59 +03:00
|
|
|
SourceLocation LParen = ConsumeParen();
|
|
|
|
ParseSpecifierQualifierList(DS);
|
2009-02-09 21:23:29 +03:00
|
|
|
DeclaratorInfo.SetSourceRange(DS.getSourceRange());
|
2008-12-02 17:43:59 +03:00
|
|
|
ParseDeclarator(DeclaratorInfo);
|
|
|
|
MatchRHSPunctuation(tok::r_paren, LParen);
|
2008-11-21 22:14:01 +03:00
|
|
|
ParenTypeId = true;
|
|
|
|
} else {
|
2008-12-02 17:43:59 +03:00
|
|
|
if (ParseCXXTypeSpecifierSeq(DS))
|
|
|
|
DeclaratorInfo.setInvalidType(true);
|
2009-02-09 21:23:29 +03:00
|
|
|
else {
|
|
|
|
DeclaratorInfo.SetSourceRange(DS.getSourceRange());
|
2008-12-02 17:43:59 +03:00
|
|
|
ParseDeclaratorInternal(DeclaratorInfo,
|
|
|
|
&Parser::ParseDirectNewDeclarator);
|
2009-02-09 21:23:29 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
ParenTypeId = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2008-12-02 17:43:59 +03:00
|
|
|
// A new-type-id is a simplified type-id, where essentially the
|
|
|
|
// direct-declarator is replaced by a direct-new-declarator.
|
|
|
|
if (ParseCXXTypeSpecifierSeq(DS))
|
|
|
|
DeclaratorInfo.setInvalidType(true);
|
2009-02-09 21:23:29 +03:00
|
|
|
else {
|
|
|
|
DeclaratorInfo.SetSourceRange(DS.getSourceRange());
|
2008-12-02 17:43:59 +03:00
|
|
|
ParseDeclaratorInternal(DeclaratorInfo,
|
|
|
|
&Parser::ParseDirectNewDeclarator);
|
2009-02-09 21:23:29 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
ParenTypeId = false;
|
|
|
|
}
|
2009-04-25 12:06:05 +04:00
|
|
|
if (DeclaratorInfo.isInvalidType()) {
|
2008-12-02 17:43:59 +03:00
|
|
|
SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-12-02 17:43:59 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
|
2008-11-26 01:21:31 +03:00
|
|
|
ExprVector ConstructorArgs(Actions);
|
2008-11-21 22:14:01 +03:00
|
|
|
SourceLocation ConstructorLParen, ConstructorRParen;
|
|
|
|
|
|
|
|
if (Tok.is(tok::l_paren)) {
|
|
|
|
ConstructorLParen = ConsumeParen();
|
|
|
|
if (Tok.isNot(tok::r_paren)) {
|
|
|
|
CommaLocsTy CommaLocs;
|
2008-12-02 17:43:59 +03:00
|
|
|
if (ParseExpressionList(ConstructorArgs, CommaLocs)) {
|
|
|
|
SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-12-02 17:43:59 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
}
|
|
|
|
ConstructorRParen = MatchRHSPunctuation(tok::r_paren, ConstructorLParen);
|
2008-12-02 17:43:59 +03:00
|
|
|
if (ConstructorRParen.isInvalid()) {
|
|
|
|
SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-12-02 17:43:59 +03:00
|
|
|
}
|
2008-11-21 22:14:01 +03:00
|
|
|
}
|
|
|
|
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
|
|
|
|
move_arg(PlacementArgs), PlacementRParen,
|
|
|
|
ParenTypeId, DeclaratorInfo, ConstructorLParen,
|
|
|
|
move_arg(ConstructorArgs), ConstructorRParen);
|
2008-11-21 22:14:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
|
|
|
|
/// passed to ParseDeclaratorInternal.
|
|
|
|
///
|
|
|
|
/// direct-new-declarator:
|
|
|
|
/// '[' expression ']'
|
|
|
|
/// direct-new-declarator '[' constant-expression ']'
|
|
|
|
///
|
2009-01-05 00:25:24 +03:00
|
|
|
void Parser::ParseDirectNewDeclarator(Declarator &D) {
|
2008-11-21 22:14:01 +03:00
|
|
|
// Parse the array dimensions.
|
|
|
|
bool first = true;
|
|
|
|
while (Tok.is(tok::l_square)) {
|
|
|
|
SourceLocation LLoc = ConsumeBracket();
|
2008-12-12 00:36:32 +03:00
|
|
|
OwningExprResult Size(first ? ParseExpression()
|
|
|
|
: ParseConstantExpression());
|
2008-12-09 16:15:23 +03:00
|
|
|
if (Size.isInvalid()) {
|
2008-11-21 22:14:01 +03:00
|
|
|
// Recover
|
|
|
|
SkipUntil(tok::r_square);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
first = false;
|
|
|
|
|
2009-02-09 21:23:29 +03:00
|
|
|
SourceLocation RLoc = MatchRHSPunctuation(tok::r_square, LLoc);
|
2008-11-21 22:14:01 +03:00
|
|
|
D.AddTypeInfo(DeclaratorChunk::getArray(0, /*static=*/false, /*star=*/false,
|
2009-07-06 19:59:29 +04:00
|
|
|
Size.release(), LLoc, RLoc),
|
2009-02-09 21:23:29 +03:00
|
|
|
RLoc);
|
2008-11-21 22:14:01 +03:00
|
|
|
|
2009-02-09 21:23:29 +03:00
|
|
|
if (RLoc.isInvalid())
|
2008-11-21 22:14:01 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
|
|
|
|
/// This ambiguity appears in the syntax of the C++ new operator.
|
|
|
|
///
|
|
|
|
/// new-expression:
|
|
|
|
/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
|
|
|
|
/// new-initializer[opt]
|
|
|
|
///
|
|
|
|
/// new-placement:
|
|
|
|
/// '(' expression-list ')'
|
|
|
|
///
|
2008-12-02 17:43:59 +03:00
|
|
|
bool Parser::ParseExpressionListOrTypeId(ExprListTy &PlacementArgs,
|
2009-01-05 00:25:24 +03:00
|
|
|
Declarator &D) {
|
2008-11-21 22:14:01 +03:00
|
|
|
// The '(' was already consumed.
|
|
|
|
if (isTypeIdInParens()) {
|
2008-12-02 17:43:59 +03:00
|
|
|
ParseSpecifierQualifierList(D.getMutableDeclSpec());
|
2009-02-09 21:23:29 +03:00
|
|
|
D.SetSourceRange(D.getDeclSpec().getSourceRange());
|
2008-12-02 17:43:59 +03:00
|
|
|
ParseDeclarator(D);
|
2009-04-25 12:06:05 +04:00
|
|
|
return D.isInvalidType();
|
2008-11-21 22:14:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// It's not a type, it has to be an expression list.
|
|
|
|
// Discard the comma locations - ActOnCXXNew has enough parameters.
|
|
|
|
CommaLocsTy CommaLocs;
|
|
|
|
return ParseExpressionList(PlacementArgs, CommaLocs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
|
|
|
|
/// to free memory allocated by new.
|
|
|
|
///
|
2009-01-05 00:25:24 +03:00
|
|
|
/// This method is called to parse the 'delete' expression after the optional
|
|
|
|
/// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
|
|
|
|
/// and "Start" is its location. Otherwise, "Start" is the location of the
|
|
|
|
/// 'delete' token.
|
|
|
|
///
|
2008-11-21 22:14:01 +03:00
|
|
|
/// delete-expression:
|
|
|
|
/// '::'[opt] 'delete' cast-expression
|
|
|
|
/// '::'[opt] 'delete' '[' ']' cast-expression
|
2009-01-05 00:25:24 +03:00
|
|
|
Parser::OwningExprResult
|
|
|
|
Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
|
|
|
|
assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
|
|
|
|
ConsumeToken(); // Consume 'delete'
|
2008-11-21 22:14:01 +03:00
|
|
|
|
|
|
|
// Array delete?
|
|
|
|
bool ArrayDelete = false;
|
|
|
|
if (Tok.is(tok::l_square)) {
|
|
|
|
ArrayDelete = true;
|
|
|
|
SourceLocation LHS = ConsumeBracket();
|
|
|
|
SourceLocation RHS = MatchRHSPunctuation(tok::r_square, LHS);
|
|
|
|
if (RHS.isInvalid())
|
2008-12-12 01:51:44 +03:00
|
|
|
return ExprError();
|
2008-11-21 22:14:01 +03:00
|
|
|
}
|
|
|
|
|
2008-12-12 00:36:32 +03:00
|
|
|
OwningExprResult Operand(ParseCastExpression(false));
|
2008-12-09 16:15:23 +03:00
|
|
|
if (Operand.isInvalid())
|
2008-12-12 01:51:44 +03:00
|
|
|
return move(Operand);
|
2008-11-21 22:14:01 +03:00
|
|
|
|
2009-03-15 20:47:39 +03:00
|
|
|
return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, move(Operand));
|
2008-11-21 22:14:01 +03:00
|
|
|
}
|
2009-01-05 23:52:13 +03:00
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind) {
|
2009-01-05 23:52:13 +03:00
|
|
|
switch(kind) {
|
|
|
|
default: assert(false && "Not a known unary type trait.");
|
|
|
|
case tok::kw___has_nothrow_assign: return UTT_HasNothrowAssign;
|
|
|
|
case tok::kw___has_nothrow_copy: return UTT_HasNothrowCopy;
|
|
|
|
case tok::kw___has_nothrow_constructor: return UTT_HasNothrowConstructor;
|
|
|
|
case tok::kw___has_trivial_assign: return UTT_HasTrivialAssign;
|
|
|
|
case tok::kw___has_trivial_copy: return UTT_HasTrivialCopy;
|
|
|
|
case tok::kw___has_trivial_constructor: return UTT_HasTrivialConstructor;
|
|
|
|
case tok::kw___has_trivial_destructor: return UTT_HasTrivialDestructor;
|
|
|
|
case tok::kw___has_virtual_destructor: return UTT_HasVirtualDestructor;
|
|
|
|
case tok::kw___is_abstract: return UTT_IsAbstract;
|
|
|
|
case tok::kw___is_class: return UTT_IsClass;
|
|
|
|
case tok::kw___is_empty: return UTT_IsEmpty;
|
|
|
|
case tok::kw___is_enum: return UTT_IsEnum;
|
|
|
|
case tok::kw___is_pod: return UTT_IsPOD;
|
|
|
|
case tok::kw___is_polymorphic: return UTT_IsPolymorphic;
|
|
|
|
case tok::kw___is_union: return UTT_IsUnion;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ParseUnaryTypeTrait - Parse the built-in unary type-trait
|
|
|
|
/// pseudo-functions that allow implementation of the TR1/C++0x type traits
|
|
|
|
/// templates.
|
|
|
|
///
|
|
|
|
/// primary-expression:
|
|
|
|
/// [GNU] unary-type-trait '(' type-id ')'
|
|
|
|
///
|
2009-09-09 19:08:12 +04:00
|
|
|
Parser::OwningExprResult Parser::ParseUnaryTypeTrait() {
|
2009-01-05 23:52:13 +03:00
|
|
|
UnaryTypeTrait UTT = UnaryTypeTraitFromTokKind(Tok.getKind());
|
|
|
|
SourceLocation Loc = ConsumeToken();
|
|
|
|
|
|
|
|
SourceLocation LParen = Tok.getLocation();
|
|
|
|
if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen))
|
|
|
|
return ExprError();
|
|
|
|
|
|
|
|
// FIXME: Error reporting absolutely sucks! If the this fails to parse a type
|
|
|
|
// there will be cryptic errors about mismatched parentheses and missing
|
|
|
|
// specifiers.
|
2009-02-18 20:45:20 +03:00
|
|
|
TypeResult Ty = ParseTypeName();
|
2009-01-05 23:52:13 +03:00
|
|
|
|
|
|
|
SourceLocation RParen = MatchRHSPunctuation(tok::r_paren, LParen);
|
|
|
|
|
2009-02-18 20:45:20 +03:00
|
|
|
if (Ty.isInvalid())
|
|
|
|
return ExprError();
|
|
|
|
|
|
|
|
return Actions.ActOnUnaryTypeTrait(UTT, Loc, LParen, Ty.get(), RParen);
|
2009-01-05 23:52:13 +03:00
|
|
|
}
|
2009-05-22 14:24:42 +04:00
|
|
|
|
|
|
|
/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
|
|
|
|
/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
|
|
|
|
/// based on the context past the parens.
|
|
|
|
Parser::OwningExprResult
|
|
|
|
Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
|
|
|
|
TypeTy *&CastTy,
|
|
|
|
SourceLocation LParenLoc,
|
|
|
|
SourceLocation &RParenLoc) {
|
|
|
|
assert(getLang().CPlusPlus && "Should only be called for C++!");
|
|
|
|
assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
|
|
|
|
assert(isTypeIdInParens() && "Not a type-id!");
|
|
|
|
|
|
|
|
OwningExprResult Result(Actions, true);
|
|
|
|
CastTy = 0;
|
|
|
|
|
|
|
|
// We need to disambiguate a very ugly part of the C++ syntax:
|
|
|
|
//
|
|
|
|
// (T())x; - type-id
|
|
|
|
// (T())*x; - type-id
|
|
|
|
// (T())/x; - expression
|
|
|
|
// (T()); - expression
|
|
|
|
//
|
|
|
|
// The bad news is that we cannot use the specialized tentative parser, since
|
|
|
|
// it can only verify that the thing inside the parens can be parsed as
|
|
|
|
// type-id, it is not useful for determining the context past the parens.
|
|
|
|
//
|
|
|
|
// The good news is that the parser can disambiguate this part without
|
2009-05-22 19:12:46 +04:00
|
|
|
// making any unnecessary Action calls.
|
2009-05-23 01:09:47 +04:00
|
|
|
//
|
|
|
|
// It uses a scheme similar to parsing inline methods. The parenthesized
|
|
|
|
// tokens are cached, the context that follows is determined (possibly by
|
|
|
|
// parsing a cast-expression), and then we re-introduce the cached tokens
|
|
|
|
// into the token stream and parse them appropriately.
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
ParenParseOption ParseAs;
|
2009-05-23 01:09:47 +04:00
|
|
|
CachedTokens Toks;
|
|
|
|
|
|
|
|
// Store the tokens of the parentheses. We will parse them after we determine
|
|
|
|
// the context that follows them.
|
|
|
|
if (!ConsumeAndStoreUntil(tok::r_paren, tok::unknown, Toks, tok::semi)) {
|
|
|
|
// We didn't find the ')' we expected.
|
2009-05-22 14:24:42 +04:00
|
|
|
MatchRHSPunctuation(tok::r_paren, LParenLoc);
|
|
|
|
return ExprError();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Tok.is(tok::l_brace)) {
|
2009-05-23 01:09:47 +04:00
|
|
|
ParseAs = CompoundLiteral;
|
|
|
|
} else {
|
|
|
|
bool NotCastExpr;
|
2009-05-25 23:41:42 +04:00
|
|
|
// FIXME: Special-case ++ and --: "(S())++;" is not a cast-expression
|
|
|
|
if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
|
|
|
|
NotCastExpr = true;
|
|
|
|
} else {
|
|
|
|
// Try parsing the cast-expression that may follow.
|
|
|
|
// If it is not a cast-expression, NotCastExpr will be true and no token
|
|
|
|
// will be consumed.
|
|
|
|
Result = ParseCastExpression(false/*isUnaryExpression*/,
|
|
|
|
false/*isAddressofOperand*/,
|
2009-08-11 03:49:36 +04:00
|
|
|
NotCastExpr, false);
|
2009-05-25 23:41:42 +04:00
|
|
|
}
|
2009-05-23 01:09:47 +04:00
|
|
|
|
|
|
|
// If we parsed a cast-expression, it's really a type-id, otherwise it's
|
|
|
|
// an expression.
|
|
|
|
ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
|
2009-05-22 14:24:42 +04:00
|
|
|
}
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
// The current token should go after the cached tokens.
|
2009-05-23 01:09:47 +04:00
|
|
|
Toks.push_back(Tok);
|
|
|
|
// Re-enter the stored parenthesized tokens into the token stream, so we may
|
|
|
|
// parse them now.
|
|
|
|
PP.EnterTokenStream(Toks.data(), Toks.size(),
|
|
|
|
true/*DisableMacroExpansion*/, false/*OwnsTokens*/);
|
|
|
|
// Drop the current token and bring the first cached one. It's the same token
|
|
|
|
// as when we entered this function.
|
|
|
|
ConsumeAnyToken();
|
|
|
|
|
|
|
|
if (ParseAs >= CompoundLiteral) {
|
|
|
|
TypeResult Ty = ParseTypeName();
|
2009-05-22 14:24:42 +04:00
|
|
|
|
2009-05-23 01:09:47 +04:00
|
|
|
// Match the ')'.
|
|
|
|
if (Tok.is(tok::r_paren))
|
|
|
|
RParenLoc = ConsumeParen();
|
|
|
|
else
|
|
|
|
MatchRHSPunctuation(tok::r_paren, LParenLoc);
|
|
|
|
|
|
|
|
if (ParseAs == CompoundLiteral) {
|
|
|
|
ExprType = CompoundLiteral;
|
|
|
|
return ParseCompoundLiteralExpression(Ty.get(), LParenLoc, RParenLoc);
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-05-23 01:09:47 +04:00
|
|
|
// We parsed '(' type-id ')' and the thing after it wasn't a '{'.
|
|
|
|
assert(ParseAs == CastExpr);
|
|
|
|
|
|
|
|
if (Ty.isInvalid())
|
|
|
|
return ExprError();
|
2009-05-22 14:24:42 +04:00
|
|
|
|
|
|
|
CastTy = Ty.get();
|
2009-05-23 01:09:47 +04:00
|
|
|
|
|
|
|
// Result is what ParseCastExpression returned earlier.
|
2009-05-22 14:24:42 +04:00
|
|
|
if (!Result.isInvalid())
|
2009-09-09 19:08:12 +04:00
|
|
|
Result = Actions.ActOnCastExpr(CurScope, LParenLoc, CastTy, RParenLoc,
|
2009-08-11 03:49:36 +04:00
|
|
|
move(Result));
|
2009-05-22 14:24:42 +04:00
|
|
|
return move(Result);
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-05-23 01:09:47 +04:00
|
|
|
// Not a compound literal, and not followed by a cast-expression.
|
|
|
|
assert(ParseAs == SimpleExpr);
|
2009-05-22 14:24:42 +04:00
|
|
|
|
|
|
|
ExprType = SimpleExpr;
|
2009-05-23 01:09:47 +04:00
|
|
|
Result = ParseExpression();
|
2009-05-22 14:24:42 +04:00
|
|
|
if (!Result.isInvalid() && Tok.is(tok::r_paren))
|
|
|
|
Result = Actions.ActOnParenExpr(LParenLoc, Tok.getLocation(), move(Result));
|
|
|
|
|
|
|
|
// Match the ')'.
|
|
|
|
if (Result.isInvalid()) {
|
|
|
|
SkipUntil(tok::r_paren);
|
|
|
|
return ExprError();
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-05-22 14:24:42 +04:00
|
|
|
if (Tok.is(tok::r_paren))
|
|
|
|
RParenLoc = ConsumeParen();
|
|
|
|
else
|
|
|
|
MatchRHSPunctuation(tok::r_paren, LParenLoc);
|
|
|
|
|
|
|
|
return move(Result);
|
|
|
|
}
|