(feat): Order-aware compile-time escape detection

[mgyoo86]

Summary

Rewrites the compile-time escape detector's taint tracking from two separate order-insensitive passes to a single forward pass. Fixes false negatives, false positives, and adds a new warning for ambiguous reassignment patterns.

What the detector now catches

Escape through pre-acquire assignment (was missed)

@with_pool pool function test()
    v = 1
    v = acquire!(pool, Float64, 3, 3)
    return (v,)  # PoolEscapeError ← previously passed silently
end

The prior two-pass approach saw v = 1 and removed v from the tainted set regardless of statement order. Now a single forward pass tracks taint per statement position.

Escape through alias with pre-assignment (was missed)

@with_pool pool function test()
    v = acquire!(pool, Float64, 3, 3)
    v2 = 1
    v2 = v
    return [v2]  # PoolEscapeError ← previously passed silently
end

Ambiguous reassignment v = f(v) (new warning)

@with_pool pool function test()
    v = acquire!(pool, Float64, 10)
    v = f(v)       # f might return same array (identity, reshape)
    return v       # PoolReassignEscapeWarning (not error)
end

Known-safe functions are excluded (no warning):

• collect, copy, deepcopy, similar
• Broadcast: .+, .*, f.(v)

What the detector no longer falsely flags

Inner-scope shadowing (was false positive)

@with_pool pool begin
    v = "hello"
    function helper()
        v = acquire!(pool, Float64, 5)
        sum(v)
    end
    helper()
    return v  # safe (outer v = "hello") ← previously threw PoolEscapeError
end

function, ->, macro blocks create new variable scopes. The detector now skips these during recursion. (let is NOT skipped — return inside let exits the enclosing function, so pool variables there can escape.)

Reassigned containers (was false positive warning)

@with_pool pool begin
    vac = (wv = acquire!(pool, Float64, 3),)
    vac = (name = "ok",)
    return vac.name  # safe ← previously warned PoolContainerEscapeWarning
end

Swap patterns (still correctly safe)

@with_pool pool begin
    v = acquire!(pool, Float64, 10)
    x = zeros(10)
    v, x = x, v    # atomic destructuring: v gets zeros, x gets pool array
    return v        # safe (v holds zeros) ← correctly no error
end

Other improvements

• Container and reassignment warnings now fire for CUDA/Metal block forms (was CPU-only)
• Removed dead _remove_flat_reassigned! (replaced by _extract_ordered_acquired)
• Pluralized "Escaping return(s):" in warning output
• Added positive test for PoolContainerEscapeWarning output path

[codecov]

Codecov Report

❌ Patch coverage is 93.81720% with 23 lines in your changes missing coverage. Please review.
✅ Project coverage is 96.23%. Comparing base (eccb87c) to head (afff7f3).
⚠️ Report is 2 commits behind head on master.

Files with missing lines	Patch %	Lines
src/macros.jl	93.73%	23 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##           master      #38      +/-   ##
==========================================
- Coverage   96.65%   96.23%   -0.43%     
==========================================
  Files          14       14              
  Lines        2753     3107     +354     
==========================================
+ Hits         2661     2990     +329     
- Misses         92      117      +25     

Files with missing lines	Coverage Δ
src/debug.jl	95.85% <100.00%> (+0.05%)	⬆️
src/macros.jl	96.70% <93.73%> (-1.29%)	⬇️

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[Copilot]

Pull request overview

This PR updates AdaptiveArrayPools’ compile-time escape detection to be order-aware (single forward taint pass), adds new compile-time warnings for ambiguous reassignment and container-field escapes, and tightens runtime structural mutation diagnostics (including improved warning messages and a rewind-time mutation edge case).

Changes:

• Replace order-insensitive taint tracking with an order-aware forward pass (_extract_ordered_acquired) used by compile-time escape and mutation checks.
• Add compile-time warnings for (1) potential container dot-access escapes and (2) ambiguous v = f(v) reassignment escapes, with supporting unit tests.
• Update runtime wrapper-mutation warning messages and adjust tests accordingly; tweak rewind invalidation behavior for wrapper bookkeeping.

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
src/macros.jl	Implements order-aware taint extraction and adds new compile-time warning passes + helpers.
src/state.jl	Changes typed-pool wrapper invalidation behavior during rewind.
src/debug.jl	Refines structural mutation warning messages for TypedPool Array wrappers.
test/test_compile_escape.jl	Adds new test coverage for ordering, scope shadowing, reassignment warning, and container warning behavior.
test/test_runtime_mutation.jl	Updates log-message expectations to match new runtime warning strings.
test/test_state.jl	Prevents pool-backed implicit returns in a few scenarios (test stabilization under stricter analysis).

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.