From 9da093d0f4a5c23479370d6e4920667ced3c9bd2 Mon Sep 17 00:00:00 2001
From: Reid Kleckner <rnk@google.com>
Date: Sat, 17 Oct 2015 00:19:04 +0000
Subject: [PATCH] Diagnose UnresolvedLookupExprs that resolve to instance
members in static methods
During the initial template parse for this code, 'member' is unresolved
and we don't know anything about it:
struct A { int member };
template <typename T>
struct B : public T {
using T::member;
static void f() {
(void)member; // Could be static or non-static.
}
};
template class B<A>;
The pattern declaration contains an UnresolvedLookupExpr rather than an
UnresolvedMemberExpr because `f` is static, and `member` should never be
a field. However, if the code is invalid, it may become a field, in
which case we should diagnose it.
Reviewers: rjmccall, rsmith
Differential Revision: http://reviews.llvm.org/D6700
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@250592 91177308-0d34-0410-b5e6-96231b3b80d8
---
include/clang/Sema/Sema.h | 3 +++
lib/Sema/SemaExprMember.cpp | 25 ++++++++---------
lib/Sema/TreeTransform.h | 12 ++++++++-
test/SemaCXX/using-decl-1.cpp | 51 ++++++++++++++++++++++++++++++++++-
4 files changed, 75 insertions(+), 16 deletions(-)
diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index cce5405a1e0..d0b3e627f69 100644
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -3692,6 +3692,9 @@ public:
Expr *baseObjectExpr = nullptr,
SourceLocation opLoc = SourceLocation());
+ void DiagnoseInstanceReference(const CXXScopeSpec &SS, NamedDecl *Rep,
+ const DeclarationNameInfo &nameInfo);
+
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
SourceLocation TemplateKWLoc,
LookupResult &R,
diff --git a/lib/Sema/SemaExprMember.cpp b/lib/Sema/SemaExprMember.cpp
index 52dfceccb94..3256bd986ff 100644
--- a/lib/Sema/SemaExprMember.cpp
+++ b/lib/Sema/SemaExprMember.cpp
@@ -192,10 +192,8 @@ static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef,
}
/// Diagnose a reference to a field with no object available.
-static void diagnoseInstanceReference(Sema &SemaRef,
- const CXXScopeSpec &SS,
- NamedDecl *Rep,
- const DeclarationNameInfo &nameInfo) {
+void Sema::DiagnoseInstanceReference(const CXXScopeSpec &SS, NamedDecl *Rep,
+ const DeclarationNameInfo &nameInfo) {
SourceLocation Loc = nameInfo.getLoc();
SourceRange Range(Loc);
if (SS.isSet()) Range.setBegin(SS.getRange().getBegin());
@@ -203,7 +201,7 @@ static void diagnoseInstanceReference(Sema &SemaRef,
// Look through using shadow decls and aliases.
Rep = Rep->getUnderlyingDecl();
- DeclContext *FunctionLevelDC = SemaRef.getFunctionLevelDeclContext();
+ DeclContext *FunctionLevelDC = getFunctionLevelDeclContext();
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FunctionLevelDC);
CXXRecordDecl *ContextClass = Method ? Method->getParent() : nullptr;
CXXRecordDecl *RepClass = dyn_cast<CXXRecordDecl>(Rep->getDeclContext());
@@ -213,20 +211,19 @@ static void diagnoseInstanceReference(Sema &SemaRef,
if (IsField && InStaticMethod)
// "invalid use of member 'x' in static member function"
- SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method)
+ Diag(Loc, diag::err_invalid_member_use_in_static_method)
<< Range << nameInfo.getName();
else if (ContextClass && RepClass && SS.isEmpty() && !InStaticMethod &&
!RepClass->Equals(ContextClass) && RepClass->Encloses(ContextClass))
// Unqualified lookup in a non-static member function found a member of an
// enclosing class.
- SemaRef.Diag(Loc, diag::err_nested_non_static_member_use)
- << IsField << RepClass << nameInfo.getName() << ContextClass << Range;
+ Diag(Loc, diag::err_nested_non_static_member_use)
+ << IsField << RepClass << nameInfo.getName() << ContextClass << Range;
else if (IsField)
- SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use)
- << nameInfo.getName() << Range;
+ Diag(Loc, diag::err_invalid_non_static_member_use) << nameInfo.getName()
+ << Range;
else
- SemaRef.Diag(Loc, diag::err_member_call_without_object)
- << Range;
+ Diag(Loc, diag::err_member_call_without_object) << Range;
}
/// Builds an expression which might be an implicit member expression.
@@ -260,7 +257,7 @@ Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
case IMA_Error_StaticContext:
case IMA_Error_Unrelated:
- diagnoseInstanceReference(*this, SS, R.getRepresentativeDecl(),
+ DiagnoseInstanceReference(SS, R.getRepresentativeDecl(),
R.getLookupNameInfo());
return ExprError();
}
@@ -474,7 +471,7 @@ static void DiagnoseQualifiedMemberReference(Sema &SemaRef,
// If this is an implicit member access, use a different set of
// diagnostics.
if (!BaseExpr)
- return diagnoseInstanceReference(SemaRef, SS, rep, nameInfo);
+ return SemaRef.DiagnoseInstanceReference(SS, rep, nameInfo);
SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated)
<< SS.getRange() << rep << BaseType;
diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h
index 31d69cbac35..81c56c2f2c6 100644
--- a/lib/Sema/TreeTransform.h
+++ b/lib/Sema/TreeTransform.h
@@ -9128,8 +9128,18 @@ TreeTransform<Derived>::TransformUnresolvedLookupExpr(
// If we have neither explicit template arguments, nor the template keyword,
// it's a normal declaration name.
- if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid())
+ if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
+ // If an UnresolvedLookupExpr resolved to an instance member, that's an
+ // error.
+ NamedDecl *D = R.getAsSingle<NamedDecl>();
+ if (D && D->isCXXInstanceMember()) {
+ SemaRef.DiagnoseInstanceReference(SS, D, Old->getNameInfo());
+ R.clear();
+ return ExprError();
+ }
+
return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
+ }
// If we have template arguments, rebuild them, then rebuild the
// templateid expression.
diff --git a/test/SemaCXX/using-decl-1.cpp b/test/SemaCXX/using-decl-1.cpp
index ca532692c1c..ac53b3758e4 100644
--- a/test/SemaCXX/using-decl-1.cpp
+++ b/test/SemaCXX/using-decl-1.cpp
@@ -1,5 +1,5 @@
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -DCXX11 -fsyntax-only -verify -std=c++11 %s
extern "C" { void f(bool); }
@@ -327,3 +327,52 @@ namespace PR24033 {
using PR24033::st; // expected-error {{target of using declaration conflicts with declaration already in scope}}
}
}
+
+namespace pr21923 {
+template <typename> struct Base {
+ int field;
+ void method();
+};
+template <typename Scalar> struct Derived : Base<Scalar> {
+ using Base<Scalar>::field;
+ using Base<Scalar>::method;
+ static void m_fn1() {
+ // expected-error@+1 {{invalid use of member 'field' in static member function}}
+ (void)field;
+ // expected-error@+1 {{invalid use of member 'field' in static member function}}
+ (void)&field;
+ // expected-error@+1 {{call to non-static member function without an object argument}}
+ (void)method;
+ // expected-error@+1 {{call to non-static member function without an object argument}}
+ (void)&method;
+ // expected-error@+1 {{call to non-static member function without an object argument}}
+ method();
+ (void)&Base<Scalar>::field;
+ (void)&Base<Scalar>::method;
+ }
+};
+// expected-note@+1 {{in instantiation of member function 'pr21923::Derived<int>::m_fn1' requested here}}
+template class Derived<int>;
+
+#ifdef CXX11
+// This is interesting because we form an UnresolvedLookupExpr in the static
+// function template and an UnresolvedMemberExpr in the instance function
+// template. As a result, we get slightly different behavior.
+struct UnresolvedTemplateNames {
+ template <typename> void maybe_static();
+ template <typename T, typename T::type = 0> static void maybe_static();
+
+ template <typename T>
+ void instance_method() { (void)maybe_static<T>(); }
+ template <typename T>
+ static void static_method() {
+ // expected-error@+1 {{call to non-static member function without an object argument}}
+ (void)maybe_static<T>();
+ }
+};
+void force_instantiation(UnresolvedTemplateNames x) {
+ x.instance_method<int>();
+ UnresolvedTemplateNames::static_method<int>(); // expected-note {{requested here}}
+}
+#endif // CXX11
+}
--
GitLab