No type traits, actually stream clang-tidy output locally, easy fixes

Author: alan-george-lk

.clang-tidy

@@ -9,6 +9,7 @@ Checks: >
   -bugprone-easily-swappable-parameters,
   -modernize-use-trailing-return-type,
   -modernize-avoid-c-arrays,
+  -modernize-type-traits,
   -modernize-use-auto,
   -modernize-use-nodiscard,
   -modernize-return-braced-init-list,

src/data_stream.cpp

@@ -38,7 +38,7 @@ std::string generateRandomId(std::size_t bytes = 16) {
   out.reserve(bytes * 2);
   const char *hex = "0123456789abcdef";
   for (std::size_t i = 0; i < bytes; ++i) {
-    int v = dist(rng);
+    const int v = dist(rng);
     out.push_back(hex[(v >> 4) & 0xF]);
     out.push_back(hex[v & 0xF]);
   }
@@ -314,7 +314,7 @@ void TextStreamWriter::write(const std::string &text) {
 
   for (const auto &chunk_str : splitUtf8(text, kStreamChunkSize)) {
     const auto *p = reinterpret_cast<const std::uint8_t *>(chunk_str.data());
-    std::vector<std::uint8_t> bytes(p, p + chunk_str.size());
+    const std::vector<std::uint8_t> bytes(p, p + chunk_str.size());
     LK_LOG_DEBUG("sending chunk");
     sendChunk(bytes);
   }
@@ -348,7 +348,7 @@ void ByteStreamWriter::write(const std::vector<std::uint8_t> &data) {
     const std::size_t n =
         std::min<std::size_t>(kStreamChunkSize, data.size() - offset);
     auto it = data.begin() + static_cast<std::ptrdiff_t>(offset);
-    std::vector<std::uint8_t> chunk(it, it + static_cast<std::ptrdiff_t>(n));
+    const std::vector<std::uint8_t> chunk(it, it + static_cast<std::ptrdiff_t>(n));
     sendChunk(chunk);
     offset += n;
   }

src/ffi_client.cpp

@@ -173,7 +173,7 @@ bool FfiClient::isInitialized() const noexcept {
 FfiClient::ListenerId
 FfiClient::AddListener(const FfiClient::Listener &listener) {
   const std::scoped_lock<std::mutex> guard(lock_);
-  FfiClient::ListenerId id = next_listener_id++;
+  const FfiClient::ListenerId id = next_listener_id++;
   listeners_[id] = listener;
   return id;
 }
@@ -191,7 +191,7 @@ FfiClient::sendRequest(const proto::FfiRequest &request) const {
   }
   const uint8_t *resp_ptr = nullptr;
   size_t resp_len = 0;
-  FfiHandleId handle =
+  const FfiHandleId handle =
       livekit_ffi_request(reinterpret_cast<const uint8_t *>(bytes.data()),
                           bytes.size(), &resp_ptr, &resp_len);
   if (handle == INVALID_HANDLE) {
@@ -455,7 +455,7 @@ FfiClient::getTrackStatsAsync(uintptr_t track_handle) {
   get_stats_req->set_request_async_id(async_id);
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_get_stats()) {
       logAndThrow("FfiResponse missing get_stats");
     }
@@ -502,7 +502,7 @@ FfiClient::publishTrackAsync(std::uint64_t local_participant_handle,
         }
 
         const proto::OwnedTrackPublication &pub = cb.publication();
-        pr.set_value(std::move(pub));
+        pr.set_value(pub);
       });
 
   // Build and send the request
@@ -701,7 +701,7 @@ FfiClient::subscribeDataTrack(std::uint64_t track_handle,
   }
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_subscribe_data_track()) {
       return Result<proto::OwnedDataTrackStream,
                     SubscribeDataTrackError>::failure(SubscribeDataTrackError{

src/local_participant.cpp

@@ -99,7 +99,7 @@ void LocalParticipant::publishDtmf(int code, const std::string &digit) {
   }
 
   // TODO, should we take destination as inputs?
-  std::vector<std::string> destination_identities;
+  const std::vector<std::string> destination_identities;
   auto fut = FfiClient::instance().publishSipDtmfAsync(
       static_cast<std::uint64_t>(handle_id), static_cast<std::uint32_t>(code),
       digit, destination_identities);
@@ -212,7 +212,7 @@ void LocalParticipant::publishTrack(const std::shared_ptr<Track> &track,
       static_cast<std::uint64_t>(track_handle), options);
 
   // Will throw if the async op fails (error in callback).
-  proto::OwnedTrackPublication owned_pub = fut.get();
+  const proto::OwnedTrackPublication owned_pub = fut.get();
 
   // Construct a LocalTrackPublication from the proto publication.
   auto publication = std::make_shared<LocalTrackPublication>(owned_pub);
@@ -436,12 +436,12 @@ void LocalParticipant::handleRpcMethodInvocation(
         state->cv.notify_all();
       }
     }
-  } guard{state};
+  } const guard{state};
 
   std::optional<RpcError> response_error;
   std::optional<std::string> response_payload;
-  RpcInvocationData params{request_id, caller_identity, payload,
-                           response_timeout_sec};
+  const RpcInvocationData params{request_id, caller_identity, payload,
+                                 response_timeout_sec};
   auto it = rpc_handlers_.find(method);
   if (it == rpc_handlers_.end()) {
     // No handler registered → built-in UNSUPPORTED_METHOD

src/room.cpp

@@ -918,7 +918,7 @@ void Room::OnEvent(const FfiEvent &event) {
               identity);
           break;
         }
-        std::string old_metadata = participant->metadata();
+        const std::string old_metadata = participant->metadata();
         participant->set_metadata(pm.metadata());
         ev.participant = participant;
         ev.old_metadata = old_metadata;
@@ -950,7 +950,7 @@ void Room::OnEvent(const FfiEvent &event) {
                       identity);
           break;
         }
-        std::string old_name = participant->name();
+        const std::string old_name = participant->name();
         participant->set_name(pn.name());
         ev.participant = participant;
         ev.old_name = old_name;
@@ -1292,7 +1292,7 @@ void Room::OnEvent(const FfiEvent &event) {
       } else if (byte_reader) {
         // Convert string bytes -> vector<uint8_t>
         const std::string &s = chunk.content();
-        std::vector<std::uint8_t> bytes(s.begin(), s.end());
+        const std::vector<std::uint8_t> bytes(s.begin(), s.end());
         byte_reader->onChunkUpdate(bytes);
       }
       break;

src/subscription_thread_dispatcher.cpp

@@ -118,7 +118,7 @@ void SubscriptionThreadDispatcher::setOnVideoFrameCallback(
     VideoFrameCallback callback, const VideoStream::Options &opts) {
   const CallbackKey key{participant_identity, TrackSource::SOURCE_UNKNOWN,
                         track_name};
-  const std::lock_guard<std::mutex> lock(lock_);
+  const std::scoped_lock<std::mutex> lock(lock_);
   const bool replacing = video_callbacks_.find(key) != video_callbacks_.end();
   video_callbacks_[key] = RegisteredVideoCallback{
       std::move(callback),
@@ -651,8 +651,8 @@ std::thread SubscriptionThreadDispatcher::startDataReaderLocked(
     const DataFrameCallback &cb) {
   auto old_thread = extractDataReaderThreadLocked(id);
 
-  int total_active = static_cast<int>(active_readers_.size()) +
-                     static_cast<int>(active_data_readers_.size());
+  const int total_active = static_cast<int>(active_readers_.size()) +
+                           static_cast<int>(active_data_readers_.size());
   if (total_active >= kMaxActiveReaders) {
     LK_LOG_ERROR("Cannot start data reader for {} track={}: active reader "
                  "limit ({}) reached",

src/trace/event_tracer.cpp

@@ -92,7 +92,7 @@ struct TraceEventData {
 // Escape a string for JSON
 std::string JsonEscape(const std::string &s) {
   std::ostringstream oss;
-  for (char c : s) {
+  for (const char c : s) {
     switch (c) {
     case '"':
       oss << "\\\"";
@@ -294,15 +294,15 @@ const unsigned char *EventTracer::GetCategoryEnabled(const char *name) {
   }
 
   // Check if this specific category is enabled
-  std::string category_name(name);
+  const std::string category_name(name);
   if (g_enabled_categories.count(category_name) > 0) {
     return &g_enabled_byte;
   }
 
   // Check for wildcard matches (e.g., "livekit.*" matches "livekit.connect")
   for (const auto &pattern : g_enabled_categories) {
     if (pattern.back() == '*') {
-      std::string prefix = pattern.substr(0, pattern.size() - 1);
+      const std::string prefix = pattern.substr(0, pattern.size() - 1);
       if (category_name.compare(0, prefix.size(), prefix) == 0) {
         return &g_enabled_byte;
       }

tidy.sh

@@ -280,7 +280,13 @@ write_step_summary() {
 log="tidy.log"
 
 set +e
-run-clang-tidy \
+# run-clang-tidy is a Python script that doesn't flush stdout in its per-file
+# loop; it only flushes once at exit. When its stdout is a pipe (the `| tee`
+# below), Python's stdio defaults to block-buffered mode, so diagnostics
+# accumulate in an ~8 KB buffer and the user sees nothing until the run is
+# essentially over. PYTHONUNBUFFERED=1 forces line/unbuffered writes so each
+# file's findings appear as soon as that file's clang-tidy finishes.
+PYTHONUNBUFFERED=1 run-clang-tidy \
   -p "${BUILD_DIR}" \
   -quiet \
   -j "${jobs}" \