Merge branch 'main' into wip-dependency-traits

Author: ktoso

.gitignore

@@ -2,6 +2,7 @@
 .sdkmanrc
 
 .DS_Store
+.metals
 .build
 .idea
 .vscode

Package.swift

@@ -100,6 +100,7 @@ let package = Package(
     // ==== SwiftJava (i.e. calling Java directly Swift utilities)
     .library(
       name: "SwiftJava",
+      type: .dynamic,
       targets: ["SwiftJava"]
     ),
 
@@ -505,26 +506,18 @@ let package = Package(
     .target(
       name: "JExtractSwiftLib",
       dependencies: [
-        .product(
-          name: "SwiftBasicFormat", package: "swift-syntax",
-          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"])
-        ),
-        .product(
-          name: "SwiftLexicalLookup", package: "swift-syntax",
-          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"])
-        ),
-        .product(
-          name: "SwiftSyntax", package: "swift-syntax",
-          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"])
-        ),
-        .product(
-          name: "SwiftSyntaxBuilder", package: "swift-syntax",
-          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"])
-        ),
-        .product(
-          name: "ArgumentParser", package: "swift-argument-parser",
+        .product(name: "SwiftBasicFormat", package: "swift-syntax",
+          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"]),
+        .product(name: "SwiftLexicalLookup", package: "swift-syntax",
+          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"]),
+        .product(name: "SwiftSyntax", package: "swift-syntax",
+          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"]),
+        .product(name: "SwiftSyntaxBuilder", package: "swift-syntax",
+          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"]),
+        .product(name: "ArgumentParser", package: "swift-argument-parser",
+          condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"]),
+        .product(name: "OrderedCollections", package: "swift-collections",
           condition: .when(traits: ["_SwiftJavaToolDependencyGuardTrait"]),
-        ),
         "JavaTypes",
         "SwiftJavaShared",
         "SwiftJavaConfigurationShared",

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
@@ -93,7 +96,7 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
       $0.pathExtension == "swift"
     }
 
-    // Output Swift files are just Java filename based converted to Swift files one-to-one
+    // Output files are flattened filenames of the inputs, with the appended +SwiftJava suffix.
     var outputSwiftFiles: [URL] = swiftFiles.compactMap { sourceFileURL in
       guard sourceFileURL.isFileURL else {
         return nil as URL?
@@ -104,7 +107,6 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
         fatalError("Could not get relative path for source file \(sourceFilePath)")
       }
       let outputURL = outputSwiftDirectory
-        .appending(path: String(sourceFilePath.dropFirst(sourceDir.count).dropLast(sourceFileURL.lastPathComponent.count + 1)))
 
       let inputFileName = sourceFileURL.deletingPathExtension().lastPathComponent
       return outputURL.appending(path: "\(inputFileName)+SwiftJava.swift")
@@ -123,15 +125,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 +333,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 {
+          continue
+        }
+
+        // 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,10 +171,12 @@ 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)")
+
+      for f in outputSwiftFiles {
+        log("Swift output file: \(f)")
+      }
       commands += [
         .buildCommand(
           displayName: displayName,
@@ -266,4 +268,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/SwiftAndJavaJarSampleLib/Package.swift

@@ -63,7 +63,9 @@ let package = Package(
     .target(
       name: "MySwiftLibrary",
       dependencies: [
-        .product(name: "SwiftRuntimeFunctions", package: "swift-java"),
+        .product(name: "SwiftJava", package: "swift-java"),
+        .product(name: "CSwiftJavaJNI", package: "swift-java"),
+        .product(name: "SwiftRuntimeFunctions", package: "swift-java")
       ],
       exclude: [
         "swift-java.config",