further correct generic handling and type variables

ktoso · ktoso · commit 478c61b9e3cb · 2025-11-11T00:00:47.000+09:00
diff --git a/Samples/SwiftJavaExtractFFMSampleApp/src/test/java/org/swift/swiftkitffm/ThrowsFFMTest.java b/Samples/SwiftJavaExtractFFMSampleApp/src/test/java/org/swift/swiftkitffm/ThrowsFFMTest.java
diff --git a/Sources/JavaStdlib/JavaLangReflect/TypeVariable+Extensions.swift b/Sources/JavaStdlib/JavaLangReflect/TypeVariable+Extensions.swift
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 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 SwiftJava
+
+// FIXME: all interfaces should ahve these https://github.com/swiftlang/swift-java/issues/430
+extension TypeVariable {  
+
+  @JavaMethod
+  public func toString() -> String
+  
+  @JavaMethod
+  public func getClass() -> JavaClass<JavaObject>!
+
+  @JavaMethod
+  public func equals(_ arg0: JavaObject?) -> Bool
+
+  @JavaMethod
+  public func hashCode() -> Int32
+
+}
+
+// FIXME: All Java objects are Hashable, we should handle that accordingly.
+extension TypeVariable: Hashable {
+
+  public func hash(into hasher: inout Hasher) {
+    guard let pojo = self.as(JavaObject.self) else {
+      return 
+    }
+
+    hasher.combine(pojo.hashCode())
+  }
+
+  public static func == (lhs: TypeVariable<D>, rhs: TypeVariable<D>) -> Bool {
+    guard let lhpojo: JavaObject = lhs.as(JavaObject.self) else {
+      return false
+    }
+    guard let rhpojo: JavaObject = rhs.as(JavaObject.self) else {
+      return false
+    }
+
+    return lhpojo.equals(rhpojo)
+  }
+
+}
diff --git a/Sources/JavaStdlib/JavaLangReflect/generated/TypeVariable.swift b/Sources/JavaStdlib/JavaLangReflect/generated/TypeVariable.swift
@@ -6,7 +6,7 @@ import CSwiftJavaJNI
 public struct TypeVariable<D: AnyJavaObject> {
   @JavaMethod
   public func getGenericDeclaration() -> GenericDeclaration!
-
+  
   @JavaMethod
   public func getAnnotatedBounds() -> [AnnotatedType?]
 
diff --git a/Sources/SwiftJavaToolLib/JavaClassTranslator.swift b/Sources/SwiftJavaToolLib/JavaClassTranslator.swift
@@ -879,7 +879,6 @@ extension JavaClassTranslator {
   /// method.
   func isOverride(_ method: Method) -> Bool {
     var currentSuperclass = effectiveJavaSuperclass
-    print("currentSuperclass = \(currentSuperclass)")
     while let currentSuperclassNonOpt = currentSuperclass {
       // Set the loop up for the next run.
       defer {
diff --git a/Sources/SwiftJavaToolLib/JavaGenericsSupport.swift b/Sources/SwiftJavaToolLib/JavaGenericsSupport.swift
@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 JavaLangReflect
+import JavaTypes
+import SwiftBasicFormat
+import SwiftJava
+import SwiftJavaConfigurationShared
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+struct GenericJavaTypeOriginInfo {
+  enum GenericSource {
+    /// The source of the generic
+    case `class`([Type])
+    case method
+  }
+
+  var source: GenericSource
+  var type: Type
+}
+
+private func collectTypeVariables(_ type: Type) -> Set<TypeVariable<JavaObject>> {
+  var result: Set<TypeVariable<JavaObject>> = []
+
+  return result
+}
+
+/// if the type (that is used by the Method) is generic, return if the use originates from the method, or a surrounding class.
+func getGenericJavaTypeOriginInfo(_ type: Type?, from method: Method) -> [GenericJavaTypeOriginInfo] {
+  guard let type else {
+    return []
+  }
+
+  guard isGenericJavaType(type) else {
+    return [] // it's not a generic type, no "origin" of the use to detect
+  }
+
+  var methodTypeVars = method.getTypeParameters()
+  
+  // TODO: also handle nested classes here...
+  var classTypeVars = method.getDeclaringClass().getTypeParameters()
+
+  var usedTypeVars: [TypeVariable<JavaObject>] = []
+
+  return []
+}
+
+func isGenericJavaType(_ 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 parameterized type (e.g., List<T>, Map<K,V>)
+  if let paramType = type.as(ParameterizedType.self) {
+    let typeArgs: [Type?] = paramType.getActualTypeArguments()
+
+    // Check if any of the type arguments are generic
+    for typeArg in typeArgs {
+      guard let typeArg else { continue }
+      if isGenericJavaType(typeArg) {
+        return true
+      }
+    }
+  }
+
+  // Check if it's a generic array type (e.g., T[], List<T>[])
+  if let arrayType = type.as(GenericArrayType.self) {
+    let componentType = arrayType.getGenericComponentType()
+    return isGenericJavaType(componentType)
+  }
+
+  // Check if it's a wildcard type (e.g., ? extends Number, ? super String)
+  if type.as(WildcardType.self) != nil {
+    return true
+  }
+
+  return false
+}
diff --git a/Sources/SwiftJavaToolLib/JavaTranslator.swift b/Sources/SwiftJavaToolLib/JavaTranslator.swift
@@ -120,20 +120,22 @@ extension JavaTranslator {
 
 // MARK: Type translation
 extension JavaTranslator {
-func getSwiftReturnTypeNameAsString(
+
+
+  func getSwiftReturnTypeNameAsString(
     method: JavaLangReflect.Method,
     preferValueTypes: Bool,
     outerOptional: OptionalKind
   ) throws -> String {
-    let returnType = method.getReturnType()
+    // 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()
-      } 
-    }
+
+    // if isGenericJavaType(genericReturnType) {
+    //   print("[swift] generic method! \(method.getDeclaringClass().getName()).\(method.getName())")
+    //   getGenericJavaTypeOriginInfo(genericReturnType, from: method)
+    // }
 
     return try getSwiftTypeNameAsString(method: method, genericReturnType!, preferValueTypes: preferValueTypes, outerOptional: outerOptional)
   }
@@ -154,23 +156,46 @@ func getSwiftReturnTypeNameAsString(
     //     }
     //  }
 
+    if isGenericJavaType(javaType) {
+      if let method {
+        print("[swift] generic method! \(method.getDeclaringClass().getName()).\(method.getName())")
+        let genericOriginInfos = getGenericJavaTypeOriginInfo(javaType, from: method)
+        print("genericOriginInfos = \(genericOriginInfos)")
+      }
+    }
+
     // Replace type variables with their bounds.
     if let typeVariable = javaType.as(TypeVariable<GenericDeclaration>.self),
       typeVariable.getBounds().count == 1,
       let bound = typeVariable.getBounds()[0]
     {
-      return try getSwiftTypeNameAsString(
-        bound,
-        preferValueTypes: preferValueTypes,
-        outerOptional: outerOptional
-      )
+      print("[swift] was type var: \(typeVariable)")
+      print("[swift] was type var: \(typeVariable.toString())")
+      print("[swift] was type var: \(typeVariable.getClass().getName())")
+      print("[swift] was type var bound: \(bound)")
+      // let typeName = try getSwiftTypeNameAsString(
+      //   bound,
+      //   preferValueTypes: preferValueTypes,
+      //   outerOptional: outerOptional
+      // )
+      // print("[swift] was type var: \(typeVariable.toString()) ----> \(typeName)")
+      return outerOptional.adjustTypeName(typeVariable.getName())
+    }
+
+    if let paramType = javaType.as(ParameterizedType.self) { 
+      print("[swift] paramType = \(paramType)")
+      let typeArgs: [Type?] = paramType.getActualTypeArguments()
+      for typeArg in typeArgs {
+        print("Type arg = \(typeArg)")
+      }
     }
 
     // Replace wildcards with their upper bound.
     if let wildcardType = javaType.as(WildcardType.self),
       wildcardType.getUpperBounds().count == 1,
       let bound = wildcardType.getUpperBounds()[0]
     {
+      print("[swift] was wildcard")
       // Replace a wildcard type with its first bound.
       return try getSwiftTypeNameAsString(
         bound,
@@ -181,6 +206,7 @@ func getSwiftReturnTypeNameAsString(
 
     // Handle array types by recursing into the component type.
     if let arrayType = javaType.as(GenericArrayType.self) {
+      print("[swift] was array")
       if preferValueTypes {
         let elementType = try getSwiftTypeNameAsString(
           arrayType.getGenericComponentType()!,
@@ -238,11 +264,19 @@ func getSwiftReturnTypeNameAsString(
       }
     }
 
+    print("[swift][swift-java][debug] Convert direct \(javaType)")
+
     // Handle direct references to Java classes.
     guard let javaClass = javaType.as(JavaClass<JavaObject>.self) else {
       throw TranslationError.unhandledJavaType(javaType)
     }
 
+    print("[swift][swift-java][debug] Java class \(javaClass) | \(javaClass.toString())")
+    if isGenericJavaType(javaType) {
+      print("[swift][swift-java][debug] is generic \(javaClass.toString())")
+    }
+
+
     let (swiftName, isOptional) = try getSwiftTypeName(javaClass, preferValueTypes: preferValueTypes)
     var resultString = swiftName
     if isOptional {
diff --git a/Tests/SwiftJavaToolLibTests/CompileJavaWrapTools.swift b/Tests/SwiftJavaToolLibTests/CompileJavaWrapTools.swift
@@ -92,6 +92,7 @@ func withJavaTranslator(
 func assertWrapJavaOutput(
   javaClassNames: [String],
   classpath: [Foundation.URL],
+  assert assertBody: (JavaTranslator) throws -> Void = { _ in },
   expectedChunks: [String],
   function: String = #function,
   file: StaticString = #filePath,
@@ -143,17 +144,20 @@ func assertWrapJavaOutput(
     let swiftClassDecls = try translator.translateClass(javaClass)
     let importDecls = translator.getImportDecls()
 
-  let swiftFileText = 
-    """
-    // ---------------------------------------------------------------------------
-    // Auto-generated by Java-to-Swift wrapper generator.
-    \(importDecls.map { $0.description }.joined())
-    \(swiftClassDecls.map { $0.description }.joined(separator: "\n"))
-    \n
-    """
-    swiftCompleteOutputText += swiftFileText
+    let swiftFileText = 
+      """
+      // ---------------------------------------------------------------------------
+      // Auto-generated by Java-to-Swift wrapper generator.
+      \(importDecls.map { $0.description }.joined())
+      \(swiftClassDecls.map { $0.description }.joined(separator: "\n"))
+      \n
+      """
+      swiftCompleteOutputText += swiftFileText
   }
 
+  // Run any additional user defined assertions:
+  try assertBody(translator)
+
   for expectedChunk in expectedChunks {
     // We make the matching in-sensitive to whitespace:
     let checkAgainstText = swiftCompleteOutputText.replacing(" ", with: "")
diff --git a/Tests/SwiftJavaToolLibTests/Java2SwiftTests.swift b/Tests/SwiftJavaToolLibTests/Java2SwiftTests.swift
diff --git a/Tests/SwiftJavaToolLibTests/WrapJavaTests.swift b/Tests/SwiftJavaToolLibTests/WrapJavaTests.swift
