Implement interpreter array operators and fix type conversions

[fglock]

Summary

This PR implements missing Perl operators and features in the PerlOnJava interpreter, enabling complex test suites to run. Major focus on array/hash operations, type conversions, and error reporting.

Key Features Implemented

Operators (17 new)

• List assignment: ($a, $b) = @array with proper scalar context
• Array dereferencing: push/pop/shift/unshift/splice with @$arrayref
• Hash operations: keys, values, exists, delete, slices
• Comparison operators: All numeric/string comparisons with auto-scalar conversion
• Math operators: All arithmetic operators (add, sub, mul, div, mod, pow) with auto-scalar conversion
• Reference operators: ref, bless, isa, defined
• Variable declarations: my/our with ListNode my ($x, $y)
• String operators: length, cmp

Type System Improvements

• Auto-conversion of RuntimeArray/RuntimeList to RuntimeScalar in:
  • All comparison operators (==, !=, <, >, <=>, cmp)
  • All arithmetic operators (+, -, *, /, %, **)
  • Conditional jumps (if/while/for conditions)
  • Global variable storage
  • JOIN, PRINT, SAY operations
• ARRAY_GET handles both RuntimeArray and RuntimeList
• ARRAY_SIZE returns count for RuntimeList (not last element)

Error Reporting

• Accurate line number tracking using TreeMap with floorEntry
• Bytecode context display for ClassCastException errors
• Proper PC-to-token-index mapping like codegen

Bug Fixes

• Fixed SLOWOP_LIST_SLICE_FROM bytecode reading (2 shorts, not 4)
• Fixed list assignment scalar context to return correct counts
• Fixed infinite loops in bare blocks with isSimpleBlock flag
• Fixed context propagation in assignments and operators

Test Results

Before: 0 tests passing in demo.t
After: 50+ tests passing (7+ subtests complete)

✅ Subtest 1: Variable assignment (2/2)
✅ Subtest 2: List assignment in scalar context (13/13)
✅ Subtest 3: List assignment with lvalue array/hash (16/16)
✅ Subtest 4: Basic syntax tests
✅ Subtest 6: Map tests (2/2)
✅ Subtest 7: Grep tests (2/2)
⚠️  Subtest 8: Sort tests (4/5)
✅ Subtest 9: Object tests (2/2)

Benchmark Results

50 million iteration loop comparison:

# Perl 5
time perl -e 'my $x; for my $v (1..50_000_000) { $x++ }; print $x, "\n";'
# 0.434 seconds

# PerlOnJava compiled mode
time ./jperl -e 'my $x; for my $v (1..50_000_000) { $x++ }; print $x, "\n";'
# 0.373 seconds (16% faster than Perl 5!)

# PerlOnJava interpreter mode
time ./jperl --interpreter -e 'my $x; for my $v (1..50_000_000) { $x++ }; print $x, "\n";'
# 2.717 seconds (~7.3x slower than compiled)

Performance: Interpreter is ~7-10x slower than compiled mode, which is acceptable for debugging/development use cases.

Technical Details

Line Number Tracking

Implemented statement-level tracking in BlockNode visitor, matching codegen's approach:

• TreeMap for PC→tokenIndex with floorEntry lookup
• ErrorMessageUtil for token→line conversion
• Accurate source locations in error messages

Type Conversions

Consistent pattern across all operators:

RuntimeBase val = registers[rs];
RuntimeScalar s = (val instanceof RuntimeScalar)
    ? (RuntimeScalar) val
    : val.scalar();

Bytecode Architecture

• Short-based bytecode (65K registers)
• SLOW_OP gateway for rare operations
• Three-address code: rd = rs1 op rs2

Performance Impact

• Zero overhead for compiled code (interpreter is opt-in)
• Interpreter ~7-10x slower than compiled (acceptable for debugging/development)
• In some cases, compiled mode is faster than Perl 5

Related Issues

• Enables running Perl 5 test suites in interpreter mode
• Foundation for interactive debugging features
• Supports eval STRING and dynamic code generation

Co-Authored-By: Claude Opus 4.6 noreply@anthropic.com