WIP: Add shared AST transformer infrastructure (Phase 1)

dev/tools/analyze_context_calls.pl

@@ -0,0 +1,47 @@
+#!/usr/bin/env perl
+# Analyze acceptChild calls in emitter to extract context expectations
+use strict;
+use warnings;
+
+my %patterns;
+my %by_file;
+
+while (<>) {
+    # Parse: file:line:    emitterVisitor.acceptChild(node.field, RuntimeContextType.CONTEXT);
+    if (/^([^:]+):(\d+):\s*.*acceptChild\(([^,]+),\s*RuntimeContextType\.(\w+)\)/) {
+        my ($file, $line, $node_expr, $context) = ($1, $2, $3, $4);
+        $file =~ s|.*/||;  # basename
+
+        # Normalize node expression
+        my $pattern = $node_expr;
+        $pattern =~ s/\s+//g;
+
+        push @{$patterns{$pattern}{$context}}, "$file:$line";
+        $by_file{$file}++;
+    }
+}
+
+print "=== Context expectations by node expression ===\n\n";
+for my $pattern (sort keys %patterns) {
+    my $contexts = $patterns{$pattern};
+    my @ctx_list = sort keys %$contexts;
+
+    if (@ctx_list == 1) {
+        # Consistent context
+        my $ctx = $ctx_list[0];
+        my $count = scalar @{$contexts->{$ctx}};
+        print "$pattern => $ctx ($count calls)\n";
+    } else {
+        # Multiple contexts - needs special handling
+        print "*** $pattern => VARIES:\n";
+        for my $ctx (@ctx_list) {
+            my $locs = $contexts->{$ctx};
+            print "    $ctx: " . join(", ", @$locs) . "\n";
+        }
+    }
+}
+
+print "\n=== Calls by file ===\n";
+for my $file (sort { $by_file{$b} <=> $by_file{$a} } keys %by_file) {
+    print "$file: $by_file{$file}\n";
+}

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

@@ -8,6 +8,7 @@
 import org.perlonjava.backend.jvm.EmitterContext;
 import org.perlonjava.backend.jvm.EmitterMethodCreator;
 import org.perlonjava.backend.jvm.JavaClassInfo;
+import org.perlonjava.frontend.analysis.ASTTransformer;
 import org.perlonjava.frontend.astnode.Node;
 import org.perlonjava.frontend.lexer.Lexer;
 import org.perlonjava.frontend.lexer.LexerToken;
@@ -165,6 +166,10 @@ public static RuntimeList executePerlCode(CompilerOptions compilerOptions,
 
         // ast = ConstantFoldingVisitor.foldConstants(ast);
 
+        // Run shared AST transformer to compute context annotations
+        // (idempotent - skips if already transformed)
+        ASTTransformer.createDefault().transform(ast);
+
         if (ctx.compilerOptions.parseOnly) {
             // Printing the ast
             System.out.println(ast);

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

@@ -80,6 +80,10 @@ public class BytecodeCompiler implements Visitor {
 
     // Track current calling context for subroutine calls
     int currentCallContext = RuntimeContextType.LIST; // Default to LIST
+
+    // Context mismatch tracking (for migration validation)
+    static final Map<String, java.util.concurrent.atomic.AtomicInteger> interpreterContextMismatches = 
+            new java.util.concurrent.ConcurrentHashMap<>();
     Map<String, Integer> capturedVarIndices;  // Name → register index
     // BEGIN support for named subroutine closures
     int currentSubroutineBeginId = 0;     // BEGIN ID for current named subroutine (0 = not in named sub)
@@ -834,12 +838,8 @@ public void visit(BlockNode node) {
 
             boolean isLastStatement = (i == lastMeaningfulIndex);
             int stmtTarget = (isLastStatement && outerResultReg >= 0) ? outerResultReg : -1;
-            int stmtContext;
-            if (!isLastStatement && !(stmt instanceof BinaryOperatorNode && ((BinaryOperatorNode) stmt).operator.equals("="))) {
-                stmtContext = RuntimeContextType.VOID;
-            } else {
-                stmtContext = currentCallContext;
-            }
+            // Non-last statements use VOID context (matches JVM emitter)
+            int stmtContext = isLastStatement ? currentCallContext : RuntimeContextType.VOID;
 
             compileNode(stmt, stmtTarget, stmtContext);
 
@@ -3732,15 +3732,81 @@ void emitAliasWithTarget(int destReg, int srcReg) {
         }
     }
 
+    /**
+     * Compiles a node using its precomputed context from ContextResolver.
+     * Use this when the node's context was set by ContextResolver.
+     */
+    void compileNode(Node node) {
+        if (node == null) return;
+        int savedTarget = targetOutputReg;
+        int savedContext = currentCallContext;
+        targetOutputReg = -1;
+
+        if (node instanceof AbstractNode an && an.hasCachedContext()) {
+            currentCallContext = an.getCachedContext();
+        }
+        // else keep current context as fallback
+
+        node.accept(this);
+        targetOutputReg = savedTarget;
+        currentCallContext = savedContext;
+    }
+
+    /**
+     * Compiles a node with explicit fallback context.
+     * Uses cached context when available, falls back to specified context otherwise.
+     */
     void compileNode(Node node, int targetReg, int callContext) {
         int savedTarget = targetOutputReg;
         int savedContext = currentCallContext;
         targetOutputReg = targetReg;
-        currentCallContext = callContext;
+
+        // Use cached context when available, track mismatches for debugging
+        int contextToUse = callContext;
+        if (node instanceof AbstractNode an && an.hasCachedContext()) {
+            int cached = an.getCachedContext();
+            if (cached != callContext) {
+                String key = nodeDescription(node) + " cached=" + contextName(cached) + " expected=" + contextName(callContext);
+                var counter = interpreterContextMismatches.computeIfAbsent(key, k -> new java.util.concurrent.atomic.AtomicInteger());
+                counter.incrementAndGet();
+            }
+            // Always use cached context - ContextResolver is authoritative
+            contextToUse = cached;
+        }
+
+        currentCallContext = contextToUse;
         node.accept(this);
         targetOutputReg = savedTarget;
         currentCallContext = savedContext;
     }
+
+    private String nodeDescription(Node node) {
+        if (node instanceof OperatorNode op) return "OperatorNode(" + op.operator + ")";
+        if (node instanceof BinaryOperatorNode bin) return "BinaryOperatorNode(" + bin.operator + ")";
+        return node.getClass().getSimpleName();
+    }
+
+    private String contextName(int ctx) {
+        return switch (ctx) {
+            case RuntimeContextType.VOID -> "VOID";
+            case RuntimeContextType.SCALAR -> "SCALAR";
+            case RuntimeContextType.LIST -> "LIST";
+            case RuntimeContextType.RUNTIME -> "RUNTIME";
+            default -> "UNKNOWN(" + ctx + ")";
+        };
+    }
+
+    // Mismatch list removed - ContextResolver is authoritative
+    // If mismatches cause test failures, fix ContextResolver, not this list
+
+    public static void printInterpreterMismatches() {
+        if (interpreterContextMismatches.isEmpty()) return;
+        System.err.println("\n=== Interpreter Context Mismatches (vs ContextResolver) ===");
+        interpreterContextMismatches.entrySet().stream()
+                .sorted((a, b) -> b.getValue().get() - a.getValue().get())
+                .forEach(e -> System.err.println(e.getKey() + " : " + e.getValue().get() + " times"));
+        System.err.println();
+    }
 
     // =========================================================================
     // HELPER METHODS

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

@@ -15,7 +15,8 @@ static void visitBinaryOperator(BytecodeCompiler bytecodeCompiler, BinaryOperato
             // left = filehandle reference (\*STDERR)
             // right = list to print
 
-            bytecodeCompiler.compileNode(node.left, -1, bytecodeCompiler.currentCallContext);
+            // Filehandle is evaluated in SCALAR context (matches ContextResolver and JVM emitter)
+            bytecodeCompiler.compileNode(node.left, -1, RuntimeContextType.SCALAR);
             int filehandleReg = bytecodeCompiler.lastResultReg;
 
             // Compile the content (right operand) in LIST context
@@ -238,7 +239,9 @@ else if (node.right instanceof BinaryOperatorNode rightCall) {
                     // Convert class name to string if needed: Class->method()
                     if (invocantNode instanceof IdentifierNode) {
                         String className = ((IdentifierNode) invocantNode).name;
-                        invocantNode = new StringNode(className, invocantNode.getIndex());
+                        invocantNode = AbstractNode.withContext(
+                            new StringNode(className, invocantNode.getIndex()),
+                            RuntimeContextType.SCALAR);
                     }
 
                     // Convert method name to string if needed
@@ -250,7 +253,9 @@ else if (node.right instanceof BinaryOperatorNode rightCall) {
                     }
                     if (methodNode instanceof IdentifierNode) {
                         String methodName = ((IdentifierNode) methodNode).name;
-                        methodNode = new StringNode(methodName, methodNode.getIndex());
+                        methodNode = AbstractNode.withContext(
+                            new StringNode(methodName, methodNode.getIndex()),
+                            RuntimeContextType.SCALAR);
                     }
 
                     // Compile invocant in scalar context
@@ -546,7 +551,8 @@ else if (node.right instanceof BinaryOperatorNode rightCall) {
             case "+", "-", "*", "/", "%", "**",
                  "&", "|", "^", "<<", ">>",
                  "binary&", "binary|", "binary^",
-                 "&.", "|.", "^." -> true;
+                 "&.", "|.", "^.",
+                 "." -> true;  // String concat always takes SCALAR operands
             default -> false;
         };
         int outerCtx = bytecodeCompiler.currentCallContext;