Merge branch 'main' into wip-build-cleanup

Author: ktoso

Package.swift

@@ -53,37 +53,31 @@ let package = Package(
     // ==== JavaKit (i.e. calling Java directly Swift utilities)
     .library(
       name: "JavaKit",
-      type: .dynamic,
       targets: ["JavaKit"]
     ),
 
     .library(
       name: "JavaKitJar",
-      type: .dynamic,
       targets: ["JavaKitReflection"]
     ),
 
     .library(
       name: "JavaKitNetwork",
-      type: .dynamic,
       targets: ["JavaKitReflection"]
     ),
 
     .library(
       name: "JavaKitReflection",
-      type: .dynamic,
       targets: ["JavaKitReflection"]
     ),
 
     .library(
       name: "JavaKitVM",
-      type: .dynamic,
       targets: ["JavaKitVM"]
     ),
 
     .library(
       name: "JavaTypes",
-      type: .dynamic,
       targets: ["JavaTypes"]
     ),
 
@@ -108,7 +102,6 @@ let package = Package(
 
     .library(
       name: "JExtractSwift",
-      type: .dynamic,
       targets: ["JExtractSwift"]
     ),
 

Sources/Java2Swift/JavaToSwift.swift

@@ -19,7 +19,6 @@ import JavaKitJar
 import JavaKitNetwork
 import JavaKitReflection
 import JavaKitVM
-import JavaRuntime
 import SwiftSyntax
 import SwiftSyntaxBuilder
 

Sources/JavaKit/AnyJavaObject.swift

@@ -81,10 +81,12 @@ extension AnyJavaObject {
   }
 
   /// Retrieve the Java class for this type.
-  public static func getJNIClass(in environment: JNIEnvironment) -> jclass? {
-    return environment.interface.FindClass(
-      environment,
-      fullJavaClassNameWithSlashes
-    )
+  public static func getJNIClass(in environment: JNIEnvironment) throws -> jclass {
+    try environment.translatingJNIExceptions {
+      environment.interface.FindClass(
+        environment,
+        fullJavaClassNameWithSlashes
+      )
+    }!
   }
 }

Sources/JavaKit/BridgedValues/JavaValue+Array.swift

@@ -12,7 +12,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import JavaRuntime
 import JavaTypes
 
 extension Array: JavaValue where Element: JavaValue {

Sources/JavaKit/BridgedValues/JavaValue+Bool.swift

@@ -12,7 +12,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import JavaRuntime
 import JavaTypes
 
 extension Bool: JavaValue {

Sources/JavaKit/BridgedValues/JavaValue+FloatingPoint.swift

@@ -12,7 +12,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import JavaRuntime
 import JavaTypes
 
 extension Float: JavaValue {

Sources/JavaKit/BridgedValues/JavaValue+Integers.swift

@@ -12,7 +12,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import JavaRuntime
 import JavaTypes
 
 extension Int8: JavaValue {

Sources/JavaKit/BridgedValues/JavaValue+String.swift

@@ -12,7 +12,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import JavaRuntime
 import JavaTypes
 
 extension String: JavaValue {

Sources/JavaKit/Exceptions/ExceptionHandling.swift

@@ -42,7 +42,7 @@ extension JNIEnvironment {
     // Otherwise, create a exception with a message.
     _ = interface.ThrowNew(
       self,
-      JavaClass<Exception>.getJNIClass(in: self),
+      try! JavaClass<Exception>.getJNIClass(in: self),
       String(describing: error)
     )
   }

Sources/JavaKit/JavaClass.swift

@@ -17,4 +17,12 @@ import JavaRuntime
 /// Wrapper around a Java class that provides access to the static members of
 /// the class.
 @JavaClass("java.lang.Class")
-public struct JavaClass<ObjectType: AnyJavaObject> { }
+public struct JavaClass<ObjectType: AnyJavaObject> {
+  /// Lookup this Java class within the given environment.
+  public init(in environment: JNIEnvironment) throws {
+    self.init(
+      javaThis: try ObjectType.getJNIClass(in: environment),
+      environment: environment
+    )
+  }
+}

Sources/JavaKit/JavaObject+Inheritance.swift

@@ -27,7 +27,7 @@ extension AnyJavaObject {
   private func isInstanceOf<OtherClass: AnyJavaObject>(
     _ otherClass: OtherClass.Type
   ) -> jclass? {
-    guard let otherJavaClass = otherClass.getJNIClass(in: javaEnvironment) else {
+    guard let otherJavaClass = try? otherClass.getJNIClass(in: javaEnvironment) else {
       return nil
     }
 

Sources/JavaKit/JavaObject+MethodCalls.swift

@@ -247,7 +247,7 @@ extension AnyJavaObject {
     in environment: JNIEnvironment,
     arguments: repeat each Param
   ) throws -> Self {
-    let thisClass = Self.getJNIClass(in: environment)!
+    let thisClass = try Self.getJNIClass(in: environment)
 
     // Compute the method signature so we can find the right method, then look up the
     // method within the class.

Sources/JavaKit/JavaRuntime+Reexport.swift

@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+@_exported import JavaRuntime

Sources/JavaKit/Optional+JavaObject.swift

@@ -70,7 +70,7 @@ extension Optional: JavaValue where Wrapped: AnyJavaObject {
 
   public static func jniNewArray(in environment: JNIEnvironment) -> JNINewArray {
     return { environment, size in
-      let jniClass = Wrapped.getJNIClass(in: environment)
+      let jniClass = try! Wrapped.getJNIClass(in: environment)
       return environment.interface.NewObjectArray(environment, size, jniClass, nil)
     }
   }

Sources/JavaKitVM/JavaVirtualMachine.swift

@@ -13,7 +13,6 @@
 //===----------------------------------------------------------------------===//
 
 import JavaKit
-import JavaRuntime
 
 typealias JavaVMPointer = UnsafeMutablePointer<JavaVM?>
 
@@ -24,19 +23,41 @@ public final class JavaVirtualMachine: @unchecked Sendable {
   /// The JNI environment for the JVM.
   public let environment: JNIEnvironment
 
-  public init(vmOptions: [String] = []) throws {
+  /// Initialize a new Java virtual machine instance.
+  ///
+  /// - Parameters:
+  ///   - classPath: The directories, JAR files, and ZIP files in which the JVM
+  ///     should look to find classes. This maps to the VM option
+  ///     `-Djava.class.path=`.
+  ///   - vmOptions: Options that should be passed along to the JVM, which will
+  ///     be prefixed by the class-path argument described above.
+  ///   - ignoreUnrecognized: Whether the JVM should ignore any VM options it
+  ///     does not recognize.
+  public init(
+    classPath: [String] = [],
+    vmOptions: [String] = [],
+    ignoreUnrecognized: Bool = true
+  ) throws {
     var jvm: JavaVMPointer? = nil
     var environment: UnsafeMutableRawPointer? = nil
     var vmArgs = JavaVMInitArgs()
-    vmArgs.version = JNI_VERSION_21
-    vmArgs.ignoreUnrecognized = jboolean(JNI_TRUE)
+    vmArgs.version = JNI_VERSION_1_6
+    vmArgs.ignoreUnrecognized = jboolean(ignoreUnrecognized ? JNI_TRUE : JNI_FALSE)
+
+    // Construct the complete list of VM options.
+    var allVMOptions: [String] = []
+    if !classPath.isEmpty {
+      let colonSeparatedClassPath = classPath.joined(separator: ":")
+      allVMOptions.append("-Djava.class.path=\(colonSeparatedClassPath)")
+    }
+    allVMOptions.append(contentsOf: vmOptions)
 
     // Convert the options
-    let optionsBuffer = UnsafeMutableBufferPointer<JavaVMOption>.allocate(capacity: vmOptions.count)
+    let optionsBuffer = UnsafeMutableBufferPointer<JavaVMOption>.allocate(capacity: allVMOptions.count)
     defer {
       optionsBuffer.deallocate()
     }
-    for (index, vmOption) in vmOptions.enumerated() {
+    for (index, vmOption) in allVMOptions.enumerated() {
       let optionString = vmOption.utf8CString.withUnsafeBufferPointer { buffer in
         let cString = UnsafeMutableBufferPointer<CChar>.allocate(capacity: buffer.count + 1)
         _ = cString.initialize(from: buffer)

Tests/JavaKitTests/BasicRuntimeTests.swift

@@ -15,7 +15,6 @@
 import JavaKit
 import JavaKitNetwork
 import JavaKitVM
-import JavaRuntime
 import Testing
 
 @MainActor
@@ -24,8 +23,7 @@ let jvm = try! JavaVirtualMachine(vmOptions: [])
 @Suite
 @MainActor
 struct BasicRuntimeTests {
-
-  @Test("Object management")
+  @Test("Object management", .disabled(if: isLinux, "Attempts to refcount a null pointer on Linux"))
   func javaObjectManagement() throws {
     let sneakyJavaThis: jobject
     do {
@@ -51,8 +49,8 @@ struct BasicRuntimeTests {
     #expect(url.javaHolder === urlAgain.javaHolder)
   }
 
-  @Test("Java exceptions")
-  func javaExceptionsInSwift() async throws {
+  @Test("Java exceptions", .disabled(if: isLinux, "Attempts to refcount a null pointer on Linux"))
+  func javaExceptionsInSwift() throws {
     do {
       _ = try URL("bad url", environment: jvm.environment)
     } catch {
@@ -61,12 +59,29 @@ struct BasicRuntimeTests {
   }
 
   @Test("Static methods", .disabled("Fails on macOS command line"))
-  func staticMethods() {
-    let urlConnectionClass = JavaClass<URLConnection>(
-      javaThis: URLConnection.getJNIClass(in: jvm.environment)!,
-      environment: jvm.environment
-    )
-
+  func staticMethods() throws {
+    let urlConnectionClass = try JavaClass<URLConnection>(in: jvm.environment)
     #expect(urlConnectionClass.getDefaultAllowUserInteraction() == false)
   }
+
+  @Test("Class instance lookup")
+  func classInstanceLookup() throws {
+    do {
+      _ = try JavaClass<Nonexistent>(in: jvm.environment)
+    } catch {
+      #expect(String(describing: error) == "org/swift/javakit/Nonexistent")
+    }
+  }
+}
+
+@JavaClass("org.swift.javakit.Nonexistent")
+struct Nonexistent { }
+
+/// Whether we're running on Linux.
+var isLinux: Bool {
+  #if os(Linux)
+  return true
+  #else
+  return false
+  #endif
 }

USER_GUIDE.md

@@ -57,7 +57,6 @@ Now, in the `HelloSwift` Swift library, define a `struct` that provides the `mai
 
 ```swift
 import JavaKit
-import JavaRuntime
 
 @JavaClass("org.swift.javakit.HelloSwiftMain")
 struct HelloSwiftMain {
@@ -87,7 +86,6 @@ The easiest way to build a command-line program in Swift is with the [Swift argu
 ```swift
 import ArgumentParser
 import JavaKit
-import JavaRuntime
 
 @JavaClass("org.swift.javakit.HelloSwiftMain")
 struct HelloSwiftMain: ParsableCommand {