Improve Optional handling, and generic get() -> T

Author: ktoso

Sources/SwiftJava/AnyJavaObject.swift

@@ -59,7 +59,11 @@ public protocol AnyJavaObjectWithCustomClassLoader: AnyJavaObject {
 extension AnyJavaObject {
   /// Retrieve the underlying Java object.
   public var javaThis: jobject {
-    javaHolder.object!
+    javaHolder.object! // FIXME: this is a bad idea, can be null
+  }
+  
+  public var javaThisOptional: jobject? {
+    javaHolder.object
   }
 
   /// Retrieve the environment in which this Java object resides.

Sources/SwiftJava/JavaObject+Inheritance.swift

@@ -22,16 +22,16 @@ extension AnyJavaObject {
   private func isInstanceOf<OtherClass: AnyJavaObject>(
     _ otherClass: OtherClass.Type
   ) -> jclass? {
-    try? otherClass.withJNIClass(in: javaEnvironment) { otherJavaClass in
-      if javaEnvironment.interface.IsInstanceOf(
-       javaEnvironment,
-       javaThis,
-       otherJavaClass
-     ) == 0 {
-       return nil
-     }
+    guard let this: jobject = javaThisOptional else {
+      return nil 
+    }
+
+    return try? otherClass.withJNIClass(in: javaEnvironment) { otherJavaClass in
+      if javaEnvironment.interface.IsInstanceOf(javaEnvironment, this, otherJavaClass) == 0 { 
+        return nil
+      }
 
-     return otherJavaClass
+      return otherJavaClass
     }
   }
 

Sources/SwiftJava/JavaString+Extensions.swift

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 CSwiftJavaJNI
+import JavaTypes
+
+extension JavaString: CustomStringConvertible, CustomDebugStringConvertible { 
+  public var description: String {
+    return toString()
+  }
+  public var debugDescription: String {
+    return "\"" + toString() + "\""
+  }
+}
+
+extension Optional where Wrapped == JavaString {
+  public var description: String {
+    switch self { 
+      case .some(let value): "Optional(\(value.toString())"
+      case .none: "nil"
+    }
+  }
+}

Sources/SwiftJava/Macros.swift

@@ -124,7 +124,9 @@ public macro JavaStaticField(_ javaFieldName: String? = nil, isFinal: Bool = fal
 ///
 /// corresponds to the Java constructor `HelloSwift(String name)`.
 @attached(body)
-public macro JavaMethod() = #externalMacro(module: "SwiftJavaMacros", type: "JavaMethodMacro")
+public macro JavaMethod(
+  genericResult: String? = nil
+) = #externalMacro(module: "SwiftJavaMacros", type: "JavaMethodMacro")
 
 /// Attached macro that turns a Swift method on JavaClass into one that wraps
 /// a Java static method on the underlying Java class object.

Sources/SwiftJava/Optional+JavaOptional.swift

@@ -79,3 +79,17 @@ public extension Optional where Wrapped == Int64 {
     }
   }
 }
+
+extension JavaOptional {
+  public func empty(environment: JNIEnvironment? = nil) -> JavaOptional<T>! {
+    guard let env = try? environment ?? JavaVirtualMachine.shared().environment() else {
+      return nil
+    }
+
+    guard let opt = try? JavaClass<JavaOptional<T>>(environment: env).empty() else {
+      return nil
+    }
+
+    return opt.as(JavaOptional<T>.self)
+  }
+}

Sources/SwiftJava/String+Extensions.swift

@@ -13,10 +13,6 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
-// import SwiftJavaToolLib
-// import SwiftJava
-// import JavaUtilJar
-// import SwiftJavaConfigurationShared
 
 extension String {
   /// For a String that's of the form java.util.Vector, return the "Vector"

Sources/SwiftJava/generated/JavaOptional.swift

@@ -3,8 +3,8 @@ import CSwiftJavaJNI
 
 @JavaClass("java.util.Optional")
 open class JavaOptional<T: AnyJavaObject>: JavaObject {
-  @JavaMethod
-  open func get() -> JavaObject! // FIXME: Currently we do generate -> T https://github.com/swiftlang/swift-java/issues/439
+  @JavaMethod(genericResult: "T")
+  open func get() -> T!
 
   @JavaMethod
   open override func equals(_ arg0: JavaObject?) -> Bool

Sources/SwiftJavaMacros/JavaMethodMacro.swift

@@ -47,18 +47,41 @@ extension JavaMethodMacro: BodyMacro {
     }
 
     guard let funcDecl = declaration.as(FunctionDeclSyntax.self) else {
-      fatalError("not a function")
+      fatalError("not a function: \(declaration)")
     }
 
     let isStatic = node.attributeName.trimmedDescription == "JavaStaticMethod"
     let funcName = funcDecl.name.text
     let params = funcDecl.signature.parameterClause.parameters
-    let resultType: String =
-      funcDecl.signature.returnClause.map { result in
-        ", resultType: \(result.type.typeReferenceString).self"
-      } ?? ""
     let paramNames = params.map { param in param.parameterName?.text ?? "" }.joined(separator: ", ")
 
+    let genericResultType: String? =
+      if case let .argumentList(arguments) = node.arguments,
+        let firstElement = arguments.first,
+        let stringLiteral = firstElement.expression
+          .as(StringLiteralExprSyntax.self),
+        stringLiteral.segments.count == 1,
+        case let .stringSegment(wrapperName)? = stringLiteral.segments.first {
+          "\(wrapperName)"
+      } else {
+        nil
+      }
+
+    // Determine the result type
+    let resultType: String =
+      if let returnClause = funcDecl.signature.returnClause {
+        if let genericResultType {
+          // we need to type-erase the signature, because on JVM level generics are erased and we'd otherwise
+          // form a signature with the "concrete" type, which would not match the real byte-code level signature 
+          // of the method we're trying to call -- which would result in a MethodNotFound exception.
+          ", resultType: /*type-erased:\(genericResultType)*/JavaObject?.self"
+        } else {
+          ", resultType: \(returnClause.type.typeReferenceString).self"
+        }
+      } else {
+        ""
+      }
+
     let parametersAsArgs: String
     if paramNames.isEmpty {
       parametersAsArgs = ""
@@ -70,8 +93,25 @@ extension JavaMethodMacro: BodyMacro {
       funcDecl.signature.effectSpecifiers?.throwsClause != nil
       ? "try" : "try!"
 
+    let resultSyntax: CodeBlockItemSyntax =
+      "\(raw: tryKeyword) dynamicJava\(raw: isStatic ? "Static" : "")MethodCall(methodName: \(literal: funcName)\(raw: parametersAsArgs)\(raw: resultType))"
+
+    if let genericResultType {
+      return [
+        """
+        /* convert erased return value to \(raw: genericResultType) */
+        if let result$ = \(resultSyntax) {
+          return \(raw: genericResultType)(javaThis: result$.javaThis, environment: try! JavaVirtualMachine.shared().environment())
+        } else {
+          return nil
+        }
+        """
+      ]
+    }
+
+    // no return type conversions
     return [
-      "return \(raw: tryKeyword) dynamicJava\(raw: isStatic ? "Static" : "")MethodCall(methodName: \(literal: funcName)\(raw: parametersAsArgs)\(raw: resultType))"
+      "return \(resultSyntax)"
     ]
   }
 

Tests/SwiftJavaMacrosTests/JavaClassMacroTests.swift

@@ -296,5 +296,34 @@ class JavaKitMacroTests: XCTestCase {
       macros: Self.javaKitMacros
     )
   }
+
+  func testJavaOptionalGenericGet() throws {
+    assertMacroExpansion("""
+        @JavaClass("java.lang.Optional")
+        open class JavaOptional<T: AnyJavaObject>: JavaObject {
+          @JavaMethod(genericResult: "T")
+          open func get() -> T!
+        }
+      """,
+      expandedSource: """
+
+        open class JavaOptional<T: AnyJavaObject>: JavaObject {
+          open func get() -> T! {
+              return try! dynamicJavaMethodCall(methodName: "get", resultType: /*type-erased:T*/ JavaObject?.self)
+          }
+
+            /// The full Java class name for this Swift type.
+            open override class var fullJavaClassName: String {
+                "java.lang.Optional"
+            }
+
+            public required init(javaHolder: JavaObjectHolder) {
+                super.init(javaHolder: javaHolder)
+            }
+        }
+      """,
+      macros: Self.javaKitMacros
+    )
+  }
 }