jextract: add support for implementing Swift protocols in Java (#449)

Co-authored-by: Konrad `ktoso` Malawski <konrad_malawski@apple.com>

Author: madsodgaard

Plugins/JExtractSwiftPlugin/JExtractSwiftPlugin.swift

@@ -25,9 +25,12 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
 
   func createBuildCommands(context: PluginContext, target: Target) throws -> [Command] {
     let toolURL = try context.tool(named: "SwiftJavaTool").url
-    
+
+    var commands: [Command] = []
+
     guard let sourceModule = target.sourceModule else { return [] }
 
+
     // Note: Target doesn't have a directoryURL counterpart to directory,
     // so we cannot eliminate this deprecation warning.
     for dependency in target.dependencies {
@@ -80,7 +83,7 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
       let (moduleName, configFile) = moduleAndConfigFile
       return [
         "--depends-on",
-        "\(configFile.path(percentEncoded: false))"
+        "\(moduleName)=\(configFile.path(percentEncoded: false))"
       ]
     }
     arguments += dependentConfigFilesArguments
@@ -123,15 +126,165 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
 
     print("[swift-java-plugin] Output swift files:\n - \(outputSwiftFiles.map({$0.absoluteString}).joined(separator: "\n - "))")
 
-    return [
+    var jextractOutputFiles = outputSwiftFiles
+
+    // If the developer has enabled java callbacks in the configuration (default is false)
+    // and we are running in JNI mode, we will run additional phases in this build plugin
+    // to generate Swift wrappers using wrap-java that can be used to callback to Java.
+    let shouldRunJavaCallbacksPhases = 
+      if let configuration, 
+         configuration.enableJavaCallbacks == true,
+         configuration.effectiveMode == .jni {
+        true
+      } else {
+        false
+      }
+
+    // Extract list of all sources
+    let javaSourcesListFileName = "jextract-generated-sources.txt"
+    let javaSourcesFile = outputJavaDirectory.appending(path: javaSourcesListFileName)
+    if shouldRunJavaCallbacksPhases {
+      arguments += [
+        "--generated-java-sources-list-file-output", javaSourcesListFileName
+      ]
+      jextractOutputFiles += [javaSourcesFile]
+    }
+
+    commands += [
       .buildCommand(
         displayName: "Generate Java wrappers for Swift types",
         executable: toolURL,
         arguments: arguments,
         inputFiles: [ configFile ] + swiftFiles,
-        outputFiles: outputSwiftFiles
+        outputFiles: jextractOutputFiles
+      )
+    ]
+
+    // If we do not need Java callbacks, we can skip the remaining steps.
+    guard shouldRunJavaCallbacksPhases else {
+      return commands
+    }
+
+    // The URL of the compiled Java sources
+    let javaCompiledClassesURL = context.pluginWorkDirectoryURL
+      .appending(path: "compiled-java-output")
+
+    // Build SwiftKitCore and get the classpath
+    // as the jextracted sources will depend on that
+
+    guard let swiftJavaDirectory = findSwiftJavaDirectory(for: target) else {
+      fatalError("Unable to find the path to the swift-java sources, please file an issue.")
+    }
+    log("Found swift-java at \(swiftJavaDirectory)")
+
+    let swiftKitCoreClassPath = swiftJavaDirectory.appending(path: "SwiftKitCore/build/classes/java/main")
+
+    // We need to use a different gradle home, because
+    // this plugin might be run from inside another gradle task
+    // and that would cause conflicts.
+    let gradleUserHome = context.pluginWorkDirectoryURL.appending(path: "gradle-user-home")
+
+    let GradleUserHome = "GRADLE_USER_HOME"
+    let gradleUserHomePath = gradleUserHome.path(percentEncoded: false)
+    log("Prepare command: :SwiftKitCore:build in \(GradleUserHome)=\(gradleUserHomePath)")
+    var gradlewEnvironment = ProcessInfo.processInfo.environment
+    gradlewEnvironment[GradleUserHome] = gradleUserHomePath
+    log("Forward environment: \(gradlewEnvironment)")
+
+    let gradleExecutable = findExecutable(name: "gradle") ?? // try using installed 'gradle' if available in PATH
+      swiftJavaDirectory.appending(path: "gradlew") // fallback to calling ./gradlew if gradle is not installed
+    log("Detected 'gradle' executable (or gradlew fallback): \(gradleExecutable)")
+
+    commands += [
+      .buildCommand(
+        displayName: "Build SwiftKitCore using Gradle (Java)",
+        executable: gradleExecutable,
+        arguments: [
+          ":SwiftKitCore:build",
+          "--project-dir", swiftJavaDirectory.path(percentEncoded: false),
+          "--gradle-user-home", gradleUserHomePath, 
+          "--configure-on-demand",
+          "--no-daemon"
+        ],
+        environment: gradlewEnvironment,
+        inputFiles: [swiftJavaDirectory],
+        outputFiles: [swiftKitCoreClassPath]
+      )
+    ]
+
+    // Compile the jextracted sources
+    let javaHome = URL(filePath: findJavaHome())
+
+    commands += [
+      .buildCommand(
+        displayName: "Build extracted Java sources",
+        executable: javaHome
+          .appending(path: "bin")
+          .appending(path: self.javacName),
+        arguments: [
+          "@\(javaSourcesFile.path(percentEncoded: false))",
+          "-d", javaCompiledClassesURL.path(percentEncoded: false),
+          "-parameters",
+          "-classpath", swiftKitCoreClassPath.path(percentEncoded: false)
+        ],
+        inputFiles: [javaSourcesFile, swiftKitCoreClassPath],
+        outputFiles: [javaCompiledClassesURL]
+      )
+    ]
+
+    // Run `configure` to extract a swift-java config to use for wrap-java
+    let swiftJavaConfigURL = context.pluginWorkDirectoryURL.appending(path: "swift-java.config")
+
+    commands += [
+      .buildCommand(
+        displayName: "Output swift-java.config that contains all extracted Java sources",
+        executable: toolURL,
+        arguments: [
+          "configure",
+          "--output-directory", context.pluginWorkDirectoryURL.path(percentEncoded: false),
+          "--cp", javaCompiledClassesURL.path(percentEncoded: false),
+          "--swift-module", sourceModule.name,
+          "--swift-type-prefix", "Java"
+        ],
+        inputFiles: [javaCompiledClassesURL],
+        outputFiles: [swiftJavaConfigURL]
       )
     ]
+
+    let singleSwiftFileOutputName = "WrapJavaGenerated.swift"
+
+    // In the end we can run wrap-java on the previous inputs
+    var wrapJavaArguments = [
+      "wrap-java",
+      "--swift-module", sourceModule.name,
+      "--output-directory", outputSwiftDirectory.path(percentEncoded: false),
+      "--config", swiftJavaConfigURL.path(percentEncoded: false),
+      "--cp", swiftKitCoreClassPath.path(percentEncoded: false),
+      "--single-swift-file-output", singleSwiftFileOutputName
+    ]
+
+    // Add any dependent config files as arguments
+    wrapJavaArguments += dependentConfigFilesArguments
+
+    commands += [
+      .buildCommand(
+        displayName: "Wrap compiled Java sources using wrap-java",
+        executable: toolURL,
+        arguments: wrapJavaArguments,
+        inputFiles: [swiftJavaConfigURL, swiftKitCoreClassPath],
+        outputFiles: [outputSwiftDirectory.appending(path: singleSwiftFileOutputName)]
+      )
+    ]
+
+    return commands
+  }
+
+  var javacName: String {
+#if os(Windows)
+    "javac.exe"
+#else
+    "javac"
+#endif
   }
 
   /// Find the manifest files from other swift-java executions in any targets
@@ -181,5 +334,43 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
 
     return dependentConfigFiles
   }
+
+  private func findSwiftJavaDirectory(for target: any Target) -> URL? {
+    for dependency in target.dependencies {
+      switch dependency {
+      case .target(let target):
+        continue
+
+      case .product(let product):
+        guard let swiftJava = product.sourceModules.first(where: { $0.name == "SwiftJava" }) else {
+          return nil
+        }
+
+        // We are inside Sources/SwiftJava
+        return swiftJava.directoryURL.deletingLastPathComponent().deletingLastPathComponent()
+
+      @unknown default:
+        continue
+      }
+    }
+
+    return nil
+  }
 }
 
+func findExecutable(name: String) -> URL? {
+  let fileManager = FileManager.default
+
+  guard let path = ProcessInfo.processInfo.environment["PATH"] else {
+    return nil
+  }
+
+  for path in path.split(separator: ":") {
+    let fullURL = URL(fileURLWithPath: String(path)).appendingPathComponent(name)
+    if fileManager.isExecutableFile(atPath: fullURL.path) {
+      return fullURL
+    }
+  }
+
+  return nil
+}

Plugins/SwiftJavaPlugin/SwiftJavaPlugin.swift

@@ -171,8 +171,6 @@ struct SwiftJavaBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
     arguments += javaStdlibModules.flatMap { ["--depends-on", $0] }
 
     if !outputSwiftFiles.isEmpty {
-      arguments += [ configFile.path(percentEncoded: false) ]
-
       let displayName = "Wrapping \(classes.count) Java classes in Swift target '\(sourceModule.name)'"
       log("Prepared: \(displayName)")
       commands += [
@@ -266,4 +264,4 @@ func getExtractedJavaStdlibModules() -> [String] {
     }
     return url.lastPathComponent
   }.sorted()
-}
+}

Samples/JavaDependencySampleApp/ci-validate.sh

@@ -3,17 +3,24 @@
 set -e
 set -x
 
+# WORKAROUND: prebuilts broken on Swift 6.2.1 and Linux and tests using macros https://github.com/swiftlang/swift-java/issues/418
+if [ "$(uname)" = "Darwin" ]; then
+  DISABLE_EXPERIMENTAL_PREBUILTS=''
+else
+  DISABLE_EXPERIMENTAL_PREBUILTS='--disable-experimental-prebuilts'
+fi
+
 # invoke resolve as part of a build run
 swift build \
-  --disable-experimental-prebuilts \
+  $DISABLE_EXPERIMENTAL_PREBUILTS \
   --disable-sandbox
 
 # explicitly invoke resolve without explicit path or dependency
 # the dependencies should be uses from the --swift-module
 
 # FIXME: until prebuilt swift-syntax isn't broken on 6.2 anymore: https://github.com/swiftlang/swift-java/issues/418 
 swift run \
-  --disable-experimental-prebuilts \
+  $DISABLE_EXPERIMENTAL_PREBUILTS \
   swift-java resolve \
   Sources/JavaCommonsCSV/swift-java.config \
   --swift-module JavaCommonsCSV \

Samples/JavaKitSampleApp/ci-validate.sh

@@ -3,8 +3,14 @@
 set -e
 set -x
 
-swift build \
-  --disable-experimental-prebuilts  # FIXME: until prebuilt swift-syntax isn't broken on 6.2 anymore: https://github.com/swiftlang/swift-java/issues/418
+# WORKAROUND: prebuilts broken on Swift 6.2.1 and Linux and tests using macros https://github.com/swiftlang/swift-java/issues/418
+if [ "$(uname)" = "Darwin" ]; then
+  DISABLE_EXPERIMENTAL_PREBUILTS=''
+else
+  DISABLE_EXPERIMENTAL_PREBUILTS='--disable-experimental-prebuilts'
+fi
+
+swift build $DISABLE_EXPERIMENTAL_PREBUILTS
 
 "$JAVA_HOME/bin/java" \
     -cp .build/plugins/outputs/javakitsampleapp/JavaKitExample/destination/JavaCompilerPlugin/Java \

Samples/JavaProbablyPrime/ci-validate.sh

@@ -3,7 +3,13 @@
 set -e
 set -x
 
-# FIXME: until prebuilt swift-syntax isn't broken on 6.2 anymore: https://github.com/swiftlang/swift-java/issues/418 
+# WORKAROUND: prebuilts broken on Swift 6.2.1 and Linux and tests using macros https://github.com/swiftlang/swift-java/issues/418
+if [ "$(uname)" = "Darwin" ]; then
+  DISABLE_EXPERIMENTAL_PREBUILTS=''
+else
+  DISABLE_EXPERIMENTAL_PREBUILTS='--disable-experimental-prebuilts'
+fi
+
 swift run \
-    --disable-experimental-prebuilts \
+    $DISABLE_EXPERIMENTAL_PREBUILTS \
     JavaProbablyPrime 1337

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/CallbackProtcol.swift

@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftJava
+
+public protocol CallbackProtocol {
+  func withBool(_ input: Bool) -> Bool
+  func withInt8(_ input: Int8) -> Int8
+  func withUInt16(_ input: UInt16) -> UInt16
+  func withInt16(_ input: Int16) -> Int16
+  func withInt32(_ input: Int32) -> Int32
+  func withInt64(_ input: Int64) -> Int64
+  func withFloat(_ input: Float) -> Float
+  func withDouble(_ input: Double) -> Double
+  func withString(_ input: String) -> String
+  func withVoid()
+  func withObject(_ input: MySwiftClass) -> MySwiftClass
+  func withOptionalInt64(_ input: Int64?) -> Int64?
+  func withOptionalObject(_ input: MySwiftClass?) -> Optional<MySwiftClass>
+}
+
+public struct CallbackOutput {
+  public let bool: Bool
+  public let int8: Int8
+  public let uint16: UInt16
+  public let int16: Int16
+  public let int32: Int32
+  public let int64: Int64
+  public let _float: Float
+  public let _double: Double
+  public let string: String
+  public let object: MySwiftClass
+  public let optionalInt64: Int64?
+  public let optionalObject: MySwiftClass?
+}
+
+public func outputCallbacks(
+  _ callbacks: some CallbackProtocol,
+  bool: Bool,
+  int8: Int8,
+  uint16: UInt16,
+  int16: Int16,
+  int32: Int32,
+  int64: Int64,
+  _float: Float,
+  _double: Double,
+  string: String,
+  object: MySwiftClass,
+  optionalInt64: Int64?,
+  optionalObject: MySwiftClass?
+) -> CallbackOutput {
+  return CallbackOutput(
+    bool: callbacks.withBool(bool),
+    int8: callbacks.withInt8(int8),
+    uint16: callbacks.withUInt16(uint16),
+    int16: callbacks.withInt16(int16),
+    int32: callbacks.withInt32(int32),
+    int64: callbacks.withInt64(int64),
+    _float: callbacks.withFloat(_float),
+    _double: callbacks.withDouble(_double),
+    string: callbacks.withString(string),
+    object: callbacks.withObject(object),
+    optionalInt64: callbacks.withOptionalInt64(optionalInt64),
+    optionalObject: callbacks.withOptionalObject(optionalObject)
+  )
+}