[clang] Warn by default that implicit capture of 'this' is deprecated in C++20 and later.

[tahonermann]

Summary

Previously, a warning that C++20 deprecated implicit capture of 'this' for lambda captures specified with a capture default of '=' was only issued when '-Wdeprecated' or '-Wdeprecated-this-capture' was specified. This change enables the warning by default (it is still only issued when compiling for C++20 or later). This is consistent with gcc which warns by default (MSVC requires '/Wall').

[erichkeane]

You'll need a rebase to get the pre-commit CI to work. Else, looks fine to me. Make sure @royjacobson knows of the change for this (https://reviews.llvm.org/D142578).

[tahonermann]

You'll need a rebase to get the pre-commit CI to work.

Yes, thank you. I'll wait for https://reviews.llvm.org/D142578 to land and then rebase.

[shafik]

LGTM

[tahonermann]

Rebased. This now targets Clang 17.

clang/docs/ReleaseNotes.rst

 - ``-Wtype-limits`` was added to ``-Wextra`` for GCC compatibility. This fixes
   `Issue 58375 <https://github.com/llvm/llvm-project/issues/58375>`_.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - We now generate a diagnostic for signed integer overflow due to unary minus
   in a non-constant expression context. This fixes
   `Issue 31643 <https://github.com/llvm/llvm-project/issues/31643>`_
+- Clang now warns by default for C++20 and later about deprecated capture of
+  ``this`` with a capture default of ``=``. This warning can be disabled with
+  ``-Wno-deprecated-this-capture``.
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
 New Compiler Flags
 ------------------
 
 Deprecated Compiler Flags

clang/include/clang/Basic/DiagnosticSemaKinds.td

let CategoryName = "Lambda Issue" in {
   def warn_cxx17_compat_equals_this_lambda_capture : Warning<
     "explicit capture of 'this' with a capture default of '=' is incompatible "
     "with C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
   def ext_equals_this_lambda_capture_cxx20 : ExtWarn<
     "explicit capture of 'this' with a capture default of '=' "
     "is a C++20 extension">, InGroup<CXX20>;
   def warn_deprecated_this_capture : Warning<
     "implicit capture of 'this' with a capture default of '=' is deprecated">,
-    InGroup<DeprecatedThisCapture>, DefaultIgnore;
+    InGroup<DeprecatedThisCapture>;
   def note_deprecated_this_capture : Note<
     "add an explicit capture of 'this' to capture '*this' by reference">;
 
   // C++20 default constructible / assignable lambdas.
   def warn_cxx17_compat_lambda_def_ctor_assign : Warning<
     "%select{default construction|assignment}0 of lambda is incompatible with "
     "C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
 }

clang/test/SemaCXX/cxx1y-generic-lambdas-capturing.cpp

 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -emit-llvm-only %s
-// RUN: %clang_cc1 -std=c++2a -verify -verify=expected-cxx2a -fsyntax-only -fblocks -emit-llvm-only %s
+// RUN: %clang_cc1 -std=c++2a -verify -verify=expected-cxx2a -fsyntax-only -fblocks -emit-llvm-only -Wno-deprecated-this-capture %s
 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -emit-llvm-only -triple i386-windows-pc %s
-// RUN: %clang_cc1 -std=c++2a -verify -verify=expected-cxx2a -fsyntax-only -fblocks -emit-llvm-only -triple i386-windows-pc %s
+// RUN: %clang_cc1 -std=c++2a -verify -verify=expected-cxx2a -fsyntax-only -fblocks -emit-llvm-only -triple i386-windows-pc -Wno-deprecated-this-capture %s
 // DONTRUNYET: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
 // DONTRUNYET: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
 // DONTRUNYET: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
 
 constexpr int ODRUSE_SZ = sizeof(char);
 
 template<class T, int N>
 void f(T, const int (&)[N]) { }

clang/test/SemaCXX/cxx2a-lambda-equals-this.cpp

-// RUN: %clang_cc1 -std=c++2a -verify %s -Wdeprecated
+// RUN: %clang_cc1 -std=c++2a -verify %s
+// expected-no-diagnostics
 
 // This test does two things.
 // Deleting the copy constructor ensures that an [=, this] capture doesn't copy the object.
 // Accessing a member variable from the lambda ensures that the capture actually works.
 class A {
   A(const A &) = delete;
   int i;
 
   void func() {
     auto L = [=, this]() -> int { return i; };
     L();
   }
 };
-
-struct B {
-  int i;
-  void f() {
-    (void) [=] { // expected-note {{add an explicit capture of 'this'}}
-      return i; // expected-warning {{implicit capture of 'this' with a capture default of '=' is deprecated}}
-    };
-  }
-};

clang/test/SemaCXX/lambda-implicit-this-capture.cpp

+// RUN: %clang_cc1 -std=c++11 -verify=cxx11 %s
+// RUN: %clang_cc1 -std=c++2a -verify=cxx2a %s
+// RUN: %clang_cc1 -std=c++2a -verify=cxx2a-no-deprecated %s -Wno-deprecated
+// cxx11-no-diagnostics
+// cxx2a-no-deprecated-no-diagnostics
+
+struct A {
+  int i;
+  void f() {
+    (void) [=] { // cxx2a-note {{add an explicit capture of 'this'}}
+      return i; // cxx2a-warning {{implicit capture of 'this' with a capture default of '=' is deprecated}}
+    };
+  }
+};