[clang-tidy] Implement CppCoreGuideline F.54

[ccotter]

Summary

Warn when a lambda specifies a default capture and captures
`this`. Offer FixIts to correct the code.

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

122

fix-it.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/avoid-capture-this-with-capture-default.rst

6 ↗

(On Diff #486858)

Please make first statement same as in Release Notes.

[ccotter]

• docs feedback

[carlosgalvezp]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

9 ↗

(On Diff #486873)

"default capture"?

9 ↗

(On Diff #486873)

I find the check name a bit unintuitive. If you are up for a rename (you can use rename_check.py), I would consider renaming to something like cppcoreguidelines-avoid-default-capture-when-capturing-this

Like, what should be avoided is not "capturing this", it's using a default capture.

Would be good to get other reviewers opinion before spending time on renaming.

9 ↗

(On Diff #486873)

Maybe put it within quotes so clarify it's a C++ keyword? Either backticks this or single quotes 'this' would work I think, unless we have some other convention.

[carlosgalvezp]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

1 ↗

(On Diff #486873)

I believe this is the default, does it make sense to remove it or do we need to be explicit?

[ccotter]

• Use "capture default" consistently and update diagnostic message

[ccotter]

oops, bad 'arc diff' again

[ccotter]

• typo

[ccotter]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

9 ↗

(On Diff #486873)

I updated all references to capture default to say "capture default" as this is how it is spelled in the standard. The CppCoreGuideline for F.54 does use "default capture" though, so I'll open an issue seeing if that wording should instead say "capture default." Also for reference, git grep within the llvm-project repo shows

$ git grep -i 'capture default' | wc -l
      43
$ git grep -i 'default capture' | wc -l
      54
$ git grep -i 'capture.default' | wc -l # E.g., 'capture-default' or 'capture default'
     105

9 ↗

(On Diff #486873)

Updated with a single quote. I didn't find any clang-tidy diagnostics emitting backticks, but saw usage of single quotes when referring to identifiers like variable or class names.

9 ↗

(On Diff #486873)

+1 - I admit, I struggled naming this check. More feedback welcome on the name

[ccotter]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

9 ↗

(On Diff #486873)

https://github.com/isocpp/CppCoreGuidelines/pull/2016 for "capture default" vs "default capture"

[carlosgalvezp]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

9 ↗

(On Diff #486873)

Interesting, thanks for investigating this! cppreference also uses that terminology.
It sounds quite strange to me since that's not how humans read english text (which is what the diagnostic is meant for). We use "default constructor", "default arguments", etc.

Anyhow this is a minor detail that shouldn't block the patch. Thanks for opening the pull requet towards CppCoreGuidelines!

[ccotter]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

9 ↗

(On Diff #486873)

Since this is a more minor detail, we could probably follow up on the "capture default" wording on the CppCoreGuidelines issue I opened. I'll add that I *just* changed the lone occurrence of "default capture" in https://en.cppreference.com/mwiki/index.php?title=cpp%2Flanguage%2Flambda&diff=146169&oldid=145543, since the other 15 references were phrased "capture default" or "capture-default."

[carlosgalvezp]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureThisWithCaptureDefaultCheck.cpp

35 ↗

(On Diff #487084)

Not having being involved in the development of this check I don't quite understand what this error message means, could you provide a more descriptive message?

It's also unclear if the program is supposed to abort when entering this branch, or if it's expected that it returns just fine? If it's supposed to return just fine, I think the check should not print anything, to keep the users' logs clean.

clang-tools-extra/docs/ReleaseNotes.rst

121

This text should also be at the beginning of the check class documentation (in the Check.h, line 18)

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/avoid-capture-this-with-capture-default.rst

9 ↗

(On Diff #487084)

defaults

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

9 ↗

(On Diff #486873)

Another suggestion for the check name:

"cppcoreguidelines-avoid-capture-default-in-member-functions"

[ccotter]

• rm trace; tidy docs

[ccotter]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureThisWithCaptureDefaultCheck.cpp

35 ↗

(On Diff #487084)

My bad - I forgot to remove this trace. Both branches are valid branches for normal program execution.

[carlosgalvezp]

LGTM! Please give a few days for other reviewers to comment. If you are not 100% happy with the check name I'd suggest to change it before merging, it will be much harder to change once it's in.

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureThisWithCaptureDefaultCheck.cpp

32 ↗

(On Diff #487130)

Should be const SourceManager &.

[ccotter]

• Use const&

[ccotter]

• rename to avoid-capture-deafult-when-capturing-this

[ccotter]

Thanks!

I opted for 'avoid-capture-default-when-capturing-this' and updated the name and docs etc in the most recent diff.

[carlosgalvezp]

LGTM! Minor nit.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/avoid-capture-default-when-capturing-this.rst

5

Fix line so it's as long as the text above

[ccotter]

• tidy up docs

[njames93]

Can you run this through clang format to make sure the pre merge is happy and address those nits

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

82

Would be nice to show if this is implicitly captured.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/avoid-capture-default-when-capturing-this.rst

7

Not necessary to specify fix behaviour as that's provided in the check list

20

Please fix these examples as this isn't actually captured because the names don't match.

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-this-with-capture-default.cpp

10 ↗

(On Diff #487195)

Please can you include the whole expected line in the check fix markers, same goes for all tests below

[ccotter]

• clang-format
• Show whether 'this' is implicitly captured
• fix docs

[ccotter]

• Rename test to match check name

[njames93]

Just 2 more CHECK-FIXES lines need updating.
FWIW the reason its good to be explicit is because FileCheck will start searching from the line where the previous CHECK-FIXES had and stop when it sees line that contains the match.
In this example:

// CHECK-FIXES: [this]() { };

If the there was an error with the fix, but later on in the file, that string was found. FileCheck would assume the CHECK-FIXES directive was found and report success.
That may in turn lead other CHECK-FIXES to fail due to the position of the previous match. But those error message would be slightly more confusing as the expected fix was actually found in the output file (just not in the correct place)
Expanding the check to this:

// CHECK-FIXES: auto explicit_this_capture = [this]() { };

Means we have to match the whole line(which is a lot less likely to appear again later in the file.)

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-default-when-capturing-this.cpp

11

15

[ccotter]

• Finish stengthening CHECK-FIXES

[ccotter]

Thanks for pointing that out.

[ccotter]

My latest update to the diff was the result of a rebase, then addressing the final comments. What I've been doing is something like

git pull upstream main --rebase
# make more edits
git commit -am ....
arc diff --update D141133 upstream/main

I'm not sure if this is the best way to rebase phabs, but please let me know if there's a better way for phab to understand.

[carlosgalvezp]

In D141133#4051068, @ccotter wrote:

My latest update to the diff was the result of a rebase, then addressing the final comments. What I've been doing is something like

git pull upstream main --rebase
# make more edits
git commit -am ....
arc diff --update D141133 upstream/main

I'm not sure if this is the best way to rebase phabs, but please let me know if there's a better way for phab to understand.

I just run arc diff HEAD~ after rebase, and works just fine :)

[ccotter]

Would someone with merge access mind committing this? I double checked and this diff can be applied on the latest upstream/main. Thanks!

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

2

Ditto.

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.h

2

Please merge these two lines. Amount of dashes and equal signs could be reduced.

clang-tools-extra/docs/ReleaseNotes.rst

121

The check also offers fix-its. could be omitted. This information presents in check table.

[ccotter]

• cleanup comments, docs

[carlosgalvezp]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

20

We recently switched to using C++17 nested namespaces for all the clang-tidy folder, please update to keep it consistent.

[ccotter]

• Use nested namespace

[ccotter]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

20

Just curious - I noticed the clang-tidy headers do not use nested namespaces as part of the recent switch. Are the headers slated to be updated too?

[carlosgalvezp]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.h

42–44

Forgot to comment but you'll need it here too :)

[carlosgalvezp]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

20

Oh crap, I must have missed to add the header-filter option when applying the change, it should apply to headers as well! Will fix in a separate patch.

[ccotter]

• Use nested namespace in header too;

[carlosgalvezp]

LGTM, thanks for the contribution! Let's give a couple days for the others to have a last look

[ccotter]

rebase

[ccotter]

Gentle poke for any last reviews?

[carlosgalvezp]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

82

Was this comment addressed? I see it marked as "Not Done".

[ccotter]

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

82

oh yes, I forgot to mark addressed.

[carlosgalvezp]

Thanks for updating the comment! Since I marked it as approved last time, I will land this in the next couple of days if no more comments come up.

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.h

+//===--- AvoidCaptureDefaultWhenCapturingThisCheck.h - clang-tidy*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDCAPTUREDEFAULTWHENCAPTURINGTHISCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDCAPTUREDEFAULTWHENCAPTURINGTHISCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::cppcoreguidelines {
+
+/// Warns when lambda specify a capture default and capture ``this``. The check
+/// also offers fix-its.
+///
+/// Capture defaults in lambas defined within member functions can be
+/// misleading about whether capturing data member is by value or reference.
+/// For example, [=] will capture local variables by value but member variables
+/// by reference. CppCoreGuideline F.54 suggests to always be explicit
+/// and never specify a capture default when also capturing this.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines/avoid-capture-default-when-capturing-this.html
+class AvoidCaptureDefaultWhenCapturingThisCheck : public ClangTidyCheck {
+public:
+  AvoidCaptureDefaultWhenCapturingThisCheck(StringRef Name,
+                                            ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus11;
+  }
+};
+
+} // namespace clang::tidy::cppcoreguidelines
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDCAPTUREDEFAULTWHENCAPTURINGTHISCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidCaptureDefaultWhenCapturingThisCheck.cpp

+//===--- AvoidCaptureDefaultWhenCapturingThisCheck.cpp - clang-tidy--------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "AvoidCaptureDefaultWhenCapturingThisCheck.h"
+#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <algorithm>
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::cppcoreguidelines {
+
+void AvoidCaptureDefaultWhenCapturingThisCheck::registerMatchers(
+    MatchFinder *Finder) {
+  Finder->addMatcher(lambdaExpr(hasAnyCapture(capturesThis())).bind("lambda"),
+                     this);
+}
+
+static SourceLocation findDefaultCaptureEnd(const LambdaExpr *Lambda,
+                                            ASTContext &Context) {
+  for (const LambdaCapture &Capture : Lambda->explicit_captures()) {
+    if (Capture.isExplicit()) {
+      if (Capture.getCaptureKind() == LCK_ByRef) {
+        const SourceManager &SourceMgr = Context.getSourceManager();
+        SourceLocation AddressofLoc = utils::lexer::findPreviousTokenKind(
+            Capture.getLocation(), SourceMgr, Context.getLangOpts(), tok::amp);
+        return AddressofLoc;
+      } else {
+        return Capture.getLocation();
+      }
+    }
+  }
+  return Lambda->getIntroducerRange().getEnd();
+}
+
+static std::string createReplacementText(const LambdaExpr *Lambda) {
+  std::string Replacement;
+  llvm::raw_string_ostream Stream(Replacement);
+
+  auto AppendName = [&](llvm::StringRef Name) {
+    if (Replacement.size() != 0) {
+      Stream << ", ";
+    }
+    if (Lambda->getCaptureDefault() == LCD_ByRef && Name != "this") {
+      Stream << "&" << Name;
+    } else {
+      Stream << Name;
+    }
+  };
+
+  for (const LambdaCapture &Capture : Lambda->implicit_captures()) {
+    assert(Capture.isImplicit());
+    if (Capture.capturesVariable() && Capture.isImplicit()) {
+      AppendName(Capture.getCapturedVar()->getName());
+    } else if (Capture.capturesThis()) {
+      AppendName("this");
+    }
+  }
+  if (Replacement.size() &&
+      Lambda->explicit_capture_begin() != Lambda->explicit_capture_end()) {
+    // Add back separator if we are adding explicit capture variables.
+    Stream << ", ";
+  }
+  return Replacement;
+}
+
+void AvoidCaptureDefaultWhenCapturingThisCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  if (const auto *Lambda = Result.Nodes.getNodeAs<LambdaExpr>("lambda")) {
+    if (Lambda->getCaptureDefault() != LCD_None) {
+      bool IsThisImplicitlyCaptured = std::any_of(
+          Lambda->implicit_capture_begin(), Lambda->implicit_capture_end(),
+          [](const LambdaCapture &Capture) { return Capture.capturesThis(); });
+      auto Diag = diag(Lambda->getCaptureDefaultLoc(),
+                       "lambdas that %select{|implicitly }0capture 'this' "
+                       "should not specify a capture default")
+                  << IsThisImplicitlyCaptured;
+
+      std::string ReplacementText = createReplacementText(Lambda);
+      SourceLocation DefaultCaptureEnd =
+          findDefaultCaptureEnd(Lambda, *Result.Context);
+      Diag << FixItHint::CreateReplacement(
+          CharSourceRange::getCharRange(Lambda->getCaptureDefaultLoc(),
+                                        DefaultCaptureEnd),
+          ReplacementText);
+    }
+  }
+}
+
+} // namespace clang::tidy::cppcoreguidelines

clang-tools-extra/clang-tidy/cppcoreguidelines/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyCppCoreGuidelinesModule
+  AvoidCaptureDefaultWhenCapturingThisCheck.cpp
   AvoidConstOrRefDataMembersCheck.cpp
   AvoidDoWhileCheck.cpp
   AvoidGotoCheck.cpp
   AvoidNonConstGlobalVariablesCheck.cpp
   AvoidReferenceCoroutineParametersCheck.cpp
   CppCoreGuidelinesTidyModule.cpp
   InitVariablesCheck.cpp
   InterfacesGlobalInitCheck.cpp

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 //===-- CppCoreGuidelinesTidyModule.cpp - clang-tidy ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../misc/NonPrivateMemberVariablesInClassesCheck.h"
 #include "../misc/UnconventionalAssignOperatorCheck.h"
 #include "../modernize/AvoidCArraysCheck.h"
 #include "../modernize/UseOverrideCheck.h"
 #include "../readability/MagicNumbersCheck.h"
+#include "AvoidCaptureDefaultWhenCapturingThisCheck.h"
 #include "AvoidConstOrRefDataMembersCheck.h"
 #include "AvoidDoWhileCheck.h"
 #include "AvoidGotoCheck.h"
 #include "AvoidNonConstGlobalVariablesCheck.h"
 #include "AvoidReferenceCoroutineParametersCheck.h"
 #include "InitVariablesCheck.h"
 #include "InterfacesGlobalInitCheck.h"
 #include "MacroUsageCheck.h"

 
 namespace clang::tidy {
 namespace cppcoreguidelines {
 
 /// A module containing checks of the C++ Core Guidelines
 class CppCoreGuidelinesModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<AvoidCaptureDefaultWhenCapturingThisCheck>(
+        "cppcoreguidelines-avoid-capture-default-when-capturing-this");
     CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
         "cppcoreguidelines-avoid-c-arrays");
     CheckFactories.registerCheck<AvoidConstOrRefDataMembersCheck>(
         "cppcoreguidelines-avoid-const-or-ref-data-members");
     CheckFactories.registerCheck<AvoidDoWhileCheck>(
         "cppcoreguidelines-avoid-do-while");
     CheckFactories.registerCheck<AvoidGotoCheck>(
         "cppcoreguidelines-avoid-goto");

clang-tools-extra/docs/ReleaseNotes.rst

 ^^^^^^^^^^
 
 - New :doc:`bugprone-suspicious-realloc-usage
   <clang-tidy/checks/bugprone/suspicious-realloc-usage>` check.
 
   Finds usages of ``realloc`` where the return value is assigned to the
   same expression as passed to the first argument.
 
+- New :doc:`cppcoreguidelines-avoid-capture-default-when-capturing-this
+  <clang-tidy/checks/cppcoreguidelines/avoid-capture-default-when-capturing-this>` check.
+
+  Warns when lambda specify a capture default and capture ``this``.
+
 - New :doc:`cppcoreguidelines-avoid-const-or-ref-data-members
   <clang-tidy/checks/cppcoreguidelines/avoid-const-or-ref-data-members>` check.
 
   Warns when a struct or class uses const or reference (lvalue or rvalue) data members.
 
 - New :doc:`cppcoreguidelines-avoid-do-while
   <clang-tidy/checks/cppcoreguidelines/avoid-do-while>` check.
 

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/avoid-capture-default-when-capturing-this.rst

+.. title:: clang-tidy - cppcoreguidelines-avoid-capture-default-when-capturing-this
+
+cppcoreguidelines-avoid-capture-default-when-capturing-this
+===========================================================
+
+Warns when lambda specify a capture default and capture ``this``.
+
+Capture-defaults in member functions can be misleading about
+whether data members are captured by value or reference. For example,
+specifying the capture default ``[=]`` will still capture data members
+by reference.
+
+Examples:
+
+.. code-block:: c++
+
+      struct AClass {
+        int member;
+        void misleadingLogic() {
+          int local = 0;
+          member = 0;
+          auto f = [=]() mutable {
+            local += 1;
+            member += 1;
+          };
+          f();
+          // Here, local is 0 but member is 1
+        }
+
+        void clearLogic() {
+          int local = 0;
+          member = 0;
+          auto f = [this, local]() mutable {
+            local += 1;
+            member += 1;
+          };
+          f();
+          // Here, local is 0 but member is 1
+        }
+      };
+
+This check implements
+`CppCoreGuideline F.54 <http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f54-if-you-capture-this-capture-all-variables-explicitly-no-default-capture>`_.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `clang-analyzer-osx.cocoa.MissingSuperCall <clang-analyzer/osx.cocoa.MissingSuperCall.html>`_,
    `clang-analyzer-osx.cocoa.NonNilReturnValue <clang-analyzer/osx.cocoa.NonNilReturnValue.html>`_,
    `clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak <clang-analyzer/osx.cocoa.RunLoopAutoreleaseLeak.html>`_,
    `clang-analyzer-valist.CopyToSelf <clang-analyzer/valist.CopyToSelf.html>`_,
    `clang-analyzer-valist.Uninitialized <clang-analyzer/valist.Uninitialized.html>`_,
    `clang-analyzer-valist.Unterminated <clang-analyzer/valist.Unterminated.html>`_,
    `concurrency-mt-unsafe <concurrency/mt-unsafe.html>`_,
    `concurrency-thread-canceltype-asynchronous <concurrency/thread-canceltype-asynchronous.html>`_,
+   `cppcoreguidelines-avoid-capture-default-when-capturing-this <cppcoreguidelines/avoid-capture-default-when-capturing-this.html>`_,
    `cppcoreguidelines-avoid-const-or-ref-data-members <cppcoreguidelines/avoid-const-or-ref-data-members.html>`_,
    `cppcoreguidelines-avoid-do-while <cppcoreguidelines/avoid-do-while.html>`_,
    `cppcoreguidelines-avoid-goto <cppcoreguidelines/avoid-goto.html>`_,
    `cppcoreguidelines-avoid-non-const-global-variables <cppcoreguidelines/avoid-non-const-global-variables.html>`_,
    `cppcoreguidelines-avoid-reference-coroutine-parameters <cppcoreguidelines/avoid-reference-coroutine-parameters.html>`_,
    `cppcoreguidelines-init-variables <cppcoreguidelines/init-variables.html>`_, "Yes"
    `cppcoreguidelines-interfaces-global-init <cppcoreguidelines/interfaces-global-init.html>`_,
    `cppcoreguidelines-macro-usage <cppcoreguidelines/macro-usage.html>`_,

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/avoid-capture-default-when-capturing-this.cpp

+// RUN: %check_clang_tidy -std=c++11-or-later %s cppcoreguidelines-avoid-capture-default-when-capturing-this %t
+
+struct Obj {
+  void lambdas_that_warn_default_capture_copy() {
+    int local{};
+    int local2{};
+
+    auto explicit_this_capture = [=, this]() { };
+    // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture = [this]() { };
+
+    auto explicit_this_capture_locals1 = [=, this]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_locals1 = [local, this]() { return (local+x) > 10; };
+
+    auto explicit_this_capture_locals2 = [=, this]() { return (local+local2) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_locals2 = [local, local2, this]() { return (local+local2) > 10; };
+
+    auto explicit_this_capture_local_ref = [=, this, &local]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_local_ref = [this, &local]() { return (local+x) > 10; };
+
+    auto explicit_this_capture_local_ref2 = [=, &local, this]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_local_ref2 = [&local, this]() { return (local+x) > 10; };
+
+    auto explicit_this_capture_local_ref3 = [=, &local, this, &local2]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_local_ref3 = [&local, this, &local2]() { return (local+x) > 10; };
+
+    auto explicit_this_capture_local_ref4 = [=, &local, &local2, this]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_local_ref4 = [&local, &local2, this]() { return (local+x) > 10; };
+
+    auto explicit_this_capture_local_ref_extra_whitespace = [=, &  local, &local2, this]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:62: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_local_ref_extra_whitespace = [&  local, &local2, this]() { return (local+x) > 10; };
+
+    auto explicit_this_capture_local_ref_with_comment = [=, & /* byref */ local, &local2, this]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:58: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto explicit_this_capture_local_ref_with_comment = [& /* byref */ local, &local2, this]() { return (local+x) > 10; };
+
+    auto implicit_this_capture = [=]() { return x > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: lambdas that implicitly capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto implicit_this_capture = [this]() { return x > 10; };
+
+    auto implicit_this_capture_local = [=]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: lambdas that implicitly capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto implicit_this_capture_local = [local, this]() { return (local+x) > 10; };
+  }
+
+  void lambdas_that_warn_default_capture_ref() {
+    int local{};
+    int local2{};
+
+    auto ref_explicit_this_capture = [&, this]() { };
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto ref_explicit_this_capture = [this]() { };
+
+    auto ref_explicit_this_capture_local = [&, this]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: lambdas that capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto ref_explicit_this_capture_local = [&local, this]() { return (local+x) > 10; };
+
+    auto ref_implicit_this_capture = [&]() { return x > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: lambdas that implicitly capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto ref_implicit_this_capture = [this]() { return x > 10; };
+
+    auto ref_implicit_this_capture_local = [&]() { return (local+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: lambdas that implicitly capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto ref_implicit_this_capture_local = [&local, this]() { return (local+x) > 10; };
+
+    auto ref_implicit_this_capture_locals = [&]() { return (local+local2+x) > 10; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: lambdas that implicitly capture 'this' should not specify a capture default [cppcoreguidelines-avoid-capture-default-when-capturing-this]
+    // CHECK-FIXES: auto ref_implicit_this_capture_locals = [&local, &local2, this]() { return (local+local2+x) > 10; };
+  }
+
+  void lambdas_that_dont_warn() {
+    int local{};
+    int local2{};
+    auto explicit_this_capture = [this]() { };
+    auto explicit_this_capture_local = [this, local]() { return local > 10; };
+    auto explicit_this_capture_local_ref = [this, &local]() { return local > 10; };
+
+    auto no_captures = []() {};
+    auto capture_local_only = [local]() {};
+    auto ref_capture_local_only = [&local]() {};
+    auto capture_many = [local, &local2]() {};
+  }
+
+  int x;
+};