Fix array self-assignment bug that was clearing arrays

When performing array self-assignment like '@arr = @arr', the array
was being cleared before the values could be copied, resulting in an
empty array. This particularly affected operations like 'chop(@stuff = @stuff)'.

The fix detects when the source list contains references to the target
array and creates a defensive copy before clearing. This ensures proper
behavior for patterns like:
- @arr = @arr (simple self-assignment)
- @x = (@x, 3, 4) (array at beginning)
- @x = (1, 2, @x) (array at end)
- @x = (1, @x, 4, 5) (array in middle)
- @x = (1, @x, @x, 4) (array appears multiple times)

Impact: Reduces op/chop.t failures from 16 to 4 (75% reduction)

Also includes:
- Documentation for dynamic eval warning handler issue (op/infnan.t)
- Documentation for empty file slurp mode issue (op/closure.t)
- Enhanced debugging strategy documentation

Author: fglock

dev/prompts/fix-dynamic-eval-warning-handler.md

@@ -0,0 +1,120 @@
+# Fix Dynamic Eval String Warning Handler Inheritance
+
+## Objective
+Fix 30 test failures in op/infnan.t where dynamically constructed eval strings don't inherit the `$SIG{__WARN__}` handler, preventing numeric warnings from being captured.
+
+## Current Status
+- **Test file:** t/op/infnan.t
+- **Failures:** 30 tests (all "numify warn" tests)
+- **Pass rate:** Currently 90% (would be ~93% after fix)
+- **Pattern:** All failures are for malformed Inf/NaN strings like "infxy", "nanxy", "nan34"
+
+## Root Cause Analysis
+
+### The Problem
+Warnings are not captured when eval strings are **dynamically constructed** (using string concatenation), even though they work correctly for:
+1. Literal eval strings: `eval 'my $x = "infxy" + 1'` ✅
+2. Eval blocks: `eval { my $x = "infxy" + 1 }` ✅
+3. Dynamically constructed strings: `eval '$a = "' . $value . '" + 1'` ❌
+
+### Evidence
+Test case demonstrates the issue clearly:
+```perl
+$SIG{__WARN__} = sub { $w = shift };
+
+# Works - captures warning
+eval 'my $x = "infxy" + 1';
+
+# Fails - doesn't capture warning
+my $str = '$a = "infxy" + 1';
+eval $str;
+```
+
+### Technical Investigation
+1. Warnings ARE being generated correctly (seen with --disassemble)
+2. The WarnDie.warn() method IS being called
+3. The issue is that dynamically compiled eval code doesn't inherit the current `$SIG{__WARN__}` handler
+
+## Why Simple Fixes Don't Work
+
+### Attempt 1: Check evalStringHelper context
+- The evalStringHelper method creates a new EmitterContext from a snapshot
+- The symbolTable snapshot might not include the current signal handlers
+- Signal handlers are stored in GlobalVariable, not in the symbol table
+
+### Attempt 2: Copy signal handlers
+- Would require passing current %SIG state to evalStringHelper
+- This breaks the caching mechanism (cacheKey would need to include %SIG state)
+- Performance impact would be significant
+
+## Implementation Strategy
+
+### Phase 1: Understand Current Architecture
+1. How are signal handlers stored? (GlobalVariable.getGlobalHash("main::SIG"))
+2. How does eval string compilation access globals?
+3. Why do literal eval strings work but dynamic ones don't?
+
+### Phase 2: Implement Fix
+**Option A: Runtime Context Inheritance**
+- Pass current runtime context to dynamically compiled code
+- Ensure %SIG is accessible from compiled eval code
+- Maintain compatibility with caching
+
+**Option B: Compile-time Binding**
+- Bind signal handlers at eval compilation time
+- Store handler references in compiled code
+- May require changes to EmitterContext
+
+### Phase 3: Testing
+1. Verify all 30 infnan.t tests pass
+2. Check for regressions in other eval-related tests
+3. Test performance impact on eval string compilation
+
+## Testing Strategy
+
+### Minimal Test Case
+```perl
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+my $captured = '';
+$SIG{__WARN__} = sub { $captured = $_[0] };
+
+# Test dynamic eval
+my $code = '$x = "infxy" + 1';
+eval $code;
+
+if ($captured =~ /isn't numeric/) {
+    print "PASS\n";
+} else {
+    print "FAIL: Warning not captured\n";
+}
+```
+
+## Expected Impact
+- **Tests fixed:** 30 tests in op/infnan.t
+- **Pass rate improvement:** 90% → 93% (+3%)
+- **Side benefits:** All dynamic eval string warning capture would be fixed
+- **Potential regressions:** None expected if implemented correctly
+
+## Complexity Assessment
+- **Estimated effort:** 2-4 hours
+- **Risk level:** Medium (affects core eval mechanism)
+- **Files to modify:** 
+  - RuntimeCode.java (evalStringHelper)
+  - EmitterContext.java (context passing)
+  - Possibly WarnDie.java (signal handler lookup)
+
+## Recommendation
+**Priority:** HIGH (30 tests, clear pattern)
+**Approach:** Defer for now and move to simpler targets
+**Reason:** Complex architectural issue requiring deep understanding of eval compilation
+
+This is a valuable fix but requires careful implementation to avoid breaking the eval caching mechanism or causing performance regressions. The issue is well-documented here for future implementation.
+
+## Alternative Quick Fix
+If we just want the tests to pass without fixing the underlying issue:
+- Modify the test to use literal eval strings instead of dynamic construction
+- This would be a test-only change, not fixing the actual bug
+- Not recommended as it masks a real compatibility issue

dev/prompts/fix-empty-file-slurp-mode.md

@@ -0,0 +1,116 @@
+# Fix Empty File Read in Slurp Mode
+
+## Objective
+Fix 18 test failures in op/closure.t where reading empty files with `local $/` (slurp mode) returns `undef` instead of an empty string.
+
+## Current Status
+- **Test file:** t/op/closure.t
+- **Failures:** 18 tests (all "STDERR is silent" tests)
+- **Pass rate:** Currently 92% (would be ~95% after fix)
+
+## Root Cause Analysis
+
+### The Problem
+When reading an empty file in scalar context with `local $/` (slurp mode), PerlOnJava returns `undef` instead of an empty string.
+
+### Test Pattern
+```perl
+# In closure.t around line 459
+{ local $/; open IN, $errfile; $errors = <IN>; close IN }
+# Test expects: $errors eq '' (empty string)
+# PerlOnJava returns: $errors is undef
+```
+
+### Technical Investigation
+1. **Slurp mode should be triggered by `local $/`** which makes `$/` undefined
+2. **The slurp mode code path exists** at lines 60-79 in Readline.java
+3. **The fix was attempted** at line 79 to return empty string instead of undef
+4. **BUT the fix didn't work**, suggesting `local $/` might not trigger the slurp mode path
+
+### Key Discovery
+The issue might be in how `$/` is handled:
+- `local $/` might not create an `InputRecordSeparator` with `isSlurpMode()` returning true
+- Or the `rsScalar instanceof InputRecordSeparator` check might be failing
+- The code might be taking the normal separator path instead
+
+## Why Simple Fixes Don't Work
+
+### Attempt 1: Change all EOF returns to empty string
+- **Problem:** Breaks list context reading which depends on `undef` to terminate loops
+- **Result:** Tests hang in infinite loops
+
+### Attempt 2: Fix only slurp mode
+- **Problem:** The slurp mode code path might not be triggered
+- **Result:** No effect on the test failures
+
+## Implementation Strategy
+
+### Phase 1: Understand `$/` Handling
+1. How does `local $/` affect the global variable?
+2. Does it create an `InputRecordSeparator` object?
+3. What value does `getGlobalVariable("main::/")` return?
+
+### Phase 2: Fix Detection Logic
+**Option A: Fix slurp mode detection**
+- Ensure `local $/` properly triggers slurp mode
+- May need to check for undefined `$/` value
+
+**Option B: Handle undefined `$/` specially**
+- Check if `rsScalar` is undefined or empty
+- Treat as slurp mode
+
+### Phase 3: Implement Targeted Fix
+- Only change behavior for first read of empty file in slurp mode
+- Maintain `undef` for subsequent reads to preserve list context
+
+## Testing Strategy
+
+### Minimal Test Case
+```perl
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Create empty file
+open(my $fh, '>', 'empty.tmp');
+close $fh;
+
+# Test slurp mode
+{
+    local $/;
+    open(IN, 'empty.tmp');
+    my $content = <IN>;
+    close IN;
+    
+    if (defined $content) {
+        print "PASS: content is '", $content, "'\n";
+    } else {
+        print "FAIL: content is undef\n";
+    }
+}
+
+unlink 'empty.tmp';
+```
+
+## Expected Impact
+- **Tests fixed:** 18 tests in op/closure.t
+- **Pass rate improvement:** 92% → 95% (+3%)
+- **Side benefits:** All slurp mode empty file reads would be fixed
+
+## Complexity Assessment
+- **Estimated effort:** 1-2 hours
+- **Risk level:** Medium (affects core IO operations)
+- **Files to modify:** 
+  - Readline.java (detection logic)
+  - Possibly InputRecordSeparator.java
+
+## Recommendation
+**Priority:** HIGH (18 tests, clear pattern)
+**Approach:** Investigate `$/` handling first, then implement targeted fix
+**Reason:** Well-defined issue with clear expected behavior
+
+## Alternative Quick Fix
+If investigation is too complex:
+- Special case empty file reads when separator is empty/undefined
+- Check at the beginning of readline() method
+- Return empty string for first read, track state for subsequent reads

dev/prompts/high-yield-test-analysis-strategy.md

@@ -370,6 +370,34 @@ grep -r "methodName\(" src/main/java/
 grep -B 5 -A 10 "pattern" file.java
 ```
 
+### Technique 7: Killing Hanging Test Processes
+**Pattern:** When a test hangs (infinite loop or deadlock), find and kill the process
+
+```bash
+# Find hanging jperl processes
+ps aux | grep "jperl test_name"
+
+# Find Java processes running tests (more reliable)
+ps aux | grep -E "java.*test_name|PerlOnJava.*test"
+
+# Kill the process (use PID from ps output)
+kill -9 <PID>
+
+# Alternative: Kill by pattern (be careful!)
+pkill -f "jperl test_name"
+```
+
+**Red Flags of a hanging test:**
+- Test doesn't complete after several seconds
+- High CPU usage (>100% in ps output)
+- List context operations that depend on `undef` to terminate
+- Infinite loops in regex or string operations
+
+**Common causes:**
+- Changing `undef` returns to empty strings breaks list context loops
+- Incorrect EOF handling in IO operations
+- Regex engine infinite loops with certain patterns
+
 ## Common PerlOnJava Patterns
 
 ### Pattern 1: Context Parameters

src/main/java/org/perlonjava/runtime/RuntimeArray.java

@@ -451,8 +451,35 @@ public RuntimeArray set(RuntimeScalar value) {
     public RuntimeArray setFromList(RuntimeList list) {
         return switch (type) {
             case PLAIN_ARRAY -> {
-                this.elements.clear();
-                list.addToArray(this);
+                // Check if the list contains references to this array's elements
+                // If so, we need to save the values before clearing
+                boolean needsCopy = false;
+                for (RuntimeBase elem : list.elements) {
+                    if (elem instanceof RuntimeArray && elem == this) {
+                        needsCopy = true;
+                        break;
+                    }
+                }
+                
+                if (needsCopy) {
+                    // Make a defensive copy of the list before clearing
+                    RuntimeList listCopy = new RuntimeList();
+                    for (RuntimeBase elem : list.elements) {
+                        if (elem instanceof RuntimeArray && elem == this) {
+                            // Copy this array's current contents
+                            for (RuntimeScalar s : this.elements) {
+                                listCopy.elements.add(s);
+                            }
+                        } else {
+                            listCopy.elements.add(elem);
+                        }
+                    }
+                    this.elements.clear();
+                    listCopy.addToArray(this);
+                } else {
+                    this.elements.clear();
+                    list.addToArray(this);
+                }
                 yield this;
             }
             case AUTOVIVIFY_ARRAY -> {