WIP: fixing up wrap-java behavior, also adding tests which compile and

extract, just like the command does

Author: ktoso

Package.swift

@@ -197,6 +197,8 @@ let package = Package(
 
   ],
   dependencies: [
+    .package(url: "https://github.com/apple/swift-log", from: "1.2.0"),
+
     .package(url: "https://github.com/swiftlang/swift-syntax", from: "601.0.1"),
     .package(url: "https://github.com/apple/swift-argument-parser", from: "1.5.0"),
     .package(url: "https://github.com/apple/swift-system", from: "1.4.0"),
@@ -377,6 +379,7 @@ let package = Package(
     .target(
       name: "SwiftJavaToolLib",
       dependencies: [
+        .product(name: "Logging", package: "swift-log"),
         .product(name: "SwiftBasicFormat", package: "swift-syntax"),
         .product(name: "SwiftSyntax", package: "swift-syntax"),
         .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
@@ -400,6 +403,7 @@ let package = Package(
     .executableTarget(
       name: "SwiftJavaTool",
       dependencies: [
+        .product(name: "Logging", package: "swift-log"),
         .product(name: "SwiftBasicFormat", package: "swift-syntax"),
         .product(name: "SwiftSyntax", package: "swift-syntax"),
         .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),

Samples/SwiftJavaExtractFFMSampleApp/src/test/java/org/swift/swiftkitffm/ThrowsFFMTest.java

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+package com.example.swift;
+
+import org.junit.jupiter.api.Test;
+import org.swift.swiftkit.core.SwiftArena;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ThrowsFFMTest {
+    @Test
+    void throwSwiftError() {
+        try (var arena = SwiftArena.ofConfined()) {
+            var funcs = ThrowingFuncs.init(12, arena);
+            funcs.throwError();
+        } catch (Exception ex) {
+            assertEquals("java.lang.Exception: MyExampleSwiftError(message: \"yes, it\\'s an error!\")", ex.toString());
+            return;
+        }
+
+        throw new AssertionError("Expected Swift error to be thrown as exception");
+    }
+}

Sources/SwiftJavaTool/String+Extensions.swift renamed to Sources/SwiftJava/String+Extensions.swift

@@ -13,17 +13,15 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
-import ArgumentParser
-import SwiftJavaToolLib
-import SwiftJava
-import JavaUtilJar
-import SwiftJavaToolLib
-import SwiftJavaConfigurationShared
+// import SwiftJavaToolLib
+// import SwiftJava
+// import JavaUtilJar
+// import SwiftJavaConfigurationShared
 
 extension String {
   /// For a String that's of the form java.util.Vector, return the "Vector"
   /// part.
-  var defaultSwiftNameForJavaClass: String {
+  package var defaultSwiftNameForJavaClass: String {
     if let dotLoc = lastIndex(of: ".") {
       let afterDot = index(after: dotLoc)
       return String(self[afterDot...]).javaClassNameToCanonicalName.adjustedSwiftTypeName
@@ -36,12 +34,12 @@ extension String {
 extension String {
   /// Replace all of the $'s for nested names with "." to turn a Java class
   /// name into a Java canonical class name,
-  var javaClassNameToCanonicalName: String {
+  package var javaClassNameToCanonicalName: String {
     return replacing("$", with: ".")
   }
 
   /// Whether this is the name of an anonymous class.
-  var isLocalJavaClass: Bool {
+  package var isLocalJavaClass: Bool {
     for segment in split(separator: "$") {
       if let firstChar = segment.first, firstChar.isNumber {
         return true
@@ -52,7 +50,7 @@ extension String {
   }
 
   /// Adjust type name for "bad" type names that don't work well in Swift.
-  var adjustedSwiftTypeName: String {
+  package var adjustedSwiftTypeName: String {
     switch self {
     case "Type": return "JavaType"
     default: return self

Sources/SwiftJavaConfigurationShared/Configuration.swift

@@ -56,7 +56,7 @@ public struct Configuration: Codable {
     memoryManagementMode ?? .default
   }
 
-  // ==== java 2 swift ---------------------------------------------------------
+  // ==== wrap-java ---------------------------------------------------------
 
   /// The Java class path that should be passed along to the swift-java tool.
   public var classpath: String? = nil
@@ -76,6 +76,10 @@ public struct Configuration: Codable {
   // Generate class files suitable for the specified Java SE release.
   public var targetCompatibility: JavaVersion?
 
+  /// Filter input Java types by their package prefix if set.
+  /// Can be overriden by `--filter-java-package`.
+  public var filterJavaPackage: String?
+
   // ==== dependencies ---------------------------------------------------------
 
   // Java dependencies we need to fetch for this target.

Sources/SwiftJavaTool/Commands/ConfigureCommand.swift

@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Logging
 import ArgumentParser
 import Foundation
 import SwiftJavaToolLib
@@ -27,6 +28,9 @@ import SwiftJavaShared
 
 extension SwiftJava {
   struct ConfigureCommand: SwiftJavaBaseAsyncParsableCommand, HasCommonOptions, HasCommonJVMOptions {
+
+    static let log: Logging.Logger = Logger(label: "swift-java:\(configuration.commandName!)")
+
     static let configuration = CommandConfiguration(
       commandName: "configure",
       abstract: "Configure and emit a swift-java.config file based on an input dependency or jar file")
@@ -63,12 +67,12 @@ extension SwiftJava {
 extension SwiftJava.ConfigureCommand {
   mutating func runSwiftJavaCommand(config: inout Configuration) async throws {
     let classpathEntries = self.configureCommandJVMClasspath(
-        searchDirs: [self.effectiveSwiftModuleURL], config: config)
+        searchDirs: [self.effectiveSwiftModuleURL], config: config, log: Self.log)
 
     let jvm =
       try self.makeJVM(classpathEntries: classpathEntries)
 
-    try emitConfiguration(classpath: self.commonJVMOptions.classpath, environment: jvm.environment())
+    try emitConfiguration(classpathEntries: classpathEntries, environment: jvm.environment())
   }
 
   /// Get base configuration, depending on if we are to 'amend' or 'overwrite' the existing configuration.
@@ -93,32 +97,42 @@ extension SwiftJava.ConfigureCommand {
 
   // TODO: make this perhaps "emit type mappings"
   mutating func emitConfiguration(
-    classpath: [String],
+    classpathEntries: [String],
     environment: JNIEnvironment
   ) throws {
+    var log = Self.log
+    log.logLevel = .init(rawValue: self.logLevel.rawValue)!
+
+
+    log.info("Run: emit configuration...")
+    var (amendExistingConfig, configuration) = try getBaseConfigurationForWrite()
+
     if let filterJavaPackage = self.commonJVMOptions.filterJavaPackage {
-      print("[java-swift][debug] Generate Java->Swift type mappings. Active filter: \(filterJavaPackage)")
+      log.debug("Generate Java->Swift type mappings. Active filter: \(filterJavaPackage)")
+    } else if let filterJavaPackage = configuration.filterJavaPackage { 
+      // take the package filter from the configuration file
+      self.commonJVMOptions.filterJavaPackage = filterJavaPackage
+    } else {
+      log.debug("Generate Java->Swift type mappings. No package filter applied.")
     }
-    print("[java-swift][debug] Classpath: \(classpath)")
+    log.debug("Classpath: \(classpathEntries)")
 
-    if classpath.isEmpty {
-      print("[java-swift][warning] Classpath is empty!")
+    if classpathEntries.isEmpty {
+      log.warning("Classpath is empty!")
     }
 
     // Get a fresh or existing configuration we'll amend
-    var (amendExistingConfig, configuration) = try getBaseConfigurationForWrite()
     if amendExistingConfig {
-      print("[swift-java] Amend existing swift-java.config file...")
+      log.info("Amend existing swift-java.config file...")
     }
-    configuration.classpath = classpath.joined(separator: ":") // TODO: is this correct?
+    configuration.classpath = classpathEntries.joined(separator: ":") // TODO: is this correct?
 
     // Import types from all the classpath entries;
     // Note that we use the package level filtering, so users have some control over what gets imported.
-    let classpathEntries = classpath.split(separator: ":").map(String.init)
     for entry in classpathEntries {
       guard fileOrDirectoryExists(at: entry) else {
         // We only log specific jars missing, as paths may be empty directories that won't hurt not existing.
-        print("[debug][swift-java] Classpath entry does not exist: \(entry)")
+        log.debug("Classpath entry does not exist: \(entry)")
         continue
       }
 
@@ -131,9 +145,9 @@ extension SwiftJava.ConfigureCommand {
           environment: environment
         )
       } else if FileManager.default.fileExists(atPath: entry) {
-        print("[warning][swift-java] Currently unable handle directory classpath entries for config generation! Skipping: \(entry)")
+        log.warning("Currently unable handle directory classpath entries for config generation! Skipping: \(entry)")
       } else {
-        print("[warning][swift-java] Classpath entry does not exist, skipping: \(entry)")
+        log.warning("Classpath entry does not exist, skipping: \(entry)")
       }
     }
 
@@ -154,6 +168,8 @@ extension SwiftJava.ConfigureCommand {
     forJar jarFile: JarFile,
     environment: JNIEnvironment
   ) throws {
+    let log = Self.log
+
     for entry in jarFile.entries()! {
       // We only look at class files in the Jar file.
       guard entry.getName().hasSuffix(".class") else {
@@ -179,6 +195,7 @@ extension SwiftJava.ConfigureCommand {
       let javaCanonicalName = String(entry.getName().replacing("/", with: ".")
         .dropLast(".class".count))
 
+
       if let filterJavaPackage = self.commonJVMOptions.filterJavaPackage,
          !javaCanonicalName.hasPrefix(filterJavaPackage) {
         // Skip classes which don't match our expected prefix
@@ -191,7 +208,17 @@ extension SwiftJava.ConfigureCommand {
         continue
       }
 
-      configuration.classes?[javaCanonicalName] =
+      if configuration.classes == nil {
+        configuration.classes = [:]
+      }
+
+      if let configuredSwiftName = configuration.classes![javaCanonicalName] {
+        log.info("Java type '\(javaCanonicalName)' already configured as '\(configuredSwiftName)' Swift type.")
+      } else {
+        log.info("Configure Java type '\(javaCanonicalName)' as '\(javaCanonicalName.defaultSwiftNameForJavaClass.bold)' Swift type.")
+      }
+
+      configuration.classes![javaCanonicalName] =
         javaCanonicalName.defaultSwiftNameForJavaClass
     }
   }

Sources/SwiftJavaTool/Commands/JExtractCommand.swift

@@ -117,9 +117,9 @@ extension SwiftJava.JExtractCommand {
     if self.mode == .jni {
       switch self.unsignedNumbers {
       case .annotate:
-        throw IllegalModeCombinationError("JNI mode does not support '\(JExtractUnsignedIntegerMode.wrapGuava)' Unsigned integer mode! \(Self.helpMessage)")
-      case .wrapGuava:
         () // OK
+      case .wrapGuava:
+        throw IllegalModeCombinationError("JNI mode does not support '\(JExtractUnsignedIntegerMode.wrapGuava)' Unsigned integer mode! \(Self.helpMessage)")
       }
     } else if self.mode == .ffm {
       guard self.memoryManagementMode == .explicit else {

Sources/SwiftJavaTool/Commands/ResolveCommand.swift

@@ -104,7 +104,10 @@ extension SwiftJava.ResolveCommand {
     let deps = dependencies.map { $0.descriptionGradleStyle }
     print("[debug][swift-java] Resolve and fetch dependencies for: \(deps)")
 
-    let dependenciesClasspath = await resolveDependencies(dependencies: dependencies)
+    let workDir = URL(fileURLWithPath: self.commonOptions.outputDirectory!)
+      .appending(path: "resolver-dir")
+
+    let dependenciesClasspath = await resolveDependencies(workDir: workDir, dependencies: dependencies)
     let classpathEntries = dependenciesClasspath.split(separator: ":")
 
     print("[info][swift-java] Resolved classpath for \(deps.count) dependencies of '\(swiftModule)', classpath entries: \(classpathEntries.count), ", terminator: "")
@@ -122,10 +125,15 @@ extension SwiftJava.ResolveCommand {
   /// 
   /// - Parameter dependencies: maven-style dependencies to resolve
   /// - Returns: Colon-separated classpath
-  func resolveDependencies(dependencies: [JavaDependencyDescriptor]) async -> String {
-    let workDir = URL(fileURLWithPath: FileManager.default.currentDirectoryPath)
-      .appendingPathComponent(".build")
-    let resolverDir = try! createTemporaryDirectory(in: workDir)
+  func resolveDependencies(workDir: URL, dependencies: [JavaDependencyDescriptor]) async -> String {
+    print("Create directory: \(workDir.absoluteString)")
+    
+    let resolverDir: URL
+    do {
+      resolverDir = try createTemporaryDirectory(in: workDir)
+    } catch {
+      fatalError("Unable to create temp directory at: \(workDir.absoluteString)! \(error)")
+    }
     defer {
       try? FileManager.default.removeItem(at: resolverDir)
     }
@@ -162,7 +170,9 @@ extension SwiftJava.ResolveCommand {
       } else {
         let suggestDisablingSandbox = "It may be that the Sandbox has prevented dependency fetching, please re-run with '--disable-sandbox'."
         fatalError("Gradle output had no SWIFT_JAVA_CLASSPATH! \(suggestDisablingSandbox). \n" +
-          "Output was:<<<\(outString)>>>; Err was:<<<\(errString ?? "<empty>")>>>")
+          "Command was: \(CommandLine.arguments.joined(separator: " ").bold)\n" + 
+          "Output was: <<<\(outString)>>>;\n" +
+          "Err was: <<<\(errString)>>>")
       }
 
       return String(classpathOutput.dropFirst(SwiftJavaClasspathPrefix.count))

Sources/SwiftJavaTool/Commands/WrapJavaCommand.swift

@@ -14,15 +14,18 @@
 
 import Foundation
 import ArgumentParser
+import Logging
 import SwiftJavaToolLib
 import SwiftJava
 import JavaUtilJar
-import SwiftJavaToolLib
 import SwiftJavaConfigurationShared
 
 extension SwiftJava {
 
   struct WrapJavaCommand: SwiftJavaBaseAsyncParsableCommand, HasCommonOptions, HasCommonJVMOptions {
+
+    static let log: Logging.Logger = .init(label: "swift-java:\(configuration.commandName!)")
+
     static let configuration = CommandConfiguration(
       commandName: "wrap-java",
       abstract: "Wrap Java classes with corresponding Swift bindings.")
@@ -74,7 +77,7 @@ extension SwiftJava.WrapJavaCommand {
     print("[trace][swift-java] INPUT: \(input)")
 
     var classpathEntries = self.configureCommandJVMClasspath(
-        searchDirs: classpathSearchDirs, config: config)
+        searchDirs: classpathSearchDirs, config: config, log: Self.log)
 
     // Load all of the dependent configurations and associate them with Swift modules.
     let dependentConfigs = try loadDependentConfigs(dependsOn: self.dependsOn).map { moduleName, config in
@@ -136,12 +139,21 @@ extension SwiftJava.WrapJavaCommand {
     translator.addConfiguration(config, forSwiftModule: effectiveSwiftModule)
 
     // Load all of the explicitly-requested classes.
-    let classLoader = try JavaClass<ClassLoader>(environment: environment)
+    let classLoader = try! JavaClass<ClassLoader>(environment: environment)
       .getSystemClassLoader()!
     var javaClasses: [JavaClass<JavaObject>] = []
     for (javaClassName, _) in config.classes ?? [:] {
+
+      if let filterPackage = config.filterJavaPackage {
+        if javaClassName.starts(with: filterPackage) {
+          log.info("SKIP Wrapping java type: \(javaClassName)")
+          continue
+        }
+      }
+      log.info("Wrapping java type: \(javaClassName)")
+
       guard let javaClass = try classLoader.loadClass(javaClassName) else {
-        print("warning: could not find Java class '\(javaClassName)'")
+        log.warning("Could not load Java class '\(javaClassName)', skipping.")
         continue
       }
 
@@ -175,18 +187,18 @@ extension SwiftJava.WrapJavaCommand {
           return nil
         }
 
+
         // If this class has been explicitly mentioned, we're done.
-        if translator.translatedClasses[javaClassName] != nil {
+        guard translator.translatedClasses[javaClassName] == nil else {
           return nil
         }
 
         // Record this as a translated class.
         let swiftUnqualifiedName = javaClassName.javaClassNameToCanonicalName
           .defaultSwiftNameForJavaClass
 
-
         let swiftName = "\(currentSwiftName).\(swiftUnqualifiedName)"
-        translator.translatedClasses[javaClassName] = (swiftName, nil)
+        translator.translatedClasses[javaClassName] = SwiftTypeName(module: nil, name: swiftName)
         return nestedClass
       }