handle the return type being the generic type

Author: ktoso

Sources/JavaStdlib/JavaLangReflect/generated/Executable.swift

@@ -11,8 +11,8 @@ open class Executable: AccessibleObject {
   @JavaMethod
   open func getModifiers() -> Int32
 
-  @JavaMethod
-  open func getTypeParameters() -> [TypeVariable<JavaObject>?]
+  // @JavaMethod // FIXME why does this clash with Method.getTypeParameters?
+  // open func getTypeParameters() -> [TypeVariable<JavaObject>?]
 
   @JavaMethod
   open func getParameterTypes() -> [JavaClass<JavaObject>?]

Sources/JavaStdlib/JavaLangReflect/generated/Type.swift

@@ -6,4 +6,13 @@ import CSwiftJavaJNI
 public struct Type {
   @JavaMethod
   public func getTypeName() -> String
+
+  @JavaMethod
+  public func toString() -> String
+}
+
+extension Type: CustomStringConvertible { 
+  public var description: String {
+    "JavaLangReflect.Type(\(self.toString()))"
+  }
 }

Sources/SwiftJavaToolLib/JavaClassTranslator.swift

@@ -576,21 +576,41 @@ extension JavaClassTranslator {
   package func renderMethod(
     _ javaMethod: Method,
     implementedInSwift: Bool,
-    genericParameterClause: String = "",
+    genericParameterClause __genericParameterClause: String = "", // FIXME: why is this a string, fix this...
     whereClause: String = ""
   ) throws -> DeclSyntax {
+    // Map the generic params on the method.
+    let typeParameters = javaMethod.getTypeParameters()
+    var genericParameterClauseStr = __genericParameterClause
+    if typeParameters.count(where: {$0 != nil }) > 0 {
+      genericParameterClauseStr = "<"
+      genericParameterClauseStr += typeParameters.map { typeParam in 
+        // FIXME: determine if it is some other constraint
+        "\(typeParam!.getTypeName()): AnyJavaObject"
+      }.joined(separator: ", ")
+      genericParameterClauseStr += ">"
+    }
+
     // Map the parameters.
     let parameters = try translateJavaParameters(javaMethod.getParameters())
 
     let parametersStr = parameters.map { $0.description }.joined(separator: ", ")
 
+    print("javaMethod.getReturnType() == \(javaMethod.getReturnType())")
+    print("javaMethod.getGenericReturnType() == \(javaMethod.getGenericReturnType())")
+
     // Map the result type.
     let resultTypeStr: String
-    let resultType = try translator.getSwiftTypeNameAsString(
-      javaMethod.getGenericReturnType()!,
-      preferValueTypes: true,
+    let resultType = try translator.getSwiftReturnTypeNameAsString(
+      method: javaMethod, 
+      preferValueTypes: true, 
       outerOptional: .implicitlyUnwrappedOptional
     )
+    // let resultType = try translator.getSwiftTypeNameAsString(
+    //   javaMethod.getGenericReturnType()!,
+    //   preferValueTypes: true,
+    //   outerOptional: .implicitlyUnwrappedOptional
+    // )
 
     // FIXME: cleanup the checking here
     if resultType != "Void" && resultType != "Swift.Void" {
@@ -632,15 +652,15 @@ extension JavaClassTranslator {
 
 
       return """
-        \(methodAttribute)\(raw: accessModifier)\(raw: overrideOpt)func \(raw: swiftMethodName)\(raw: genericParameterClause)(\(raw: parametersStr))\(raw: throwsStr)\(raw: resultTypeStr)\(raw: whereClause)
+        \(methodAttribute)\(raw: accessModifier)\(raw: overrideOpt)func \(raw: swiftMethodName)\(raw: genericParameterClauseStr)(\(raw: parametersStr))\(raw: throwsStr)\(raw: resultTypeStr)\(raw: whereClause)
         
-        \(raw: accessModifier)\(raw: overrideOpt)func \(raw: swiftMethodName)Optional\(raw: genericParameterClause)(\(raw: parameters.map(\.clause.description).joined(separator: ", ")))\(raw: throwsStr) -> \(raw: resultOptional)\(raw: whereClause) {
+        \(raw: accessModifier)\(raw: overrideOpt)func \(raw: swiftMethodName)Optional\(raw: genericParameterClauseStr)(\(raw: parameters.map(\.clause.description).joined(separator: ", ")))\(raw: throwsStr) -> \(raw: resultOptional)\(raw: whereClause) {
           \(body)
         }
         """
     } else {
       return """
-        \(methodAttribute)\(raw: accessModifier)\(raw: overrideOpt)func \(raw: swiftMethodName)\(raw: genericParameterClause)(\(raw: parametersStr))\(raw: throwsStr)\(raw: resultTypeStr)\(raw: whereClause)
+        \(methodAttribute)\(raw: accessModifier)\(raw: overrideOpt)func \(raw: swiftMethodName)\(raw: genericParameterClauseStr)(\(raw: parametersStr))\(raw: throwsStr)\(raw: resultTypeStr)\(raw: whereClause)
         """
     }
   }

Sources/SwiftJavaToolLib/JavaTranslator.swift

@@ -120,6 +120,24 @@ extension JavaTranslator {
 
 // MARK: Type translation
 extension JavaTranslator {
+func getSwiftReturnTypeNameAsString(
+    method: JavaLangReflect.Method,
+    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()`
+    if returnType?.getCanonicalName() == "java.lang.Object" { 
+      if let genericReturnType {
+        return genericReturnType.getTypeName()
+      } 
+    }
+
+    return try getSwiftTypeNameAsString(genericReturnType!, preferValueTypes: preferValueTypes, outerOptional: outerOptional)
+  }
+
   /// Turn a Java type into a string.
   func getSwiftTypeNameAsString(
     _ javaType: Type,

Tests/SwiftJavaToolLibTests/WrapJavaTests.swift

@@ -63,13 +63,8 @@ class WrapJavaTests: XCTestCase {
         class Pair<First, Second> { }
 
         class ExampleSimpleClass {
-          <KeyType, ValueType> Pair<KeyType, ValueType> get(
-            String name,
-            Item<KeyType> key,
-            Item<ValueType> value
-          ) { 
-            return null; 
-          }
+          <KeyType> KeyType getGeneric(Item<KeyType> key) { return null; }
+          // <KeyType, ValueType> Pair<KeyType, ValueType> getPair(String name, Item<KeyType> key, Item<ValueType> value) { return null; }
         }
         """)
 
@@ -95,8 +90,12 @@ class WrapJavaTests: XCTestCase {
           """,
           """
           @JavaMethod
-          open func getStore<T1, T2>(_ arg0: String, _ arg1: Item<T1>?, _ arg2: Item<T2>?) -> BDStore<T1, T2>!
-          """
+          open func getGeneric<T1>(_ arg0: String, _ arg1: Item<T1>?) -> T1!
+          """,
+          // """
+          // @JavaMethod
+          // open func getStore<T1, T2>(_ arg0: String, _ arg1: Item<T1>?, _ arg2: Item<T2>?) -> BDStore<T1, T2>!
+          // """
         ]
       )
     } catch let error as Throwable {