[Clang] Implement CWG2654: Un-deprecation of compound volatile assignments

[cor3ntin]

Thanks Erich!

clang-tools-extra/clangd/Diagnostics.cpp

 
 void setTags(clangd::Diag &D) {
   static const auto *DeprecatedDiags = new llvm::DenseSet<unsigned>{
       diag::warn_access_decl_deprecated,
       diag::warn_atl_uuid_deprecated,
       diag::warn_deprecated,
       diag::warn_deprecated_altivec_src_compat,
       diag::warn_deprecated_comma_subscript,
-      diag::warn_deprecated_compound_assign_volatile,
       diag::warn_deprecated_copy,
       diag::warn_deprecated_copy_with_dtor,
       diag::warn_deprecated_copy_with_user_provided_copy,
       diag::warn_deprecated_copy_with_user_provided_dtor,
       diag::warn_deprecated_def,
       diag::warn_deprecated_increment_decrement_volatile,
       diag::warn_deprecated_message,
       diag::warn_deprecated_redundant_constexpr_static_def,

clang/docs/ReleaseNotes.rst

- Implemented `DR692 <https://wg21.link/cwg692>`_, `DR1395 <https://wg21.link/cwg1395>`_,
   and `DR1432 <https://wg21.link/cwg1432>`_. The fix for DR1432 is speculative since the
   issue is still open and has no proposed resolution at this time. A speculative fix
   for DR1432 is needed to prevent regressions that would otherwise occur due to DR692.
 - Clang's default C++/ObjC++ standard is now ``gnu++17`` instead of ``gnu++14``.
   This means Clang will by default accept code using features from C++17 and
   conforming GNU extensions. Projects incompatible with C++17 can add
   ``-std=gnu++14`` to their build settings to restore the previous behaviour.
 - Implemented DR2358 allowing init captures in lambdas in default arguments.
+- implemented `DR2654 <https://wg21.link/cwg2654>`_ which undeprecates
+  all compound assignements operations on volatile qualified variables.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 - Support capturing structured bindings in lambdas
   (`P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`_).
   This fixes issues `Issue 52720 <https://github.com/llvm/llvm-project/issues/52720>`_,
   `Issue 54300 <https://github.com/llvm/llvm-project/issues/54300>`_,
   `Issue 54301 <https://github.com/llvm/llvm-project/issues/54301>`_,

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_increment_decrement_enum : Error<
   "cannot %select{decrement|increment}0 expression of enum type %1">;
 
 def warn_deprecated_increment_decrement_volatile : Warning<
   "%select{decrement|increment}0 of object of volatile-qualified type %1 "
   "is deprecated">, InGroup<DeprecatedVolatile>;
 def warn_deprecated_simple_assign_volatile : Warning<
   "use of result of assignment to object of volatile-qualified type %0 "
   "is deprecated">, InGroup<DeprecatedVolatile>;
-def warn_deprecated_compound_assign_volatile : Warning<
-  "compound assignment to object of volatile-qualified type %0 is deprecated">,
-  InGroup<DeprecatedVolatile>;
 def warn_deprecated_volatile_return : Warning<
   "volatile-qualified return type %0 is deprecated">,
   InGroup<DeprecatedVolatile>;
 def warn_deprecated_volatile_param : Warning<
   "volatile-qualified parameter type %0 is deprecated">,
   InGroup<DeprecatedVolatile>;
 def warn_deprecated_volatile_structured_binding : Warning<
   "volatile qualifier in structured binding declaration is deprecated">,

clang/lib/Sema/SemaExpr.cpp

QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
 
   if (getLangOpts().CPlusPlus20 && LHSType.isVolatileQualified()) {
     if (CompoundType.isNull()) {
       // C++2a [expr.ass]p5:
       //   A simple-assignment whose left operand is of a volatile-qualified
       //   type is deprecated unless the assignment is either a discarded-value
       //   expression or an unevaluated operand
       ExprEvalContexts.back().VolatileAssignmentLHSs.push_back(LHSExpr);
-    } else {
-      // C++20 [expr.ass]p6:
-      //   [Compound-assignment] expressions are deprecated if E1 has
-      //   volatile-qualified type and op is not one of the bitwise
-      //   operators |, &, ˆ.
-      switch (Opc) {
-      case BO_OrAssign:
-      case BO_AndAssign:
-      case BO_XorAssign:
-        break;
-      default:
-        Diag(Loc, diag::warn_deprecated_compound_assign_volatile) << LHSType;
-      }
     }
   }
 
   // C11 6.5.16p3: The type of an assignment expression is the type of the
   // left operand would have after lvalue conversion.
   // C11 6.3.2.1p2: ...this is called lvalue conversion. If the lvalue has
   // qualified type, the value has the unqualified version of the type of the
   // lvalue; additionally, if the lvalue has atomic type, the value has the

clang/test/CXX/drs/dr26xx.cpp

 namespace dr2650 { // dr2650: yes
 template <class T, T> struct S {};
 template <class T> int f(S<T, T{}>*); // expected-note {{type 'X' of non-type template parameter is not a structural type}}
 class X {
   int m;
 };
 int i0 = f<X>(0);   //expected-error {{no matching function for call to 'f'}}
 }
+
+namespace dr2654 { // dr2654: 16
+void f() {
+    int neck, tail;
+    volatile int brachiosaur;
+    brachiosaur += neck;                // OK
+    brachiosaur -= neck;                // OK
+    brachiosaur |= neck;                // OK
+}
+}

clang/test/SemaCXX/deprecated.cpp

for (volatile bool x = true;
          volatile bool y = true; // ok despite volatile load from volatile initialization
         ) {}
 
     // inc / dec / compound assignments are always deprecated
     ++n; // cxx20-warning {{increment of object of volatile-qualified type 'volatile int' is deprecated}}
     --n; // cxx20-warning {{decrement of object of volatile-qualified type 'volatile int' is deprecated}}
     n++; // cxx20-warning {{increment of object of volatile-qualified type 'volatile int' is deprecated}}
     n--; // cxx20-warning {{decrement of object of volatile-qualified type 'volatile int' is deprecated}}
-    n += 5; // cxx20-warning {{compound assignment to object of volatile-qualified type 'volatile int' is deprecated}}
-    n *= 3; // cxx20-warning {{compound assignment to object of volatile-qualified type 'volatile int' is deprecated}}
-    n /= 2; // cxx20-warning {{compound assignment to object of volatile-qualified type 'volatile int' is deprecated}}
-    n %= 42; // cxx20-warning {{compound assignment to object of volatile-qualified type 'volatile int' is deprecated}}
+    n += 5; // undeprecated as a DR in C++23
+    n *= 3; // undeprecated as a DR in C++23
+    n /= 2; // undeprecated as a DR in C++23
+    n %= 42; // undeprecated as a DR in C++23
     n &= 2; // undeprecated as a DR in C++23
     n |= 2; // undeprecated as a DR in C++23
     n ^= 2; // undeprecated as a DR in C++23
 
     (void)__is_trivially_assignable(volatile int&, int); // no warning
 
 #if __cplusplus >= 201703L
     struct X { int a, b; };

clang/www/cxx_dr_status.html

<tr id="2653">
     <td>accepted</td>
     <td>Can an explicit object parameter have a default argument?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2654">
     <td><a href="https://wg21.link/cwg2654">2654</a></td>
     <td>DR</td>
     <td>Un-deprecation of compound volatile assignments</td>
-    <td class="none" align="center">Unknown</td>
+    <td class="unreleased" align="center">Clang 16</td>
   </tr></table>
 
 </div>
 </body>
 </html>