js-port: merge throwing instructions into one case in handler-free methods

Per-suspension-boundary emission step: in methods with no exception
wrapper (~91% of methods), a throwing instruction (method call, field/
array access, NEW, ...) no longer forces its own case + pc=N+1; break;
tail. That break+redispatch existed only so exception unwind could
resume at the right frame pc; with no handler wrapper a thrown error
propagates straight out of the generator and yield* resumes inline via
delegation, so it's pure overhead.

- computeJumpTargets takes forceThrowingTargets; only adds the post-throw
  i+1 target when the method has an exception wrapper.
- mergeThrowing (gated !hasTryCatch, kill switch parparvm.js.merge.throwing.off)
  extends the safe-strip to throwing ops.

Modest on its own (~0.21MB; case scaffolding is only ~7% of the bundle --
the bulk is per-bytecode statement emission, addressed by the
expression-folding work that follows) but a correct foundational step.
node --check clean; CI JS screenshot suite is the functional gate.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptMethodGenerator.java

@@ -2205,8 +2205,17 @@ private static void appendMethodImpl(StringBuilder out, StringBuilder regs, Byte
         // shape. Flip via the JVM system property
         // ``parparvm.js.merge.off``.
         boolean mergeCases = System.getProperty("parparvm.js.merge.off") == null;
+        // When the method has no exception-dispatch wrapper (no try/catch),
+        // throwing instructions (method calls etc.) need neither a pc update
+        // nor a case boundary -- a thrown error propagates straight out of the
+        // generator and yield* resumes inline. So we can merge them into the
+        // same case, collapsing the per-call ``pc=N+1; break;`` + ``case N+1:``
+        // pairs that dominate the emitted size. Gated off by
+        // ``parparvm.js.merge.throwing.off`` as a kill switch.
+        boolean mergeThrowing = mergeCases && !hasTryCatch
+                && System.getProperty("parparvm.js.merge.throwing.off") == null;
         java.util.Set<Integer> jumpTargets = mergeCases
-                ? computeJumpTargets(instructions, labelToIndex)
+                ? computeJumpTargets(instructions, labelToIndex, !mergeThrowing)
                 : java.util.Collections.<Integer>emptySet();
         boolean blockOpen = false;
         // True when the previous emission was a bare ``case N:`` label
@@ -2271,7 +2280,10 @@ private static void appendMethodImpl(StringBuilder out, StringBuilder regs, Byte
             // access), conflating its pc with the next is harmless.
             boolean nextIsNewBlock = i + 1 >= instructions.size() || jumpTargets.contains(i + 1);
             boolean isTerminal = isTerminatingInstruction(instruction);
-            boolean strip = !isTerminal && !nextIsNewBlock && isNonThrowingInstruction(instruction);
+            // In a wrapper-free method (mergeThrowing) a throwing op needs no
+            // pc/break either -- merge it straight-line like a non-throwing op.
+            boolean strip = !isTerminal && !nextIsNewBlock
+                    && (isNonThrowingInstruction(instruction) || mergeThrowing);
             if (isTarget || pendingBareLabel) {
                 if (blockOpen) {
                     out.append("      }\n");
@@ -3737,7 +3749,8 @@ private static boolean isPcSkippableNoOp(Instruction instruction) {
      * label is purely decorative and a preceding ``pc = i; break;``
      * may be omitted.
      */
-    private static java.util.Set<Integer> computeJumpTargets(List<Instruction> instructions, Map<Label, Integer> labelToIndex) {
+    private static java.util.Set<Integer> computeJumpTargets(List<Instruction> instructions, Map<Label, Integer> labelToIndex,
+                                                              boolean forceThrowingTargets) {
         java.util.Set<Integer> targets = new java.util.HashSet<Integer>();
         for (int i = 0; i < instructions.size(); i++) {
             Instruction instr = instructions.get(i);
@@ -3808,7 +3821,17 @@ private static java.util.Set<Integer> computeJumpTargets(List<Instruction> instr
             // and drops the instruction there — producing a switch
             // whose body targets a missing case label and silently
             // falls through to ``default:return``.
-            if (!(instr instanceof Jump) && !(instr instanceof SwitchInstruction)
+            //
+            // This pc-jump exists ONLY so exception unwind can resume at
+            // the right pc (findExceptionHandler reads the frame pc). In a
+            // method with NO exception-dispatch wrapper a thrown error just
+            // propagates out of the generator and the break+re-dispatch is
+            // pure overhead, so the caller passes forceThrowingTargets=false
+            // and the throwing op merges straight-line into the same case
+            // (its tail is safe-stripped). yield* method calls resume inline
+            // via generator delegation, so no case label is needed there.
+            if (forceThrowingTargets
+                    && !(instr instanceof Jump) && !(instr instanceof SwitchInstruction)
                     && !(instr instanceof LabelInstruction) && !(instr instanceof LineNumber)
                     && !(instr instanceof LocalVariable) && !(instr instanceof TryCatch)
                     && !isTerminatingInstruction(instr) && !isNonThrowingInstruction(instr)