fix: complete CPANPLUS runtime support

Fix the remaining CPANPLUS blockers after Archive::Extract by handling
tied lexical scalar cleanup, strict bareword coderef arrow calls,
version numification, and stale blib/lib sources in PerlOnJava
MakeMaker reruns.

Add focused regressions and update the CPANPLUS progress note with the
passing test result and follow-up warning.

Generated with [Codex](https://openai.com/codex)

Co-Authored-By: Codex <codex@openai.com>

Author: fglock

dev/modules/cpanplus.md

@@ -2,20 +2,21 @@
 
 ## Current Status
 
-`CPANPLUS::Config` now loads under PerlOnJava after fixing loop-control parsing for bare labels that share a name with an imported constant. This unblocks the upstream `Makefile.PL` path that declares CPANPLUS' dynamic prerequisites.
+`CPANPLUS::Config` loads under PerlOnJava after fixing loop-control parsing for bare labels that share a name with an imported constant. This unblocks the upstream `Makefile.PL` path that declares CPANPLUS' dynamic prerequisites.
 
-The current `./jcpan -t CPANPLUS` run now gets through dependency discovery and the `Archive::Extract` dependency. It is blocked by `Object::Accessor`:
+`./jcpan -t CPANPLUS` now passes with CPANPLUS 0.9916:
 
 ```text
-t/03_Object-Accessor-local.t line 49
-got:      't/03_Object-Accessor-local.t'
-expected: '<process pid>'
+Files=20, Tests=1751, Result: PASS
+EXIT: 0
 ```
 
-Because `Object::Accessor` fails its dependency test, it is not installed, and CPANPLUS' own test files then fail at compile time with:
+The run also verifies the dependency chain that previously blocked CPANPLUS: `Archive::Extract`, `Object::Accessor`, `File::Fetch`, `Log::Message`, `Module::Loaded`, `Package::Constants`, `Log::Message::Simple`, and `Term::UI`.
+
+The only observed remaining issue is a non-fatal warning during CPANPLUS' own suite:
 
 ```text
-Base class package "Object::Accessor" is empty.
+Use of uninitialized value in addition (+) at jar:PERL5LIB/File/Copy.pm line 303.
 ```
 
 ## Symptom
@@ -39,7 +40,7 @@ WriteMakefile(
 
 That fallback had no `PREREQ_PM`, so `Log::Message` was never scheduled.
 
-## Root Cause Fixed
+## Root Causes Fixed
 
 `CPANPLUS::Config` imports constants from `CPANPLUS::Internals::Constants`, including:
 
@@ -59,6 +60,16 @@ Perl treats bare `last BIN` as a literal loop label, even when a constant sub na
 
 The fix keeps a standalone bare identifier immediately after `last`, `next`, or `redo` as a literal loop label. Parenthesized and expression labels still go through the dynamic-label path.
 
+`Archive::Extract` then failed because PerlOnJava's bundled `Archive::Zip` member objects exposed `_name` but CPAN `Archive::Extract` expects the compatibility hash key `fileName`, and it passes member objects back into `extractMember`. The bundled module now exposes both names and accepts member objects.
+
+`Object::Accessor` then exposed tied lexical cleanup differences. A tied lexical scalar whose tie object should be destroyed at scope exit was being cleaned through the generic scalar path, so `DESTROY` did not fire at the Perl-compatible time. Tied scalar cleanup is now explicit and idempotent, including the closure-capture case.
+
+CPANPLUS' tests also use strict bareword coderef calls in forms such as `BUILD_PL->(...)`, `-e BUILD_PL->(...)`, and `stat MAKEFILE->(...)`. PerlOnJava now treats a bareword to the left of `->(...)` as a sub call returning a coderef, and reassociates filetest and `stat`/`lstat` unary operators so those expressions match Perl's parse.
+
+Version checks then exposed decimal vs dotted-version numification differences. `version->parse("v1.5")->numify` now returns `1.005000`, while decimal versions such as `1.5` and `1.2345` retain decimal-padding semantics.
+
+The final CPANPLUS blocker was in the generated Makefile for a dummy `Foo-Bar` distribution. When `Makefile.PL` was rerun after `blib/lib` already existed, PerlOnJava's MakeMaker treated staged `blib/lib/*.pm` files as source files. Its generated `pm_to_blib` target could delete `blib/lib/Foo/Bar.pm` and then try to copy that same path back to itself. MakeMaker now prefers real `lib/` sources over stale `blib/` entries and does not stage already-staged files back into `blib`.
+
 ## Completed Work
 
 - Fixed loop-control parsing in [`OperatorParser.java`](../../src/main/java/org/perlonjava/frontend/parser/OperatorParser.java).
@@ -67,30 +78,37 @@ The fix keeps a standalone bare identifier immediately after `last`, `next`, or
 - Fixed the `Archive::Extract` dependency failure by making PerlOnJava's bundled `Archive::Zip` expose the CPAN-compatible member hash field `fileName` and accept member objects in `extractMember`.
 - Added regression coverage in [`archive_zip_members_matching_qr.t`](../../src/test/resources/unit/archive_zip_members_matching_qr.t) for direct member hash access and object extraction.
 - Verified `Archive::Extract` 0.88 upstream suite passes: `Files=1, Tests=1795, Result: PASS`.
-- Verified `./jcpan -t CPANPLUS` now gets past `Archive::Extract`; `File::Fetch`, `Log::Message`, `Module::Loaded`, `Package::Constants`, `Log::Message::Simple`, and `Term::UI` pass in the observed run.
+- Fixed tied scalar scope cleanup so `Object::Accessor` local attribute restore passes.
+- Added regression coverage in [`tie_scalar.t`](../../src/test/resources/unit/tie_scalar.t) for tied lexical `DESTROY` at scope exit and deferred destruction while a tie object is still referenced.
+- Fixed strict bareword coderef arrow parsing and filetest/stat reassociation for CPANPLUS' `BUILD_PL->(...)` and `MAKEFILE->(...)` patterns.
+- Added regression coverage in [`subroutine.t`](../../src/test/resources/unit/subroutine.t) for strict bareword coderef calls and unary-operator reassociation.
+- Fixed `version` numification/normalization for dotted `v` versions and decimal versions.
+- Added regression coverage in [`version_numify.t`](../../src/test/resources/unit/version_numify.t).
+- Fixed PerlOnJava MakeMaker reruns after `blib/lib` exists so stale staged files are not copied onto themselves.
+- Added regression coverage in [`makemaker_stale_blib_source.t`](../../src/test/resources/unit/makemaker_stale_blib_source.t).
+- Verified `Object::Accessor` upstream suite passes: `Files=7, Tests=155, Result: PASS`.
+- Verified `./jcpan -t CPANPLUS` passes: `Files=20, Tests=1751, Result: PASS`.
 - Verified `make` passes.
 
 ## Acceptance
 
 ```bash
 timeout 60 ./jperl src/test/resources/unit/loop_label_bareword_constant.t
 timeout 60 ./jperl -I$CPANPLUS_DIR/inc/bundle -I$CPANPLUS_DIR/lib -e 'require CPANPLUS::Config; print "ok\n"'
-timeout 600 ./jcpan -t CPANPLUS
+timeout 1200 ./jcpan -t CPANPLUS
 make
 ```
 
 Before running the full `jcpan -t CPANPLUS` acceptance, make sure no local CPANPLUS distropref is masking the dependency path. A previous investigation generated `/Users/fglock/.perlonjava/cpan/prefs/CPANPLUS.yml`; move it aside or use an isolated CPAN home before judging dependency discovery.
 
 ## Next Steps
 
-1. Reduce `Object::Accessor`'s `t/03_Object-Accessor-local.t` failure. The failing construct is scoped attribute restore via `$Object->$Acc( $0 => \my $temp )`; PerlOnJava restores `$0` instead of the previous `$$` value when `$temp` leaves scope.
-2. Compare the reduced `Object::Accessor` case with system Perl and both PerlOnJava backends. Likely areas are `local`/scope cleanup, weak/DESTROY-like cleanup behavior around temporary references, or assignment to lexical references passed as arguments.
-3. Add a minimal unit regression for the runtime behavior before changing CPAN module prefs or overlays.
-4. Re-run `timeout 600 ./jcpan -t Object::Accessor` after the runtime fix, then re-run `timeout 1200 ./jcpan -t CPANPLUS`.
-5. Inspect the generated `Makefile`, `MYMETA.yml`, and CPAN log to verify `PREREQ_PM` includes the CPANPLUS runtime dependency set from `CPANPLUS::Selfupdate`.
-6. When CPANPLUS tests are passing or have documented non-runtime blockers, update this document with the final test count and remaining skips/failures.
+1. Reduce the non-fatal `File::Copy.pm line 303` warning from CPANPLUS' own suite. It appears to come from numeric conversion of `$!` or `$^E` after a failed move fallback, but it does not currently fail CPANPLUS.
+2. Re-run `timeout 1200 ./jcpan -t CPANPLUS` from a fresh or isolated CPAN home before merging if cache independence is required.
+3. Audit whether MakeMaker still needs to discover installable files from `blib/lib`; if it does, keep the new no-self-staging behavior as the regression guard.
+4. Keep CPANPLUS as a regression target when touching `Archive::Extract`, `Object::Accessor`, `ExtUtils::MakeMaker`, parser precedence, or `version`.
 
 ## Open Questions
 
-- Is the `Object::Accessor` failure a generic PerlOnJava scope-cleanup bug or specific to the module's accessor implementation?
-- After `Object::Accessor` installs, do CPANPLUS' own tests expose runtime failures beyond dependency loading?
+- Does the `File::Copy` warning reveal a generic `$!` / `$^E` numeric conversion difference when the error variables are unset?
+- Are there CPAN distributions that intentionally rely on MakeMaker installing files that only exist under `blib/lib` after configure/build, and should that path be modeled more explicitly?

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

@@ -191,6 +191,15 @@ public static Node parseInfixOperation(Parser parser, Node left, int precedence)
                     case "(":
                         TokenUtils.consume(parser);
                         right = new ListNode(ListParser.parseList(parser, ")", 0), parser.tokenIndex);
+                        if (left instanceof OperatorNode op && isArrowReassociatingUnaryOperator(op.operator)) {
+                            Node arrowLeft = coderefArrowLeft(op.operand);
+                            BinaryOperatorNode arrowCall = new BinaryOperatorNode(token.text,
+                                    arrowLeft,
+                                    right,
+                                    parser.tokenIndex);
+                            return new OperatorNode(op.operator, arrowCall, op.getIndex());
+                        }
+                        left = coderefArrowLeft(left);
                         return new BinaryOperatorNode(token.text, left, right, parser.tokenIndex);
                     case "**":
                         // Postfix GLOB dereference: $ref->**
@@ -630,4 +639,23 @@ private static void checkMyInFalseConditional(String operator, Node left, Node r
             }
         }
     }
+
+    private static Node coderefArrowLeft(Node left) {
+        if (left instanceof IdentifierNode) {
+            OperatorNode subRef = new OperatorNode("&", left, left.getIndex());
+            return new BinaryOperatorNode("(",
+                    subRef,
+                    new ListNode(left.getIndex()),
+                    left.getIndex());
+        }
+        return left;
+    }
+
+    private static boolean isArrowReassociatingUnaryOperator(String operator) {
+        if (operator == null) return false;
+        if (operator.equals("stat") || operator.equals("lstat")) return true;
+        return operator.length() == 2
+                && operator.charAt(0) == '-'
+                && "rwxoRWXOezsfdlpSbctugkTBMAC".indexOf(operator.charAt(1)) >= 0;
+    }
 }

src/main/java/org/perlonjava/runtime/operators/VersionHelper.java

@@ -336,6 +336,9 @@ public static String normalizeVersion(RuntimeScalar wantVersion) {
                 if (minor.length() > 3) {
                     minor = minor.substring(0, 3);
                 }
+                while (patch.length() < 3) {
+                    patch = patch + "0";
+                }
                 if (patch.length() > 3) {
                     patch = patch.substring(0, 3);
                 }

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

@@ -173,12 +173,6 @@ else if (versionStr.type == VSTRING) {
                 // Perl 5 treats these as v-strings with is_qv=true
                 isVString = true;
                 version = "v" + version;
-            } else if (dotCount == 1 && version.length() < 4) {
-                // If exactly one dot and short, prepend "v" for internal processing
-                // but keep the original for stringify() and qv flag
-                version = "v" + version;
-                // Note: originalVersionStr stays as the user's input (e.g., "1.0")
-                // Note: isVString remains false - this is a decimal version
             }
         }
 
@@ -192,7 +186,7 @@ else if (versionStr.type == VSTRING) {
             versionObj.put("qv", getScalarBoolean(isVString));
 
             // Parse components
-            String normalized = VersionHelper.normalizeVersion(new RuntimeScalar(version));
+            String normalized = normalizeDottedVersion(version);
             versionObj.put("version", new RuntimeScalar(normalized));
         } else {
             // Decimal format
@@ -216,6 +210,18 @@ else if (versionStr.type == VSTRING) {
         return blessed.getList();
     }
 
+    private static String normalizeDottedVersion(String version) {
+        String normalized = version.startsWith("v") ? version.substring(1) : version;
+        normalized = normalized.replace("_", "");
+        String[] parts = normalized.split("\\.");
+        StringBuilder dotted = new StringBuilder();
+        for (int i = 0; i < parts.length; i++) {
+            if (i > 0) dotted.append(".");
+            dotted.append(Integer.parseInt(parts[i]));
+        }
+        return dotted.toString();
+    }
+
     /**
      * Creates a dotted-decimal version object.
      * This is a method that expects to be called as version->declare()
@@ -263,6 +269,11 @@ public static RuntimeList numify(RuntimeArray args, int ctx) {
         RuntimeHash versionObj = self.hashDeref();
 
         String version = versionObj.get("version").toString();
+        if (!versionObj.get("qv").getBoolean()) {
+            String original = versionObj.get("original").toString().replace("_", "");
+            return new RuntimeScalar(numifyDecimalVersion(original)).getList();
+        }
+
         String[] parts = version.split("\\.");
 
         if (parts.length == 0) {
@@ -285,6 +296,32 @@ public static RuntimeList numify(RuntimeArray args, int ctx) {
         return new RuntimeScalar(numified.toString()).getList();
     }
 
+    private static String numifyDecimalVersion(String version) {
+        String clean = version.trim();
+        if (clean.startsWith("v")) {
+            clean = clean.substring(1);
+        }
+        int dot = clean.indexOf('.');
+        if (dot < 0) {
+            return clean + ".000";
+        }
+
+        String major = clean.substring(0, dot);
+        String decimal = clean.substring(dot + 1);
+        if (major.isEmpty()) {
+            major = "0";
+        }
+        if (decimal.isEmpty()) {
+            decimal = "0";
+        }
+        int width = ((decimal.length() + 2) / 3) * 3;
+        StringBuilder padded = new StringBuilder(decimal);
+        while (padded.length() < width) {
+            padded.append("0");
+        }
+        return major + "." + padded;
+    }
+
     /**
      * Returns the normalized dotted-decimal form with leading v.
      */

src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeCode.java

@@ -746,6 +746,11 @@ public void releaseCaptures() {
                     // Sub::Defer/Moo's %DEFERRED and %QUOTED weak ref tables.
                     // The JVM GC handles truly-dead unblessed containers eventually.
                     if (s.scopeExited) {
+                        if (s.type == RuntimeScalarType.TIED_SCALAR
+                                && s.value instanceof TiedVariableBase tiedVariable) {
+                            tiedVariable.releaseTiedObject();
+                            continue;
+                        }
                         if ((s.type & RuntimeScalarType.REFERENCE_BIT) != 0
                                 && s.value instanceof RuntimeBase rb
                                 && rb.blessId != 0) {

src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeScalar.java

@@ -2712,7 +2712,8 @@ public static void scopeExitCleanup(RuntimeScalar scalar) {
         // - captureCount=0 → capture handling branch not taken
         // - ioOwner=false → IO fd recycling branch not taken
         if (!scalar.refCountOwned && scalar.captureCount == 0 && !scalar.ioOwner
-                && !scalar.ownsScalarReferenceContents) {
+                && !scalar.ownsScalarReferenceContents
+                && scalar.type != RuntimeScalarType.TIED_SCALAR) {
             // Special case: CODE refs with unreleased captures that were never
             // stored via set() (e.g., anonymous subs passed directly as arguments).
             // These have refCount=0 (from makeCodeObject) and refCountOwned=false
@@ -2812,6 +2813,12 @@ public static void scopeExitCleanup(RuntimeScalar scalar) {
         // Captures are properly released when the CODE ref is overwritten
         // (via setLarge) or undef'd (via undefine).
 
+        if (scalar.type == RuntimeScalarType.TIED_SCALAR
+                && scalar.value instanceof TiedVariableBase tiedVariable) {
+            tiedVariable.releaseTiedObject();
+            return;
+        }
+
         // Existing: IO fd recycling for anonymous filehandle globs
         if (scalar.ioOwner && scalar.type == GLOBREFERENCE
                 && scalar.value instanceof RuntimeGlob glob

src/main/java/org/perlonjava/runtime/runtimetypes/TiedVariableBase.java

@@ -25,6 +25,8 @@ public abstract class TiedVariableBase extends RuntimeBaseProxy {
      */
     protected final String tiedPackage;
 
+    private boolean tiedObjectReleased = false;
+
     /**
      * Creates a new TiedVariableBase instance.
      *
@@ -207,6 +209,8 @@ public String getTiedPackage() {
      * Called by untie() after UNTIE has been dispatched.
      */
     public void releaseTiedObject() {
+        if (tiedObjectReleased) return;
+        tiedObjectReleased = true;
         if ((self.type & RuntimeScalarType.REFERENCE_BIT) != 0
                 && self.value instanceof RuntimeBase base) {
             if (base.refCount > 0 && --base.refCount == 0) {
@@ -216,4 +220,3 @@ public void releaseTiedObject() {
         }
     }
 }
-

src/main/perl/lib/ExtUtils/MakeMaker.pm

@@ -282,26 +282,32 @@ sub _install_pure_perl {
         # Some modules like Image::ExifTool use .pl files loaded via require,
         # .dat files for data (e.g., Geolocation.dat), and Mozilla::CA uses .pem
         my $installable_re = qr/\.(?:pm|pl|pod|dat|json|ya?ml|xml|txt|cfg|conf|ini|pem)$/i;
+        my %pm_rel_seen;
         if (-d 'lib') {
             find({
                 wanted => sub {
                     return unless -f && /$installable_re/;
                     my $src = $File::Find::name;
                     (my $rel = $src) =~ s{^lib/}{};
                     $pm{$src} = File::Spec->catfile($INSTALL_BASE, $rel);
+                    $pm_rel_seen{$rel} = 1;
                 },
                 no_chdir => 1,
             }, 'lib');
         }
 
-        # Also check for blib/lib (after a build)
+        # Also check for blib/lib (after a build).  Prefer real sources
+        # under lib/ when both exist; rerunning Makefile.PL after a build
+        # must not turn blib/lib files into self-copying pm_to_blib sources.
         if (-d 'blib/lib') {
             find({
                 wanted => sub {
                     return unless -f && /$installable_re/;
                     my $src = $File::Find::name;
                     (my $rel = $src) =~ s{^blib/lib/}{};
+                    return if $pm_rel_seen{$rel};
                     $pm{$src} = File::Spec->catfile($INSTALL_BASE, $rel);
+                    $pm_rel_seen{$rel} = 1;
                 },
                 no_chdir => 1,
             }, 'blib/lib');
@@ -670,7 +676,7 @@ sub _create_install_makefile {
             # Flat layout: compute from dest path relative to INSTALL_BASE
             ($blib_rel = $dest) =~ s{^\Q$INSTALL_BASE\E/?}{};
         }
-        if ($blib_rel) {
+        if ($blib_rel && $src !~ m{^blib/lib/}) {
             my $blib_dest = "\$(INST_LIB)/$blib_rel";
             my $blib_dir = dirname($blib_dest);
             unless ($blib_dirs_seen{$blib_dir}++) {
@@ -716,7 +722,7 @@ sub _create_install_makefile {
     my $blib_script_cmds_str = join("\n", @blib_script_cmds) || "\t\@true";
     my $file_count = scalar(keys %$pm) + scalar(keys %$scripts);
 
-    my $pm_deps_str = join(' ', sort keys %$pm);
+    my $pm_deps_str = join(' ', sort grep { $_ !~ m{^blib/lib/} } keys %$pm);
     $pm_deps_str = " $pm_deps_str" if length $pm_deps_str;
 
     # Make pm_to_blib target conditional - if no .pm files, make it a no-op