[JExtract] Import any C compatible closures

[rintaro]

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]

Maybe it's better to make a static func outside the interface, so it won't leak toUpcallStub method?

private static func $toUpcallStub(\(functionType.name) fi, Arena arena) { ... }

[ktoso]

Agreed, that'll be nicer. In order keep the interface without default impls so users aren't confused what those funcs are about.

Most importantly we want only one non-default method, but it'll be nice to have those not have any defaulted ones either

[ktoso]

That's pretty good structure, I like it 👍

[ktoso]

Include the name and cType in the crash message?

[ktoso]

Suggested change

	public interface Function {
	@FunctionalInterface
	public interface Function {

This isn't "required" in order for an interface to be a functional interface, but it's a good pattern.

What this does is that if we accidentally added one more non-default method to the interface then the java compiler would then error about it. That's important because we want callers to use the () -> {} lambda syntax rather than spell out the explicit types

[ktoso]

Agreed, that'll be nicer. In order keep the interface without default impls so users aren't confused what those funcs are about.

Most importantly we want only one non-default method, but it'll be nice to have those not have any defaulted ones either

[ktoso]

If always unreachable, should we make this fatal error and remove the code below it? It's not like we'll be testing if that code is correct after all right?

[rintaro]

I'd prefer to keep the code below for now. It illustrates how things would work for non-C-compat closures, and it's also something I plan to implement pretty soon.

[ktoso]

Suggested change

	/// Function interfaces (i.e. lambda types) required for the Java method.
	/// Function interfaces (i.e. functional interface types) required for the Java method.

Nitpick but there's no real lambda types in java, just functional interface types which happen to get implemented with a lambda expression

[ktoso]

Is trivial the right word? or are those c-convention compatible or something like that?

[ktoso]

Suggested change

	/// Translate Swift closure type to Java function interface.
	/// Translate Swift closure type to Java functional interface.

minor wording nitpick

[ktoso]

Sorry about the conflicts 🙏 No more big "move everything" incoming now anymore I think after the big command refactor.

[rintaro]

(holding off merging until #249 is merged)

[ktoso]

#249 is merged so this needs a rebase and can be merged at will! 👍