Implemented P0704R1 - Fixing const-qualified pointers to members

[hamzasood]

Summary

This patch provides an implementation for P0704R1.

I also made it work pre-C++2a as an extension (with a warning) since that's how Clang seems to deal with small additions like this. Hopefully someone more knowledgable on the matter can clarify whether that's appropriate.

include/clang/Basic/DiagnosticGroups.td

 
 // Warnings for C++1y code which is not compatible with prior C++ standards.
 def CXXPre14Compat : DiagGroup<"c++98-c++11-compat">;
 def CXXPre14CompatPedantic : DiagGroup<"c++98-c++11-compat-pedantic",
                                        [CXXPre14Compat]>;
 def CXXPre1zCompat : DiagGroup<"c++98-c++11-c++14-compat">;
 def CXXPre1zCompatPedantic : DiagGroup<"c++98-c++11-c++14-compat-pedantic",
                                        [CXXPre1zCompat]>;
+def CXXPre2aCompat : DiagGroup<"c++98-c++11-c++14-c++1z-compat">;
+def CXXPre2aCompatPedantic : DiagGroup<"c++98-c++11-c++14-c++1z-compat-pedantic",
+                                       [CXXPre2aCompat]>;
 
 def CXX98CompatBindToTemporaryCopy :
   DiagGroup<"c++98-compat-bind-to-temporary-copy">;
 def CXX98CompatLocalTypeTemplateArgs :
   DiagGroup<"c++98-compat-local-type-template-args">;
 def CXX98CompatUnnamedTypeTemplateArgs :
   DiagGroup<"c++98-compat-unnamed-type-template-args">;
 

 // A warning group for warnings about using C++14 features as extensions in
 // earlier C++ versions.
 def CXX14 : DiagGroup<"c++14-extensions", [CXX14BinaryLiteral]>;
 
 // A warning group for warnings about using C++1z features as extensions in
 // earlier C++ versions.
 def CXX1z : DiagGroup<"c++1z-extensions">;
 
+// A warning group for warnings about using C++2a features as extensions in
+// earlier C++ versions.
+def CXX2a : DiagGroup<"c++2a-extensions">;
+
 def : DiagGroup<"c++0x-extensions", [CXX11]>;
 def : DiagGroup<"c++1y-extensions", [CXX14]>;
 
 def DelegatingCtorCycles :
   DiagGroup<"delegating-ctor-cycles">;
 
 // A warning group for warnings about using C11 features as extensions.
 def C11 : DiagGroup<"c11-extensions">;

include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx98_compat_template_arg_extra_parens : Warning<
   "incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore;
 def err_pointer_to_member_type : Error<
   "invalid use of pointer to member type after %select{.*|->*}0">;
 def err_pointer_to_member_call_drops_quals : Error<
   "call to pointer to member function of type %0 drops '%1' qualifier%s2">;
 def err_pointer_to_member_oper_value_classify: Error<
   "pointer-to-member function type %0 can only be called on an "
   "%select{rvalue|lvalue}1">;
+def warn_cxx1z_compat_const_amp_pointer_to_member_on_rvalue : Warning<
+  "invocation of a 'const&' qualified pointer-to-member function on an rvalue "
+  "is incompatible with C++ standards before C++2a">,
+  InGroup<CXXPre2aCompat>, DefaultIgnore;
+def ext_const_amp_pointer_to_member_on_rvalue_cxx2a : ExtWarn<
+  "invocation of a 'const&' qualified pointer-to-member function on an rvalue "
+  "is a C++2a extension">, InGroup<CXX2a>;
 def ext_ms_deref_template_argument: ExtWarn<
   "non-type template argument containing a dereference operation is a "
   "Microsoft extension">, InGroup<MicrosoftTemplate>;
 def ext_ms_delayed_template_argument: ExtWarn<
   "using the undeclared type %0 as a default template argument is a "
   "Microsoft extension">, InGroup<MicrosoftTemplate>;
 def err_template_arg_deduced_incomplete_pack : Error<
   "deduced incomplete pack %0 for template parameter %1">;

lib/Sema/SemaExprCXX.cpp

QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
   // C++ 5.5p2
   //   The result is an object or a function of the type specified by the
   //   second operand.
   // The cv qualifiers are the union of those in the pointer and the left side,
   // in accordance with 5.5p5 and 5.2.5.
   QualType Result = MemPtr->getPointeeType();
   Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers());
 
-  // C++0x [expr.mptr.oper]p6:
+  // C++2a [expr.mptr.oper]p6:
   //   In a .* expression whose object expression is an rvalue, the program is
-  //   ill-formed if the second operand is a pointer to member function with
-  //   ref-qualifier &. In a ->* expression or in a .* expression whose object
-  //   expression is an lvalue, the program is ill-formed if the second operand
-  //   is a pointer to member function with ref-qualifier &&.
+  //   ill-formed if the second operand is a pointer to member function whose
+  //   ref-qualifier is &, unless its cv-qualifier-seq is const. In an ->*
+  //   expression or in a .* expression whose object expression is an lvalue,
+  //   the program is ill-formed if the second operand is a pointer to member
+  //   function with ref-qualifier &&.
   if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
     switch (Proto->getRefQualifier()) {
     case RQ_None:
       // Do nothing
       break;
 
     case RQ_LValue:
-      if (!isIndirect && !LHS.get()->Classify(Context).isLValue())
+      if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) {
+        if (Proto->isConst() && !Proto->isVolatile())
+          Diag(Loc,
+               !getLangOpts().CPlusPlus2a
+                   ? diag::
+                     ext_const_amp_pointer_to_member_on_rvalue_cxx2a
+                   : diag::
+                     warn_cxx1z_compat_const_amp_pointer_to_member_on_rvalue);
+        else
           Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
             << RHSType << 1 << LHS.get()->getSourceRange();
+      }
       break;
 
     case RQ_RValue:
       if (isIndirect || !LHS.get()->Classify(Context).isRValue())
         Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
           << RHSType << 0 << LHS.get()->getSourceRange();
       break;
     }

test/CXX/expr/expr.mptr.oper/p6-0x.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
 
 struct X { };
 
 template<typename T> T& lvalue();
 template<typename T> T&& xvalue();
 template<typename T> T prvalue();
 
 // In a .* expression whose object expression is an rvalue, the
 // program is ill-formed if the second operand is a pointer to member
 // function with ref-qualifier &. In a ->* expression or in a .*
 // expression whose object expression is an lvalue, the program is
 // ill-formed if the second operand is a pointer to member function
 // with ref-qualifier &&.
-void test(X *xp, int (X::*pmf)(int), int (X::*l_pmf)(int) &, 
-          int (X::*r_pmf)(int) &&) {
+void test(X *xp, int (X::*pmf)(int), int (X::*const_l_pmf)(int) const&,
+          int (X::*l_pmf)(int) &, int (X::*r_pmf)(int) &&) {
   // No ref-qualifier.
   (lvalue<X>().*pmf)(17);
   (xvalue<X>().*pmf)(17);
   (prvalue<X>().*pmf)(17);
   (xp->*pmf)(17);
 
+  // Const Lvalue ref-qualifier.
+  (lvalue<X>().*const_l_pmf)(17);
+  (xvalue<X>().*const_l_pmf)(17); // expected-warning {{C++2a extension}}
+  (prvalue<X>().*const_l_pmf)(17); // expected-warning {{C++2a extension}}
+  (xp->*const_l_pmf)(17);
+
   // Lvalue ref-qualifier.
   (lvalue<X>().*l_pmf)(17);
   (xvalue<X>().*l_pmf)(17); // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}}
   (prvalue<X>().*l_pmf)(17); // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}}
   (xp->*l_pmf)(17);
 
   // Rvalue ref-qualifier.
   (lvalue<X>().*r_pmf)(17); // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}}
   (xvalue<X>().*r_pmf)(17);
   (prvalue<X>().*r_pmf)(17);
   (xp->*r_pmf)(17);  // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}}
 }

test/CXX/expr/expr.mptr.oper/p6-2a.cpp

+// RUN: %clang_cc1 -std=c++2a -verify %s
+// expected-no-diagnostics
+
+struct X { void foo() const&; };
+
+void test() {
+  // Example from P0704R1.
+  X{}.foo();
+  (X{}.*&X::foo)();
+}

www/cxx_status.html

 ordering, resulting in ambiguity errors for reasonable and previously-valid
 code. This issue is expected to be rectified soon.
 </span>
 </p>
 </details>
 
 <h2 id="cxx20">C++2a implementation status</h2>
 
-<p>Clang does not yet support any of the proposed features of
-<!--<p>Clang has <b>experimental</b> support for some proposed features of-->
+<p>Clang has <b>experimental</b> support for some proposed features of
 the C++ standard following C++17, provisionally named C++2a.
 Note that support for these features may change or be removed without notice,
 as the draft C++2a standard evolves.
 
-<!--<p>You can use Clang in C++2a mode with the <code>-std=c++2a</code> option.</p>-->
+<p>You can use Clang in C++2a mode with the <code>-std=c++2a</code> option.</p>
 
 <details open>
 <summary>List of features and minimum Clang version with support</summary>
 
 <table width="689" border="1" cellspacing="0">
  <tr>
     <th>Language Feature</th>
     <th>C++2a Proposal</th>
     <th>Available in Clang?</th>
  </tr>
     <!-- Toronto 2017 papers -->
     <tr>
       <td>Default member initializers for bit-fields</td>
       <td><a href="http://wg21.link/p0683r1">P0683R1</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td><tt>const&amp;</tt>-qualified pointers to members</td>
       <td><a href="http://wg21.link/p0704r1">P0704R1</a></td>
-      <td class="none" align="center">No</td>
+      <td class="svn" align="center">SVN</td>
     </tr>
     <tr>
       <td>Allow <i>lambda-capture</i> <tt>[=, this]</tt></td>
       <td><a href="http://wg21.link/p0409r2">P0409R2</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td><tt>__VA_OPT__</tt> for preprocessor comma elision</td>