2009-02-14 23:20:19 +03:00
|
|
|
//===--- SemaCXXScopeSpec.cpp - Semantic Analysis for C++ scope specifiers-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements C++ semantic analysis for scope specifiers.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-08-13 00:07:10 +04:00
|
|
|
#include "clang/Sema/Sema.h"
|
|
|
|
#include "clang/Sema/Lookup.h"
|
2009-02-14 23:20:19 +03:00
|
|
|
#include "clang/AST/ASTContext.h"
|
2009-05-11 23:58:34 +04:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
2009-08-06 07:17:00 +04:00
|
|
|
#include "clang/AST/ExprCXX.h"
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@67265 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-19 03:18:19 +03:00
|
|
|
#include "clang/AST/NestedNameSpecifier.h"
|
2009-08-27 03:45:07 +04:00
|
|
|
#include "clang/Basic/PartialDiagnostic.h"
|
2009-02-14 23:20:19 +03:00
|
|
|
#include "clang/Parse/DeclSpec.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2009-07-22 04:28:09 +04:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2009-02-14 23:20:19 +03:00
|
|
|
using namespace clang;
|
|
|
|
|
2009-11-05 01:49:18 +03:00
|
|
|
/// \brief Find the current instantiation that associated with the given type.
|
2010-04-27 04:57:59 +04:00
|
|
|
static CXXRecordDecl *getCurrentInstantiationOf(QualType T) {
|
2009-11-05 01:49:18 +03:00
|
|
|
if (T.isNull())
|
|
|
|
return 0;
|
2010-04-27 04:57:59 +04:00
|
|
|
|
|
|
|
const Type *Ty = T->getCanonicalTypeInternal().getTypePtr();
|
|
|
|
if (isa<RecordType>(Ty))
|
|
|
|
return cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
|
|
|
|
else if (isa<InjectedClassNameType>(Ty))
|
|
|
|
return cast<InjectedClassNameType>(Ty)->getDecl();
|
|
|
|
else
|
|
|
|
return 0;
|
2009-11-05 01:49:18 +03:00
|
|
|
}
|
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
/// \brief Compute the DeclContext that is associated with the given type.
|
|
|
|
///
|
|
|
|
/// \param T the type for which we are attempting to find a DeclContext.
|
|
|
|
///
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \returns the declaration context represented by the type T,
|
2009-09-03 02:59:36 +04:00
|
|
|
/// or NULL if the declaration context cannot be computed (e.g., because it is
|
|
|
|
/// dependent and not the current instantiation).
|
|
|
|
DeclContext *Sema::computeDeclContext(QualType T) {
|
|
|
|
if (const TagType *Tag = T->getAs<TagType>())
|
|
|
|
return Tag->getDecl();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-04-27 04:57:59 +04:00
|
|
|
return ::getCurrentInstantiationOf(T);
|
2009-09-03 02:59:36 +04:00
|
|
|
}
|
|
|
|
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@67265 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-19 03:18:19 +03:00
|
|
|
/// \brief Compute the DeclContext that is associated with the given
|
|
|
|
/// scope specifier.
|
2009-07-22 03:53:31 +04:00
|
|
|
///
|
|
|
|
/// \param SS the C++ scope specifier as it appears in the source
|
|
|
|
///
|
|
|
|
/// \param EnteringContext when true, we will be entering the context of
|
|
|
|
/// this scope specifier, so we can retrieve the declaration context of a
|
|
|
|
/// class template or class template partial specialization even if it is
|
|
|
|
/// not the current instantiation.
|
|
|
|
///
|
|
|
|
/// \returns the declaration context represented by the scope specifier @p SS,
|
|
|
|
/// or NULL if the declaration context cannot be computed (e.g., because it is
|
|
|
|
/// dependent and not the current instantiation).
|
|
|
|
DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS,
|
|
|
|
bool EnteringContext) {
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@67265 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-19 03:18:19 +03:00
|
|
|
if (!SS.isSet() || SS.isInvalid())
|
2009-03-18 03:36:05 +03:00
|
|
|
return 0;
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
NestedNameSpecifier *NNS
|
2009-03-27 02:56:24 +03:00
|
|
|
= static_cast<NestedNameSpecifier *>(SS.getScopeRep());
|
2009-05-11 23:58:34 +04:00
|
|
|
if (NNS->isDependent()) {
|
|
|
|
// If this nested-name-specifier refers to the current
|
|
|
|
// instantiation, return its DeclContext.
|
|
|
|
if (CXXRecordDecl *Record = getCurrentInstantiationOf(NNS))
|
|
|
|
return Record;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-22 03:53:31 +04:00
|
|
|
if (EnteringContext) {
|
2010-03-10 06:28:59 +03:00
|
|
|
const Type *NNSType = NNS->getAsType();
|
|
|
|
if (!NNSType) {
|
|
|
|
// do nothing, fall out
|
|
|
|
} else if (const TemplateSpecializationType *SpecType
|
|
|
|
= NNSType->getAs<TemplateSpecializationType>()) {
|
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
|
|
|
// We are entering the context of the nested name specifier, so try to
|
|
|
|
// match the nested name specifier to either a primary class template
|
|
|
|
// or a class template partial specialization.
|
2009-09-09 19:08:12 +04:00
|
|
|
if (ClassTemplateDecl *ClassTemplate
|
2009-07-22 03:53:31 +04:00
|
|
|
= dyn_cast_or_null<ClassTemplateDecl>(
|
|
|
|
SpecType->getTemplateName().getAsTemplateDecl())) {
|
2009-07-30 21:40:51 +04:00
|
|
|
QualType ContextType
|
|
|
|
= Context.getCanonicalType(QualType(SpecType, 0));
|
|
|
|
|
2009-07-22 03:53:31 +04:00
|
|
|
// If the type of the nested name specifier is the same as the
|
|
|
|
// injected class name of the named class template, we're entering
|
|
|
|
// into that class template definition.
|
2010-03-10 06:28:59 +03:00
|
|
|
QualType Injected
|
2010-07-08 22:37:38 +04:00
|
|
|
= ClassTemplate->getInjectedClassNameSpecialization();
|
2009-07-30 21:40:51 +04:00
|
|
|
if (Context.hasSameType(Injected, ContextType))
|
2009-07-22 03:53:31 +04:00
|
|
|
return ClassTemplate->getTemplatedDecl();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-30 21:40:51 +04:00
|
|
|
// If the type of the nested name specifier is the same as the
|
|
|
|
// type of one of the class template's class template partial
|
|
|
|
// specializations, we're entering into the definition of that
|
|
|
|
// class template partial specialization.
|
|
|
|
if (ClassTemplatePartialSpecializationDecl *PartialSpec
|
|
|
|
= ClassTemplate->findPartialSpecialization(ContextType))
|
|
|
|
return PartialSpec;
|
2009-07-22 03:53:31 +04:00
|
|
|
}
|
2010-03-10 06:28:59 +03:00
|
|
|
} else if (const RecordType *RecordT = NNSType->getAs<RecordType>()) {
|
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
|
|
|
// The nested name specifier refers to a member of a class template.
|
|
|
|
return RecordT->getDecl();
|
2009-07-22 03:53:31 +04:00
|
|
|
}
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-22 03:53:31 +04:00
|
|
|
return 0;
|
2009-05-11 23:58:34 +04:00
|
|
|
}
|
2009-03-27 02:50:42 +03:00
|
|
|
|
|
|
|
switch (NNS->getKind()) {
|
|
|
|
case NestedNameSpecifier::Identifier:
|
|
|
|
assert(false && "Dependent nested-name-specifier has no DeclContext");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NestedNameSpecifier::Namespace:
|
|
|
|
return NNS->getAsNamespace();
|
|
|
|
|
|
|
|
case NestedNameSpecifier::TypeSpec:
|
|
|
|
case NestedNameSpecifier::TypeSpecWithTemplate: {
|
2010-02-25 07:46:04 +03:00
|
|
|
const TagType *Tag = NNS->getAsType()->getAs<TagType>();
|
|
|
|
assert(Tag && "Non-tag type in nested-name-specifier");
|
|
|
|
return Tag->getDecl();
|
|
|
|
} break;
|
2009-03-27 02:50:42 +03:00
|
|
|
|
|
|
|
case NestedNameSpecifier::Global:
|
|
|
|
return Context.getTranslationUnitDecl();
|
|
|
|
}
|
|
|
|
|
2010-02-25 07:46:04 +03:00
|
|
|
// Required to silence a GCC warning.
|
2009-03-27 02:50:42 +03:00
|
|
|
return 0;
|
2009-03-18 03:36:05 +03:00
|
|
|
}
|
|
|
|
|
Introduce a new expression type, UnresolvedDeclRefExpr, that describes
dependent qualified-ids such as
Fibonacci<N - 1>::value
where N is a template parameter. These references are "unresolved"
because the name is dependent and, therefore, cannot be resolved to a
declaration node (as we would do for a DeclRefExpr or
QualifiedDeclRefExpr). UnresolvedDeclRefExprs instantiate to
DeclRefExprs, QualifiedDeclRefExprs, etc.
Also, be a bit more careful about keeping only a single set of
specializations for a class template, and instantiating from the
definition of that template rather than a previous declaration. In
general, we need a better solution for this for all TagDecls, because
it's too easy to accidentally look at a declaration that isn't the
definition.
We can now process a simple Fibonacci computation described as a
template metaprogram.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@67308 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-19 20:26:29 +03:00
|
|
|
bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) {
|
|
|
|
if (!SS.isSet() || SS.isInvalid())
|
|
|
|
return false;
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
NestedNameSpecifier *NNS
|
2009-03-27 02:56:24 +03:00
|
|
|
= static_cast<NestedNameSpecifier *>(SS.getScopeRep());
|
2009-03-27 02:50:42 +03:00
|
|
|
return NNS->isDependent();
|
Introduce a new expression type, UnresolvedDeclRefExpr, that describes
dependent qualified-ids such as
Fibonacci<N - 1>::value
where N is a template parameter. These references are "unresolved"
because the name is dependent and, therefore, cannot be resolved to a
declaration node (as we would do for a DeclRefExpr or
QualifiedDeclRefExpr). UnresolvedDeclRefExprs instantiate to
DeclRefExprs, QualifiedDeclRefExprs, etc.
Also, be a bit more careful about keeping only a single set of
specializations for a class template, and instantiating from the
definition of that template rather than a previous declaration. In
general, we need a better solution for this for all TagDecls, because
it's too easy to accidentally look at a declaration that isn't the
definition.
We can now process a simple Fibonacci computation described as a
template metaprogram.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@67308 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-19 20:26:29 +03:00
|
|
|
}
|
|
|
|
|
2009-05-11 23:58:34 +04:00
|
|
|
// \brief Determine whether this C++ scope specifier refers to an
|
|
|
|
// unknown specialization, i.e., a dependent type that is not the
|
|
|
|
// current instantiation.
|
|
|
|
bool Sema::isUnknownSpecialization(const CXXScopeSpec &SS) {
|
|
|
|
if (!isDependentScopeSpecifier(SS))
|
|
|
|
return false;
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
NestedNameSpecifier *NNS
|
2009-05-11 23:58:34 +04:00
|
|
|
= static_cast<NestedNameSpecifier *>(SS.getScopeRep());
|
|
|
|
return getCurrentInstantiationOf(NNS) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief If the given nested name specifier refers to the current
|
|
|
|
/// instantiation, return the declaration that corresponds to that
|
|
|
|
/// current instantiation (C++0x [temp.dep.type]p1).
|
|
|
|
///
|
|
|
|
/// \param NNS a dependent nested name specifier.
|
|
|
|
CXXRecordDecl *Sema::getCurrentInstantiationOf(NestedNameSpecifier *NNS) {
|
|
|
|
assert(getLangOptions().CPlusPlus && "Only callable in C++");
|
|
|
|
assert(NNS->isDependent() && "Only dependent nested-name-specifier allowed");
|
|
|
|
|
2009-07-22 03:53:31 +04:00
|
|
|
if (!NNS->getAsType())
|
|
|
|
return 0;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-31 22:32:42 +04:00
|
|
|
QualType T = QualType(NNS->getAsType(), 0);
|
2010-04-27 04:57:59 +04:00
|
|
|
return ::getCurrentInstantiationOf(T);
|
2009-05-11 23:58:34 +04:00
|
|
|
}
|
|
|
|
|
2009-03-11 19:48:53 +03:00
|
|
|
/// \brief Require that the context specified by SS be complete.
|
|
|
|
///
|
|
|
|
/// If SS refers to a type, this routine checks whether the type is
|
|
|
|
/// complete enough (or can be made complete enough) for name lookup
|
|
|
|
/// into the DeclContext. A type that is not yet completed can be
|
|
|
|
/// considered "complete enough" if it is a class/struct/union/enum
|
|
|
|
/// that is currently being defined. Or, if we have a type that names
|
|
|
|
/// a class template specialization that is not a complete type, we
|
|
|
|
/// will attempt to instantiate that class template.
|
2010-05-01 04:40:08 +04:00
|
|
|
bool Sema::RequireCompleteDeclContext(CXXScopeSpec &SS,
|
|
|
|
DeclContext *DC) {
|
|
|
|
assert(DC != 0 && "given null context");
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-03-11 19:48:53 +03:00
|
|
|
if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) {
|
2010-02-05 07:39:02 +03:00
|
|
|
// If this is a dependent type, then we consider it complete.
|
|
|
|
if (Tag->isDependentContext())
|
|
|
|
return false;
|
|
|
|
|
2009-03-11 19:48:53 +03:00
|
|
|
// If we're currently defining this type, then lookup into the
|
|
|
|
// type is okay: don't complain that it isn't complete yet.
|
2009-07-30 01:53:49 +04:00
|
|
|
const TagType *TagT = Context.getTypeDeclType(Tag)->getAs<TagType>();
|
2010-03-10 06:28:59 +03:00
|
|
|
if (TagT && TagT->isBeingDefined())
|
2009-03-11 19:48:53 +03:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// The type must be complete.
|
2010-04-08 20:38:48 +04:00
|
|
|
if (RequireCompleteType(SS.getRange().getBegin(),
|
|
|
|
Context.getTypeDeclType(Tag),
|
|
|
|
PDiag(diag::err_incomplete_nested_name_spec)
|
2010-05-01 04:40:08 +04:00
|
|
|
<< SS.getRange())) {
|
2010-04-08 20:38:48 +04:00
|
|
|
SS.setScopeRep(0); // Mark the ScopeSpec invalid.
|
|
|
|
return true;
|
|
|
|
}
|
2009-03-11 19:48:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2009-02-14 23:20:19 +03:00
|
|
|
|
|
|
|
/// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
|
|
|
|
/// global scope ('::').
|
|
|
|
Sema::CXXScopeTy *Sema::ActOnCXXGlobalScopeSpecifier(Scope *S,
|
|
|
|
SourceLocation CCLoc) {
|
2009-03-27 02:50:42 +03:00
|
|
|
return NestedNameSpecifier::GlobalSpecifier(Context);
|
2009-02-14 23:20:19 +03:00
|
|
|
}
|
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
/// \brief Determines whether the given declaration is an valid acceptable
|
|
|
|
/// result for name lookup of a nested-name-specifier.
|
2010-02-25 07:46:04 +03:00
|
|
|
bool Sema::isAcceptableNestedNameSpecifier(NamedDecl *SD) {
|
2009-09-03 02:59:36 +04:00
|
|
|
if (!SD)
|
|
|
|
return false;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
// Namespace and namespace aliases are fine.
|
|
|
|
if (isa<NamespaceDecl>(SD) || isa<NamespaceAliasDecl>(SD))
|
|
|
|
return true;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
if (!isa<TypeDecl>(SD))
|
|
|
|
return false;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
// Determine whether we have a class (or, in C++0x, an enum) or
|
|
|
|
// a typedef thereof. If so, build the nested-name-specifier.
|
|
|
|
QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
|
|
|
|
if (T->isDependentType())
|
|
|
|
return true;
|
|
|
|
else if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) {
|
|
|
|
if (TD->getUnderlyingType()->isRecordType() ||
|
2009-09-09 19:08:12 +04:00
|
|
|
(Context.getLangOptions().CPlusPlus0x &&
|
2009-09-03 02:59:36 +04:00
|
|
|
TD->getUnderlyingType()->isEnumeralType()))
|
|
|
|
return true;
|
2009-09-09 19:08:12 +04:00
|
|
|
} else if (isa<RecordDecl>(SD) ||
|
2009-09-03 02:59:36 +04:00
|
|
|
(Context.getLangOptions().CPlusPlus0x && isa<EnumDecl>(SD)))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-04 01:38:09 +04:00
|
|
|
/// \brief If the given nested-name-specifier begins with a bare identifier
|
2009-09-09 19:08:12 +04:00
|
|
|
/// (e.g., Base::), perform name lookup for that identifier as a
|
2009-09-04 01:38:09 +04:00
|
|
|
/// nested-name-specifier within the given scope, and return the result of that
|
|
|
|
/// name lookup.
|
|
|
|
NamedDecl *Sema::FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS) {
|
|
|
|
if (!S || !NNS)
|
|
|
|
return 0;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-04 01:38:09 +04:00
|
|
|
while (NNS->getPrefix())
|
|
|
|
NNS = NNS->getPrefix();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-04 01:38:09 +04:00
|
|
|
if (NNS->getKind() != NestedNameSpecifier::Identifier)
|
|
|
|
return 0;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-17 05:14:36 +03:00
|
|
|
LookupResult Found(*this, NNS->getAsIdentifier(), SourceLocation(),
|
|
|
|
LookupNestedNameSpecifierName);
|
|
|
|
LookupName(Found, S);
|
2009-09-04 01:38:09 +04:00
|
|
|
assert(!Found.isAmbiguous() && "Cannot handle ambiguities here yet");
|
|
|
|
|
2009-12-02 11:25:40 +03:00
|
|
|
if (!Found.isSingleResult())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
NamedDecl *Result = Found.getFoundDecl();
|
2010-02-25 07:46:04 +03:00
|
|
|
if (isAcceptableNestedNameSpecifier(Result))
|
2009-09-04 01:38:09 +04:00
|
|
|
return Result;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-04 01:38:09 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-08 20:38:48 +04:00
|
|
|
bool Sema::isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
|
2010-02-25 00:29:12 +03:00
|
|
|
SourceLocation IdLoc,
|
|
|
|
IdentifierInfo &II,
|
|
|
|
TypeTy *ObjectTypePtr) {
|
|
|
|
QualType ObjectType = GetTypeFromParser(ObjectTypePtr);
|
|
|
|
LookupResult Found(*this, &II, IdLoc, LookupNestedNameSpecifierName);
|
|
|
|
|
|
|
|
// Determine where to perform name lookup
|
|
|
|
DeclContext *LookupCtx = 0;
|
|
|
|
bool isDependent = false;
|
|
|
|
if (!ObjectType.isNull()) {
|
|
|
|
// This nested-name-specifier occurs in a member access expression, e.g.,
|
|
|
|
// x->B::f, and we are looking into the type of the object.
|
|
|
|
assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
|
|
|
|
LookupCtx = computeDeclContext(ObjectType);
|
|
|
|
isDependent = ObjectType->isDependentType();
|
|
|
|
} else if (SS.isSet()) {
|
|
|
|
// This nested-name-specifier occurs after another nested-name-specifier,
|
|
|
|
// so long into the context associated with the prior nested-name-specifier.
|
|
|
|
LookupCtx = computeDeclContext(SS, false);
|
|
|
|
isDependent = isDependentScopeSpecifier(SS);
|
|
|
|
Found.setContextRange(SS.getRange());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (LookupCtx) {
|
|
|
|
// Perform "qualified" name lookup into the declaration context we
|
|
|
|
// computed, which is either the type of the base of a member access
|
|
|
|
// expression or the declaration context associated with a prior
|
|
|
|
// nested-name-specifier.
|
|
|
|
|
|
|
|
// The declaration context must be complete.
|
2010-05-01 04:40:08 +04:00
|
|
|
if (!LookupCtx->isDependentContext() &&
|
|
|
|
RequireCompleteDeclContext(SS, LookupCtx))
|
2010-02-25 00:29:12 +03:00
|
|
|
return false;
|
|
|
|
|
|
|
|
LookupQualifiedName(Found, LookupCtx);
|
|
|
|
} else if (isDependent) {
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
LookupName(Found, S);
|
|
|
|
}
|
|
|
|
Found.suppressDiagnostics();
|
|
|
|
|
|
|
|
if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
|
|
|
|
return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-04 01:38:09 +04:00
|
|
|
/// \brief Build a new nested-name-specifier for "identifier::", as described
|
|
|
|
/// by ActOnCXXNestedNameSpecifier.
|
|
|
|
///
|
|
|
|
/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
|
|
|
|
/// that it contains an extra parameter \p ScopeLookupResult, which provides
|
|
|
|
/// the result of name lookup within the scope of the nested-name-specifier
|
2009-12-30 19:01:52 +03:00
|
|
|
/// that was computed at template definition time.
|
2009-12-07 04:36:53 +03:00
|
|
|
///
|
|
|
|
/// If ErrorRecoveryLookup is true, then this call is used to improve error
|
|
|
|
/// recovery. This means that it should not emit diagnostics, it should
|
|
|
|
/// just return null on failure. It also means it should only return a valid
|
|
|
|
/// scope if it *knows* that the result is correct. It should not return in a
|
|
|
|
/// dependent context, for example.
|
2009-09-04 01:38:09 +04:00
|
|
|
Sema::CXXScopeTy *Sema::BuildCXXNestedNameSpecifier(Scope *S,
|
2010-04-08 20:38:48 +04:00
|
|
|
CXXScopeSpec &SS,
|
2009-02-14 23:20:19 +03:00
|
|
|
SourceLocation IdLoc,
|
|
|
|
SourceLocation CCLoc,
|
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
|
|
|
IdentifierInfo &II,
|
2009-09-04 01:38:09 +04:00
|
|
|
QualType ObjectType,
|
|
|
|
NamedDecl *ScopeLookupResult,
|
2009-12-07 04:36:53 +03:00
|
|
|
bool EnteringContext,
|
|
|
|
bool ErrorRecoveryLookup) {
|
2009-09-09 19:08:12 +04:00
|
|
|
NestedNameSpecifier *Prefix
|
2009-03-27 02:56:24 +03:00
|
|
|
= static_cast<NestedNameSpecifier *>(SS.getScopeRep());
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-17 05:14:36 +03:00
|
|
|
LookupResult Found(*this, &II, IdLoc, LookupNestedNameSpecifierName);
|
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
// Determine where to perform name lookup
|
|
|
|
DeclContext *LookupCtx = 0;
|
|
|
|
bool isDependent = false;
|
2009-09-04 01:38:09 +04:00
|
|
|
if (!ObjectType.isNull()) {
|
2009-09-03 02:59:36 +04:00
|
|
|
// This nested-name-specifier occurs in a member access expression, e.g.,
|
|
|
|
// x->B::f, and we are looking into the type of the object.
|
|
|
|
assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
|
|
|
|
LookupCtx = computeDeclContext(ObjectType);
|
|
|
|
isDependent = ObjectType->isDependentType();
|
|
|
|
} else if (SS.isSet()) {
|
|
|
|
// This nested-name-specifier occurs after another nested-name-specifier,
|
|
|
|
// so long into the context associated with the prior nested-name-specifier.
|
|
|
|
LookupCtx = computeDeclContext(SS, EnteringContext);
|
|
|
|
isDependent = isDependentScopeSpecifier(SS);
|
2009-11-17 05:14:36 +03:00
|
|
|
Found.setContextRange(SS.getRange());
|
2009-09-03 02:59:36 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-17 05:14:36 +03:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
bool ObjectTypeSearchedInScope = false;
|
|
|
|
if (LookupCtx) {
|
2009-09-09 19:08:12 +04:00
|
|
|
// Perform "qualified" name lookup into the declaration context we
|
2009-09-03 02:59:36 +04:00
|
|
|
// computed, which is either the type of the base of a member access
|
2009-09-09 19:08:12 +04:00
|
|
|
// expression or the declaration context associated with a prior
|
2009-09-03 02:59:36 +04:00
|
|
|
// nested-name-specifier.
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
// The declaration context must be complete.
|
2010-05-01 04:40:08 +04:00
|
|
|
if (!LookupCtx->isDependentContext() &&
|
|
|
|
RequireCompleteDeclContext(SS, LookupCtx))
|
2009-09-03 02:59:36 +04:00
|
|
|
return 0;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-17 05:14:36 +03:00
|
|
|
LookupQualifiedName(Found, LookupCtx);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-17 05:14:36 +03:00
|
|
|
if (!ObjectType.isNull() && Found.empty()) {
|
2009-09-03 02:59:36 +04:00
|
|
|
// C++ [basic.lookup.classref]p4:
|
|
|
|
// If the id-expression in a class member access is a qualified-id of
|
2009-09-09 19:08:12 +04:00
|
|
|
// the form
|
2009-09-03 02:59:36 +04:00
|
|
|
//
|
|
|
|
// class-name-or-namespace-name::...
|
|
|
|
//
|
2009-09-09 19:08:12 +04:00
|
|
|
// the class-name-or-namespace-name following the . or -> operator is
|
|
|
|
// looked up both in the context of the entire postfix-expression and in
|
2009-09-03 02:59:36 +04:00
|
|
|
// the scope of the class of the object expression. If the name is found
|
2009-09-09 19:08:12 +04:00
|
|
|
// only in the scope of the class of the object expression, the name
|
|
|
|
// shall refer to a class-name. If the name is found only in the
|
2009-09-03 02:59:36 +04:00
|
|
|
// context of the entire postfix-expression, the name shall refer to a
|
|
|
|
// class-name or namespace-name. [...]
|
|
|
|
//
|
|
|
|
// Qualified name lookup into a class will not find a namespace-name,
|
2009-09-09 19:08:12 +04:00
|
|
|
// so we do not need to diagnoste that case specifically. However,
|
2009-09-03 02:59:36 +04:00
|
|
|
// this qualified name lookup may find nothing. In that case, perform
|
2009-09-09 19:08:12 +04:00
|
|
|
// unqualified name lookup in the given scope (if available) or
|
2009-09-04 01:38:09 +04:00
|
|
|
// reconstruct the result from when name lookup was performed at template
|
|
|
|
// definition time.
|
|
|
|
if (S)
|
2009-11-17 05:14:36 +03:00
|
|
|
LookupName(Found, S);
|
2009-10-10 01:13:30 +04:00
|
|
|
else if (ScopeLookupResult)
|
|
|
|
Found.addDecl(ScopeLookupResult);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
ObjectTypeSearchedInScope = true;
|
|
|
|
}
|
2010-07-28 18:49:07 +04:00
|
|
|
} else if (!isDependent) {
|
|
|
|
// Perform unqualified name lookup in the current scope.
|
|
|
|
LookupName(Found, S);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we performed lookup into a dependent context and did not find anything,
|
|
|
|
// that's fine: just build a dependent nested-name-specifier.
|
|
|
|
if (Found.empty() && isDependent &&
|
|
|
|
!(LookupCtx && LookupCtx->isRecord() &&
|
|
|
|
(!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
|
|
|
|
!cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases()))) {
|
2009-12-07 04:36:53 +03:00
|
|
|
// Don't speculate if we're just trying to improve error recovery.
|
|
|
|
if (ErrorRecoveryLookup)
|
|
|
|
return 0;
|
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
// We were not able to compute the declaration context for a dependent
|
2009-09-09 19:08:12 +04:00
|
|
|
// base object type or prior nested-name-specifier, so this
|
2009-09-03 02:59:36 +04:00
|
|
|
// nested-name-specifier refers to an unknown specialization. Just build
|
|
|
|
// a dependent nested-name-specifier.
|
2009-09-03 03:58:38 +04:00
|
|
|
if (!Prefix)
|
|
|
|
return NestedNameSpecifier::Create(Context, &II);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
return NestedNameSpecifier::Create(Context, Prefix, &II);
|
2010-07-28 18:49:07 +04:00
|
|
|
}
|
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
// FIXME: Deal with ambiguities cleanly.
|
2009-12-31 11:26:35 +03:00
|
|
|
|
|
|
|
if (Found.empty() && !ErrorRecoveryLookup) {
|
|
|
|
// We haven't found anything, and we're not recovering from a
|
|
|
|
// different kind of error, so look for typos.
|
|
|
|
DeclarationName Name = Found.getLookupName();
|
2010-04-15 00:04:41 +04:00
|
|
|
if (CorrectTypo(Found, S, &SS, LookupCtx, EnteringContext,
|
|
|
|
CTC_NoKeywords) &&
|
2009-12-31 11:26:35 +03:00
|
|
|
Found.isSingleResult() &&
|
2010-02-25 07:46:04 +03:00
|
|
|
isAcceptableNestedNameSpecifier(Found.getAsSingle<NamedDecl>())) {
|
2009-12-31 11:26:35 +03:00
|
|
|
if (LookupCtx)
|
|
|
|
Diag(Found.getNameLoc(), diag::err_no_member_suggest)
|
|
|
|
<< Name << LookupCtx << Found.getLookupName() << SS.getRange()
|
2010-03-31 21:46:05 +04:00
|
|
|
<< FixItHint::CreateReplacement(Found.getNameLoc(),
|
|
|
|
Found.getLookupName().getAsString());
|
2009-12-31 11:26:35 +03:00
|
|
|
else
|
|
|
|
Diag(Found.getNameLoc(), diag::err_undeclared_var_use_suggest)
|
|
|
|
<< Name << Found.getLookupName()
|
2010-03-31 21:46:05 +04:00
|
|
|
<< FixItHint::CreateReplacement(Found.getNameLoc(),
|
|
|
|
Found.getLookupName().getAsString());
|
2010-01-07 03:17:44 +03:00
|
|
|
|
|
|
|
if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
|
|
|
|
Diag(ND->getLocation(), diag::note_previous_decl)
|
|
|
|
<< ND->getDeclName();
|
2010-06-29 23:27:42 +04:00
|
|
|
} else {
|
2009-12-31 11:26:35 +03:00
|
|
|
Found.clear();
|
2010-06-29 23:27:42 +04:00
|
|
|
Found.setLookupName(&II);
|
|
|
|
}
|
2009-12-31 11:26:35 +03:00
|
|
|
}
|
|
|
|
|
2009-12-02 11:25:40 +03:00
|
|
|
NamedDecl *SD = Found.getAsSingle<NamedDecl>();
|
2010-02-25 07:46:04 +03:00
|
|
|
if (isAcceptableNestedNameSpecifier(SD)) {
|
2009-09-04 01:38:09 +04:00
|
|
|
if (!ObjectType.isNull() && !ObjectTypeSearchedInScope) {
|
2009-09-03 02:59:36 +04:00
|
|
|
// C++ [basic.lookup.classref]p4:
|
2009-09-09 19:08:12 +04:00
|
|
|
// [...] If the name is found in both contexts, the
|
2009-09-03 02:59:36 +04:00
|
|
|
// class-name-or-namespace-name shall refer to the same entity.
|
|
|
|
//
|
|
|
|
// We already found the name in the scope of the object. Now, look
|
|
|
|
// into the current scope (the scope of the postfix-expression) to
|
2009-09-04 01:38:09 +04:00
|
|
|
// see if we can find the same name there. As above, if there is no
|
|
|
|
// scope, reconstruct the result from the template instantiation itself.
|
2009-10-10 01:13:30 +04:00
|
|
|
NamedDecl *OuterDecl;
|
|
|
|
if (S) {
|
2010-02-25 07:46:04 +03:00
|
|
|
LookupResult FoundOuter(*this, &II, IdLoc, LookupNestedNameSpecifierName);
|
2009-11-17 05:14:36 +03:00
|
|
|
LookupName(FoundOuter, S);
|
2009-12-02 11:25:40 +03:00
|
|
|
OuterDecl = FoundOuter.getAsSingle<NamedDecl>();
|
2009-10-10 01:13:30 +04:00
|
|
|
} else
|
|
|
|
OuterDecl = ScopeLookupResult;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-02-25 07:46:04 +03:00
|
|
|
if (isAcceptableNestedNameSpecifier(OuterDecl) &&
|
2009-09-03 02:59:36 +04:00
|
|
|
OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() &&
|
|
|
|
(!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) ||
|
|
|
|
!Context.hasSameType(
|
2009-09-04 01:38:09 +04:00
|
|
|
Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
|
2009-09-03 02:59:36 +04:00
|
|
|
Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
|
2009-12-07 04:36:53 +03:00
|
|
|
if (ErrorRecoveryLookup)
|
|
|
|
return 0;
|
|
|
|
|
2009-09-04 01:38:09 +04:00
|
|
|
Diag(IdLoc, diag::err_nested_name_member_ref_lookup_ambiguous)
|
|
|
|
<< &II;
|
|
|
|
Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type)
|
|
|
|
<< ObjectType;
|
|
|
|
Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-12-07 04:36:53 +03:00
|
|
|
// Fall through so that we'll pick the name we found in the object
|
|
|
|
// type, since that's probably what the user wanted anyway.
|
2009-09-04 01:38:09 +04:00
|
|
|
}
|
2009-09-03 02:59:36 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-03-27 02:50:42 +03:00
|
|
|
if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD))
|
|
|
|
return NestedNameSpecifier::Create(Context, Prefix, Namespace);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-08-26 04:04:55 +04:00
|
|
|
// FIXME: It would be nice to maintain the namespace alias name, then
|
|
|
|
// see through that alias when resolving the nested-name-specifier down to
|
|
|
|
// a declaration context.
|
2009-03-29 03:53:49 +04:00
|
|
|
if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD))
|
|
|
|
return NestedNameSpecifier::Create(Context, Prefix,
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
Alias->getNamespace());
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-03 02:59:36 +04:00
|
|
|
QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
|
|
|
|
return NestedNameSpecifier::Create(Context, Prefix, false,
|
|
|
|
T.getTypePtr());
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-12-07 04:36:53 +03:00
|
|
|
// Otherwise, we have an error case. If we don't want diagnostics, just
|
|
|
|
// return an error now.
|
|
|
|
if (ErrorRecoveryLookup)
|
|
|
|
return 0;
|
|
|
|
|
2009-02-14 23:20:19 +03:00
|
|
|
// If we didn't find anything during our lookup, try again with
|
|
|
|
// ordinary name lookup, which can help us produce better error
|
|
|
|
// messages.
|
2009-12-02 11:25:40 +03:00
|
|
|
if (Found.empty()) {
|
2009-11-17 05:14:36 +03:00
|
|
|
Found.clear(LookupOrdinaryName);
|
|
|
|
LookupName(Found, S);
|
2009-10-10 01:13:30 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-02-14 23:20:19 +03:00
|
|
|
unsigned DiagID;
|
2009-12-02 11:25:40 +03:00
|
|
|
if (!Found.empty())
|
2009-02-14 23:20:19 +03:00
|
|
|
DiagID = diag::err_expected_class_or_namespace;
|
2009-08-30 11:09:50 +04:00
|
|
|
else if (SS.isSet()) {
|
2009-10-14 01:16:44 +04:00
|
|
|
Diag(IdLoc, diag::err_no_member) << &II << LookupCtx << SS.getRange();
|
2009-08-30 11:09:50 +04:00
|
|
|
return 0;
|
|
|
|
} else
|
2009-02-14 23:20:19 +03:00
|
|
|
DiagID = diag::err_undeclared_var_use;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-02-14 23:20:19 +03:00
|
|
|
if (SS.isSet())
|
|
|
|
Diag(IdLoc, DiagID) << &II << SS.getRange();
|
|
|
|
else
|
|
|
|
Diag(IdLoc, DiagID) << &II;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-02-14 23:20:19 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-04 01:38:09 +04:00
|
|
|
/// ActOnCXXNestedNameSpecifier - Called during parsing of a
|
|
|
|
/// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
|
|
|
|
/// we want to resolve "bar::". 'SS' is empty or the previously parsed
|
|
|
|
/// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
|
|
|
|
/// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
|
|
|
|
/// Returns a CXXScopeTy* object representing the C++ scope.
|
|
|
|
Sema::CXXScopeTy *Sema::ActOnCXXNestedNameSpecifier(Scope *S,
|
2010-04-08 20:38:48 +04:00
|
|
|
CXXScopeSpec &SS,
|
2009-09-04 01:38:09 +04:00
|
|
|
SourceLocation IdLoc,
|
|
|
|
SourceLocation CCLoc,
|
|
|
|
IdentifierInfo &II,
|
|
|
|
TypeTy *ObjectTypePtr,
|
|
|
|
bool EnteringContext) {
|
2009-09-09 19:08:12 +04:00
|
|
|
return BuildCXXNestedNameSpecifier(S, SS, IdLoc, CCLoc, II,
|
2009-09-04 01:38:09 +04:00
|
|
|
QualType::getFromOpaquePtr(ObjectTypePtr),
|
2009-12-07 04:36:53 +03:00
|
|
|
/*ScopeLookupResult=*/0, EnteringContext,
|
|
|
|
false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// IsInvalidUnlessNestedName - This method is used for error recovery
|
|
|
|
/// purposes to determine whether the specified identifier is only valid as
|
|
|
|
/// a nested name specifier, for example a namespace name. It is
|
|
|
|
/// conservatively correct to always return false from this method.
|
|
|
|
///
|
|
|
|
/// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
|
2010-04-08 20:38:48 +04:00
|
|
|
bool Sema::IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
|
2010-02-25 07:46:04 +03:00
|
|
|
IdentifierInfo &II, TypeTy *ObjectType,
|
2009-12-07 04:36:53 +03:00
|
|
|
bool EnteringContext) {
|
|
|
|
return BuildCXXNestedNameSpecifier(S, SS, SourceLocation(), SourceLocation(),
|
2010-02-25 07:46:04 +03:00
|
|
|
II, QualType::getFromOpaquePtr(ObjectType),
|
2009-12-07 04:36:53 +03:00
|
|
|
/*ScopeLookupResult=*/0, EnteringContext,
|
|
|
|
true);
|
2009-09-04 01:38:09 +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
|
|
|
Sema::CXXScopeTy *Sema::ActOnCXXNestedNameSpecifier(Scope *S,
|
|
|
|
const CXXScopeSpec &SS,
|
|
|
|
TypeTy *Ty,
|
|
|
|
SourceRange TypeRange,
|
2010-02-25 07:46:04 +03:00
|
|
|
SourceLocation CCLoc) {
|
2009-09-09 19:08:12 +04:00
|
|
|
NestedNameSpecifier *Prefix
|
2009-03-27 02:56:24 +03:00
|
|
|
= static_cast<NestedNameSpecifier *>(SS.getScopeRep());
|
2009-08-19 05:28:28 +04:00
|
|
|
QualType T = GetTypeFromParser(Ty);
|
2009-03-27 02:50:42 +03:00
|
|
|
return NestedNameSpecifier::Create(Context, Prefix, /*FIXME:*/false,
|
2009-05-14 04:28:11 +04:00
|
|
|
T.getTypePtr());
|
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-12-11 23:04:54 +03:00
|
|
|
bool Sema::ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
|
|
|
|
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
|
|
|
|
|
|
|
|
NestedNameSpecifier *Qualifier =
|
|
|
|
static_cast<NestedNameSpecifier*>(SS.getScopeRep());
|
|
|
|
|
|
|
|
// There are only two places a well-formed program may qualify a
|
|
|
|
// declarator: first, when defining a namespace or class member
|
|
|
|
// out-of-line, and second, when naming an explicitly-qualified
|
|
|
|
// friend function. The latter case is governed by
|
|
|
|
// C++03 [basic.lookup.unqual]p10:
|
|
|
|
// In a friend declaration naming a member function, a name used
|
|
|
|
// in the function declarator and not part of a template-argument
|
|
|
|
// in a template-id is first looked up in the scope of the member
|
|
|
|
// function's class. If it is not found, or if the name is part of
|
|
|
|
// a template-argument in a template-id, the look up is as
|
|
|
|
// described for unqualified names in the definition of the class
|
|
|
|
// granting friendship.
|
|
|
|
// i.e. we don't push a scope unless it's a class member.
|
|
|
|
|
|
|
|
switch (Qualifier->getKind()) {
|
|
|
|
case NestedNameSpecifier::Global:
|
|
|
|
case NestedNameSpecifier::Namespace:
|
|
|
|
// These are always namespace scopes. We never want to enter a
|
|
|
|
// namespace scope from anything but a file context.
|
|
|
|
return CurContext->getLookupContext()->isFileContext();
|
|
|
|
|
|
|
|
case NestedNameSpecifier::Identifier:
|
|
|
|
case NestedNameSpecifier::TypeSpec:
|
|
|
|
case NestedNameSpecifier::TypeSpecWithTemplate:
|
|
|
|
// These are never namespace scopes.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Silence bogus warning.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-02-14 23:20:19 +03:00
|
|
|
/// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
|
|
|
|
/// scope or nested-name-specifier) is parsed, part of a declarator-id.
|
|
|
|
/// After this method is called, according to [C++ 3.4.3p3], names should be
|
|
|
|
/// looked up in the declarator-id's scope, until the declarator is parsed and
|
|
|
|
/// ActOnCXXExitDeclaratorScope is called.
|
|
|
|
/// The 'SS' should be a non-empty valid CXXScopeSpec.
|
2010-04-08 20:38:48 +04:00
|
|
|
bool Sema::ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS) {
|
2009-02-14 23:20:19 +03:00
|
|
|
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
|
2009-12-19 13:49:29 +03:00
|
|
|
|
|
|
|
if (SS.isInvalid()) return true;
|
|
|
|
|
|
|
|
DeclContext *DC = computeDeclContext(SS, true);
|
|
|
|
if (!DC) return true;
|
|
|
|
|
|
|
|
// Before we enter a declarator's context, we need to make sure that
|
|
|
|
// it is a complete declaration context.
|
2010-05-01 04:40:08 +04:00
|
|
|
if (!DC->isDependentContext() && RequireCompleteDeclContext(SS, DC))
|
2009-12-19 13:49:29 +03:00
|
|
|
return true;
|
|
|
|
|
|
|
|
EnterDeclaratorContext(S, DC);
|
2010-04-27 04:57:59 +04:00
|
|
|
|
|
|
|
// Rebuild the nested name specifier for the new scope.
|
|
|
|
if (DC->isDependentContext())
|
|
|
|
RebuildNestedNameSpecifierInCurrentInstantiation(SS);
|
|
|
|
|
2009-09-25 03:39:01 +04:00
|
|
|
return false;
|
2009-02-14 23:20:19 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
|
|
|
|
/// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
|
|
|
|
/// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
|
|
|
|
/// Used to indicate that names should revert to being looked up in the
|
|
|
|
/// defining scope.
|
|
|
|
void Sema::ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
|
|
|
|
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
|
2009-08-26 04:04:55 +04:00
|
|
|
if (SS.isInvalid())
|
|
|
|
return;
|
2009-12-19 13:49:29 +03:00
|
|
|
assert(!SS.isInvalid() && computeDeclContext(SS, true) &&
|
|
|
|
"exiting declarator scope we never really entered");
|
|
|
|
ExitDeclaratorContext(S);
|
2009-02-14 23:20:19 +03:00
|
|
|
}
|