wrap-java: generate genericResult info in @JavaMethods

Author: ktoso

Sources/SwiftJava/Macros.swift

@@ -123,6 +123,22 @@ public macro JavaStaticField(_ javaFieldName: String? = nil, isFinal: Bool = fal
 /// ```
 ///
 /// corresponds to the Java constructor `HelloSwift(String name)`.
+/// 
+/// ### Generics and type-erasure
+/// Swift and Java differ in how they represent generics at runtime.
+/// In Java, generics are type-erased and the JVM representation of generic types is erased to `java.lang.Object`.
+/// Swift on the other hand, reifies types which means a `Test<T>` in practice will be a specific type with 
+/// the generic substituted `Test<String>`. This means that at runtime, calling a generic @JavaMethod needs to know
+/// which of the parameters (or result type) must be subjected to type-erasure as we form the call into the Java function.
+/// 
+/// In order to mark a generic return type you must indicate it to the @JavaMethod macro like this:
+/// ```swift
+/// // Java: class Test<T> { public <T> get(); }
+/// @JavaMethod(genericResult: "T!")
+/// func get() -> T!
+/// ```
+/// This allows the macro to form a call into the get() method, which at runtime, will have an `java.lang.Object` 
+/// returning method signature, and then, convert the result to the expected `T` type on the Swift side.
 @attached(body)
 public macro JavaMethod(
   genericResult: String? = nil

Sources/SwiftJavaToolLib/JavaClassTranslator.swift

@@ -643,11 +643,8 @@ extension JavaClassTranslator {
       preferValueTypes: true, 
       outerOptional: .implicitlyUnwrappedOptional
     )
-    // let resultType = try translator.getSwiftTypeNameAsString(
-    //   javaMethod.getGenericReturnType()!,
-    //   preferValueTypes: true,
-    //   outerOptional: .implicitlyUnwrappedOptional
-    // )
+    let typeEraseGenericResultType: Bool = 
+      isGenericJavaType(javaMethod.getGenericReturnType())
 
     // FIXME: cleanup the checking here
     if resultType != "Void" && resultType != "Swift.Void" {
@@ -659,9 +656,33 @@ extension JavaClassTranslator {
     // --- Handle other effects
     let throwsStr = javaMethod.throwsCheckedException ? "throws" : ""
     let swiftMethodName = javaMethod.getName().escapedSwiftName
-    let methodAttribute: AttributeSyntax = implementedInSwift
-      ? ""
-      : javaMethod.isStatic ? "@JavaStaticMethod\n" : "@JavaMethod\n";
+    
+    // Compute the '@...JavaMethod(...)' details
+    let methodAttribute: AttributeSyntax
+      if implementedInSwift {
+        methodAttribute = ""
+      } else {
+        var methodAttributeStr =
+          if javaMethod.isStatic {
+            "@JavaStaticMethod"
+          } else {
+            "@JavaMethod"
+          }
+        // Do we need to record any generic information, in order to enable type-erasure for the upcalls?
+        var parameters: [String] = []
+        if typeEraseGenericResultType {
+          parameters.append("genericResult: \"\(resultType)\"")
+        }
+        // TODO: generic parameters?
+        if !parameters.isEmpty {
+          methodAttributeStr += "("
+          methodAttributeStr.append(parameters.joined(separator: ", "))
+          methodAttributeStr += ")"
+        }
+        methodAttributeStr += "\n"
+        methodAttribute = "\(raw: methodAttributeStr)"
+      }
+
     let accessModifier = implementedInSwift ? ""
       : (javaMethod.isStatic || !translateAsClass) ? "public "
       : "open "

Tests/SwiftJavaToolLibTests/WrapJavaTests.swift

@@ -227,7 +227,7 @@ final class WrapJavaTests: XCTestCase {
     )
   }
 
-  func testGenericSuperclass() async throws {
+  func testWrapJavaGenericSuperclass() async throws {
     return  // FIXME: we need this 
 
     let classpathURL = try await compileJava(
@@ -270,4 +270,35 @@ final class WrapJavaTests: XCTestCase {
       ]
     )
   }
+
+  func testWrapJavaGenericMethodTypeErasure_returnType() async throws {
+    let classpathURL = try await compileJava(
+      """
+      package com.example;
+
+      final class Kappa<T> { 
+        public T get() { return null; }
+      }
+      """)
+
+    try assertWrapJavaOutput(
+      javaClassNames: [
+        "com.example.Kappa",
+      ],
+      classpath: [classpathURL],
+      expectedChunks: [
+        """
+        import CSwiftJavaJNI
+        import SwiftJava
+        """,
+        """
+        @JavaClass("com.example.Kappa")
+        open class Kappa<T: AnyJavaObject>: JavaObject {
+          @JavaMethod(genericResult: "T!")
+          open func get() -> T!
+        }
+        """
+      ]
+    )
+  }
 }