work on upcall

Author: madsodgaard

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/Async.swift

@@ -15,7 +15,6 @@
 import SwiftJava
 
 public func asyncSum(i1: Int64, i2: Int64) async -> Int64 {
-  try? await Task.sleep(for: .milliseconds(500))
   return i1 + i2
 }
 
@@ -29,6 +28,11 @@ public func asyncCopy(myClass: MySwiftClass) async throws -> MySwiftClass {
   return new
 }
 
+public func asyncOptional(i: Int64) async throws -> Int64? {
+  try await Task.sleep(for: .milliseconds(100))
+  return i
+}
+
 public func asyncRunningSum() async -> Int64 {
     let totalSum = await withTaskGroup(of: Int64.self) { group in
         // 1. Add child tasks to the group

Samples/SwiftJavaExtractJNISampleApp/src/jmh/java/com/example/swift/AsyncBenchmark.java

@@ -20,21 +20,41 @@
 import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
 import org.swift.swiftkit.core.SwiftArena;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.OptionalInt;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
 @BenchmarkMode(Mode.AverageTime)
 @Warmup(iterations = 5, time = 200, timeUnit = TimeUnit.MILLISECONDS)
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
-@OutputTimeUnit(TimeUnit.SECONDS)
-@Fork(value = 3, jvmArgsAppend = { "--enable-native-access=ALL-UNNAMED" })
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+@Fork(value = 1, jvmArgsAppend = { "--enable-native-access=ALL-UNNAMED" })
 public class AsyncBenchmark {
+    /**
+     * Parameter for the number of parallel tasks to launch.
+     */
+    @Param({"100", "500", "1000"})
+    public int taskCount;
+
+    @Setup(Level.Trial)
+    public void beforeAll() {}
+
+    @TearDown(Level.Trial)
+    public void afterAll() {}
 
     @Benchmark
-    public long asyncSum() {
-        return MySwiftLibrary.asyncRunningSum().join();
+    public void asyncSum(Blackhole bh) {
+        CompletableFuture<Void>[] futures = new CompletableFuture[taskCount];
+
+        // Launch all tasks in parallel using supplyAsync on our custom executor
+        for (int i = 0; i < taskCount; i++) {
+            futures[i] = MySwiftLibrary.asyncSum(10, 5).thenAccept(bh::consume);
+        }
+
+        // Wait for all futures to complete.
+        CompletableFuture.allOf(futures).join();
     }
 }

Sources/JExtractSwiftLib/Convenience/JavaType+Extensions.swift

@@ -25,7 +25,7 @@ extension JavaType {
     case .long: return "J"
     case .float: return "F"
     case .double: return "D"
-    case .class(let package, let name):
+    case .class(let package, let name, _):
       let nameWithInnerClasses = name.replacingOccurrences(of: ".", with: "$")
       if let package {
         return "L\(package.replacingOccurrences(of: ".", with: "/"))/\(nameWithInnerClasses);"
@@ -112,26 +112,27 @@ extension JavaType {
     }
   }
 
-  var wrapperClassIfNeeded: JavaType {
+  /// Returns the boxed type, or self if the type is already a Java class.
+  var boxedType: JavaType {
     switch self {
     case .boolean:
-      return .class(package: nil, name: "Boolean")
-    case .byte(let parameterAnnotations):
-      return .class(package: nil, name: "Byte")
-    case .char(let parameterAnnotations):
-      return .class(package: nil, name: "Character")
-    case .short(let parameterAnnotations):
-      return .class(package: nil, name: "Short")
-    case .int(let parameterAnnotations):
-      return .class(package: nil, name: "Integer")
-    case .long(let parameterAnnotations):
-      return .class(package: nil, name: "Long")
+      return .class(package: "java.lang", name: "Boolean")
+    case .byte:
+      return .class(package: "java.lang", name: "Byte")
+    case .char:
+      return .class(package: "java.lang", name: "Character")
+    case .short:
+      return .class(package: "java.lang", name: "Short")
+    case .int:
+      return .class(package: "java.lang", name: "Integer")
+    case .long:
+      return .class(package: "java.lang", name: "Long")
     case .float:
-      return .class(package: nil, name: "Float")
+      return .class(package: "java.lang", name: "Float")
     case .double:
-      return .class(package: nil, name: "Double")
+      return .class(package: "java.lang", name: "Double")
     case .void:
-      return .class(package: nil, name: "Void")
+      return .class(package: "java.lang", name: "Void")
     default:
       return self
     }

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -453,7 +453,7 @@ extension FFMSwift2JavaGenerator {
   func renderMemoryLayoutValue(for javaType: JavaType) -> String {
     if let layout = ForeignValueLayout(javaType: javaType) {
       return layout.description
-    } else if case .class(package: _, name: let customClass) = javaType {
+    } else if case .class(package: _, name: let customClass, _) = javaType {
       return ForeignValueLayout(customType: customClass).description
     } else {
       fatalError("renderMemoryLayoutValue not supported for \(javaType)")

Sources/JExtractSwiftLib/ImportedDecls.swift

@@ -193,7 +193,7 @@ public final class ImportedFunc: ImportedDecl, CustomStringConvertible {
   }
 
   var isAsync: Bool {
-    self.functionSignature.effectSpecifiers.contains(.async)
+    self.functionSignature.isAsync
   }
 
   init(

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -522,7 +522,7 @@ extension JNISwift2JavaGenerator {
 
     // Indirect return receivers
     for outParameter in translatedFunctionSignature.resultType.outParameters {
-      printer.print("\(outParameter.type) \(outParameter.name) = \(outParameter.allocation.render());")
+      printer.print("\(outParameter.type) \(outParameter.name) = \(outParameter.allocation.render(type: outParameter.type));")
       arguments.append(outParameter.name)
     }
 

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -182,13 +182,13 @@ extension JNISwift2JavaGenerator {
       }
 
       // Swift -> Java
-      let translatedFunctionSignature = try translate(
+      var translatedFunctionSignature = try translate(
         functionSignature: decl.functionSignature,
         methodName: javaName,
         parentName: parentName
       )
       // Java -> Java (native)
-      let nativeFunctionSignature = try nativeTranslation.translate(
+      var nativeFunctionSignature = try nativeTranslation.translate(
         functionSignature: decl.functionSignature,
         translatedFunctionSignature: translatedFunctionSignature,
         methodName: javaName,
@@ -213,6 +213,16 @@ extension JNISwift2JavaGenerator {
         }
       }
 
+      // Handle async methods
+      if decl.functionSignature.isAsync {
+        self.convertToAsync(
+          translatedFunctionSignature: &translatedFunctionSignature,
+          nativeFunctionSignature: &nativeFunctionSignature,
+          originalFunctionSignature: decl.functionSignature,
+          mode: config.effectiveAsyncFuncMode
+        )
+      }
+
       return TranslatedFunctionDecl(
         name: javaName,
         isStatic: decl.isStatic || !decl.hasParent || decl.isInitializer,
@@ -281,11 +291,7 @@ extension JNISwift2JavaGenerator {
         genericRequirements: functionSignature.genericRequirements
       )
 
-      var resultType = try translate(swiftResult: functionSignature.result)
-
-      if functionSignature.effectSpecifiers.contains(.async) {
-        resultType = asyncResultConversion(result: resultType, mode: config.effectiveAsyncMode)
-      }
+      let resultType = try translate(swiftResult: functionSignature.result)
 
       return TranslatedFunctionSignature(
         selfParameter: selfParameter,
@@ -476,49 +482,58 @@ extension JNISwift2JavaGenerator {
       }
     }
 
-    func asyncResultConversion(
-      result: TranslatedResult,
-      mode: JExtractAsyncMode
-    ) -> TranslatedResult {
+    func convertToAsync(
+      translatedFunctionSignature: inout TranslatedFunctionSignature,
+      nativeFunctionSignature: inout NativeFunctionSignature,
+      originalFunctionSignature: SwiftFunctionSignature,
+      mode: JExtractAsyncFuncMode
+    ) {
       switch mode {
       case .completableFuture:
-        let supplyAsyncBodyConversion: JavaNativeConversionStep = if result.javaType.isVoid {
-          .aggregate([
-            .print(result.conversion),
-            .null
-          ])
-        } else {
-          result.conversion
-        }
+//        let supplyAsyncBodyConversion: JavaNativeConversionStep = if result.javaType.isVoid {
+//          .aggregate([
+//            .print(result.conversion),
+//            .null
+//          ])
+//        } else {
+//          result.conversion
+//        }
+
+        // Update translated function
+
+        let nativeFutureType = JavaType.completableFuture(nativeFunctionSignature.result.javaType)
+
+        let futureOutParameter = OutParameter(
+          name: "$future",
+          type: nativeFutureType,
+          allocation: .new
+        )
 
-        return TranslatedResult(
-          javaType: .class(package: "java.util.concurrent", name: "CompletableFuture<\(result.javaType.wrapperClassIfNeeded)>"),
+        let result = translatedFunctionSignature.resultType
+        translatedFunctionSignature.resultType = TranslatedResult(
+          javaType: .completableFuture(translatedFunctionSignature.resultType.javaType),
           annotations: result.annotations,
-          outParameters: result.outParameters,
-          conversion: .method(.constant("java.util.concurrent.CompletableFuture"), function: "supplyAsync", arguments: [
-            .lambda(body: supplyAsyncBodyConversion),
-            .constant("SwiftAsync.SWIFT_ASYNC_EXECUTOR")
+          outParameters: result.outParameters + [futureOutParameter],
+          conversion: .aggregate(variable: nil, [
+            .print(.placeholder), // Make the downcall
+            .method(.constant("$future"), function: "thenApply", arguments: [
+             .lambda(args: ["futureResult$"], body: .replacingPlaceholder(result.conversion, placeholder: "futureResult$"))
+           ])
           ])
         )
 
-      case .future:
-        let asyncBodyConversion: JavaNativeConversionStep = if result.javaType.isVoid {
-          .aggregate([
-            .print(result.conversion),
-            .null
-          ])
-        } else {
-          result.conversion
-        }
-
-        return TranslatedResult(
-          javaType: .class(package: "java.util.concurrent", name: "Future<\(result.javaType.wrapperClassIfNeeded)>"),
-          annotations: result.annotations,
-          outParameters: result.outParameters,
-          conversion: .method(.constant("SwiftAsync.SWIFT_ASYNC_EXECUTOR"), function: "submit", arguments: [
-            .lambda(body: asyncBodyConversion)
-          ])
+        // Update native function
+        nativeFunctionSignature.result.javaType = .void
+        nativeFunctionSignature.result.conversion = .asyncCompleteFuture(
+          nativeFunctionSignature.result.conversion,
+          swiftFunctionResultType: originalFunctionSignature.result.type,
+          nativeReturnType: nativeFunctionSignature.result.javaType,
+          outParameters: nativeFunctionSignature.result.outParameters
         )
+        nativeFunctionSignature.result.outParameters.append(.init(name: "result_future", type: nativeFutureType))
+
+      case .future:
+        fatalError()
       }
     }
 
@@ -866,11 +881,15 @@ extension JNISwift2JavaGenerator {
   struct OutParameter {
     enum Allocation {
       case newArray(JavaType, size: Int)
+      case new
 
-      func render() -> String {
+      func render(type: JavaType) -> String {
         switch self {
         case .newArray(let javaType, let size):
           "new \(javaType)[\(size)]"
+
+        case .new:
+          "new \(type)()"
         }
       }
     }
@@ -969,8 +988,8 @@ extension JNISwift2JavaGenerator {
     /// `return value`
     indirect case `return`(JavaNativeConversionStep)
 
-    /// `() -> { return body; }`
-    indirect case lambda(body: JavaNativeConversionStep)
+    /// `(args) -> { return body; }`
+    indirect case lambda(args: [String] = [], body: JavaNativeConversionStep)
 
     case null
 
@@ -1094,9 +1113,9 @@ extension JNISwift2JavaGenerator {
         let inner = inner.render(&printer, placeholder)
         return "return \(inner);"
 
-      case .lambda(let body):
+      case .lambda(let args, let body):
         var printer = CodePrinter()
-        printer.printBraceBlock("() ->") { printer in
+        printer.printBraceBlock("(\(args.joined(separator: ", "))) ->") { printer in
           let body = body.render(&printer, placeholder)
           if !body.isEmpty {
             printer.print("return \(body);")
@@ -1167,7 +1186,7 @@ extension JNISwift2JavaGenerator {
       case .return(let inner):
         return inner.requiresSwiftArena
 
-      case .lambda(let body):
+      case .lambda(_, let body):
         return body.requiresSwiftArena
 
       case .print(let inner):