jextract/jni: Support static function calls for specialized types

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/BoxSpecialization.swift

@@ -18,6 +18,10 @@ public struct Box<Element>: Hashable {
   public init(count: Int64) {
     self.count = count
   }
+
+  public static func describeElement() -> String {
+    String(describing: Element.self)
+  }
 }
 
 public struct Fish: Hashable {

Samples/SwiftJavaExtractJNISampleApp/src/test/java/com/example/swift/BoxSpecializationTest.java

@@ -36,6 +36,11 @@ void fishBoxHasExpectedMethods() throws Exception {
         Method setCount = fishBoxClass.getMethod("setCount", long.class);
         assertNotNull(setCount);
 
+        // Static method
+        Method describeElement = fishBoxClass.getMethod("describeElement");
+        assertNotNull(describeElement);
+        assertEquals(String.class, describeElement.getReturnType());
+
         // Constrained extension method (only on FishBox, not on Box)
         Method describeFish = fishBoxClass.getMethod("describeFish");
         assertNotNull(describeFish);
@@ -56,4 +61,9 @@ void boxHasGenericTypeParameter() {
             "Box should have one generic type parameter");
         assertEquals("Element", Box.class.getTypeParameters()[0].getName());
     }
+
+    @Test
+    void callFishBoxStaticMethod() {
+        assertEquals("Fish", FishBox.describeElement());
+    }
 }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -349,11 +349,19 @@ extension JNISwift2JavaGenerator {
       }
 
       for method in decl.methods {
+        if isEffectivelyGeneric && method.isStatic {
+          self.logger.debug("Skipping static method '\(method.name)' on unspecialized generic type '\(decl.effectiveJavaName)'")
+          continue
+        }
         printFunctionDowncallMethods(&printer, method)
         printer.println()
       }
 
       for variable in decl.variables {
+        if isEffectivelyGeneric && variable.isStatic {
+          self.logger.debug("Skipping static property '\(variable.name)' on unspecialized generic type '\(decl.effectiveJavaName)'")
+          continue
+        }
         printFunctionDowncallMethods(&printer, variable)
         printer.println()
       }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -366,21 +366,23 @@ extension JNISwift2JavaGenerator {
       guard let selfParameter else {
         return nil
       }
-
       let isGeneric = selfParameter.selfType.asNominalTypeDeclaration?.isGeneric == true
-      if isGeneric {
-        return try self.translateParameter(
-          swiftType: .metatype(selfParameter.selfType),
-          parameterName: "selfTypePointer",
-          methodName: methodName,
-          parentName: parentName,
-          genericParameters: genericParameters,
-          genericRequirements: genericRequirements,
-          parameterPosition: nil,
-        )
-      } else {
+      guard isGeneric else {
         return nil
       }
+
+      switch selfParameter {
+      case .instance:
+        return TranslatedParameter(
+          parameter: JavaParameter(name: "selfTypePointer", type: .long),
+          conversion: .typeMetadataAddress(.placeholder),
+        )
+      case .staticMethod, .initializer:
+        return TranslatedParameter(
+          parameter: JavaParameter(name: "selfTypePointer", type: .long),
+          conversion: .constant("$typeMetadataAddressDowncall()"),
+        )
+      }
     }
 
     func translateParameter(

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift

@@ -1039,12 +1039,10 @@ extension JNISwift2JavaGenerator {
     printer.println()
     printer.printBraceBlock("extension \(type.swiftNominal.qualifiedName): \(protocolName)") { printer in
       for variable in type.variables {
-        if variable.isStatic { continue }
         printFunctionDecl(&printer, decl: variable, skipMethodBody: false)
       }
 
       for method in type.methods {
-        if method.isStatic { continue }
         printFunctionDecl(&printer, decl: method, skipMethodBody: false)
       }
     }

Sources/JExtractSwiftLib/Swift2JavaVisitor.swift

@@ -213,11 +213,6 @@ final class Swift2JavaVisitor {
       functionSignature: signature,
     )
 
-    if typeContext?.swiftNominal.isGeneric == true && typeContext?.isSpecialization != true && imported.isStatic {
-      log.debug("Skip importing static function in generic type: '\(node.qualifiedNameForDebug)'")
-      return
-    }
-
     log.debug("Record imported method \(node.qualifiedNameForDebug)")
     if let typeContext {
       typeContext.methods.append(imported)
@@ -451,11 +446,6 @@ final class Swift2JavaVisitor {
       functionSignature: signature,
     )
 
-    if typeContext?.swiftNominal.isGeneric == true && typeContext?.isSpecialization != true && imported.isStatic {
-      log.debug("Skip importing static accessor in generic type: '\(node.qualifiedNameForDebug)'")
-      return
-    }
-
     log.debug(
       "Record imported variable accessor \(kind == .getter || kind == .subscriptGetter ? "getter" : "setter"):\(node.qualifiedNameForDebug)"
     )

Tests/JExtractSwiftTests/JNI/JNIGenericTypeTests.swift

@@ -214,6 +214,39 @@ struct JNIGenericTypeTests {
     )
   }
 
+  @Test
+  func generateOpenerForGenericStaticMethod() throws {
+    let input =
+      #"""
+      public struct Box<Element> {
+        public static func describeElement() -> String {
+          "\(Element.self)"
+        }
+      }
+      """#
+
+    try assertOutput(
+      input: input,
+      .jni,
+      .swift,
+      detectChunkByInitialLines: 2,
+      expectedChunks: [
+        """
+        protocol _SwiftModule_Box_opener {
+          static func _describeElement(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) -> jstring?
+        }
+        """,
+        #"""
+        extension Box: _SwiftModule_Box_opener {
+          static func _describeElement(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) -> jstring? {
+            return Box<Element>.describeElement().getJNILocalRefValue(in: environment)
+          }
+        }
+        """#,
+      ]
+    )
+  }
+
   @Test
   func genericValueInEnumCase() throws {
     let input =

Tests/JExtractSwiftTests/SpecializationTests.swift

@@ -213,6 +213,10 @@ struct SpecializationTests {
         public func count() -> Int {
           return items.count
         }
+
+        public static func elementDescription() -> String {
+          return "\(Element.self)"
+        }
       }
 
       public struct Fish {
@@ -226,10 +230,21 @@ struct SpecializationTests {
       input: input,
       .jni,
       .java,
-      detectChunkByInitialLines: 1,
+      detectChunkByInitialLines: 2,
       expectedChunks: [
         "public final class FishBox implements JNISwiftInstance {",
-        "public long count()",
+        """
+        public long count() {
+          return FishBox.$count(this.$memoryAddress(), this.$typeMetadataAddress());
+        }
+        private static native long $count(long selfPointer, long selfTypePointer);
+        """,
+        """
+        public static java.lang.String elementDescription() {
+          return FishBox.$elementDescription($typeMetadataAddressDowncall());
+        }
+        private static native java.lang.String $elementDescription(long selfTypePointer);
+        """,
       ],
     )
   }