fix: keep live weak closure arguments callable

DBIx::Class::Storage::BlockRunner weakens a fresh closure argument copy
before invoking it. Perl keeps the caller's strong lexical alive, but
PerlOnJava's CODE weak-ref sweep cleared the weak copy immediately when
the closure had no counted owners.

Teach the CODE weak-ref cleanup path to preserve weak CODE refs while a
current live scalar still points at the same RuntimeCode, without
preserving stale deleted stash slots used by Sub::Quote cleanup.

Generated with Codex (https://openai.com/codex)

Co-Authored-By: Codex <codex@openai.com>

Author: fglock

src/main/java/org/perlonjava/runtime/runtimetypes/ReachabilityWalker.java

@@ -522,6 +522,26 @@ && followGlobalCodeCaptures(code, target, seen, todo)) {
         return false;
     }
 
+    public static boolean hasLiveStrongScalarReferent(RuntimeBase target) {
+        if (target == null) return false;
+        for (Object liveVar : MyVarCleanupStack.snapshotLiveVars()) {
+            if (liveVar instanceof RuntimeScalar sc
+                    && !WeakRefRegistry.isweak(sc)
+                    && !sc.scopeExited
+                    && sc.value == target) {
+                return true;
+            }
+        }
+        for (RuntimeScalar sc : ScalarRefRegistry.snapshot()) {
+            if (sc == null) continue;
+            if (WeakRefRegistry.isweak(sc)) continue;
+            if (sc.scopeExited) continue;
+            if (!MyVarCleanupStack.isLive(sc)) continue;
+            if (sc.value == target) return true;
+        }
+        return false;
+    }
+
     public static boolean isReachableFromGlobalCodeCaptures(RuntimeBase target) {
         if (target == null) return false;
         Set<RuntimeBase> seen = Collections.newSetFromMap(new IdentityHashMap<>());

src/main/java/org/perlonjava/runtime/runtimetypes/WeakRefRegistry.java

@@ -188,10 +188,13 @@ public static void weaken(RuntimeScalar ref) {
             ref.refCountOwned = false;
             base.refCount = WEAKLY_TRACKED;
         }
+        boolean shouldSweepLiveCodeRef = weakenedLiveCodeRef
+                && codeRefHasCountedOwners(base)
+                && !ModuleInitGuard.inModuleInit();
         if (base instanceof RuntimeCode code
                 && code.refCount >= 0
                 && weakRefsExist
-                && ((weakenedLiveCodeRef && !ModuleInitGuard.inModuleInit())
+                && (shouldSweepLiveCodeRef
                 || (code.hadStashRef
                 && code.stashRefCount <= 0
                 && !isInstalledGlobalCodeRef(code)))) {
@@ -205,6 +208,10 @@ public static void weaken(RuntimeScalar ref) {
         }
     }
 
+    private static boolean codeRefHasCountedOwners(RuntimeBase base) {
+        return base.refCount > 0 || base.activeOwnerCount() > 0;
+    }
+
     /**
      * Check if a RuntimeScalar is a weak reference.
      */
@@ -295,6 +302,7 @@ private static boolean isInstalledGlobalCodeRef(RuntimeCode code) {
 
     private static boolean shouldKeepCodeWeakRefs(RuntimeCode code) {
         if (code.stashRefCount > 0 || isInstalledGlobalCodeRef(code)) return true;
+        if (ReachabilityWalker.hasLiveStrongScalarReferent(code)) return true;
         return RuntimeCode.isActiveCode(code);
     }
 

src/test/resources/unit/refcount/weaken_closure_argument.t

@@ -0,0 +1,22 @@
+#!/usr/bin/env perl
+use strict;
+use warnings;
+
+use Scalar::Util qw(isweak weaken);
+use Test::More tests => 3;
+
+sub run_callback {
+    my $callback = shift;
+    return weaken_and_call($callback);
+}
+
+sub weaken_and_call {
+    weaken(my $weak_callback = shift);
+
+    ok(isweak($weak_callback), 'closure argument copy is weak');
+    ok(defined $weak_callback, 'weak closure argument copy survives while caller holds it');
+    is($weak_callback->(), 'captured value', 'weak closure argument remains callable');
+}
+
+my $captured = 'captured value';
+run_callback(sub { $captured });