Merge master (includes PR 359 changes)

Author: fglock

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

@@ -205,6 +205,7 @@ public static RuntimeList executePerlCode(CompilerOptions compilerOptions,
 
     /**
      * Executes the given Perl code using a syntax tree and returns the result.
+     * Uses VOID context by default.
      *
      * @param ast             The abstract syntax tree representing the Perl code.
      * @param tokens          The list of tokens representing the Perl code.
@@ -214,6 +215,22 @@ public static RuntimeList executePerlCode(CompilerOptions compilerOptions,
     public static RuntimeList executePerlAST(Node ast,
                                              List<LexerToken> tokens,
                                              CompilerOptions compilerOptions) throws Exception {
+        return executePerlAST(ast, tokens, compilerOptions, RuntimeContextType.VOID);
+    }
+
+    /**
+     * Executes the given Perl code using a syntax tree with specified context.
+     *
+     * @param ast             The abstract syntax tree representing the Perl code.
+     * @param tokens          The list of tokens representing the Perl code.
+     * @param compilerOptions Compiler flags, file name and source code.
+     * @param contextType     The context to use for execution (VOID, SCALAR, LIST).
+     * @return The result of the Perl code execution.
+     */
+    public static RuntimeList executePerlAST(Node ast,
+                                             List<LexerToken> tokens,
+                                             CompilerOptions compilerOptions,
+                                             int contextType) throws Exception {
 
         // Save the current scope so we can restore it after execution.
         ScopedSymbolTable savedCurrentScope = SpecialBlockParser.getCurrentScope();
@@ -229,7 +246,7 @@ public static RuntimeList executePerlAST(Node ast,
                 globalSymbolTable.snapShot(),
                 null,
                 null,
-                RuntimeContextType.VOID,
+                contextType,
                 true,
                 null,
                 compilerOptions,
@@ -255,8 +272,7 @@ public static RuntimeList executePerlAST(Node ast,
             // Compile to executable (compiler or interpreter based on flag)
             RuntimeCode runtimeCode = compileToExecutable(ast, ctx);
 
-            // executePerlAST is always called from special blocks which use VOID context
-            return executeCode(runtimeCode, ctx, false, RuntimeContextType.VOID);
+            return executeCode(runtimeCode, ctx, false, contextType);
         } finally {
             // Restore the caller's scope
             if (savedCurrentScope != null) {

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

@@ -3911,14 +3911,18 @@ void compileVariableReference(OperatorNode node, String op) {
                 // This will add the current package if no package is specified
                 subName = NameNormalizer.normalizeVariableName(subName, getCurrentPackage());
 
-                // Allocate register for code reference
+                // Cache the RuntimeScalar code reference at compile time.
+                // This matches Perl's behavior where the CV (code value) is cached
+                // in the compiled bytecode, surviving stash entry deletion.
+                RuntimeScalar codeRef = GlobalVariable.getGlobalCodeRef(subName);
+
+                // Allocate register and load from constant pool
                 int rd = allocateOutputRegister();
-                int nameIdx = addToStringPool(subName);
+                int constIdx = addToConstantPool(codeRef);
 
-                // Emit LOAD_GLOBAL_CODE
-                emit(Opcodes.LOAD_GLOBAL_CODE);
+                emit(Opcodes.LOAD_CONST);
                 emitReg(rd);
-                emit(nameIdx);
+                emit(constIdx);
 
                 lastResultReg = rd;
             } else if (node.operand instanceof BlockNode || node.operand instanceof OperatorNode) {

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

@@ -365,14 +365,69 @@ static void handleArrayElementOperator(EmitterVisitor emitterVisitor, BinaryOper
             }
         }
         if (node.left instanceof ListNode list) { // ("a","b","c")[2]
-            // transform to:  ["a","b","c"]->[2]
-            BinaryOperatorNode refNode = new BinaryOperatorNode("->",
-                    new ArrayLiteralNode(list.elements, list.getIndex()),
-                    node.right, node.tokenIndex);
-            refNode.accept(emitterVisitor);
+            // Use proper list slice semantics: evaluate list, then slice
+            // This differs from array dereference because empty list returns empty, not undef
+            if (CompilerOptions.DEBUG_ENABLED) emitterVisitor.ctx.logDebug("visit(BinaryOperatorNode) (list)[indices] - list slice");
+            
+            // Evaluate the list
+            list.accept(emitterVisitor.with(RuntimeContextType.LIST));
+            
+            // Convert to RuntimeList if not already (handles RuntimeScalar case)
+            emitterVisitor.ctx.mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,
+                    "org/perlonjava/runtime/runtimetypes/RuntimeBase",
+                    "getList",
+                    "()Lorg/perlonjava/runtime/runtimetypes/RuntimeList;",
+                    false);
+            
+            // Save the list to a local variable before evaluating indices.
+            // This is necessary because indices may contain function calls that
+            // generate complex bytecode with exception handlers, and the JVM
+            // verifier requires consistent stack heights at merge points.
+            int listVar = emitterVisitor.ctx.symbolTable.allocateLocalVariable();
+            emitterVisitor.ctx.mv.visitVarInsn(Opcodes.ASTORE, listVar);
+            
+            // Evaluate the indices
+            ListNode indices = ((ArrayLiteralNode) node.right).asListNode();
+            indices.accept(emitterVisitor.with(RuntimeContextType.LIST));
+            
+            // Save indices to local variable too
+            int indicesVar = emitterVisitor.ctx.symbolTable.allocateLocalVariable();
+            emitterVisitor.ctx.mv.visitVarInsn(Opcodes.ASTORE, indicesVar);
+            
+            // Load list and indices back, call RuntimeList.getSlice(indices)
+            emitterVisitor.ctx.mv.visitVarInsn(Opcodes.ALOAD, listVar);
+            emitterVisitor.ctx.mv.visitVarInsn(Opcodes.ALOAD, indicesVar);
+            emitterVisitor.ctx.mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,
+                    "org/perlonjava/runtime/runtimetypes/RuntimeList",
+                    "getSlice",
+                    "(Lorg/perlonjava/runtime/runtimetypes/RuntimeList;)Lorg/perlonjava/runtime/runtimetypes/RuntimeList;",
+                    false);
+            
+            // Handle context conversion
+            if (emitterVisitor.ctx.contextType == RuntimeContextType.SCALAR) {
+                emitterVisitor.ctx.mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/perlonjava/runtime/runtimetypes/RuntimeList",
+                        "scalar", "()Lorg/perlonjava/runtime/runtimetypes/RuntimeScalar;", false);
+            } else if (emitterVisitor.ctx.contextType == RuntimeContextType.VOID) {
+                emitterVisitor.ctx.mv.visitInsn(Opcodes.POP);
+            }
             return;
         }
 
+        // For function calls and other expressions: (func())[index]
+        // We need to use list slice semantics to handle empty lists correctly.
+        // However, this should NOT apply to chained dereferences like $matrix[1][0]
+        // where the first [1] returns a scalar (array reference) and the second
+        // [0] should dereference it.
+        // 
+        // List slice semantics apply when:
+        // 1. The left side is a ListNode (literal list) - handled above
+        // 2. The left side is a parenthesized function call (wantarray context)
+        //
+        // For now, we use the old transformation to ->[] for non-ListNode cases,
+        // as most cases are array dereferences, not list slices.
+        // TODO: Properly detect when the left side is a list-returning expression
+        //       vs. a scalar-returning expression.
+
         // default: call `->[]`
         BinaryOperatorNode refNode = new BinaryOperatorNode("->", node.left, node.right, node.tokenIndex);
         refNode.accept(emitterVisitor);

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 = "38832fe97";
+    public static final String gitCommitId = "427621554";
 
     /**
      * Git commit date of the build (ISO format: YYYY-MM-DD).

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

@@ -201,6 +201,11 @@ public static String parseComplexIdentifierInner(Parser parser, boolean insideBr
             if (insideBraces && firstChar == '*' && nextToken.text.equals("{")) {
                 return null; // Force fallback to expression parsing for glob dereference
             }
+            // Special case: & followed by { is subroutine call when inside braces
+            // %{&{$code}} should be parsed as %{ &{$code} }, not %&{$code} (hash subscript on %&)
+            if (insideBraces && firstChar == '&' && nextToken.text.equals("{")) {
+                return null; // Force fallback to expression parsing for subroutine call
+            }
             // Check if this is a leading single quote followed by an identifier ($'foo means $main::foo)
             if (firstChar == '\'' && (nextToken.type == LexerTokenType.IDENTIFIER || nextToken.type == LexerTokenType.NUMBER)) {
                 // This is $'foo which means $main::foo

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

@@ -28,12 +28,27 @@ static BinaryOperatorNode parseSort(Parser parser, LexerToken token) {
         if (nextToken.type == LexerTokenType.IDENTIFIER && !nextToken.text.equals("{")
                 && !ParserTables.CORE_PROTOTYPES.containsKey(nextToken.text)
                 && !ParsePrimary.isIsQuoteLikeOperator(nextToken.text)) {
+            // This could be a subroutine name for comparison (sort mysub LIST)
+            // or a class name for method call (sort MyClass->method)
+            // Save position and try to determine which
+            int identStart = parser.tokenIndex;
             String subName = IdentifierParser.parseSubroutineIdentifier(parser);
-            Node var = new OperatorNode("&",
-                    new IdentifierNode(subName, parser.tokenIndex), parser.tokenIndex);
-            operand = ListParser.parseZeroOrMoreList(parser, 0, false, false, false, false);
-            operand.handle = var;
-            if (CompilerOptions.DEBUG_ENABLED) parser.ctx.logDebug("parseSort identifier: " + operand.handle + " : " + operand);
+            
+            // Check if followed by -> (method call) - if so, backtrack and parse as list
+            if (peek(parser).text.equals("->")) {
+                // This is a method call like "sort MyClass->method" 
+                // Backtrack and parse the whole thing as a list expression
+                parser.tokenIndex = identStart;
+                operand = ListParser.parseZeroOrMoreList(parser, 0, false, false, false, false);
+                if (CompilerOptions.DEBUG_ENABLED) parser.ctx.logDebug("parseSort method call: " + operand);
+            } else {
+                // This is a comparison subroutine name
+                Node var = new OperatorNode("&",
+                        new IdentifierNode(subName, parser.tokenIndex), parser.tokenIndex);
+                operand = ListParser.parseZeroOrMoreList(parser, 0, false, false, false, false);
+                operand.handle = var;
+                if (CompilerOptions.DEBUG_ENABLED) parser.ctx.logDebug("parseSort identifier: " + operand.handle + " : " + operand);
+            }
         } else {
             try {
                 operand = ListParser.parseZeroOrMoreList(parser, 1, true, false, false, false);

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

@@ -98,13 +98,27 @@ static Node parseSpecialBlock(Parser parser) {
 
     /**
      * Executes a special block with the given block phase and block AST.
+     * Uses VOID context by default.
      *
      * @param parser     The parser instance.
      * @param blockPhase The phase of the block (e.g., BEGIN, END).
      * @param block      The block AST to execute.
      * @return A RuntimeList containing the result of the execution.
      */
     static RuntimeList runSpecialBlock(Parser parser, String blockPhase, Node block) {
+        return runSpecialBlock(parser, blockPhase, block, RuntimeContextType.VOID);
+    }
+
+    /**
+     * Executes a special block with the given block phase, block AST, and context.
+     *
+     * @param parser      The parser instance.
+     * @param blockPhase  The phase of the block (e.g., BEGIN, END).
+     * @param block       The block AST to execute.
+     * @param contextType The context to use for execution (VOID, SCALAR, LIST).
+     * @return A RuntimeList containing the result of the execution.
+     */
+    static RuntimeList runSpecialBlock(Parser parser, String blockPhase, Node block, int contextType) {
         int tokenIndex = parser.tokenIndex;
 
         // Create AST nodes for setting up the capture variables and package declaration
@@ -252,7 +266,8 @@ static RuntimeList runSpecialBlock(Parser parser, String blockPhase, Node block)
             result = PerlLanguageProvider.executePerlAST(
                     new BlockNode(nodes, tokenIndex),
                     parser.tokens,
-                    parsedArgs);
+                    parsedArgs,
+                    contextType);
         } catch (PerlExitException e) {
             // exit() inside BEGIN block should terminate the program, not cause compilation error
             // Re-throw so it propagates to the CLI (Main.main()) which will call System.exit()

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

@@ -658,8 +658,10 @@ public static Node parseUseDeclaration(Parser parser, LexerToken token) {
                 // call Module->import( LIST )
                 // or Module->unimport( LIST )
 
-                // Execute the argument list immediately
-                RuntimeList args = runSpecialBlock(parser, "BEGIN", list);
+                // Execute the argument list immediately in LIST context
+                // This is necessary for expressions like: use lib ($path =~ /^(.*)$/);
+                // where the regex match must return captured groups, not just success/failure
+                RuntimeList args = runSpecialBlock(parser, "BEGIN", list, RuntimeContextType.LIST);
 
                 if (CompilerOptions.DEBUG_ENABLED) ctx.logDebug("Use statement list: " + args);
                 if (hasParentheses && args.isEmpty()) {

src/main/java/org/perlonjava/runtime/perlmodule/Base.java

@@ -27,6 +27,8 @@ public static void initialize() {
         Base base = new Base();
         try {
             base.registerMethod("import", "importBase", ";$");
+            // Set $VERSION so CPAN.pm can detect our bundled version
+            GlobalVariable.getGlobalVariable("base::VERSION").set(new RuntimeScalar("2.27"));
         } catch (NoSuchMethodException e) {
             System.err.println("Warning: Missing Base method: " + e.getMessage());
         }

src/main/java/org/perlonjava/runtime/perlmodule/Parent.java

@@ -29,6 +29,8 @@ public static void initialize() {
         Parent parent = new Parent();
         try {
             parent.registerMethod("import", "importParent", ";$");
+            // Set $VERSION so CPAN.pm can detect our bundled version
+            GlobalVariable.getGlobalVariable("parent::VERSION").set(new RuntimeScalar("0.244"));
         } catch (NoSuchMethodException e) {
             System.err.println("Warning: Missing Parent method: " + e.getMessage());
         }