Remove some slop from the interface rust <-> java

Author: slinkydeveloper

sdk-core/src/main/java23/dev/restate/sdk/core/statemachine/ffm/FfmEncoding.java

@@ -12,7 +12,6 @@
 import dev.restate.sdk.common.RetryPolicy;
 import dev.restate.sdk.common.TerminalException;
 import dev.restate.sdk.core.statemachine.StateMachine;
-import dev.restate.sdk.core.statemachine.ffm.generated.NonEmptyValueAbi;
 import dev.restate.sdk.core.statemachine.ffm.generated.SharedCoreNative;
 import dev.restate.sdk.core.statemachine.ffm.generated.Slice;
 import dev.restate.sdk.core.statemachine.ffm.generated.TargetAbi;
@@ -86,6 +85,11 @@ static long len(MemorySegment seg) {
     return seg.byteSize();
   }
 
+  /** Allocates a result {@link Slice} struct out-param (for calls that write a bare Slice). */
+  static MemorySegment allocateSliceStruct(SegmentAllocator alloc) {
+    return Slice.allocate(alloc);
+  }
+
   // -------------------------------------------------------------------------
   // Result Slice reading (outputs: owned by Rust, must be freed)
   // -------------------------------------------------------------------------
@@ -136,22 +140,10 @@ static dev.restate.common.Slice wrapOwnedSlice(MemorySegment sliceStruct) {
     return new MemorySegmentSlice(seg);
   }
 
-  /**
-   * Releases an owned result {@link Slice} we are not consuming (e.g. the unused {@code value}/
-   * {@code extra} arm of a notification). No-op for the null/empty slice.
-   */
-  static void freeSlice(MemorySegment sliceStruct) {
-    MemorySegment ptr = Slice.ptr(sliceStruct);
-    long len = Slice.len(sliceStruct);
-    if (ptr.address() != 0 && len != 0) {
-      SharedCoreNative.free_buffer(ptr, len);
-    }
-  }
-
   private static final byte[] EMPTY_BYTES = new byte[0];
 
   // -------------------------------------------------------------------------
-  // TargetAbi & NonEmptyValueAbi (passed by value as a MemorySegment)
+  // TargetAbi (passed by value as a MemorySegment)
   // -------------------------------------------------------------------------
 
   /**
@@ -189,30 +181,6 @@ static MemorySegment buildTarget(
     return t;
   }
 
-  /** Builds a success-valued {@link NonEmptyValueAbi} struct, copying {@code value} zero-hop. */
-  static MemorySegment buildSuccessValue(SegmentAllocator alloc, dev.restate.common.Slice value) {
-    MemorySegment v = NonEmptyValueAbi.allocate(alloc);
-    NonEmptyValueAbi.is_failure(v, 0);
-    MemorySegment val = allocateSlice(alloc, value);
-    NonEmptyValueAbi.value_ptr(v, val);
-    NonEmptyValueAbi.value_len(v, len(val));
-    NonEmptyValueAbi.failure_ptr(v, MemorySegment.NULL);
-    NonEmptyValueAbi.failure_len(v, 0L);
-    return v;
-  }
-
-  /** Builds a failure-valued {@link NonEmptyValueAbi} struct. */
-  static MemorySegment buildFailureValue(SegmentAllocator alloc, TerminalException failure) {
-    MemorySegment v = NonEmptyValueAbi.allocate(alloc);
-    NonEmptyValueAbi.is_failure(v, 1);
-    NonEmptyValueAbi.value_ptr(v, MemorySegment.NULL);
-    NonEmptyValueAbi.value_len(v, 0L);
-    MemorySegment fail = allocateBytes(alloc, encodeFailure(failure));
-    NonEmptyValueAbi.failure_ptr(v, fail);
-    NonEmptyValueAbi.failure_len(v, len(fail));
-    return v;
-  }
-
   // -------------------------------------------------------------------------
   // Blob encoders (little-endian, matching the Rust decode_* functions)
   // -------------------------------------------------------------------------
@@ -307,38 +275,20 @@ private static void encodeFailureInto(LeBuffer buf, TerminalException failure) {
   }
 
   /**
-   * Encodes the {@code propose_run_completion} params buffer: {@code u64 attempt_duration_millis}
-   * followed by, for a retryable failure, {@code u16 code, str message, u8 has_stacktrace, [str
-   * stacktrace]}; for a terminal failure, the {@code decode_failure} layout; then the retry-policy
-   * blob. The leading {@code value} (run success bytes) is passed separately.
-   *
-   * @param resultKind 0 success, 1 terminal failure, 2 retryable failure.
+   * Encodes the {@code propose_run_completion_retryable_failure} params buffer: {@code u16 code,
+   * str message, u8 has_stacktrace, [str stacktrace]}, then the retry-policy blob. The attempt
+   * duration is passed as a direct arg.
    */
-  static byte[] encodeRunCompletionParams(
-      int resultKind,
-      long attemptDurationMillis,
-      @Nullable TerminalException terminalFailure,
-      @Nullable String retryableMessage,
-      @Nullable String retryableStacktrace,
-      @Nullable RetryPolicy retryPolicy) {
+  static byte[] encodeRetryableRunParams(
+      String message, @Nullable String stacktrace, @Nullable RetryPolicy retryPolicy) {
     LeBuffer buf = new LeBuffer();
-    buf.putU64(attemptDurationMillis);
-    switch (resultKind) {
-      case 0 -> {
-        // success: no failure payload in params
-      }
-      case 1 -> encodeFailureInto(buf, terminalFailure);
-      default -> {
-        // retryable failure
-        buf.putU16(500);
-        buf.putStr(retryableMessage != null ? retryableMessage : "");
-        if (retryableStacktrace != null) {
-          buf.putU8(1);
-          buf.putStr(retryableStacktrace);
-        } else {
-          buf.putU8(0);
-        }
-      }
+    buf.putU16(500);
+    buf.putStr(message != null ? message : "");
+    if (stacktrace != null) {
+      buf.putU8(1);
+      buf.putStr(stacktrace);
+    } else {
+      buf.putU8(0);
     }
     encodeRetryPolicyInto(buf, retryPolicy);
     return buf.toByteArray();