From 8671b0d185bf5088e83c61d1f48b85b1f4e63740 Mon Sep 17 00:00:00 2001 From: Algent Date: Fri, 4 Sep 2026 17:38:02 +0200 Subject: [PATCH] refactor: port StackAnalyser constant types to Java --- JAVA_MIGRATION.md | 5 ++-- JAVA_MIGRATION_HANDOFF.md | 29 ++++++++++--------- docs/migration/HISTORY.md | 27 +++++++++++++++++ .../multipart/asm/StackAnalyser.scala | 14 +-------- .../multipart/asm/StackAnalyserLogic.java | 16 ++++++++++ 5 files changed, 62 insertions(+), 29 deletions(-) diff --git a/JAVA_MIGRATION.md b/JAVA_MIGRATION.md index 68d922f..3db835b 100644 --- a/JAVA_MIGRATION.md +++ b/JAVA_MIGRATION.md @@ -26,8 +26,9 @@ No trustworthy tool will produce a maintainable Java port automatically. A decom Work continues on `algent/java`. The low-coupling queue, core part/tile types, registries, handlers, factories, placement/render helpers, both generators and all built-in tile traits are Java. Common, face, corner, edge, post, hollow and occlusion microblock traits retain Scala inheritance/state/super declarations over Java behavior, -including client bounds/mask updates. The next bounded target is `StackAnalyser` constructor initialization; -retain the coordinated Scala class/companion/models and characterize initialization before extraction. +including client bounds/mask updates. `StackAnalyser` initialization and constant-type classification delegate to +Java; retain its coordinated Scala class/companion/models. The next bounded candidate is +`ASMMixinCompiler.FieldMixin.accessName`, with characterization before extraction. Java-trait rewriting and compiler startup also delegate to Java helpers. Abstract Java mixins and Java-path side-only filtering are complete; multiple Scala-trait inheritance still needs its metadata. Retain trait state/accessor/super bridges and the compiler/signature/analyser model shells. diff --git a/JAVA_MIGRATION_HANDOFF.md b/JAVA_MIGRATION_HANDOFF.md index 3586bc1..69b4716 100644 --- a/JAVA_MIGRATION_HANDOFF.md +++ b/JAVA_MIGRATION_HANDOFF.md @@ -16,32 +16,32 @@ migration checkout; `codex/tile-compatibility-fixes` was deleted after its fixes ## Current state and next target -**407 plain-JVM tests and 237 Java 8 Forge tests pass, with zero failures/errors/skips.** Sources total **224 Java -files and 9 Scala files / 779 nonblank Scala lines**. The packaged inventory has 444 classes. +**415 plain-JVM tests and 237 Java 8 Forge tests pass, with zero failures/errors/skips.** Sources total **224 Java +files and 9 Scala files / 767 nonblank Scala lines**. The packaged inventory has 444 classes. Review follow-up: restored packet-scheduler callback mutation behavior with the original Scala hash-map traversal, virtual tile accessor dispatch throughout `TMultiPart`, and null-safe equality for scheduled-tick deduplication. Six JVM and two Forge regression cases cover the fixes. Callable signatures remain unchanged; the packet traversal callback adds one anonymous class. See the latest history entries for the individual fixes and validation. -Latest bounded target: `StackAnalyser` delegates constructor control flow to `StackAnalyserLogic.initialize`. -Nine characterization tests were committed first as `929a704`. They pin constructor argument use, virtual -`pushL`/`setL` ordering, descriptor mutation/parsing failures, wide slots, partial publication and handler behavior. -Scala retains the class/companion/models, field initialization, default-argument bridges and a handler callback -that preserves its mangled virtual map accessor. Handler traversal retains Scala-backed buffers' `foreach` dispatch. -All 407 frozen JVM consumers pass; checks preserve 443 retained class/member APIs, all 17 ScalaSignature payloads, -3,727 unrelated method bodies and all 116 generated dumps. The obsolete parameter-loop closure disappears; -the handler callback changes only its compiler number. Evidence: `run/migration-stack-initialization-reference/`. +Latest bounded target: `StackAnalyser.Const.getType` delegates to `StackAnalyserLogic.constType`. +Eight characterization tests were committed first as `89f31e3`. They pin every boxed primitive, fresh null/String +types, unsupported values, repeated virtual `c` access and accessor/formatting failures. Success reads `c` once; +failure rereads it for the message without reclassifying the second value. Scala retains the complete case class, +companion, product/copy methods and serialization shape. All 415 frozen JVM consumers pass; checks preserve 443 +retained class/member APIs, all 17 ScalaSignature payloads, 3,731 unrelated method bodies and all 116 generated +dumps. Only the package-private helper method and its private string-concatenation helper are added. +Evidence: `run/migration-stack-const-reference/`. -**Next bounded candidate: `StackAnalyser.Const.getType`.** Characterize boxed constant classification, null/String -handling, unsupported-value formatting/failure and virtual `c` access before extracting to the existing helper. +**Next bounded candidate: `ASMMixinCompiler.FieldMixin.accessName`.** Characterize private-flag selection, owner +mangling, null handling and virtual accessor/failure ordering before extracting its body to an existing Java helper. Keep case-class/product/serialization shapes and simple model accessors. Broader shell replacement and opcode algorithm fixes remain separate work. The external ProjectRed Scala-trait fixture and ScalaSignature model bridges remain required. Actual client generation, GPU output and full-pack checks remain manual. The JVM Downgrader checkpoint now supports Java 21 method-body syntax in `StackAnalyserLogic` while retaining -Scala 2.11.5 on Java 8. The constructor extraction uses that existing build stage; it adds no build configuration +Scala 2.11.5 on Java 8. The constant-type extraction uses that existing build stage; it adds no build configuration or runtime dependencies. See `JVM_DOWNGRADER_HANDOFF.md` for the original 398-test integration checkpoint. Finish the remaining useful behavior extractions and define the retained compilation boundary before a broad modern-syntax pass. Removing every remaining Scala declaration still requires the documented consumer/ABI work. @@ -227,7 +227,8 @@ three options: leave it in Scala, invent a Java type to hold its members, or inl Scala either way; it is a method on `RenderBlocks` and Java needs the parentheses. It fails at compile time rather than silently, but expect it in every remaining renderer conversion. -**Java 8 target.** No `List.of`, no `var`, no switch expressions in main or test sources. +**Java 8 target.** Joint main sources and tests cannot use `List.of`, `var` or switch expressions. The scoped +`StackAnalyserLogic` stage supports verified Java 21 method bodies; its packaged output must still target Java 8. **Two test classes sharing global registry state** must guard their registrations, and the registries' error paths call a logger that is null until `preInit`, so they cannot run headless at all. diff --git a/docs/migration/HISTORY.md b/docs/migration/HISTORY.md index 8c8f54f..b639107 100644 --- a/docs/migration/HISTORY.md +++ b/docs/migration/HISTORY.md @@ -1339,3 +1339,30 @@ differences belong in the [divergence ledger](../../JAVA_MIGRATION_DIVERGENCES.m Scala files / 779 nonblank lines. Next bounded candidate: `StackAnalyser.Const.getType`, preserving its case-class, product and serialization contracts. The simple model getters and full Scala shell replacement remain separate from useful behavior extraction. + +### 2026-09-04 — StackAnalyser constant types + +- Committed eight JVM characterization cases first as `89f31e3`, against the untouched Scala `Const.getType`. + They cover all eight boxed primitive classes without numeric coercion, fresh object types for null and strings, + unsupported numbers/ASM types/unit/arrays/string-like objects, virtual accessor read counts, message formatting + and unwrapped accessor/formatting failures. The unsupported branch reads `c` a second time for its message; + even a supported second value is formatted without reclassification. A null-returning `toString` prints `null`. +- Extracted classification into the existing package-private `StackAnalyserLogic.constType`, using direct type + checks and a second virtual accessor call only for failures. Scala retains the entire case class, companion, + product/copy methods and serialization shape. The scoped modern Java build is reused without configuration or + dependency changes; the only extra compiler method handles the failure string concatenation. +- The build, formatting, checkstyle, frozen-consumer lane and Java 8 Forge tests pass, including verification from + a clean build after stopping the Gradle daemon: 415 JVM tests, 415 frozen JVM consumers and 237 Forge tests, with + zero failures/errors/skips. All 116 generated ASM dump names and hashes match. Both jars contain 444 Java 8 + classes, their five `@Mod` versions match their filenames, and both edited sources match the source jar. +- Preserved all 443 retained class/member APIs, all 17 ScalaSignature payloads and 3,731 unrelated method bodies. + The helper retains every previous member and adds only `constType` and its private synthetic concatenation + method. No class is added or removed, no JVM Downgrader runtime-stub reference is introduced, and there is no new + effective compatibility divergence. The consumer source scan found no direct `StackAnalyser` references. +- Baseline jar/sources, frozen compiled tests/resources, JVM/Forge reports, generated dumps, comparison tools and + build logs are saved under ignored `run/migration-stack-const-reference/`. Rerun `frozen-consumers.gradle` with + `VERSION` from `version.txt` to preserve the two existing frozen tests' inlined version assertions; ordinary final + builds still use the actual Git version. `verify.py`, `Compare.java` and `VerifyVersions.java` check the artifacts. +- Sources now total 224 Java files and nine Scala files / 767 nonblank lines. The next bounded candidate is + `ASMMixinCompiler.FieldMixin.accessName`: characterize private-flag selection, owner mangling, null behavior and + virtual accessor/failure ordering while retaining the case-class model. diff --git a/src/main/scala/codechicken/multipart/asm/StackAnalyser.scala b/src/main/scala/codechicken/multipart/asm/StackAnalyser.scala index 2831162..c7d05ca 100644 --- a/src/main/scala/codechicken/multipart/asm/StackAnalyser.scala +++ b/src/main/scala/codechicken/multipart/asm/StackAnalyser.scala @@ -29,19 +29,7 @@ object StackAnalyser { } case class Const(c: Any)(implicit insn: AbstractInsnNode) extends StackEntry { - def getType = c match { - case o: Byte => BYTE_TYPE - case o: Short => SHORT_TYPE - case o: Int => INT_TYPE - case o: Long => LONG_TYPE - case o: Float => FLOAT_TYPE - case o: Double => DOUBLE_TYPE - case o: Char => CHAR_TYPE - case o: Boolean => BOOLEAN_TYPE - case o: String => getObjectType("java/lang/String") - case null => getObjectType("java/lang/Object") - case _ => throw new IllegalArgumentException("Unknown const " + c) - } + def getType: Type = StackAnalyserLogic.constType(this) } case class Load(e: LocalEntry)(implicit insn: AbstractInsnNode) extends StackEntry { diff --git a/src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java b/src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java index be1b489..9328d94 100644 --- a/src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java +++ b/src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java @@ -54,6 +54,22 @@ final class StackAnalyserLogic { private StackAnalyserLogic() {} + static Type constType(Const constant) { + Object value = constant.c(); + if (value instanceof Byte) return BYTE_TYPE; + if (value instanceof Short) return SHORT_TYPE; + if (value instanceof Integer) return INT_TYPE; + if (value instanceof Long) return LONG_TYPE; + if (value instanceof Float) return FLOAT_TYPE; + if (value instanceof Double) return DOUBLE_TYPE; + if (value instanceof Character) return CHAR_TYPE; + if (value instanceof Boolean) return BOOLEAN_TYPE; + if (value instanceof String) return getObjectType("java/lang/String"); + if (value == null) return getObjectType("java/lang/Object"); + // The failure message rereads the virtual accessor after classification. + throw new IllegalArgumentException("Unknown const " + constant.c()); + } + static void initialize(StackAnalyser a, Type owner, MethodNode method, Function1> addHandler) { if ((method.access & ACC_STATIC) == 0) a.pushL(new This(owner));