fix clang-tidy: unmute previously muted C++20 checks

commit_hash:e40745c72da8fc59ce7502daf4d4aa47459a0164

Author: Anton3

.clang-tidy

@@ -109,19 +109,9 @@ Checks:
   ,-readability-use-anyofallof\
   ,-hicpp-use-emplace\
   ,-modernize-use-emplace\
-  ,-clang-analyzer-optin.cplusplus.UninitializedObject\
-  ,-google-readability-casting\
-  ,-performance-inefficient-vector-operation\
-  ,-performance-unnecessary-copy-initialization\
   "
 # WARNING: DO NOT PUT COMMENTS BETWEEN CHECKS ABOVE!
-# It will have the effect of silencing all checks below the comment.
-
-# TODO: remove the following check excludes in TAXICOMMON-11134
-#  ,-clang-analyzer-optin.cplusplus.UninitializedObject\
-#  ,-google-readability-casting\
-#  ,-performance-inefficient-vector-operation\
-#  ,-performance-unnecessary-copy-initialization\
+# It will have the effect of silently breaking clang-tidy checks altogether.
 
 WarningsAsErrors: '*'
 HeaderFilterRegex: '/userver/(build|clickhouse|core|grpc|mongo|postgresql|redis|kafka|shared|tools)/'

clickhouse/src/storages/tests/metrics_chtest.cpp

@@ -61,6 +61,7 @@ UTEST(Metrics, ActiveConnections) {
     PoolWrapper pool{};
 
     std::vector<storages::clickhouse::impl::ConnectionPtr> connections;
+    connections.reserve(3);
     for (size_t i = 0; i < 3; ++i) {
         connections.emplace_back(pool->Acquire());
     }

core/include/userver/engine/impl/task_local_storage.hpp

@@ -164,6 +164,7 @@ class Storage final {
     // Provides strong exception guarantee. Does not delete the old data, if any.
     template <typename T, VariableKind Kind, typename... Args>
     T& DoEmplace(Key key, bool has_existing_variable, Args&&... args) {
+        // NOLINTNEXTLINE(google-readability-casting)
         auto new_data = std::make_unique<DataImpl<T, Kind>>(key, std::forward<Args>(args)...);
         SetGeneric(key, *new_data, has_existing_variable);
         return new_data.release()->Get();

core/src/concurrent/impl/striped_read_indicator_test.cpp

@@ -23,6 +23,7 @@ UTEST_MT(StripedReadIndicator, LockPassingStress, kReadersCount + kCheckersCount
 
     std::atomic<bool> keep_running{true};
     std::vector<engine::TaskWithResult<void>> tasks;
+    tasks.reserve(kReadersCount + kCheckersCount);
 
     for (std::size_t i = 0; i < kReadersCount; ++i) {
         tasks.push_back(engine::AsyncNoSpan([&] {

core/src/dump/dumper_test.cpp

@@ -154,6 +154,7 @@ UTEST_F_MT(DumperFixture, ThreadSafety, kUpdatersCount + kWritersCount + kReader
 
     std::atomic<bool> keep_running{true};
     std::vector<engine::TaskWithResult<void>> tasks;
+    tasks.reserve(kUpdatersCount + kReadersCount);
 
     for (std::size_t i = 0; i < kUpdatersCount; ++i) {
         tasks.push_back(utils::Async("updater", [&, i] {

core/src/engine/errno_test.cpp

@@ -20,17 +20,18 @@ USERVER_NAMESPACE_BEGIN
 // Test is not ready to TSan non-migrating scheduler
 #if !USERVER_IMPL_HAS_TSAN
 namespace {
-constexpr size_t kNumThreads = 2;
+constexpr std::size_t kNumThreads = 2;
 }  // namespace
 
 UTEST_MT(Errno, IsCoroLocal, kNumThreads) {
-    size_t threads_started{0};
-    size_t threads_switched{0};
+    const auto deadline = engine::Deadline::FromDuration(utest::kMaxTestWaitTime);
+
+    std::size_t threads_started{0};
+    std::size_t threads_switched{0};
     std::mutex mutex;
     std::condition_variable cv;
     std::vector<engine::TaskWithResult<bool>> tasks;
-
-    auto deadline = engine::Deadline::FromDuration(utest::kMaxTestWaitTime);
+    tasks.reserve(kNumThreads);
 
     for (size_t i = 0; i < kNumThreads; ++i) {
         tasks.push_back(engine::AsyncNoSpan([&] {

core/src/engine/get_all_test.cpp

@@ -48,9 +48,11 @@ UTEST(GetAll, MultipleResult) {
 UTEST(GetAll, ContainerVoid) {
     for (std::size_t task_count = 0; task_count < 10; ++task_count) {
         std::vector<engine::TaskWithResult<void>> tasks;
+        tasks.reserve(task_count);
         for (std::size_t i = 0; i < task_count; ++i) {
             tasks.push_back(engine::AsyncNoSpan([] {}));
         }
+
         static_assert(std::is_void_v<decltype(engine::GetAll(tasks))>);
         UEXPECT_NO_THROW(engine::GetAll(tasks));
         for (auto& task : tasks) {

core/src/engine/mutex_test.cpp

@@ -96,9 +96,11 @@ TYPED_UTEST_P_MT(Mutex, LockPassing, kThreads) {
 
     while (!test_deadline.IsReached()) {
         std::vector<engine::TaskWithResult<void>> tasks;
+        tasks.reserve(worker_count);
         for (size_t i = 0; i < worker_count; ++i) {
             tasks.push_back(engine::AsyncNoSpan(work));
         }
+
         for (auto& task : tasks) {
             task.Get();
         }

core/src/engine/semaphore_test.cpp

@@ -205,9 +205,11 @@ UTEST_MT(Semaphore, LockPassing, 4) {
 
     while (!test_deadline.IsReached()) {
         std::vector<engine::TaskWithResult<void>> tasks;
+        tasks.reserve(GetThreadCount());
         for (size_t i = 0; i < GetThreadCount(); ++i) {
             tasks.push_back(engine::AsyncNoSpan(work));
         }
+
         for (auto& task : tasks) {
             task.Get();
         }
@@ -218,6 +220,7 @@ UTEST_MT(Semaphore, LockFastPathRace, 5) {
     const auto test_deadline = engine::Deadline::FromDuration(100ms);
     engine::Semaphore sem{-1UL};
     std::vector<engine::TaskWithResult<void>> tasks;
+    tasks.reserve(GetThreadCount());
 
     for (std::size_t i = 0; i < GetThreadCount(); ++i) {
         tasks.push_back(engine::AsyncNoSpan([&] {
@@ -247,6 +250,7 @@ UTEST(Semaphore, AllWaitersWakeUpWhenNeeded) {
     }
 
     std::vector<engine::TaskWithResult<void>> tasks;
+    tasks.reserve(kLocksCount);
 
     std::atomic<std::size_t> locks_acquired{0};
     engine::SingleConsumerEvent all_locks_acquired;

core/src/engine/single_consumer_event_test.cpp

@@ -210,6 +210,7 @@ UTEST_MT(SingleConsumerEvent, ParallelSend, 3) {
     engine::SingleConsumerEvent event;
 
     std::vector<engine::TaskWithResult<void>> producers;
+    producers.reserve(kProducersCount);
     for (std::size_t i = 0; i < kProducersCount; ++i) {
         producers.push_back(engine::CriticalAsyncNoSpan([&] {
             while (!engine::current_task::ShouldCancel()) {