Merge pull request GaijinEntertainment#2676 from GaijinEntertainment/bbatkin/lexer-tracker-leak-fix

alloc-tracker: fix phantom lexer_track_map leaks; re-enable parallel-lint test

Author: borisbat

include/daScript/misc/platform.h

@@ -386,6 +386,16 @@ namespace das {
     DAS_API void    track_free_hook(void *p) noexcept;
     DAS_API void    arm_alloc_tracking() noexcept;
     DAS_API size_t  dump_alloc_leaks(FILE *out);
+    // RAII: sets the tracker's tl_inside so allocations/frees inside the scope
+    // are not recorded in the LeakMap. Use for internal bookkeeping containers
+    // (e.g. lexer_track_map) whose operator delete during erase would otherwise
+    // recurse into track_free_hook, bail on the already-true tl_inside, and
+    // leave phantom LeakMap entries.
+    struct DAS_API AllocTrackerInternalGuard {
+        bool prev;
+        AllocTrackerInternalGuard() noexcept;
+        ~AllocTrackerInternalGuard() noexcept;
+    };
     // Landmark RAII: ctor walks the stack once and stores the chain; alloc-site
     // captures that match the landmark's RSP short-circuit with a memcpy. Place
     // one on the stack high in the call tree (e.g. top of compile_and_run) to
@@ -409,6 +419,10 @@ namespace das {
     inline void   track_free_hook(void *) noexcept {}
     inline void   arm_alloc_tracking() noexcept {}
     inline size_t dump_alloc_leaks(FILE *) { return 0; }
+    struct AllocTrackerInternalGuard {
+        AllocTrackerInternalGuard() noexcept {}
+        ~AllocTrackerInternalGuard() noexcept {}
+    };
     struct AllocTrackingLandmark {
         AllocTrackingLandmark() noexcept {}
         ~AllocTrackingLandmark() noexcept {}

src/misc/alloc_tracker.cpp

@@ -217,6 +217,14 @@ void arm_alloc_tracking() noexcept {
     g_armed.store(true, std::memory_order_release);
 }
 
+AllocTrackerInternalGuard::AllocTrackerInternalGuard() noexcept : prev(tl_inside) {
+    tl_inside = true;
+}
+
+AllocTrackerInternalGuard::~AllocTrackerInternalGuard() noexcept {
+    tl_inside = prev;
+}
+
 // ------------------------- Symbolization -------------------------
 
 #if defined(_MSC_VER)

src/misc/lexer_alloc_track.cpp

@@ -40,13 +40,24 @@ namespace das {
     void lexer_track_alloc(std::string *p, const char *tokenText) noexcept {
         if (!p || tl_inside) return;
         ReentryGuard g;
+        // Internal: suppress LeakMap tracking for our map's own node allocations.
+        // Otherwise the node alloc gets recorded in LeakMap; later, the matching
+        // operator delete during m.erase runs while alloc_tracker's tl_inside is
+        // already true (lexer_track_free is invoked from track_free_hook's
+        // ReentryGuard scope), so the nested track_free_hook bails before
+        // removing the entry, leaving a phantom leak attributed back to this
+        // very alloc site.
+        AllocTrackerInternalGuard atg;
         std::lock_guard<std::mutex> lk(lexer_track_mu());
         lexer_track_map()[p] = tokenText ? tokenText : "";
     }
 
     void lexer_track_free(std::string *p) noexcept {
         if (!p || tl_inside) return;
         ReentryGuard g;
+        // Match the alloc side so the matching internal frees during erase do
+        // not flag as orphan-frees (alloc was untracked, free must be too).
+        AllocTrackerInternalGuard atg;
         std::lock_guard<std::mutex> lk(lexer_track_mu());
         auto & m = lexer_track_map();
         auto it = m.find(p);
@@ -55,6 +66,7 @@ namespace das {
 
     int dump_lexer_string_leaks(FILE *out) noexcept {
         ReentryGuard g;
+        AllocTrackerInternalGuard atg;
         std::lock_guard<std::mutex> lk(lexer_track_mu());
         auto & m = lexer_track_map();
         if (m.empty()) return 0;