javakit-macros: Support wrapping generic arguments

Sources/SwiftJava/Optional+JavaOptional.swift

@@ -14,7 +14,7 @@
 
 extension Optional where Wrapped: AnyJavaObject {
   public func toJavaOptional() -> JavaOptional<Wrapped> {
-    try! JavaClass<JavaOptional<Wrapped>>().ofNullable(self?.as(JavaObject.self)).as(JavaOptional<Wrapped>.self)!
+    try! JavaClass<JavaOptional<Wrapped>>().ofNullable(self)
   }
 
   public init(javaOptional: JavaOptional<Wrapped>?) {
@@ -29,7 +29,7 @@ extension Optional where Wrapped: AnyJavaObject {
 extension Optional where Wrapped == String {
   public func toJavaOptional() -> JavaOptional<JavaString> {
     if let self {
-      return try! JavaClass<JavaOptional<JavaString>>().of(JavaString(self).as(JavaObject.self)).as(JavaOptional<JavaString>.self)!
+      return try! JavaClass<JavaOptional<JavaString>>().of(JavaString(self))
     } else {
       return try! JavaClass<JavaOptional<JavaString>>().empty().as(JavaOptional<JavaString>.self)!
     }

Sources/SwiftJava/generated/JavaOptional.swift

@@ -3,51 +3,115 @@ import SwiftJavaJNICore
 
 @JavaClass("java.util.Optional")
 open class JavaOptional<T: AnyJavaObject>: JavaObject {
-  @JavaMethod(typeErasedResult: "T")
+  /// Java method `get`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public T java.util.Optional.get()
+  /// ```
+  @JavaMethod(typeErasedResult: "T!")
   open func get() -> T!
 
+  /// Java method `equals`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public boolean java.util.Optional.equals(java.lang.Object)
+  /// ```
   @JavaMethod
   open override func equals(_ arg0: JavaObject?) -> Bool
 
+  /// Java method `toString`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public java.lang.String java.util.Optional.toString()
+  /// ```
   @JavaMethod
   open override func toString() -> String
 
+  /// Java method `hashCode`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public int java.util.Optional.hashCode()
+  /// ```
   @JavaMethod
   open override func hashCode() -> Int32
 
+  /// Java method `isEmpty`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public boolean java.util.Optional.isEmpty()
+  /// ```
   @JavaMethod
   open func isEmpty() -> Bool
 
-  @JavaMethod
-  open func isPresent() -> Bool
+  /// Java method `orElse`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public T java.util.Optional.orElse(T)
+  /// ```
+  @JavaMethod(typeErasedResult: "T!")
+  open func orElse(_ arg0: T?) -> T!
 
+  /// Java method `isPresent`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public boolean java.util.Optional.isPresent()
+  /// ```
   @JavaMethod
-  open func orElse(_ arg0: JavaObject?) -> JavaObject!
+  open func isPresent() -> Bool
 
-  @JavaMethod
-  open func orElseThrow() -> JavaObject!
+  /// Java method `orElseThrow`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public T java.util.Optional.orElseThrow()
+  /// ```
+  @JavaMethod(typeErasedResult: "T!")
+  open func orElseThrow() -> T!
 }
 extension JavaClass {
+  /// Java method `of`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public static <T> java.util.Optional<T> java.util.Optional.of(T)
+  /// ```
   @JavaStaticMethod
-  public func of<T: AnyJavaObject>(_ arg0: JavaObject?) -> JavaOptional<JavaObject>! where ObjectType == JavaOptional<T>
+  public func of<T: AnyJavaObject>(_ arg0: T?) -> JavaOptional<T>! where ObjectType == JavaOptional<T>
 
-  public func ofOptional<T: AnyJavaObject>(_ arg0: JavaObject?) -> JavaObject? where ObjectType == JavaOptional<T> {
+  public func ofOptional<T: AnyJavaObject>(_ arg0: T?) -> T? where ObjectType == JavaOptional<T> {
     Optional(javaOptional: of(arg0))
   }
 
+  /// Java method `empty`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public static <T> java.util.Optional<T> java.util.Optional.empty()
+  /// ```
   @JavaStaticMethod
-  public func empty<T: AnyJavaObject>() -> JavaOptional<JavaObject>! where ObjectType == JavaOptional<T>
+  public func empty<T: AnyJavaObject>() -> JavaOptional<T>! where ObjectType == JavaOptional<T>
 
-  public func emptyOptional<T: AnyJavaObject>() -> JavaObject? where ObjectType == JavaOptional<T> {
+  public func emptyOptional<T: AnyJavaObject>() -> T? where ObjectType == JavaOptional<T> {
     Optional(javaOptional: empty())
   }
 
+  /// Java method `ofNullable`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public static <T> java.util.Optional<T> java.util.Optional.ofNullable(T)
+  /// ```
   @JavaStaticMethod
-  public func ofNullable<T: AnyJavaObject>(_ arg0: JavaObject?) -> JavaOptional<JavaObject>!
-  where ObjectType == JavaOptional<T>
+  public func ofNullable<T: AnyJavaObject>(_ arg0: T?) -> JavaOptional<T>! where ObjectType == JavaOptional<T>
 
-  public func ofNullableOptional<T: AnyJavaObject>(_ arg0: JavaObject?) -> JavaObject?
-  where ObjectType == JavaOptional<T> {
+  public func ofNullableOptional<T: AnyJavaObject>(_ arg0: T?) -> T? where ObjectType == JavaOptional<T> {
     Optional(javaOptional: ofNullable(arg0))
   }
 }

Sources/SwiftJava/generated/List.swift

@@ -33,11 +33,23 @@ public struct List<E: AnyJavaObject> {
   @JavaMethod
   public func isEmpty() -> Bool
 
-  @JavaMethod
-  public func add(_ arg0: JavaObject?) -> Bool
-
-  @JavaMethod
-  public func add(_ arg0: Int32, _ arg1: JavaObject?)
+  /// Java method `add`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public abstract void java.util.List.add(int,E)
+  /// ```
+  @JavaMethod
+  public func add(_ arg0: Int32, _ arg1: E?)
+
+  /// Java method `add`.
+  ///
+  /// ### Java method signature
+  /// ```java
+  /// public abstract boolean java.util.List.add(E)
+  /// ```
+  @JavaMethod
+  public func add(_ arg0: E?) -> Bool
 
   @JavaMethod
   public func subList(_ arg0: Int32, _ arg1: Int32) -> List<JavaObject>!

Sources/SwiftJavaMacros/JavaMethodMacro.swift

@@ -50,6 +50,8 @@ extension JavaMethodMacro: BodyMacro {
       fatalError("not a function: \(declaration)")
     }
 
+    var resultStatements: [CodeBlockItemSyntax] = []
+
     let funcName =
       if case .argumentList(let arguments) = node.arguments,
         let argument = arguments.first,
@@ -65,7 +67,28 @@ extension JavaMethodMacro: BodyMacro {
 
     let isStatic = node.attributeName.trimmedDescription == "JavaStaticMethod"
     let params = funcDecl.signature.parameterClause.parameters
-    let paramNames = params.map { param in param.parameterName?.text ?? "" }.joined(separator: ", ")
+
+    var paramNames: [String] = []
+    for param in params {
+      guard let name = param.parameterName else {
+        throw MacroErrors.parameterMustHaveName(method: funcName, paramSyntax: param.trimmedDescription)
+      }
+      if isJNIGenericParameter(param.type, funcDecl: funcDecl, in: context) {
+        let erasedName: TokenSyntax = "\(name)$erased"
+        if param.type.optionalUnwrappedType() != nil {
+          resultStatements.append(
+            "let \(erasedName) = \(name).map { JavaObject(javaHolder: $0.javaHolder) }"
+          )
+        } else {
+          resultStatements.append(
+            "let \(erasedName) = JavaObject(javaHolder: \(name).javaHolder)"
+          )
+        }
+        paramNames.append(erasedName.text)
+      } else {
+        paramNames.append(name.text)
+      }
+    }
 
     let genericResultType: String? =
       if case let .argumentList(arguments) = node.arguments,
@@ -106,7 +129,7 @@ extension JavaMethodMacro: BodyMacro {
     if paramNames.isEmpty {
       parametersAsArgs = ""
     } else {
-      parametersAsArgs = ", arguments: \(paramNames)"
+      parametersAsArgs = ", arguments: \(paramNames.joined(separator: ", "))"
     }
 
     let canRethrowError = funcDecl.signature.effectSpecifiers?.throwsClause != nil
@@ -137,23 +160,60 @@ extension JavaMethodMacro: BodyMacro {
       """
 
     if let genericResultType {
-      return [
+      resultStatements.append(
         """
         /* convert erased return value to \(raw: genericResultType) */
         let result$ = \(resultSyntax)
+        """
+      )
+      resultStatements.append(
+        """
         if let result$ {
           return \(raw: genericResultType)(javaThis: result$.javaThis, environment: try! JavaVirtualMachine.shared().environment())
         } else {
           return nil
         }
         """
-      ]
+      )
+    } else {
+      // no return type conversions
+      resultStatements.append("return \(resultSyntax)")
     }
 
-    // no return type conversions
-    return [
-      "return \(resultSyntax)"
-    ]
+    return resultStatements
+  }
+
+  /// Determines whether an argument is generic in heuristic way.
+  /// Since Optional does not appear in JNI signatures, it is removed before checking.
+  /// FIXME: It might be preferable to explicitly specify the type from JavaClass, similar to `typeErasedResult`.
+  private static func isJNIGenericParameter(
+    _ type: TypeSyntax,
+    funcDecl: FunctionDeclSyntax,
+    in context: some MacroExpansionContext
+  ) -> Bool {
+    let baseType = type.optionalUnwrappedType() ?? type
+    guard let identifier = baseType.as(IdentifierTypeSyntax.self) else {
+      return false
+    }
+    let typeName = identifier.name.text
+
+    if let genericParams = funcDecl.genericParameterClause?.parameters {
+      if genericParams.contains(where: { $0.name.text == typeName }) {
+        return true
+      }
+    }
+
+    for contextNode in context.lexicalContext {
+      if let decl = contextNode.asProtocol(WithGenericParametersSyntax.self) {
+        if decl.genericParameterClause?.parameters.contains(where: {
+          $0.name.text == typeName
+        }) == true {
+          return true
+        }
+      }
+    }
+
+    return false
   }
 
   /// Bridge an initializer into a call to Java.
@@ -238,4 +298,23 @@ extension TypeSyntaxProtocol {
   var typeReferenceString: String {
     typeReference.description
   }
+
+  func optionalUnwrappedType() -> TypeSyntax? {
+    if let optionalType = self.as(OptionalTypeSyntax.self) {
+      return optionalType.wrappedType
+    }
+
+    if let implicitlyUnwrappedType = self.as(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
+      return implicitlyUnwrappedType.wrappedType
+    }
+
+    if let identifierType = self.as(IdentifierTypeSyntax.self),
+      identifierType.name.text == "Optional",
+      let genericArgumentClause = identifierType.genericArgumentClause
+    {
+      return genericArgumentClause.arguments.first?.argument.as(TypeSyntax.self)
+    }
+
+    return nil
+  }
 }

Sources/SwiftJavaMacros/MacroErrors.swift

@@ -21,4 +21,5 @@ enum MacroErrors: Error {
   case methodNotOnFunction
   case missingEnvironment
   case macroOutOfContext(String)
+  case parameterMustHaveName(method: String, paramSyntax: String)
 }