fix: short-circuit //=, ||=, &&= in bytecode interpreter, parser disambiguation, DBI last_insert_id

.gitignore

@@ -87,6 +87,7 @@ Image-ExifTool-*
 
 # Ignore xxx/ directory (temporary module staging area)
 xxx/
+cpan_build_dir/
 *.jfr
 report.txt
 exiftool_results.json

src/main/java/org/perlonjava/app/scriptengine/PerlLanguageProvider.java

@@ -20,6 +20,7 @@
 import org.perlonjava.runtime.perlmodule.FilterUtilCall;
 import org.perlonjava.runtime.perlmodule.Strict;
 import org.perlonjava.runtime.runtimetypes.*;
+import org.perlonjava.runtime.WarningBitsRegistry;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.reflect.Constructor;
@@ -305,6 +306,9 @@ public static RuntimeList executePerlAST(Node ast,
             // code in the same lexical block sees the updated hints
             if (savedCurrentScope != null) {
                 savedCurrentScope.setStrictOptions(ctx.symbolTable.getStrictOptions());
+                // Also update per-call-site hints so caller()[8] and caller()[10] are correct
+                WarningBitsRegistry.setCallSiteHints(ctx.symbolTable.getStrictOptions());
+                WarningBitsRegistry.snapshotCurrentHintHash();
                 SpecialBlockParser.setCurrentScope(savedCurrentScope);
             }
         }

src/main/java/org/perlonjava/backend/bytecode/BytecodeInterpreter.java

@@ -1960,6 +1960,27 @@ public static RuntimeList execute(InterpretedCode code, RuntimeArray args, int c
                                 pc = SlowOpcodeHandler.executeDispatchVarAttrs(bytecode, pc, registers, code.constants);
                             }
 
+                            case Opcodes.VIVIFY_LVALUE -> {
+                                // Vivify an lvalue proxy so the entry exists in the parent container.
+                                // For plain scalars this is a no-op.
+                                int reg = bytecode[pc++];
+                                RuntimeBase val = registers[reg];
+                                if (val instanceof RuntimeScalar rs) {
+                                    rs.vivifyLvalue();
+                                }
+                            }
+
+                            case Opcodes.LIST_SLICE -> {
+                                // List slice: rd = list.getSlice(indices)
+                                // Used for (list)[indices] syntax
+                                int rd = bytecode[pc++];
+                                int listReg = bytecode[pc++];
+                                int indicesReg = bytecode[pc++];
+                                RuntimeList list = registers[listReg].getList();
+                                RuntimeList indices = registers[indicesReg].getList();
+                                registers[rd] = list.getSlice(indices);
+                            }
+
                             default -> {
                                 int opcodeInt = opcode;
                                 throw new RuntimeException(

src/main/java/org/perlonjava/backend/bytecode/CompileBinaryOperator.java

@@ -291,14 +291,36 @@ else if (node.right instanceof BinaryOperatorNode rightCall) {
                 }
             }
 
-            // Handle ListNode case: (expr)[index] like (caller)[0]
-            // Transform to [expr]->[index] like JVM does
+            // Handle ListNode case: (expr)[indices] like (caller(0))[0] or (1,2,3,4)[1,2]
+            // Use proper list slice semantics: evaluate list, then slice by indices
             if (node.left instanceof ListNode listNode) {
-                // Create: ArrayLiteralNode containing the list elements
-                // Then: BinaryOperatorNode("->", arrayLiteral, node.right)
-                ArrayLiteralNode arrayLiteral = new ArrayLiteralNode(listNode.elements, listNode.getIndex());
-                BinaryOperatorNode arrowNode = new BinaryOperatorNode("->", arrayLiteral, node.right, node.getIndex());
-                arrowNode.accept(bytecodeCompiler);
+                // Compile the list in LIST context
+                bytecodeCompiler.compileNode(listNode, -1, RuntimeContextType.LIST);
+                int listReg = bytecodeCompiler.lastResultReg;
+
+                // Compile the indices in LIST context
+                ListNode indices = ((ArrayLiteralNode) node.right).asListNode();
+                bytecodeCompiler.compileNode(indices, -1, RuntimeContextType.LIST);
+                int indicesReg = bytecodeCompiler.lastResultReg;
+
+                // Emit LIST_SLICE opcode: rd = list.getSlice(indices)
+                int sliceReg = bytecodeCompiler.allocateOutputRegister();
+                bytecodeCompiler.emit(Opcodes.LIST_SLICE);
+                bytecodeCompiler.emitReg(sliceReg);
+                bytecodeCompiler.emitReg(listReg);
+                bytecodeCompiler.emitReg(indicesReg);
+
+                // Handle context conversion: LIST_SLICE returns a RuntimeList,
+                // but in scalar context we need to extract the scalar value
+                if (bytecodeCompiler.currentCallContext == RuntimeContextType.SCALAR) {
+                    int scalarReg = bytecodeCompiler.allocateOutputRegister();
+                    bytecodeCompiler.emit(Opcodes.LIST_TO_SCALAR);
+                    bytecodeCompiler.emitReg(scalarReg);
+                    bytecodeCompiler.emitReg(sliceReg);
+                    bytecodeCompiler.lastResultReg = scalarReg;
+                } else {
+                    bytecodeCompiler.lastResultReg = sliceReg;
+                }
                 return;
             }
 

src/main/java/org/perlonjava/backend/bytecode/Disassemble.java

@@ -880,6 +880,19 @@ public static String disassemble(InterpretedCode interpretedCode) {
                                 .append("[r").append(asdlIndicesReg).append("]\n");
                         break;
                     }
+                    case Opcodes.VIVIFY_LVALUE: {
+                        int vivReg = interpretedCode.bytecode[pc++];
+                        sb.append("VIVIFY_LVALUE r").append(vivReg).append("\n");
+                        break;
+                    }
+                    case Opcodes.LIST_SLICE: {
+                        rd = interpretedCode.bytecode[pc++];
+                        int lsListReg = interpretedCode.bytecode[pc++];
+                        int lsIndicesReg = interpretedCode.bytecode[pc++];
+                        sb.append("LIST_SLICE r").append(rd).append(" = r").append(lsListReg)
+                                .append(".getSlice(r").append(lsIndicesReg).append(")\n");
+                        break;
+                    }
                     case Opcodes.HASH_KEYS:
                         rd = interpretedCode.bytecode[pc++];
                         int hashKeysReg = interpretedCode.bytecode[pc++];

src/main/java/org/perlonjava/backend/bytecode/InlineOpcodeHandler.java

@@ -358,7 +358,8 @@ public static int executeIntegerDivAssign(int[] bytecode, int pc, RuntimeBase[]
         int rd = bytecode[pc++];
         int rs = bytecode[pc++];
         RuntimeScalar s1 = (RuntimeScalar) registers[rd];
-        s1.set(MathOperators.integerDivide(s1, (RuntimeScalar) registers[rs]));
+        RuntimeScalar s2 = (registers[rs] instanceof RuntimeScalar) ? (RuntimeScalar) registers[rs] : registers[rs].scalar();
+        registers[rd] = MathOperators.integerDivideAssignWarn(s1, s2);
         return pc;
     }
 

src/main/java/org/perlonjava/backend/bytecode/Opcodes.java

@@ -2132,6 +2132,21 @@ public class Opcodes {
      */
     public static final short DISPATCH_VAR_ATTRS = 451;
 
+    /**
+     * Vivify an lvalue proxy (hash/array element) so the entry exists in the parent container.
+     * For plain scalars this is a no-op. Used by ||=/&&=//= to match Perl 5's lvalue semantics
+     * where hash element access creates the entry before the condition check.
+     * Format: VIVIFY_LVALUE reg
+     */
+    public static final short VIVIFY_LVALUE = 452;
+
+    /**
+     * List slice: rd = list.getSlice(indices)
+     * Used for (list)[indices] syntax in the interpreter.
+     * Format: LIST_SLICE rd list_reg indices_reg
+     */
+    public static final short LIST_SLICE = 453;
+
     private Opcodes() {
     } // Utility class - no instantiation
 }

src/main/java/org/perlonjava/backend/jvm/EmitBinaryOperator.java

@@ -214,9 +214,16 @@ static void handleCompoundAssignment(EmitterVisitor emitterVisitor, BinaryOperat
         };
 
         // Check if we have an operator handler for this compound operator
-        OperatorHandler operatorHandler = shouldUseWarnVariant 
-                ? OperatorHandler.getWarn(node.operator)
-                : OperatorHandler.get(node.operator);
+        // Under "use integer", use the integer warn variant for /=
+        boolean isInteger = emitterVisitor.ctx.symbolTable.isStrictOptionEnabled(Strict.HINT_INTEGER);
+        OperatorHandler operatorHandler;
+        if (shouldUseWarnVariant && isInteger && node.operator.equals("/=")) {
+            operatorHandler = OperatorHandler.get("/=_int_warn");
+        } else {
+            operatorHandler = shouldUseWarnVariant 
+                    ? OperatorHandler.getWarn(node.operator)
+                    : OperatorHandler.get(node.operator);
+        }
 
         if (operatorHandler != null) {
             // Use the new *Assign methods which check for compound overloads first

src/main/java/org/perlonjava/backend/jvm/EmitCompilerFlag.java

@@ -43,6 +43,21 @@ public static void emitCompilerFlag(EmitterContext ctx, CompilerFlagNode node) {
                 "setCallSiteBits",
                 "(Ljava/lang/String;)V", false);
 
+        // Emit runtime code to update per-call-site $^H (hints).
+        // This allows caller()[8] to return accurate hints for the current statement.
+        int hints = node.getStrictOptions();
+        mv.visitLdcInsn(hints);
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC,
+                "org/perlonjava/runtime/WarningBitsRegistry",
+                "setCallSiteHints",
+                "(I)V", false);
+
+        // Emit runtime code to snapshot %^H for caller()[10].
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC,
+                "org/perlonjava/runtime/WarningBitsRegistry",
+                "snapshotCurrentHintHash",
+                "()V", false);
+
         // Emit runtime code for warning scope if needed
         int warningScopeId = node.getWarningScopeId();
         if (warningScopeId > 0) {

src/main/java/org/perlonjava/backend/jvm/EmitLiteral.java

@@ -443,15 +443,33 @@ public static void emitNumber(EmitterContext ctx, NumberNode node) {
                         "getScalarInt",
                         "(I)Lorg/perlonjava/runtime/runtimetypes/RuntimeScalar;", false);
             } else if (isLargeInteger) {
-                // Store large integers as strings to preserve precision
-                // This emulates 32-bit Perl behavior
-                if (CompilerOptions.DEBUG_ENABLED) ctx.logDebug("visit(NumberNode) emit large integer as string");
+                // Store large integers with precision preservation.
+                // Try long first (exact for values up to 2^63-1).
+                // RuntimeScalar(long) uses initializeWithLong() which stores values
+                // within 2^53 as DOUBLE and larger ones as STRING for full precision.
+                // Fall back to double for values that overflow long (e.g., unsigned 64-bit).
+                if (CompilerOptions.DEBUG_ENABLED) ctx.logDebug("visit(NumberNode) emit large integer");
+                boolean fitsInLong = true;
+                long longVal = 0;
+                try {
+                    longVal = Long.parseLong(value);
+                } catch (NumberFormatException e) {
+                    fitsInLong = false;
+                }
                 mv.visitTypeInsn(Opcodes.NEW, "org/perlonjava/runtime/runtimetypes/RuntimeScalar");
                 mv.visitInsn(Opcodes.DUP);
-                mv.visitLdcInsn(value);
-                mv.visitMethodInsn(
-                        Opcodes.INVOKESPECIAL, "org/perlonjava/runtime/runtimetypes/RuntimeScalar",
-                        "<init>", "(Ljava/lang/String;)V", false);
+                if (fitsInLong) {
+                    mv.visitLdcInsn(longVal);
+                    mv.visitMethodInsn(
+                            Opcodes.INVOKESPECIAL, "org/perlonjava/runtime/runtimetypes/RuntimeScalar",
+                            "<init>", "(J)V", false);
+                } else {
+                    // Value exceeds long range — store as double (Perl NV promotion)
+                    mv.visitLdcInsn(Double.valueOf(value));
+                    mv.visitMethodInsn(
+                            Opcodes.INVOKESPECIAL, "org/perlonjava/runtime/runtimetypes/RuntimeScalar",
+                            "<init>", "(D)V", false);
+                }
             } else {
                 // Create new RuntimeScalar for floating-point values
                 mv.visitTypeInsn(Opcodes.NEW, "org/perlonjava/runtime/runtimetypes/RuntimeScalar");
@@ -466,8 +484,8 @@ public static void emitNumber(EmitterContext ctx, NumberNode node) {
             if (isInteger) {
                 mv.visitLdcInsn(Integer.parseInt(value));
             } else if (isLargeInteger) {
-                // For large integers in unboxed context, we have to convert to double
-                // but this will lose precision - same as 32-bit Perl
+                // For unboxed context, convert to double (only option for primitive numeric)
+                // This may lose precision for values beyond 2^53
                 mv.visitLdcInsn(Double.parseDouble(value));
             } else {
                 mv.visitLdcInsn(Double.parseDouble(value));

src/main/java/org/perlonjava/backend/jvm/EmitLogicalOperator.java

@@ -107,6 +107,13 @@ static void emitLogicalAssign(EmitterVisitor emitterVisitor, BinaryOperatorNode
         // and jump away during evaluation.
         node.left.accept(emitterVisitor.with(RuntimeContextType.SCALAR)); // target - left parameter
 
+        // Vivify the LHS proxy so hash/array entries exist before the condition check.
+        // This matches Perl 5's behavior where $h{key} ||= expr creates the hash entry
+        // (with undef value) during lvalue resolution, before evaluating the boolean condition.
+        mv.visitInsn(Opcodes.DUP);
+        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/perlonjava/runtime/runtimetypes/RuntimeScalar",
+                "vivifyLvalue", "()V", false);
+
         int leftSlot = emitterVisitor.ctx.javaClassInfo.acquireSpillSlot();
         boolean pooledLeft = leftSlot >= 0;
         if (!pooledLeft) {

src/main/java/org/perlonjava/backend/jvm/EmitStatement.java

@@ -427,14 +427,22 @@ static void emitDoWhile(EmitterVisitor emitterVisitor, For3Node node) {
         // Continue label (for next iteration)
         mv.visitLabel(continueLabel);
 
-        // Visit the condition node in scalar context
-        node.condition.accept(emitterVisitor.with(RuntimeContextType.SCALAR));
-
-        // Convert the result to a boolean
-        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/perlonjava/runtime/runtimetypes/RuntimeBase", "getBoolean", "()Z", false);
+        // Check if condition is a compile-time constant (e.g., "do {} until TRUE_CONST")
+        String currentPackage = emitterVisitor.ctx.symbolTable.getCurrentPackage();
+        Boolean constantCondition = ConstantFoldingVisitor.getConstantConditionValue(node.condition, currentPackage);
 
-        // If condition is true, jump back to start
-        mv.visitJumpInsn(Opcodes.IFNE, startLabel);
+        if (constantCondition != null) {
+            if (constantCondition) {
+                // Condition is constant true — infinite loop, jump back unconditionally
+                mv.visitJumpInsn(Opcodes.GOTO, startLabel);
+            }
+            // else: condition is constant false — don't jump back, body runs exactly once
+        } else {
+            // Non-constant condition — emit normal runtime evaluation
+            node.condition.accept(emitterVisitor.with(RuntimeContextType.SCALAR));
+            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/perlonjava/runtime/runtimetypes/RuntimeBase", "getBoolean", "()Z", false);
+            mv.visitJumpInsn(Opcodes.IFNE, startLabel);
+        }
 
         // End of loop
         mv.visitLabel(endLabel);

src/main/java/org/perlonjava/core/Configuration.java

@@ -33,7 +33,7 @@ public final class Configuration {
      * Automatically populated by Gradle/Maven during build.
      * DO NOT EDIT MANUALLY - this value is replaced at build time.
      */
-    public static final String gitCommitId = "9ac685c8e";
+    public static final String gitCommitId = "e22613062";
 
     /**
      * Git commit date of the build (ISO format: YYYY-MM-DD).

src/main/java/org/perlonjava/frontend/analysis/ConstantFoldingVisitor.java

@@ -123,6 +123,14 @@ public static Boolean getConstantConditionValue(Node condition, String currentPa
             }
         }
 
+        // Handle not/! operators (used for `until` conditions and explicit negation)
+        if (condition instanceof OperatorNode opNode && opNode.operand != null) {
+            if ("not".equals(opNode.operator) || "!".equals(opNode.operator)) {
+                Boolean innerValue = getConstantConditionValue(opNode.operand, currentPackage);
+                if (innerValue != null) return !innerValue;
+            }
+        }
+
         return null;
     }
 
@@ -143,6 +151,11 @@ private static Boolean resolveConstantSubBoolean(String name, String currentPack
                     }
                     RuntimeBase firstElement = constList.elements.getFirst();
                     if (firstElement instanceof RuntimeScalar scalar) {
+                        // References are always truthy in Perl — don't call getBoolean()
+                        // which could trigger overloaded bool at compile time
+                        if (RuntimeScalarType.isReference(scalar)) {
+                            return true;
+                        }
                         return scalar.getBoolean();
                     }
                 }

src/main/java/org/perlonjava/frontend/parser/Parser.java

@@ -47,6 +47,9 @@ public class Parser {
     public boolean isInClassBlock = false;
     // Are we parsing inside a method?
     public boolean isInMethod = false;
+    // Are we parsing inside a braced dereference like %{...} or @{...}?
+    // When true, inner {} should default to hash constructor, not block.
+    public boolean insideBracedDereference = false;
     // List to store ADJUST blocks for the current class
     public List<Node> classAdjustBlocks = new ArrayList<>();
     // List to store heredoc nodes encountered during parsing.

src/main/java/org/perlonjava/frontend/parser/StatementResolver.java

@@ -933,6 +933,12 @@ public static boolean isHashLiteral(Parser parser) {
             // { %hash } or { @array } or { %{$ref} } - treat as hash constructor
             if (CompilerOptions.DEBUG_ENABLED) parser.ctx.logDebug("isHashLiteral RESULT: TRUE - starts with sigil (% or @)");
             return true;
+        } else if (parser.insideBracedDereference) {
+            // Inside %{...}, inner {} should default to hash constructor, not block.
+            // Perl 5 sets PL_expect = XTERM after %{, making the next { a hash constructor.
+            // Example: %{ {map { $_ => 1 } @_} } — inner {} is a hashref.
+            if (CompilerOptions.DEBUG_ENABLED) parser.ctx.logDebug("isHashLiteral RESULT: TRUE - inside braced dereference context");
+            return true;
         } else {
             if (CompilerOptions.DEBUG_ENABLED) parser.ctx.logDebug("isHashLiteral RESULT: FALSE - default for ambiguous case (assuming block)");
             return false; // Default: assume block when we can't determine

src/main/java/org/perlonjava/frontend/parser/SubroutineParser.java

@@ -708,7 +708,12 @@ public static Node parseSubroutineDefinition(Parser parser, boolean wantName, St
         boolean previousInSubroutineBody = parser.ctx.symbolTable.isInSubroutineBody();
 
         // Set the current subroutine name (use empty string for anonymous subs)
-        parser.ctx.symbolTable.setCurrentSubroutine(subName != null ? subName : "");
+        // Use fully qualified name so ByteCodeSourceMapper records the declaration-time
+        // package, not whatever package might be set inside the sub body
+        String qualifiedSubName = subName != null
+                ? NameNormalizer.normalizeVariableName(subName, parser.ctx.symbolTable.getCurrentPackage())
+                : "";
+        parser.ctx.symbolTable.setCurrentSubroutine(qualifiedSubName);
         // We are now parsing inside a subroutine body (named or anonymous)
         parser.ctx.symbolTable.setInSubroutineBody(true);