[clang-tidy] Add readability-avoid-default-lambda-capture

clang-tools-extra/clang-tidy/readability/AvoidDefaultLambdaCaptureCheck.cpp

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "AvoidDefaultLambdaCaptureCheck.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/Lambda.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::readability {
+
+static std::string generateCaptureText(const LambdaCapture &Capture) {
+  if (Capture.capturesThis())
+    return Capture.getCaptureKind() == LCK_StarThis ? "*this" : "this";
+
+  std::string Result;
+  if (Capture.getCaptureKind() == LCK_ByRef)
+    Result += "&";
+
+  Result += Capture.getCapturedVar()->getName().str();
+  return Result;
+}
+
+void AvoidDefaultLambdaCaptureCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(lambdaExpr(hasDefaultCapture()).bind("lambda"), this);
+}
+
+void AvoidDefaultLambdaCaptureCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *Lambda = Result.Nodes.getNodeAs<LambdaExpr>("lambda");
+  assert(Lambda);
+
+  const SourceLocation DefaultCaptureLoc = Lambda->getCaptureDefaultLoc();
+  if (DefaultCaptureLoc.isInvalid())
+    return;
+
+  std::vector<std::string> ImplicitCaptures;
+  for (const LambdaCapture &Capture : Lambda->implicit_captures()) {
+    // It is impossible to explicitly capture a VLA in C++, since VLAs don't
+    // exist in ISO C++ and so the syntax was never created to capture them.
+    if (Capture.getCaptureKind() == LCK_VLAType)
+      return;
+    ImplicitCaptures.push_back(generateCaptureText(Capture));
+  }
+
+  auto Diag = diag(DefaultCaptureLoc,
+                   "lambda uses default capture mode; explicitly capture "
+                   "variables instead");
+
+  // For template-dependent lambdas, the list of captures hasn't been created
+  // yet, so the list of implicit captures is empty.
+  if (ImplicitCaptures.empty() && Lambda->getLambdaClass()->isDependentType())
+    return;
+
+  const std::string ReplacementText = llvm::join(ImplicitCaptures, ", ");
+
+  Diag << FixItHint::CreateReplacement(Lambda->getCaptureDefaultLoc(),
+                                       ReplacementText);
+}
+
+} // namespace clang::tidy::readability

clang-tools-extra/clang-tidy/readability/AvoidDefaultLambdaCaptureCheck.h

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_READABILITY_AVOIDDEFAULTLAMBDACAPTURECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_AVOIDDEFAULTLAMBDACAPTURECHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::readability {
+
+/// Flags lambdas that use default capture modes
+///
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/readability/avoid-default-lambda-capture.html
+class AvoidDefaultLambdaCaptureCheck : public ClangTidyCheck {
+public:
+  AvoidDefaultLambdaCaptureCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  std::optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus11;
+  }
+};
+
+} // namespace clang::tidy::readability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_AVOIDDEFAULTLAMBDACAPTURECHECK_H

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

@@ -6,6 +6,7 @@ set(LLVM_LINK_COMPONENTS
 add_clang_library(clangTidyReadabilityModule STATIC
   AmbiguousSmartptrResetCallCheck.cpp
   AvoidConstParamsInDeclsCheck.cpp
+  AvoidDefaultLambdaCaptureCheck.cpp
   AvoidNestedConditionalOperatorCheck.cpp
   AvoidReturnWithVoidValueCheck.cpp
   AvoidUnconditionalPreprocessorIfCheck.cpp

clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp

@@ -11,6 +11,7 @@
 #include "../ClangTidyModuleRegistry.h"
 #include "AmbiguousSmartptrResetCallCheck.h"
 #include "AvoidConstParamsInDeclsCheck.h"
+#include "AvoidDefaultLambdaCaptureCheck.h"
 #include "AvoidNestedConditionalOperatorCheck.h"
 #include "AvoidReturnWithVoidValueCheck.h"
 #include "AvoidUnconditionalPreprocessorIfCheck.h"
@@ -76,6 +77,8 @@ class ReadabilityModule : public ClangTidyModule {
         "readability-ambiguous-smartptr-reset-call");
     CheckFactories.registerCheck<AvoidConstParamsInDeclsCheck>(
         "readability-avoid-const-params-in-decls");
+    CheckFactories.registerCheck<AvoidDefaultLambdaCaptureCheck>(
+        "readability-avoid-default-lambda-capture");
     CheckFactories.registerCheck<AvoidNestedConditionalOperatorCheck>(
         "readability-avoid-nested-conditional-operator");
     CheckFactories.registerCheck<AvoidReturnWithVoidValueCheck>(

clang-tools-extra/docs/ReleaseNotes.rst

@@ -233,6 +233,11 @@ New checks
   Finds virtual function overrides with different visibility than the function
   in the base class.
 
+- New :doc:`readability-avoid-default-lambda-capture
+  <clang-tidy/checks/readability/avoid-default-lambda-capture>` check.
+
+  Warns on default lambda captures (e.g. ``[&](){ ... }``, ``[=](){ ... }``).
+
 - New :doc:`readability-redundant-parentheses
   <clang-tidy/checks/readability/redundant-parentheses>` check.
 

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

@@ -373,6 +373,7 @@ Clang-Tidy Checks
    :doc:`portability-template-virtual-member-function <portability/template-virtual-member-function>`,
    :doc:`readability-ambiguous-smartptr-reset-call <readability/ambiguous-smartptr-reset-call>`, "Yes"
    :doc:`readability-avoid-const-params-in-decls <readability/avoid-const-params-in-decls>`, "Yes"
+   :doc:`readability-avoid-default-lambda-capture <readability/avoid-default-lambda-capture>`, "Yes"
    :doc:`readability-avoid-nested-conditional-operator <readability/avoid-nested-conditional-operator>`,
    :doc:`readability-avoid-return-with-void-value <readability/avoid-return-with-void-value>`, "Yes"
    :doc:`readability-avoid-unconditional-preprocessor-if <readability/avoid-unconditional-preprocessor-if>`,

clang-tools-extra/docs/clang-tidy/checks/readability/avoid-default-lambda-capture.rst

@@ -0,0 +1,60 @@
+.. title:: clang-tidy - readability-avoid-default-lambda-capture
+
+readability-avoid-default-lambda-capture
+========================================
+
+Tries to replace default lambda captures (e.g. ``[&](){ ... }``, 
+``[=](){ ... }``) with explicit lists of captures.
+
+Captures can lead to subtle bugs including dangling references and unnecessary
+copies. Writing out the name of the variables being captured reminds programmers
+and reviewers about what is being captured.
+
+This check does not warn on variable-length array (VLA) captures. VLAs are not
+ISO C++, and it is impossible to explicitly capture them as the syntax for doing
+so does not exist.
+
+This check does not provide automatic fixes for macros.
+
+Coding guidelines that recommend against defaulted lambda captures include:
+
+* Item 31 of Effective Modern C++ by Scott Meyers
+
+Example
+-------
+
+.. code-block:: c++
+
+  #include <iostream>
+
+  class Widget {
+    std::vector<std::function<void(int)>> callbacks;
+    int                                   widgetId;
+    void addCallback(int factoryId) {
+      callbacks.emplace_back(
+        [&](){
+          std::cout << "Widget " << widgetId << " made in factory " << factoryId;
+        }
+      );
+    }
+  }
+
+When ``callbacks`` is executed, ``factoryId`` will dangle. Writing the name of
+``factoryId`` in the capture list reminds the reader that it is being captured,
+which will hopefully lead to the bug being fixed during code review.
+
+.. code-block:: c++
+
+  #include <iostream>
+
+  class Widget {
+    std::vector<std::function<void(int)>> callbacks;
+    int                                   widgetId;
+    void addCallback(int factoryId) {
+      callbacks.emplace_back(
+        [&factoryId, &widgetId](){ // Why isn't factoryId captured by value??
+          std::cout << "Widget " << widgetId << " made in factory " << factoryId;
+        }
+      );
+    }
+  }

clang-tools-extra/test/clang-tidy/checkers/readability/avoid-default-lambda-capture.cpp

@@ -0,0 +1,179 @@
+// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s readability-avoid-default-lambda-capture %t -- -- -Wno-vla-extension
+// RUN: %check_clang_tidy -std=c++20-or-later -check-suffixes=,20 %s readability-avoid-default-lambda-capture %t -- -- -Wno-vla-extension
+
+void test_default_captures() {
+  int value = 42;
+  int another = 10;
+
+  auto lambda1 = [=](int x) { return value + x; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto lambda1 = [value](int x) { return value + x; };
+
+  auto lambda2 = [&](int x) { return value + x; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto lambda2 = [&value](int x) { return value + x; };
+
+  auto lambda3 = [=, &another](int x) { return value + another + x; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto lambda3 = [value, &another](int x) { return value + another + x; };
+
+  auto lambda4 = [&, value](int x) { return value + another + x; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto lambda4 = [&another, value](int x) { return value + another + x; };
+}
+
+#if __cplusplus >= 202002L
+template<typename... Args>
+void test_pack_expansion_captures(Args... args) {
+  int local = 5;
+
+  auto lambda1 = [=]() { return (args + ...); };
+  // CHECK-MESSAGES-20: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+
+  auto lambda2 = [&]() { return (args + ...); };
+  // CHECK-MESSAGES-20: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+
+  auto lambda3 = [=]() { return (args + ...) + local; };
+  // CHECK-MESSAGES-20: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+
+  auto lambda4 = [&]() { return (args + ...) + local; };
+  // CHECK-MESSAGES-20: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+
+  auto lambda5 = [=, ...copied = args]() { return (copied + ...); };
+  // CHECK-MESSAGES-20: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+
+  auto lambda6 = [&, ...refs = args]() { return (refs + ...); };
+  // CHECK-MESSAGES-20: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+}
+
+void instantiate_pack_expansion_tests() {
+  test_pack_expansion_captures(1, 2, 3);
+  test_pack_expansion_captures(1.0, 2.0, 3.0);
+}
+#endif
+
+void test_acceptable_captures() {
+  int value = 42;
+  int another = 10;
+
+  auto lambda1 = [value](int x) { return value + x; };
+  auto lambda2 = [&value](int x) { return value + x; };
+  auto lambda3 = [value, another](int x) { return value + another + x; };
+  auto lambda4 = [&value, &another](int x) { return value + another + x; };
+
+  auto lambda5 = [](int x, int y) { return x + y; };
+
+  struct S {
+    int member = 5;
+    void foo() {
+      auto lambda = [this]() { return member; };
+    }
+  };
+}
+
+void test_nested_lambdas() {
+  int outer_var = 1;
+  int middle_var = 2;
+  int inner_var = 3;
+
+  auto outer = [=]() {
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+    // CHECK-FIXES: auto outer = [outer_var, middle_var, inner_var]() {
+
+    auto inner = [&](int x) { return outer_var + middle_var + inner_var + x; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+    // CHECK-FIXES: auto inner = [&outer_var, &middle_var, &inner_var](int x) { return outer_var + middle_var + inner_var + x; };
+
+    return inner(10);
+  };
+}
+
+void test_lambda_returns() {
+  int a = 1, b = 2, c = 3;
+
+  auto create_adder = [=](int x) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+    // CHECK-FIXES: auto create_adder = [](int x) {
+    return [x](int y) { return x + y; }; // Inner lambda is fine - explicit capture
+  };
+
+  auto func1 = [&]() { return a; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto func1 = [&a]() { return a; };
+
+  auto func2 = [=]() { return b; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto func2 = [b]() { return b; };
+}
+
+class TestClass {
+  int member = 42;
+
+public:
+  void test_member_function_lambdas() {
+    int local = 10;
+
+    auto lambda1 = [=]() { return member + local; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+    // CHECK-FIXES: auto lambda1 = [this, local]() { return member + local; };
+
+    auto lambda2 = [&]() { return member + local; };
+    // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+    // CHECK-FIXES: auto lambda2 = [this, &local]() { return member + local; };
+
+    auto lambda3 = [this, local]() { return member + local; };
+    auto lambda4 = [this, &local]() { return member + local; };
+  }
+};
+
+// Lambda captures dependent on a template parameter don't have a fix it
+template<typename T>
+void test_template_lambdas() {
+  T value{};
+
+  auto lambda = [=](T x) { return value + x; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+}
+
+void instantiate_templates() {
+  test_template_lambdas<int>();
+  test_template_lambdas<double>();
+}
+
+void test_init_captures() {
+  int x = 3;
+  int nx = 5;
+
+  int y1 = [&, z = x + 5]() -> int {
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: int y1 = [&nx, z = x + 5]() -> int {
+    return z * z + nx;
+  }();
+
+  int y2 = [=, &ref = x]() {
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: int y2 = [nx, &ref = x]() {
+    ref += 1;
+    return nx - ref;
+  }();
+
+  int y3 = [=, &ref = x, z = x + 5]() {
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: lambda uses default capture mode; explicitly capture variables instead [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: int y3 = [nx, &ref = x, z = x + 5]() {
+    ref += 2;
+    return nx + z - ref;
+  }();
+
+  (void)y1;
+  (void)y2;
+  (void)y3;
+}
+
+void test_vla() {
+  // VLAs create implicit VLA bound captures that cannot be written explicitly.
+  // No warning should be issued.
+  int n = 5;
+  int vla[n];
+
+  auto lambda = [&]() { return vla[0]; };
+}