handle open class CompressingStore: AbstractStore<ByteArray, [UInt8], [UInt8]> {

Author: ktoso

Sources/SwiftJavaToolLib/JavaClassTranslator.swift

@@ -47,7 +47,7 @@ struct JavaClassTranslator {
   let effectiveJavaSuperclass: JavaClass<JavaObject>?
 
   /// The Swift name of the superclass.
-  let swiftSuperclass: String?
+  let swiftSuperclass: SwiftJavaParameterizedType?
 
   /// The Swift names of the interfaces that this class implements.
   let swiftInterfaces: [String]
@@ -114,7 +114,7 @@ struct JavaClassTranslator {
   init(javaClass: JavaClass<JavaObject>, translator: JavaTranslator) throws {
     let fullName = javaClass.getName()
     print("TRANSLATE = \(fullName)")
-    
+
     self.javaClass = javaClass
     self.translator = translator
     self.translateAsClass = translator.translateAsClass && !javaClass.isInterface()
@@ -128,30 +128,46 @@ struct JavaClassTranslator {
     self.javaTypeParameters = javaClass.getTypeParameters().compactMap { $0 }
     self.nestedClasses = translator.nestedClasses[fullName] ?? []
 
-    // Superclass.
+    // Superclass, incl parameter types (if any)
     if !javaClass.isInterface() {
       var javaSuperclass = javaClass.getSuperclass()
-      var swiftSuperclass: String? = nil
+      var javaGenericSuperclass: JavaReflectType? = javaClass.getGenericSuperclass()
+      var swiftSuperclassName: String? = nil
+      var swiftSuperclassTypeArgs: [String] = []
       while let javaSuperclassNonOpt = javaSuperclass {
         do {
-          swiftSuperclass = try translator.getSwiftTypeName(javaSuperclassNonOpt, preferValueTypes: false).swiftName
+          swiftSuperclassName = try translator.getSwiftTypeName(javaSuperclassNonOpt, preferValueTypes: false).swiftName
+          if let javaGenericSuperclass = javaGenericSuperclass?.as(JavaReflectParameterizedType.self) {
+            print("javaGenericSuperclass = \(javaGenericSuperclass)")
+            for typeArg in javaGenericSuperclass.getActualTypeArguments() {
+              let javaTypeArgName = typeArg?.getTypeName() ?? ""
+              if let swiftTypeArgName = self.translator.translatedClasses[javaTypeArgName] {
+                swiftSuperclassTypeArgs.append(swiftTypeArgName.qualifiedName)
+              } else {
+                swiftSuperclassTypeArgs.append("/* MISSING MAPPING FOR */ \(javaTypeArgName)")
+              }
+            }
+          }
           break
         } catch {
           translator.logUntranslated("Unable to translate '\(fullName)' superclass: \(error)")
         }
 
         javaSuperclass = javaSuperclassNonOpt.getSuperclass()
+        javaGenericSuperclass = javaClass.getGenericSuperclass()
       }
 
+      print("swiftSuperclassTypeArgs = \(swiftSuperclassTypeArgs)")
+
       self.effectiveJavaSuperclass = javaSuperclass
-      self.swiftSuperclass = swiftSuperclass
+      self.swiftSuperclass = SwiftJavaParameterizedType(
+        name: swiftSuperclassName, 
+        typeArguments: swiftSuperclassTypeArgs)
     } else {
       self.effectiveJavaSuperclass = nil
       self.swiftSuperclass = nil
     }
 
-    print("[\(fullName)] SWUFT SUPER CLASS = \(swiftSuperclass)")
-
     // Interfaces.
     self.swiftInterfaces = javaClass.getGenericInterfaces().compactMap { (javaType) -> String? in
       guard let javaType else {
@@ -333,7 +349,14 @@ extension JavaClassTranslator {
     let inheritanceClause: String
     if translateAsClass {
       extends = ""
-      inheritanceClause = swiftSuperclass.map { ": \($0)" } ?? ""
+      inheritanceClause = 
+        if let swiftSuperclass, swiftSuperclass.typeArguments.isEmpty {
+           ": \(swiftSuperclass.name)" 
+        } else if let swiftSuperclass {
+           ": \(swiftSuperclass.name)<\(swiftSuperclass.typeArguments.joined(separator: ", "))>" 
+        } else { 
+          "" 
+        }
     } else {
       extends = swiftSuperclass.map { ", extends: \($0).self" } ?? ""
       inheritanceClause = ""

Sources/SwiftJavaToolLib/JavaParameterizedType.swift

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// E.g. `Another<Bites, The, Dust>`
+struct SwiftJavaParameterizedType {
+  let name: String
+  let typeArguments: [String]
+
+  init?(name: String?, typeArguments: [String]) {
+    guard let name else {
+      return nil
+    }
+
+    self.name = name
+    self.typeArguments = typeArguments
+  }
+}

Sources/SwiftJavaToolLib/JavaTranslator+Validation.swift

@@ -23,6 +23,14 @@ package struct SwiftTypeName: Hashable, CustomStringConvertible {
     self.swiftType = name
   }
 
+  package var qualifiedName: String {
+    if let swiftModule {
+      "\(swiftModule).\(swiftType)"
+    } else {
+      "\(swiftType)"
+    }
+  }
+
   package var description: String {
     if let swiftModule {
       "`\(swiftModule)/\(swiftType)`"

Sources/SwiftJavaToolLib/JavaTranslator.swift

@@ -37,7 +37,8 @@ package class JavaTranslator {
   /// A mapping from the name of each known Java class to the corresponding
   /// Swift type name and its Swift module.
   package var translatedClasses: [JavaFullyQualifiedTypeName: SwiftTypeName] = [
-    "java.lang.Object": SwiftTypeName(module: "SwiftJava", name: "JavaObject")
+    "java.lang.Object": SwiftTypeName(module: "SwiftJava", name: "JavaObject"),
+    "byte[]": SwiftTypeName(module: nil, name: "[UInt8]")
   ]
 
   /// A mapping from the name of each known Java class with the Swift value type

Tests/SwiftJavaToolLibTests/WrapJavaTests.swift

@@ -94,13 +94,13 @@ class WrapJavaTests: XCTestCase {
         @JavaClass("com.example.ByteArray")
         open class ByteArray: JavaObject {
         """,
-        """
-        @JavaInterface("com.example.Store")
-        public struct Store<K: AnyJavaObject, V: AnyJavaObject, T: AnyJavaObject> {
-        """,
+        // """
+        // @JavaInterface("com.example.Store")
+        // public struct Store<K: AnyJavaObject, V: AnyJavaObject, T: AnyJavaObject> {
+        // """,
         """
         @JavaClass("com.example.CompressingStore")
-        open class CompressingStore: AbstractStore {
+        open class CompressingStore: AbstractStore<ByteArray, [UInt8], [UInt8]> {
         """
       ]
     )