commit vibe coded work

on-behalf-of: @amd <[email protected]>

Author: jjmarr-amd

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

@@ -8,6 +8,8 @@
 
 #include "AvoidDefaultLambdaCaptureCheck.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/Lambda.h"
+#include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
@@ -18,6 +20,45 @@ AST_MATCHER(LambdaExpr, hasDefaultCapture) {
   return Node.getCaptureDefault() != LCD_None;
 }
 
+std::string getCaptureString(const LambdaCapture &Capture) {
+  if (Capture.capturesThis()) {
+    return Capture.getCaptureKind() == LCK_StarThis ? "*this" : "this";
+  }
+
+  if (Capture.capturesVariable()) {
+    std::string Result;
+    if (Capture.getCaptureKind() == LCK_ByRef) {
+      Result += "&";
+    }
+    Result += Capture.getCapturedVar()->getName().str();
+    return Result;
+  }
+
+  // Handle VLA captures - these are rare but possible
+  return "/* VLA capture */";
+}
+
+std::string buildExplicitCaptureList(const LambdaExpr *Lambda) {
+  std::vector<std::string> CaptureStrings;
+
+  // Add explicit captures first (preserve their order and syntax)
+  for (const auto &Capture : Lambda->explicit_captures()) {
+    CaptureStrings.push_back(getCaptureString(Capture));
+  }
+
+  // Add implicit captures (convert to explicit syntax)
+  for (const auto &Capture : Lambda->implicit_captures()) {
+    CaptureStrings.push_back(getCaptureString(Capture));
+  }
+
+  return "[" + llvm::join(CaptureStrings, ", ") + "]";
+}
+
+SourceRange getCaptureListRange(const LambdaExpr *Lambda) {
+  SourceRange IntroducerRange = Lambda->getIntroducerRange();
+  return IntroducerRange;
+}
+
 } // namespace
 
 void AvoidDefaultLambdaCaptureCheck::registerMatchers(MatchFinder *Finder) {
@@ -33,8 +74,20 @@ void AvoidDefaultLambdaCaptureCheck::check(
   if (DefaultCaptureLoc.isInvalid())
     return;
 
-  diag(DefaultCaptureLoc, "lambda default captures are discouraged; "
-                          "prefer to capture specific variables explicitly");
+  // Build the replacement capture list
+  std::string NewCaptureList = buildExplicitCaptureList(Lambda);
+
+  // Get the range of the entire capture list [...]
+  SourceRange CaptureListRange = getCaptureListRange(Lambda);
+
+  auto Diag = diag(DefaultCaptureLoc,
+                   "lambda default captures are discouraged; "
+                   "prefer to capture specific variables explicitly");
+
+  // Only provide fixit if we can determine a valid replacement
+  if (CaptureListRange.isValid() && !NewCaptureList.empty()) {
+    Diag << FixItHint::CreateReplacement(CaptureListRange, NewCaptureList);
+  }
 }
 
 } // namespace clang::tidy::readability

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

@@ -6,15 +6,19 @@ void test_default_captures() {
 
   auto lambda1 = [=](int x) { return value + x; };
   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: lambda default captures are discouraged; prefer to capture specific variables explicitly [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 default captures are discouraged; prefer to capture specific variables explicitly [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 default captures are discouraged; prefer to capture specific variables explicitly [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto lambda3 = [&another, value](int x) { return value + another + x; };
 
   auto lambda4 = [&, value](int x) { return value + another + x; };
   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: lambda default captures are discouraged; prefer to capture specific variables explicitly [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto lambda4 = [value, &another](int x) { return value + another + x; };
 }
 
 void test_acceptable_captures() {
@@ -43,9 +47,11 @@ void test_nested_lambdas() {
 
   auto outer = [=]() {
     // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: lambda default captures are discouraged; prefer to capture specific variables explicitly [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 default captures are discouraged; prefer to capture specific variables explicitly [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);
   };
@@ -56,14 +62,17 @@ void test_lambda_returns() {
 
   auto create_adder = [=](int x) {
     // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: lambda default captures are discouraged; prefer to capture specific variables explicitly [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 default captures are discouraged; prefer to capture specific variables explicitly [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto func1 = [&a]() { return a; };
 
   auto func2 = [=]() { return b; };
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: lambda default captures are discouraged; prefer to capture specific variables explicitly [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto func2 = [b]() { return b; };
 }
 
 class TestClass {
@@ -75,9 +84,11 @@ class TestClass {
 
     auto lambda1 = [=]() { return member + local; };
     // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: lambda default captures are discouraged; prefer to capture specific variables explicitly [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 default captures are discouraged; prefer to capture specific variables explicitly [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; };
@@ -90,6 +101,7 @@ void test_template_lambdas() {
 
   auto lambda = [=](T x) { return value + x; };
   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: lambda default captures are discouraged; prefer to capture specific variables explicitly [readability-avoid-default-lambda-capture]
+  // CHECK-FIXES: auto lambda = [](T x) { return value + x; };
 }
 
 void instantiate_templates() {