Allow pointer to static member function

[Manna]

Summary

This patch allows pointer to static member function and fixes the bug in Bugzilla (https://bugs.llvm.org/show_bug.cgi?id=28419).

This is valid C++ codes. Both GCC and MSVC accepts this.

[majnemer]

lib/Sema/SemaOverload.cpp

10996

Is this still used after you deleted that user of this?

[aaron.ballman]

This is valid C++ codes. Both GCC and MSVC accepts this.

Just because GCC and MSVC accept something doesn't always mean it's valid C++ code; do you have references to where this is allowed by the standard? It seems like this changes the behavior of at least one DR, which is why I'm wondering about it. By my strict reading of the standard, this actually isn't valid C++ (though it seems like it could be a reasonable extension to support).

lib/Sema/SemaExpr.cpp

11881

Missing grammatical correctness. How about "Explicitly accessing a static member function." instead?

test/CXX/drs/dr0xx.cpp

754–755

This seems to have changed the behavior of DR61: https://wg21.cmeerw.net/cwg/issue61
Was this DR later superseded by something (I didn't spot anything -- the use of "name" still exists in http://eel.is/c++draft/over.over#1.sentence-1)?

test/CXX/drs/dr1xx.cpp

127–128

Spurious whitespace changes.

[Manna]

In D59286#1429034, @aaron.ballman wrote:

This is valid C++ codes. Both GCC and MSVC accepts this.

Just because GCC and MSVC accept something doesn't always mean it's valid C++ code; do you have references to where this is allowed by the standard? It seems like this changes the behavior of at least one DR, which is why I'm wondering about it. By my strict reading of the standard, this actually isn't valid C++ (though it seems like it could be a reasonable extension to support).

Thanks Aaron.
Yes, my proposed changes are not correct. This changes the behavior of one DR, which is not allowed and valid by C++ code. I do not find any references to where this is allowed by the standard. I tested my proposed changes with gcc8 and latest MSVS environment. I was not aware that both GCC and MSVC are violating C++ Standard. Clang is following the standard.

I am withdrawing my patches and this feature will not be supported in Clang.

lib/Sema/SemaExpr.cpp

if (PTy->getKind() == BuiltinType::Overload) {
       if (!isa<OverloadExpr>(E)) {
         assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
         Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
           << OrigOp.get()->getSourceRange();
         return QualType();
       }
 
       OverloadExpr *Ovl = cast<OverloadExpr>(E);
+      /// Allow pointer to static member function.
+      /// GCC and MSVC both accepts this.
+      if (!Ovl->hasExplicitTemplateArgs())
+        if (auto *UME = dyn_cast<UnresolvedMemberExpr>(Ovl))
+          if (!UME->isImplicitAccess())
+            // static member function access
+            return Context.OverloadTy; 
+
       if (isa<UnresolvedMemberExpr>(Ovl))
         if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
           Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
             << OrigOp.get()->getSourceRange();
           return QualType();
         }
 
       return Context.OverloadTy;

lib/Sema/SemaOverload.cpp

class AddressOfFunctionResolver {
   QualType TargetFunctionType; // Extracted function type from target type
 
   bool Complain;
   //DeclAccessPair& ResultFunctionAccessPair;
   ASTContext& Context;
 
   bool TargetTypeIsNonStaticMemberFunction;
   bool FoundNonTemplateFunction;
   bool StaticMemberFunctionFromBoundPointer;
   bool HasComplained;
 
   OverloadExpr::FindResult OvlExprInfo;
   OverloadExpr *OvlExpr;
   TemplateArgumentListInfo OvlExplicitTemplateArgs;
   SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches;
   TemplateSpecCandidateSet FailedCandidates;
 
public:
 
   void ComplainIsInvalidFormOfPointerToMemberFunction() const {
       // TODO: Should we condition this on whether any functions might
       // have matched, or is it more appropriate to do that in callers?
       // TODO: a fixit wouldn't hurt.
       S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
         << TargetType << OvlExpr->getSourceRange();
   }
   
-  bool IsStaticMemberFunctionFromBoundPointer() const {
-    return StaticMemberFunctionFromBoundPointer;
-  }
-
-  void ComplainIsStaticMemberFunctionFromBoundPointer() const {
-    S.Diag(OvlExpr->getBeginLoc(),
-           diag::err_invalid_form_pointer_member_function)
-        << OvlExpr->getSourceRange();
-  }
-
-  void ComplainOfInvalidConversion() const {
     S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_not_func_ptrref)
         << OvlExpr->getName() << TargetType;
   }
 
   void ComplainMultipleMatchesFound() const {
     assert(Matches.size() > 1);
     S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous)
         << OvlExpr->getName() << OvlExpr->getSourceRange();
else if (NumMatches > 1 && ShouldComplain)
     Resolver.ComplainMultipleMatchesFound();
   else if (NumMatches == 1) {
     Fn = Resolver.getMatchingFunctionDecl();
     assert(Fn);
     if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
       ResolveExceptionSpec(AddressOfExpr->getExprLoc(), FPT);
     FoundResult = *Resolver.getMatchingFunctionAccessPair();
     if (Complain) {
-      if (Resolver.IsStaticMemberFunctionFromBoundPointer())
-        Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
-      else
-        CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
+      /// Allow pointer to static member function.
+      /// GCC and MSVC both accepts this.
     }
   }
 
   if (pHadMultipleCandidates)
     *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
   return Fn;
 }
 

test/CXX/drs/dr0xx.cpp

namespace dr61 { // dr61: yes
   } x;
   struct Y {
     static void f();
     static void f(int);
   } y;
   // This is (presumably) valid, because x.f does not refer to an overloaded
   // function name.
   void (*p)() = &x.f;
-  void (*q)() = &y.f; // expected-error {{cannot create a non-constant pointer to member function}}
-  void (*r)() = y.f; // expected-error {{cannot create a non-constant pointer to member function}}
+  void (*q)() = &y.f; // OK
+  void (*r)() = y.f; // OK
 }
 
 namespace dr62 { // dr62: yes
   struct A {
     struct { int n; } b;
   };
   template<typename T> struct X {};
   template<typename T> T get() { return get<T>(); }

test/CXX/drs/dr1xx.cpp

namespace dr114 { // dr114: yes
   };
   struct B : A {
     template<typename T> void f(T);
     void g() { f(0); }
   } b; // expected-error {{abstract}}
 }
 
 namespace dr115 { // dr115: yes
-  template<typename T> int f(T); // expected-note +{{}}
-  template<typename T> int g(T); // expected-note +{{}}
+  template<typename T> int f(T);  // expected-note +{{}}
+  template<typename T> int g(T);  // expected-note +{{}}
   template<typename T> int g(T, int); // expected-note +{{}}
 
   int k1 = f(&f); // expected-error {{no match}}
   int k2 = f(&f<int>);
   int k3 = f(&g<int>); // expected-error {{no match}}
 
   void h() {
     (void)&f; // expected-error {{address of overloaded function 'f' cannot be cast to type 'void'}}
     (void)&f<int>;
     (void)&g<int>; // expected-error {{address of overloaded function 'g' cannot be cast to type 'void'}}
 
     &f; // expected-error {{reference to overloaded function could not be resolved}}
     &f<int>; // expected-warning {{unused}}
     &g<int>; // expected-error {{reference to overloaded function could not be resolved}}
   }
 
   struct S {
     template<typename T> static int f(T);
     template<typename T> static int g(T);
     template<typename T> static int g(T, int);
   } s;
 
-  int k4 = f(&s.f); // expected-error {{non-constant pointer to member}}
+  int k4 = f(&s.f); // expected-error {{no match}}
   int k5 = f(&s.f<int>);
   int k6 = f(&s.g<int>); // expected-error {{non-constant pointer to member}}
 
   void i() {
-    (void)&s.f; // expected-error {{non-constant pointer to member}}
+    (void)&s.f; // expected-error {{address of overloaded function 'f' cannot be cast to type 'void'}}
     (void)&s.f<int>;
     (void)&s.g<int>; // expected-error {{non-constant pointer to member}}
 
-    &s.f; // expected-error {{non-constant pointer to member}}
+    &s.f; // expected-error {{reference to overloaded function could not be resolved}}
     &s.f<int>; // expected-warning {{unused}}
     &s.g<int>; // expected-error {{non-constant pointer to member}}
   }
 
   struct T {
     template<typename T> int f(T);
     template<typename T> int g(T);
     template<typename T> int g(T, int);
   } t;
 
-  int k7 = f(&s.f); // expected-error {{non-constant pointer to member}}
+  int k7 = f(&s.f); // expected-error {{no match}}
   int k8 = f(&s.f<int>);
   int k9 = f(&s.g<int>); // expected-error {{non-constant pointer to member}}
 
   void j() {
-    (void)&s.f; // expected-error {{non-constant pointer to member}}
+    (void)&s.f; // expected-error {{address of overloaded function 'f' cannot be cast to type 'void'}}
     (void)&s.f<int>;
     (void)&s.g<int>; // expected-error {{non-constant pointer to member}}
 
-    &s.f; // expected-error {{non-constant pointer to member}}
+    &s.f; // expected-error {{reference to overloaded function could not be resolved}}
     &s.f<int>; // expected-warning {{unused}}
     &s.g<int>; // expected-error {{non-constant pointer to member}}
   }
 
 #if __cplusplus >= 201103L
   // Special case kicks in only if a template argument list is specified.
   template<typename T=int> void with_default(); // expected-note +{{}}
   int k10 = f(&with_default); // expected-error {{no matching function}}

test/CodeGenCXX/pointer-to-static-member.cpp

+// RUN: %clang_cc1 %s -fexceptions -O0  -triple x86_64-unknown-linux-gnu -emit-llvm -o - | FileCheck %s
+
+struct X {
+  static void foo();
+} x;
+struct Y {
+  static void bar();
+  static void bar(int);
+} y;
+
+void (*ptr1)() = &x.foo;
+void (*ptr2)() = &y.bar;
+void (*ptr3)() = y.bar;
+
+struct X *xptr = &x;
+void (*p1)() = &xptr->foo;
+
+struct Y *yptr = &y;
+void (*ptr4)() = &yptr->bar;
+void (*ptr5)(int) = &yptr->bar;
+
+// CHECK: @{{.*}}ptr1{{.*}} = global {{.+}}@[[PTR1:.+]],
+// CHECK:  store {{.+}}[[PTR1]],{{.*}}@{{.*}}p1

test/Sema/pointer-to-static-member.cpp

+// RUN: %clang_cc1 %s -fexceptions -O0 -verify
+
+namespace member_pointers {
+struct S {
+  template <typename T>
+  bool f(T) { return false; }
+  template <typename T>
+  static bool g(T) { return false; }
+
+  template <typename T>
+  bool h(T) { return false; } // expected-note 3 {{possible target for call}}
+  template <int N>
+  static bool h(int) { return false; } // expected-note 3 {{possible target for call}}
+};
+
+void test(S s) {
+  if (&S::f<char>)
+    return;
+  if (&S::f<int>)
+    return;
+  if (&s.f<char>) // expected-error {{cannot create a non-constant pointer to member function}}
+    return;
+  if (&s.f<int>) // expected-error {{cannot create a non-constant pointer to member function}}
+    return;
+
+  if (&S::g<char>)
+    return;
+  if (&S::g<int>)
+    return;
+  if (&s.g<char>)
+    return;
+  if (&s.g<int>)
+    return;
+
+  if (S::h<42>) // expected-warning {{address of function 'S::h<42>' will always evaluate to 'true'}} \
+                // expected-note {{prefix with the address-of operator to silence this warning}}
+    return;
+
+  if (S::h<int>) // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+    return;
+  if (&S::h<42>)
+    return;
+  if (&S::h<int>)
+    return;
+  if (s.h<int>) // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+    return;
+  if (&s.h<42>)
+    return;
+  if (&s.h<int>) // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+    return;
+
+  { bool b = &S::f<char>; }
+  { bool b = &S::f<int>; }
+  { bool b = &s.f<char>; } // expected-error {{cannot create a non-constant pointer to member function}}
+  { bool b = &s.f<int>; }  // expected-error {{cannot create a non-constant pointer to member function}}
+}
+}
+
+struct Y {
+  static void bar();
+  static void bar(int);
+} y;
+
+struct Y *yptr = &y;
+void (*ptr4)() = &yptr->bar;
+void (*ptr5)(int) = &yptr->bar;
+
+bool foo() {
+  return ptr4 == &Y::bar; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+}
+
+struct A
+{
+  static void f (int) {}
+  static void f () {};
+};
+
+
+A a;
+void (*p) (int) = a.f;