Actually, just use explicit capture

... and get rid of the macro mess for [=,this]

CMakeLists.txt

@@ -507,35 +507,6 @@ if(HAVE_AUXV_GETAUXVAL)
   add_definitions(-DROCKSDB_AUXV_GETAUXVAL_PRESENT)
 endif()
 
-# Workaround to get c++ std version option coming from CMAKE_CXX_STANDARD for try_compile
-include(CxxFlags)
-get_cxx_std_flags(CMAKE_REQUIRED_FLAGS)
-
-CHECK_CXX_SOURCE_COMPILES("
-struct test {
-  test() : value_(0) {}
-
-  int lambda() {
-    return [=,this]() { return value_; }();
-  }
-
-  int value_;
-};
-
-int main() {
-  test t;
-  return t.lambda();
-}
-" USE_EXPLICIT_CAPTURE_THIS
-)
-
-unset(CMAKE_REQUIRED_FLAGS)
-
-if(USE_EXPLICIT_CAPTURE_THIS)
-  add_definitions(-DROCKSDB_EXPLICIT_CAPTURE_THIS)
-endif()
-
-
 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_SOURCE_DIR}/include)
 include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/third-party/gtest-1.8.1/fused-src)

build_tools/build_detect_platform

@@ -706,26 +706,6 @@ EOF
 fi
 
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -Werror -x c++ - -o /dev/null 2>/dev/null <<EOF
-struct test {
-  test() : value_(0) {}
-
-  int lambda() {
-    return [=,this]() { return value_; }();
-  }
-
-  int value_;
-};
-
-int main() {
-  test t;
-  return t.lambda();
-}
-EOF
-if [ "$?" = 0 ]; then
-  COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_EXPLICIT_CAPTURE_THIS"
-fi
-
 if [ "$FBCODE_BUILD" != "true" -a "$PLATFORM" = OS_LINUX ]; then
   $CXX $COMMON_FLAGS $PLATFORM_SHARED_CFLAGS -x c++ -c - -o test_dl.o 2>/dev/null <<EOF
   void dummy_func() {}

memory/concurrent_arena.h

@@ -49,9 +49,8 @@ class ConcurrentArena : public Allocator {
                            size_t huge_page_size = 0);
 
   char* Allocate(size_t bytes) override {
-    return AllocateImpl(
-        bytes, false /*force_arena*/,
-        [ROCKSDB_THIS_LAMBDA_CAPTURE]() { return arena_.Allocate(bytes); });
+    return AllocateImpl(bytes, false /*force_arena*/,
+                        [this, bytes]() { return arena_.Allocate(bytes); });
   }
 
   char* AllocateAligned(size_t bytes, size_t huge_page_size = 0,
@@ -61,7 +60,7 @@ class ConcurrentArena : public Allocator {
            (rounded_up % sizeof(void*)) == 0);
 
     return AllocateImpl(rounded_up, huge_page_size != 0 /*force_arena*/,
-                        [ROCKSDB_THIS_LAMBDA_CAPTURE]() {
+                        [this, rounded_up, huge_page_size, logger]() {
                           return arena_.AllocateAligned(rounded_up,
                                                         huge_page_size, logger);
                         });

port/lang.h

@@ -14,10 +14,3 @@
 #define FALLTHROUGH_INTENDED do {} while (0)
 #endif
 #endif
-
-#if defined(ROCKSDB_EXPLICIT_CAPTURE_THIS) || __cplusplus >= 202002L
-// C++20 deprecates implicit capture of 'this' in [=]
-#define ROCKSDB_THIS_LAMBDA_CAPTURE =, this
-#else
-#define ROCKSDB_THIS_LAMBDA_CAPTURE =
-#endif

table/block_based/block_based_table_builder.cc

@@ -662,14 +662,13 @@ BlockBasedTableBuilder::BlockBasedTableBuilder(
     rep_->pc_rep->compress_thread_pool.reserve(
         rep_->compression_opts.parallel_threads);
     for (uint32_t i = 0; i < rep_->compression_opts.parallel_threads; i++) {
-      rep_->pc_rep->compress_thread_pool.emplace_back(
-          [ROCKSDB_THIS_LAMBDA_CAPTURE] {
-            BGWorkCompression(*(rep_->compression_ctxs[i]),
-                              rep_->verify_ctxs[i].get());
-          });
+      rep_->pc_rep->compress_thread_pool.emplace_back([this, i] {
+        BGWorkCompression(*(rep_->compression_ctxs[i]),
+                          rep_->verify_ctxs[i].get());
+      });
     }
-    rep_->pc_rep->write_thread.reset(new port::Thread(
-        [ROCKSDB_THIS_LAMBDA_CAPTURE] { BGWorkWriteRawBlock(); }));
+    rep_->pc_rep->write_thread.reset(
+        new port::Thread([this] { BGWorkWriteRawBlock(); }));
   }
 }
 
@@ -834,7 +833,7 @@ void BlockBasedTableBuilder::Flush() {
     if (first_block) {
       std::unique_lock<std::mutex> lock(r->pc_rep->first_block_mutex);
       r->pc_rep->first_block_cond.wait(lock,
-                                       [=] { return !r->pc_rep->first_block; });
+                                       [r] { return !r->pc_rep->first_block; });
     }
   } else {
     WriteBlock(&r->data_block, &r->pending_handle, true /* is_data_block */);

utilities/blob_db/blob_db_impl.cc

@@ -622,17 +622,15 @@ void BlobDBImpl::MarkUnreferencedBlobFilesObsolete() {
   const SequenceNumber obsolete_seq = GetLatestSequenceNumber();
 
   MarkUnreferencedBlobFilesObsoleteImpl(
-      [ROCKSDB_THIS_LAMBDA_CAPTURE](
-          const std::shared_ptr<BlobFile>& blob_file) {
+      [this, obsolete_seq](const std::shared_ptr<BlobFile>& blob_file) {
         WriteLock file_lock(&blob_file->mutex_);
         return MarkBlobFileObsoleteIfNeeded(blob_file, obsolete_seq);
       });
 }
 
 void BlobDBImpl::MarkUnreferencedBlobFilesObsoleteDuringOpen() {
   MarkUnreferencedBlobFilesObsoleteImpl(
-      [ROCKSDB_THIS_LAMBDA_CAPTURE](
-          const std::shared_ptr<BlobFile>& blob_file) {
+      [this](const std::shared_ptr<BlobFile>& blob_file) {
         return MarkBlobFileObsoleteIfNeeded(blob_file, /* obsolete_seq */ 0);
       });
 }