Merge pull request #92 from fglock/fix/comp-proto-test

Fix comp/proto.t test failures

Author: fglock

src/main/java/org/perlonjava/parser/PrototypeArgs.java

@@ -551,6 +551,61 @@ private static void handlePlusArgument(Parser parser, ListNode args, boolean isO
         }
     }
 
+    /**
+     * Unwraps unary plus from expressions like +(%hash) or +(@array) for backslash prototypes.
+     * In Perl, +() is used for disambiguation but should be transparent for \% and \@ prototypes.
+     *
+     * @param arg The argument node to potentially unwrap
+     * @param refType The reference type from the prototype ('%', '@', etc.)
+     * @return The unwrapped node if applicable, or the original node
+     */
+    private static Node unwrapUnaryPlus(Node arg, char refType) {
+        // Only unwrap for \% and \@ prototypes
+        if (refType != '%' && refType != '@') {
+            return arg;
+        }
+        
+        // Check if arg is unary plus: OperatorNode with operator "+"
+        if (!(arg instanceof OperatorNode plusOp) || !plusOp.operator.equals("+")) {
+            return arg;
+        }
+        
+        // Get the operand of the unary plus
+        Node operand = plusOp.operand;
+        
+        // If the operand is a ListNode with a single element, extract it
+        if (operand instanceof ListNode listNode && listNode.elements.size() == 1) {
+            operand = listNode.elements.get(0);
+        }
+        
+        // Check if the operand is the expected type (hash or array variable)
+        if (operand instanceof OperatorNode varOp) {
+            String expectedSigil = (refType == '%') ? "%" : "@";
+            if (varOp.operator.equals(expectedSigil)) {
+                return operand;
+            }
+        }
+        
+        // Also check if operand is directly a ListNode containing a hash/array expression
+        // This handles cases like +(%hash) where the parentheses create a list context
+        if (operand instanceof ListNode listNode) {
+            // In Perl +(%hash) should pass the hash itself, not a list
+            // Look for a single hash or array variable inside the list
+            if (listNode.elements.size() == 1) {
+                Node element = listNode.elements.get(0);
+                if (element instanceof OperatorNode varOp) {
+                    String expectedSigil = (refType == '%') ? "%" : "@";
+                    if (varOp.operator.equals(expectedSigil)) {
+                        return element;
+                    }
+                }
+            }
+        }
+        
+        // Return original if no match
+        return arg;
+    }
+
     private static int handleBackslashArgument(Parser parser, ListNode args, String prototype, int prototypeIndex,
                                                boolean isOptional, boolean needComma) {
         if (prototypeIndex >= prototype.length()) {
@@ -572,6 +627,9 @@ private static int handleBackslashArgument(Parser parser, ListNode args, String
         // Restore flag
         parser.parsingTakeReference = oldParsingTakeReference;
         if (referenceArg != null) {
+            // Handle +(%hash) and +(@array) constructs for \% and \@ prototypes
+            // The unary + is used for disambiguation but should be transparent for prototypes
+            referenceArg = unwrapUnaryPlus(referenceArg, refType);
             // For \& prototype, check for invalid forms like &foo(), foo(), or bareword foo
             if (refType == '&') {
                 String subName = parser.ctx.symbolTable.getCurrentSubroutine();

src/main/java/org/perlonjava/runtime/RuntimeStashEntry.java

@@ -119,6 +119,19 @@ public RuntimeScalar set(RuntimeScalar value) {
                 return value;
             case UNDEF:
                 return value;
+            case STRING:
+            case BYTE_STRING:
+                // Assigning a string to a stash entry sets the prototype for that symbol
+                // e.g., $::{foo} = '$$' sets the prototype of &foo to '$$'
+                RuntimeScalar codeRef = GlobalVariable.getGlobalCodeRef(this.globName);
+                if (codeRef.type == CODE) {
+                    ((RuntimeCode) codeRef.value).prototype = value.toString();
+                } else {
+                    // Create a new RuntimeCode with the prototype
+                    RuntimeCode code = new RuntimeCode(value.toString(), null);
+                    codeRef.set(new RuntimeScalar(code));
+                }
+                return value;
         }
         throw new IllegalStateException("typeglob assignment not implemented for " + value.type);
     }