further improvements in handling type erased return types

Author: ktoso

Sources/SwiftJavaToolLib/JavaClassTranslator.swift

@@ -610,18 +610,19 @@ extension JavaClassTranslator {
   // TODO: make it more precise with the "origin" of the generic parameter (outer class etc)
   func collectMethodGenericParameters(
     genericParameters: [String],
-    method javaMethod: Method
+    method: Method
   ) -> OrderedSet<String> {
     var allGenericParameters = OrderedSet(genericParameters)
-    let typeParameters = javaMethod.getTypeParameters()
-    if typeParameters.contains(where: {$0 != nil }) {
-      allGenericParameters.appending(contentsOf: typeParameters.compactMap { typeParam in 
-        guard let typeParam else { return nil }
-        guard genericParameterIsUsedInSignature(typeParam, in: javaMethod) else {
-          return nil
-        }
-        return "\(typeParam.getTypeName()): AnyJavaObject"
-      })
+    
+    let typeParameters = method.getTypeParameters()
+    for typeParameter in typeParameters {
+      guard let typeParameter else { continue }
+      
+      guard genericParameterIsUsedInSignature(typeParameter, in: method) else {
+        continue
+      }
+
+      allGenericParameters.append("\(typeParameter.getTypeName()): AnyJavaObject")
     }
 
     return allGenericParameters
@@ -654,8 +655,8 @@ extension JavaClassTranslator {
       preferValueTypes: true, 
       outerOptional: .implicitlyUnwrappedOptional
     )
-    let typeEraseGenericResultType: Bool = 
-      isGenericJavaType(javaMethod.getGenericReturnType())
+    let hasTypeEraseGenericResultType: Bool = 
+      isTypeErased(javaMethod.getGenericReturnType())
 
     // FIXME: cleanup the checking here
     if resultType != "Void" && resultType != "Swift.Void" {
@@ -681,7 +682,7 @@ extension JavaClassTranslator {
           }
         // Do we need to record any generic information, in order to enable type-erasure for the upcalls?
         var parameters: [String] = []
-        if typeEraseGenericResultType {
+        if hasTypeEraseGenericResultType {
           parameters.append("genericResult: \"\(resultType)\"")
         }
         // TODO: generic parameters?
@@ -951,7 +952,7 @@ extension JavaClassTranslator {
           return true
         }
       } catch {
-        log.warning("Failed to determine if method '\(method)' is an override, error: \(error)")
+        log.debug("Failed to determine if method '\(method)' is an override, error: \(error)")
       }
     }
 

Sources/SwiftJavaToolLib/JavaGenericsSupport.swift

@@ -87,3 +87,25 @@ func isGenericJavaType(_ type: Type?) -> Bool {
 
   return false
 }
+
+/// Check if a type is type-erased att runtime.
+/// 
+/// E.g. in a method returning a generic `T` the T is type erased and must 
+/// be represented as a `java.lang.Object` instead.
+func isTypeErased(_ type: Type?) -> Bool {
+  guard let type else {
+    return false
+  }
+
+  // Check if it's a type variable (e.g., T, E, etc.)
+  if type.as(TypeVariable<JavaObject>.self) != nil {
+    return true
+  }
+
+  // Check if it's a wildcard type (e.g., ? extends Number, ? super String)
+  if type.as(WildcardType.self) != nil {
+    return true
+  }
+
+  return false
+}

Sources/SwiftJavaToolLib/JavaTranslator.swift

@@ -133,7 +133,6 @@ extension JavaTranslator {
     preferValueTypes: Bool,
     outerOptional: OptionalKind
   ) throws -> String {
-    // let returnType = method.getReturnType()
     let genericReturnType = method.getGenericReturnType()
 
     // Special handle the case when the return type is the generic type of the method: `<T> T foo()`

Tests/SwiftJavaToolLibTests/Java2SwiftTests.swift

@@ -262,7 +262,7 @@ class Java2SwiftTests: XCTestCase {
         public struct MyJavaObjects {
         """,
         """
-        @JavaStaticMethod
+        @JavaStaticMethod(genericResult: "T!")
         public func requireNonNull<T: AnyJavaObject>(_ arg0: T?, _ arg1: MySupplier<JavaString>?) -> T
         """,
       ]
@@ -475,7 +475,7 @@ class Java2SwiftTests: XCTestCase {
         public struct MyJavaIntFunction<R: AnyJavaObject> {
         """,
         """
-        @JavaMethod
+        @JavaMethod(genericResult: "R!")
         public func apply(_ arg0: Int32) -> R!
         """,
       ]

Tests/SwiftJavaToolLibTests/WrapJavaTests/GenericsWrapJavaTests.swift

@@ -62,8 +62,8 @@ final class GenericsWrapJavaTests: XCTestCase {
         open class ExampleSimpleClass: JavaObject {
         """,
         """
-        @JavaMethod
-        open func getGeneric<KeyType: AnyJavaObject>(_ arg0: Item<KeyType>?) -> KeyType
+        @JavaMethod(genericResult: "KeyType!")
+        open func getGeneric<KeyType: AnyJavaObject>(_ arg0: Item<KeyType>?) -> KeyType!
         """,
       ]
     )
@@ -100,8 +100,8 @@ final class GenericsWrapJavaTests: XCTestCase {
       classpath: [classpathURL],
       expectedChunks: [
         """
-        @JavaMethod
-        open func getGeneric<KeyType: AnyJavaObject>() -> KeyType
+        @JavaMethod(genericResult: "KeyType!")
+        open func getGeneric<KeyType: AnyJavaObject>() -> KeyType!
         """,
       ]
     )
@@ -162,8 +162,10 @@ final class GenericsWrapJavaTests: XCTestCase {
       """
       package com.example;
 
+      // Mini decls in order to avoid warnings about some funcs we're not yet importing cleanly
       final class List<T> {}
       final class Map<T, U> {}
+      final class Number {}
 
       class GenericClass<T> {
         public T getClassGeneric() { return null; }
@@ -184,18 +186,41 @@ final class GenericsWrapJavaTests: XCTestCase {
 
     try assertWrapJavaOutput(
       javaClassNames: [
+        "com.example.Map",
+        "com.example.List",
+        "com.example.Number",
         "com.example.GenericClass",
       ],
       classpath: [classpathURL],
       expectedChunks: [
+        """
+        @JavaMethod(genericResult: "T!")
+        open func getClassGeneric() -> T!
+        """,
+        """
+        @JavaMethod(genericResult: "M!")
+        open func getMethodGeneric<M: AnyJavaObject>() -> M!
+        """,
         """
         @JavaMethod
-        open func getClassGeneric() -> T
+        open func getMixedGeneric<M: AnyJavaObject>() -> Map<T, M>!
         """,
         """
         @JavaMethod
         open func getNonGeneric() -> String
         """,
+        """
+        @JavaMethod
+        open func getParameterizedClassGeneric() -> List<T>!
+        """,
+        """
+        @JavaMethod
+        open func getWildcard() -> List<Number>!
+        """,
+        """
+        @JavaMethod
+        open func getGenericArray() -> [T?]
+        """,
       ]
     )
   }
@@ -275,13 +300,15 @@ final class GenericsWrapJavaTests: XCTestCase {
     )
   }
 
-  func test_wrapJava_genericMethodTypeErasure_ofNullableOptional() async throws {
+  func test_wrapJava_genericMethodTypeErasure_ofNullableOptional_staticMethods() async throws {
     let classpathURL = try await compileJava(
       """
       package com.example;
 
       final class Optional<T> {
         public static <T> Optional<T> ofNullable(T value) { return null; }
+        
+        public static <T> T nonNull(T value) { return null; }
       }
       """)
 
@@ -294,14 +321,18 @@ final class GenericsWrapJavaTests: XCTestCase {
         """
         @JavaClass("com.example.Optional")
         open class Optional<T: AnyJavaObject>: JavaObject {
-
-        }
         """,
         """
         extension JavaClass {
-          @JavaStaticMethod(genericResult: "Optional<T>!")
-          public func ofNullable<T: AnyJavaObject>(_ arg0: T?) -> Optional<T>! where ObjectType == Optional<T>
+        """,
+        """
+        @JavaStaticMethod
+        public func ofNullable<T: AnyJavaObject>(_ arg0: T?) -> Optional<T>! where ObjectType == Optional<T>
         }
+        """,
+        """
+        @JavaStaticMethod(genericResult: "T!")
+        public func nonNull<T: AnyJavaObject>(_ arg0: T?) -> T! where ObjectType == Optional<T>
         """
       ]
     )