work on swiftpm plugin

Author: madsodgaard

Plugins/JExtractSwiftPlugin/JExtractSwiftPlugin.swift

@@ -152,6 +152,8 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
     }
     log("Found swift-java at \(swiftJavaDirectory)")
 
+    let swiftKitCoreClassPath = swiftJavaDirectory.appending(path: "SwiftKitCore/build/classes/java/main")
+
     commands += [
       .buildCommand(
         displayName: "Build SwiftKitCore",
@@ -164,19 +166,20 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
         ],
         environment: [:],
         inputFiles: [swiftJavaDirectory],
-        outputFiles: []
+        outputFiles: [swiftKitCoreClassPath]
       )
     ]
 
-    let swiftKitCoreClassPath = swiftJavaDirectory.appending(path: "SwiftKitCore/build/classes/java/main")
-
     // Compile the jextracted sources
     let javaHome = URL(filePath: findJavaHome())
   #if os(Windows)
     let javac = "javac.exe"
+    let jar = "jar.exe"
   #else
     let javac = "javac"
+    let jar = "jar"
   #endif
+
     commands += [
       .buildCommand(
         displayName: "Build extracted Java sources",
@@ -185,12 +188,68 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
           .appending(path: javac),
         arguments: [
           "@\(javaSourcesFile.path(percentEncoded: false))",
-          "-d", javaClassFileURL.path,
+          "-d", javaClassFileURL.path(percentEncoded: false),
           "-parameters",
           "-classpath", swiftKitCoreClassPath.path(percentEncoded: false)
         ],
-        inputFiles: [javaSourcesFile],
-        outputFiles: []
+        inputFiles: [javaSourcesFile, swiftKitCoreClassPath],
+        outputFiles: [javaClassFileURL]
+      )
+    ]
+
+    // Wrap into JAR that we can use `swift-java configure` on
+//    let jarFileURL = context.pluginWorkDirectoryURL.appending(path: "generated-sources.jar")
+//
+//    commands += [
+//      .buildCommand(
+//        displayName: "Wrap compiled Java sources into .jar",
+//        executable: javaHome
+//          .appending(path: "bin")
+//          .appending(path: jar),
+//        arguments: [
+//          "--create",
+//          "--file", jarFileURL.path(percentEncoded: false),
+//          "-C", javaClassFileURL.path(percentEncoded: false),
+//          "."
+//        ],
+//        inputFiles: [javaClassFileURL],
+//        outputFiles: [jarFileURL]
+//      )
+//    ]
+
+    // 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: "Wrap compiled Java sources using wrap-java",
+        executable: toolURL,
+        arguments: [
+          "configure",
+          "--output-directory", context.pluginWorkDirectoryURL.path(percentEncoded: false),
+          "--cp", javaClassFileURL.path(percentEncoded: false),
+          "--swift-module", sourceModule.name,
+          "--swift-prefix", "Java"
+        ],
+        inputFiles: [javaClassFileURL],
+        outputFiles: [swiftJavaConfigURL]
+      )
+    ]
+
+    // In the end we can run wrap-java on the previous inputs
+    commands += [
+      .buildCommand(
+        displayName: "Wrap compiled Java sources using wrap-java",
+        executable: toolURL,
+        arguments: [
+          "wrap-java",
+          "--swift-module", sourceModule.name,
+          "--output-directory", outputSwiftDirectory.path(percentEncoded: false),
+          "--config", swiftJavaConfigURL.path(percentEncoded: false),
+          "--cp", swiftKitCoreClassPath.path(percentEncoded: false),
+        ],
+        inputFiles: [swiftJavaConfigURL, swiftKitCoreClassPath],
+        outputFiles: [outputSwiftDirectory.appending(path: "JavaStorage.swift")]
       )
     ]
 

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/Storage.swift

@@ -75,20 +75,3 @@ struct JavaJNISwiftInstance {
   @JavaMethod("$memoryAddress")
   public func memoryAddress() -> Int64
 }
-
-@JavaClass("com.example.swift.StorageItem", implements: JavaJNISwiftInstance.self)
-open class JavaStorageItem: JavaObject {}
-
-extension JavaClass<JavaStorageItem> {
-  @JavaStaticMethod
-  public func wrapMemoryAddressUnsafe(selfPointer: Int64) -> JavaStorageItem!
-}
-
-@JavaInterface("com.example.swift.Storage")
-struct JavaStorage {
-    @JavaMethod
-    func load() -> JavaStorageItem!
-
-    @JavaMethod
-    func save(item: JavaStorageItem!)
-}

Sources/JavaStdlib/JavaLangReflect/JavaClass+Utilities.swift

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 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
+
+extension JavaClass {
+  /// Whether this is a 'public' class.
+  public var isPublic: Bool {
+    return (getModifiers() & 0x00000001) != 0
+  }
+
+  /// Whether this is a 'private' class.
+  public var isPrivate: Bool {
+    return (getModifiers() & 0x00000002) != 0
+  }
+
+  /// Whether this is a 'protected' class.
+  public var isProtected: Bool {
+    return (getModifiers() & 0x00000004) != 0
+  }
+
+  /// Whether this is a 'package' method.
+  ///
+  /// The "default" access level in Java is 'package', it is signified by lack of a different access modifier.
+  public var isPackage: Bool {
+    return !isPublic && !isPrivate && !isProtected
+  }
+}

Sources/SwiftJava/String+Extensions.swift

@@ -27,10 +27,14 @@ 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,
+  /// Convert a Java class name to its canonical name.
+  /// Replaces `$` with `.` for nested classes but preserves `$` at the start of identifiers.
   package var javaClassNameToCanonicalName: String {
-    return replacing("$", with: ".")
+    self.replacingOccurrences(
+      of: #"(?<=\w)\$"#,
+      with: ".",
+      options: .regularExpression
+    )
   }
 
   /// Whether this is the name of an anonymous class.

Sources/SwiftJavaConfigurationShared/Configuration.swift

@@ -162,7 +162,11 @@ public func readConfiguration(sourceDir: String, file: String = #fileID, line: U
 /// Configuration is expected to be "JSON-with-comments".
 /// Specifically "//" comments are allowed and will be trimmed before passing the rest of the config into a standard JSON parser.
 public func readConfiguration(configPath: URL, file: String = #fileID, line: UInt = #line) throws -> Configuration? {
-  guard let configData = try? Data(contentsOf: configPath) else {
+  let configData: Data
+  do {
+    configData = try Data(contentsOf: configPath)
+  } catch {
+    print("Failed to read SwiftJava configuration at '\(configPath.absoluteURL)', error: \(error)")
     return nil
   }
 

Sources/SwiftJavaTool/Commands/ConfigureCommand.swift

@@ -59,8 +59,8 @@ extension SwiftJava {
       swiftModule
     }
 
-    @Argument(help: "The input file, which is either a swift-java configuration file or (if '-jar' was specified) a Jar file.")
-    var input: String?
+    @Option(help: "A prefix that will be added to the names of the Swift types")
+    var swiftPrefix: String?
   }
 }
 
@@ -137,14 +137,19 @@ extension SwiftJava.ConfigureCommand {
 
       print("[debug][swift-java] Importing classpath entry: \(entry)")
       if entry.hasSuffix(".jar") {
+        print("[debug][swift-java] Importing classpath as JAR file: \(entry)")
         let jarFile = try JarFile(entry, false, environment: environment)
         try addJavaToSwiftMappings(
           to: &config,
           forJar: jarFile,
           environment: environment
         )
-      } else if FileManager.default.fileExists(atPath: entry) {
-        log.warning("Currently unable handle directory classpath entries for config generation! Skipping: \(entry)")
+      } else if FileManager.default.fileExists(atPath: entry), let entryURL = URL(string: entry) {
+        print("[debug][swift-java] Importing classpath as directory: \(entryURL)")
+        try addJavaToSwiftMappings(
+          to: &configuration,
+          forDirectory: entryURL
+        )
       } else {
         log.warning("Classpath entry does not exist, skipping: \(entry)")
       }
@@ -162,62 +167,82 @@ extension SwiftJava.ConfigureCommand {
     )
   }
 
+  mutating func addJavaToSwiftMappings(
+    to configuration: inout Configuration,
+    forDirectory url: Foundation.URL
+  ) throws {
+    let enumerator = FileManager.default.enumerator(atPath: url.path())
+
+    while let filePath = enumerator?.nextObject() as? String {
+      try addJavaToSwiftMappings(to: &configuration, fileName: filePath)
+    }
+  }
+
   mutating func addJavaToSwiftMappings(
     to configuration: inout Configuration,
     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 {
-        continue
-      }
+      try addJavaToSwiftMappings(to: &configuration, fileName: entry.getName())
+    }
+  }
 
-      // Skip some "common" files we know that would be duplicated in every jar
-      guard !entry.getName().hasPrefix("META-INF") else {
-        continue
-      }
-      guard !entry.getName().hasSuffix("package-info") else {
-        continue
-      }
-      guard !entry.getName().hasSuffix("package-info.class") else {
-        continue
-      }
+  mutating func addJavaToSwiftMappings(
+    to configuration: inout Configuration,
+    fileName: String
+  ) throws {
+    // We only look at class files
+    guard fileName.hasSuffix(".class") else {
+      return
+    }
 
-      // If this is a local class, it cannot be mapped into Swift.
-      if entry.getName().isLocalJavaClass {
-        continue
-      }
+    // Skip some "common" files we know that would be duplicated in every jar
+    guard !fileName.hasPrefix("META-INF") else {
+      return
+    }
+    guard !fileName.hasSuffix("package-info") else {
+      return
+    }
+    guard !fileName.hasSuffix("package-info.class") else {
+      return
+    }
 
-      let javaCanonicalName = String(entry.getName().replacing("/", with: ".")
-        .dropLast(".class".count))
+    // If this is a local class, it cannot be mapped into Swift.
+    if fileName.isLocalJavaClass {
+      return
+    }
 
-      guard SwiftJava.shouldImport(javaCanonicalName: javaCanonicalName, commonOptions: self.commonOptions) else {
-        log.info("Skip importing class: \(javaCanonicalName) due to include/exclude filters")
-        continue
-      }
+    let javaCanonicalName = String(fileName.replacing("/", with: ".")
+      .dropLast(".class".count))
 
-      if configuration.classes?[javaCanonicalName] != nil {
-        // We never overwrite an existing class mapping configuration.
-        // E.g. the user may have configured a custom name for a type.
-        continue
-      }
+    guard SwiftJava.shouldImport(javaCanonicalName: javaCanonicalName, commonOptions: self.commonOptions) else {
+      log.info("Skip importing class: \(javaCanonicalName) due to include/exclude filters")
+      return
+    }
 
-      if configuration.classes == nil {
-        configuration.classes = [:]
-      }
+    if configuration.classes?[javaCanonicalName] != nil {
+      // We never overwrite an existing class mapping configuration.
+      // E.g. the user may have configured a custom name for a type.
+      return
+    }
 
-      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.")
-      }
+    if configuration.classes == nil {
+      configuration.classes = [:]
+    }
 
-      configuration.classes![javaCanonicalName] =
-        javaCanonicalName.defaultSwiftNameForJavaClass
+    var swiftName = javaCanonicalName.defaultSwiftNameForJavaClass
+    if let swiftPrefix {
+      swiftName = "\(swiftPrefix)\(swiftName)"
     }
+
+    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 '\(swiftName.bold)' Swift type.")
+    }
+
+    configuration.classes![javaCanonicalName] = swiftName
   }
 }
 

Sources/SwiftJavaTool/Commands/JExtractCommand.swift

@@ -81,6 +81,9 @@ extension SwiftJava {
 
     @Option(help: "The mode to use for extracting asynchronous Swift functions. By default async methods are extracted as Java functions returning CompletableFuture.")
     var asyncFuncMode: JExtractAsyncFuncMode?
+
+    @Flag
+    var swiftJavaConfigMode = false
   }
 }