This method uses compile-time type information to generate optimized - * bytecode that calls the specific addToList method for known types, avoiding - * the overhead of interface dispatch when possible.
+ *List-valued expressions can cross control-flow/context boundaries that + * widen their verifier type to RuntimeBase. Other statically known values + * retain the specialized overloads used by hot list-construction paths.
* *Stack transformation: [RuntimeList] [element] → [RuntimeList]
* * @param mv The method visitor for bytecode generation * @param element The AST node representing the element being added - * @param contextType The context type (used for scalar context optimization) + * @param contextType The context in which the list element was emitted */ private static void addElementToList(MethodVisitor mv, Node element, int contextType) { - String returnType; // Stack: [RuntimeList] [element] - // Determine the element's return type for optimization - if (contextType == RuntimeContextType.SCALAR) { - // In scalar context, all elements are treated as scalars - returnType = RuntimeDescriptorConstants.SCALAR_TYPE; + String returnType = ReturnTypeVisitor.getReturnType(element); + String methodName = "add"; + // Memoize::_wrap exposed a list-valued expression whose verifier type had + // been widened while control-flow branches were merged. The addList base + // entry point keeps the bytecode verifier-safe while preserving the old + // list-flattening semantics inside RuntimeList. + if (RuntimeDescriptorConstants.LIST_TYPE.equals(returnType) + && contextType != RuntimeContextType.RUNTIME) { + methodName = "addList"; + returnType = RuntimeDescriptorConstants.BASE_TYPE; } else if (contextType == RuntimeContextType.RUNTIME) { - // In RUNTIME context, array/hash elements may have been converted to RuntimeBase - // via emitRuntimeContextConversion(), so we must use the generic add(RuntimeBase) returnType = RuntimeDescriptorConstants.BASE_TYPE; - } else { - // Use static analysis to determine the element's return type - returnType = ReturnTypeVisitor.getReturnType(element); } - // Generate type-specific method call for better performance - if (RuntimeDescriptorConstants.isKnownRuntimeType(returnType)) { - mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, RuntimeDescriptorConstants.LIST_CLASS, - "add", "(" + returnType + ")V", false); - } else { - // Fall back for unknown types - mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, RuntimeDescriptorConstants.LIST_CLASS, - "add", "(" + RuntimeDescriptorConstants.BASE_TYPE + ")V", false); + if (!RuntimeDescriptorConstants.isKnownRuntimeType(returnType)) { + returnType = RuntimeDescriptorConstants.BASE_TYPE; } + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, RuntimeDescriptorConstants.LIST_CLASS, + methodName, "(" + returnType + ")V", false); } /** diff --git a/src/main/java/org/perlonjava/frontend/parser/StatementParser.java b/src/main/java/org/perlonjava/frontend/parser/StatementParser.java index a035456f7..e5be5e072 100644 --- a/src/main/java/org/perlonjava/frontend/parser/StatementParser.java +++ b/src/main/java/org/perlonjava/frontend/parser/StatementParser.java @@ -338,6 +338,7 @@ public static Node parseIfStatement(Parser parser) { * @return An IfNode representing the if/unless/elsif statement */ private static Node parseIfStatementInternal(Parser parser, boolean enterNewScope) { + int statementStartIndex = parser.tokenIndex; LexerToken operator = TokenUtils.consume(parser, LexerTokenType.IDENTIFIER); // "if", "unless", "elsif" // Enter a new scope for 'if' and 'unless' (but not for 'elsif' which is part of the same chain) @@ -375,12 +376,42 @@ private static Node parseIfStatementInternal(Parser parser, boolean enterNewScop TestMoreHelper.handleSkipTest(parser, thenBranch); IfNode result = new IfNode(operator.text, condition, thenBranch, elseBranch, parser.tokenIndex); + // A lexical declaration in the condition owns the next COP in Perl, so + // the first standalone call reports the conditional's source line. + // Ordinary conditions keep the call's own line (see op/caller.t). + if (!thenBranch.elements.isEmpty() + && thenBranch.elements.get(0) instanceof BinaryOperatorNode first + && "(".equals(first.operator) + && conditionContainsLexicalDeclaration(condition)) { + first.setAnnotation("callerLineTokenOverride", statementStartIndex); + } if (enterNewScope) { result.setAnnotation("postBlockHintHashId", HintHashRegistry.snapshotCurrentHintHash()); } return result; } + private static boolean conditionContainsLexicalDeclaration(Node node) { + if (node instanceof OperatorNode operatorNode) { + if ("my".equals(operatorNode.operator) || "state".equals(operatorNode.operator)) { + return true; + } + return conditionContainsLexicalDeclaration(operatorNode.operand); + } + if (node instanceof BinaryOperatorNode binaryNode) { + return conditionContainsLexicalDeclaration(binaryNode.left) + || conditionContainsLexicalDeclaration(binaryNode.right); + } + if (node instanceof ListNode listNode) { + for (Node element : listNode.elements) { + if (conditionContainsLexicalDeclaration(element)) { + return true; + } + } + } + return false; + } + /** * Parses a try-catch-finally statement. * diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeList.java b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeList.java index 98d95ce69..a5f7d76a5 100644 --- a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeList.java +++ b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeList.java @@ -198,6 +198,15 @@ public void add(RuntimeList value) { } } + /** + * Verifier-safe entry point for values statically known to be RuntimeList. + * Control-flow merges may widen the JVM stack type to RuntimeBase even though + * the Perl expression contract still guarantees a list result. + */ + public void addList(RuntimeBase value) { + add((RuntimeList) value); + } + /** * Gets the size of the list. * diff --git a/src/test/resources/unit/caller_exported_first_statement_in_if.t b/src/test/resources/unit/caller_exported_first_statement_in_if.t new file mode 100644 index 000000000..050f9e8b0 --- /dev/null +++ b/src/test/resources/unit/caller_exported_first_statement_in_if.t @@ -0,0 +1,17 @@ +use strict; +use warnings; +use Test::Builder::Tester tests => 1; + +sub failing_test($$;$) { + return Test::Builder->new->ok(0, $_[2]); +} + +test_out('not ok 1 - captured failure'); +if (my $fail = 1) { + test_fail(6); +} +if (my $error = 0) { + test_err('unused'); +} +failing_test('left', 'right', 'captured failure'); +test_test('exported first statement retains Perl caller line'); diff --git a/src/test/resources/unit/caller_if_condition_line.t b/src/test/resources/unit/caller_if_condition_line.t new file mode 100644 index 000000000..c807f5b29 --- /dev/null +++ b/src/test/resources/unit/caller_if_condition_line.t @@ -0,0 +1,21 @@ +use strict; +use warnings; +no warnings 'syntax'; +use Test::More tests => 2; + +my @caller_lines; +sub capture_caller_line { push @caller_lines, (caller)[2] } + +my $ordinary_call_line = __LINE__ + 2; +if (1) { + capture_caller_line(); +} +is($caller_lines[0], $ordinary_call_line, + 'ordinary if body call keeps its own source line'); + +my $declaration_condition_line = __LINE__ + 1; +if (my $enabled = 1) { + capture_caller_line(); +} +is($caller_lines[1], $declaration_condition_line, + 'lexical declaration condition owns the first call source line'); diff --git a/src/test/resources/unit/data_handle_absolute_position.t b/src/test/resources/unit/data_handle_absolute_position.t new file mode 100644 index 000000000..705d2a9e2 --- /dev/null +++ b/src/test/resources/unit/data_handle_absolute_position.t @@ -0,0 +1,19 @@ +package DataHandleAbsolutePosition; +use strict; +use warnings; +use Test::More; +use Fcntl qw(SEEK_SET); + +my $start = tell(DATA); +ok($start > 0, 'DATA tell is the absolute source-file position'); + +my $first = do { local $/; }; +ok(seek(DATA, $start, SEEK_SET), 'DATA seeks back to its absolute start'); +my $second = do { local $/; }; + +is($second, $first, 'DATA content can be read again after restoring tell'); + +done_testing; + +__DATA__ +payload diff --git a/src/test/resources/unit/memoize_runtime_list_bytecode.t b/src/test/resources/unit/memoize_runtime_list_bytecode.t new file mode 100644 index 000000000..56c429597 --- /dev/null +++ b/src/test/resources/unit/memoize_runtime_list_bytecode.t @@ -0,0 +1,18 @@ +use strict; +use warnings; +use Test::More; +use Memoize; + +my $calls = 0; +sub doubled { + $calls++; + return $_[0] * 2; +} + +my $memoized = memoize(\&doubled, INSTALL => undef); + +is($memoized->(21), 42, 'memoized closure returns its value'); +is($memoized->(21), 42, 'memoized closure returns its cached value'); +is($calls, 1, 'memoized wrapper called the original once'); + +done_testing;