[JExtract] Import any C compatible closures #253

rintaro · 2025-06-06T23:34:32Z

Generalized closure parameter import, part 1.

Start with C-compatible closures which don't need any conversions.

For this Swift API:

public func callMeMore(
  callback: (UnsafeRawPointer, Float) -> Int,
  fn: () -> ()
)

The binding descriptor class has additional nested classes that describes the lowered functional interface and the method handle for each closure parameter.

/**
 * {@snippet lang=c :
 * void swiftjava___FakeModule_callMeMore_callback_fn(ptrdiff_t (*callback)(const void *, float), void (*fn)(void))
 * }
 */
private static class swiftjava___FakeModule_callMeMore_callback_fn {
  private static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
    /* callback: */SwiftValueLayout.SWIFT_POINTER,
    /* fn: */SwiftValueLayout.SWIFT_POINTER
  );
  private static final MemorySegment ADDR =
    __FakeModule.findOrThrow("swiftjava___FakeModule_callMeMore_callback_fn");
  private static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC);
  public static void call(java.lang.foreign.MemorySegment callback, java.lang.foreign.MemorySegment fn) {
    try {
      if (SwiftKit.TRACE_DOWNCALLS) {
        SwiftKit.traceDowncall(callback, fn);
      }
      HANDLE.invokeExact(callback, fn);
    } catch (Throwable ex$) {
      throw new AssertionError("should not reach here", ex$);
    }
  }
  /**
   * {snippet lang=c :
   * ptrdiff_t (*)(const void *, float)
   * }
   */
  private static class $callback {
    public interface Function {
      long apply(java.lang.foreign.MemorySegment _0, float _1);
    }
    private static final FunctionDescriptor DESC = FunctionDescriptor.of(
      /* -> */SwiftValueLayout.SWIFT_INT,
      /* _0: */SwiftValueLayout.SWIFT_POINTER,
      /* _1: */SwiftValueLayout.SWIFT_FLOAT
    );
    private static final MethodHandle HANDLE = SwiftKit.upcallHandle(Function.class, "apply", DESC);
    private static MemorySegment toUpcallStub(Function fi, Arena arena) {
      return Linker.nativeLinker().upcallStub(HANDLE.bindTo(fi), DESC, arena);
    }
  }
  /**
   * {snippet lang=c :
   * void (*)(void)
   * }
   */
  private static class $fn {
    public interface Function {
      void apply();
    }
    private static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid();
    private static final MethodHandle HANDLE = SwiftKit.upcallHandle(Function.class, "apply", DESC);
    private static MemorySegment toUpcallStub(Function fi, Arena arena) {
      return Linker.nativeLinker().upcallStub(HANDLE.bindTo(fi), DESC, arena);
    }
  }
}

Additional nested class containing the "wrapper" functional interfaces:

public static class callMeMore {
  @FunctionalInterface
  public interface callback extends swiftjava___FakeModule_callMeMore_callback_fn.$callback.Function {}
  private static MemorySegment $toUpcallStub(callback fi, Arena arena) {
    return swiftjava___FakeModule_callMeMore_callback_fn.$callback.toUpcallStub(fi, arena);
  }
  @FunctionalInterface
  public interface fn extends swiftjava___FakeModule_callMeMore_callback_fn.$fn.Function {}
  private static MemorySegment $toUpcallStub(fn fi, Arena arena) {
    return swiftjava___FakeModule_callMeMore_callback_fn.$fn.toUpcallStub(fi, arena);
  }
}

The wrapper method converts the "wrapper" lambda to the lowered lambda, and allocate the upcall stub by calling .toUpcallStub(arena$)

/**
 * Downcall to Swift:
 * {@snippet lang=swift :
 * public func callMeMore(callback: (UnsafeRawPointer, Float) -> Int, fn: () -> ())
 * }
 */
public static void callMeMore(callMeMore.callback callback, callMeMore.fn fn) {
  try(var arena$ = Arena.ofConfined()) {
    swiftjava___FakeModule_callMeMore_callback_fn.call(callMeMore.$toUpcallStub(callback, arena$), callMeMore.$toUpcallStub(fn, arena$));
  }
}

rintaro · 2025-06-07T21:49:00Z