jextract/jni: Fix protocol parameter helper naming

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/CallbackProtcol.swift

@@ -105,3 +105,11 @@ public func outputCallbacks(
     optionalString: callbacks.withOptionalString(optionalString)
   )
 }
+
+public struct CallbackHolder {
+  public init(callback: any CallbackProtocol) {
+    self.callback = callback
+  }
+
+  public var callback: any CallbackProtocol
+}

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift

@@ -480,7 +480,7 @@ extension JNISwift2JavaGenerator {
       return
     }
 
-    printAllSwiftFunctionHelperClasses(&printer, decl)
+    printAllSwiftFunctionHelperClasses(&printer, decl, translatedDecl)
 
     printCDecl(
       &printer,
@@ -497,52 +497,53 @@ extension JNISwift2JavaGenerator {
   private func printAllSwiftFunctionHelperClasses(
     _ printer: inout SwiftPrinter,
     _ decl: ExtractedFunc,
+    _ translatedDecl: TranslatedFunctionDecl,
   ) {
     // Emit the `@JavaInterface` Swift wrappers for any `@escaping` closure parameters.
-    if let translatedDecl = translatedDecl(for: decl) {
-      printEscapingClosureSwiftFunctionHelperClasses(&printer, translatedDecl)
-    }
+    printEscapingClosureSwiftFunctionHelperClasses(&printer, translatedDecl)
 
     // Emit the `@JavaInterface` Swift wrappers any existential / protocol parameters.
-    printProtocolParameterSwiftFunctionHelperClasses(&printer, decl)
+    printProtocolParameterSwiftFunctionHelperClasses(&printer, decl, translatedDecl)
   }
 
   /// Emits Swift wrapper types for any parameter type that is a protocol
   /// (or a `some`/`any`/generic constraint bound to protocols).
   private func printProtocolParameterSwiftFunctionHelperClasses(
     _ printer: inout SwiftPrinter,
     _ decl: ExtractedFunc,
+    _ translatedDecl: TranslatedFunctionDecl,
   ) {
-    let protocolParameters = decl.functionSignature.parameters.compactMap { parameter in
+    let parameters = zip(decl.functionSignature.parameters, translatedDecl.translatedFunctionSignature.parameters)
+    let protocolParameters = parameters.compactMap { parameter, translatedParameter in
       if let concreteType = parameter.type.typeIn(
         genericParameters: decl.functionSignature.genericParameters,
         genericRequirements: decl.functionSignature.genericRequirements,
       ) {
-        return (parameter, concreteType)
+        return (translatedParameter.parameter.name, concreteType)
       }
 
       switch parameter.type {
       case .opaque(let protocolType),
         .existential(let protocolType):
-        return (parameter, protocolType)
+        return (translatedParameter.parameter.name, protocolType)
 
       default:
         return nil
       }
-    }.map { parameter, protocolType in
+    }.map { parameterName, protocolType in
       // We flatten any composite types
       switch protocolType {
       case .composite(let protocols):
-        return (parameter, protocols)
+        return (parameterName, protocols)
 
       default:
-        return (parameter, [protocolType])
+        return (parameterName, [protocolType])
       }
     }
 
     // For each parameter that is a generic or a protocol,
     // we generate a Swift class that conforms to all of those.
-    for (parameter, protocolTypes) in protocolParameters {
+    for (parameterName, protocolTypes) in protocolParameters {
       let protocolWrappers: [JavaInterfaceSwiftWrapper] = protocolTypes.compactMap { protocolType in
         guard let importedType = self.asExtractedNominalTypeDecl(protocolType),
           let wrapper = self.interfaceProtocolWrappers[importedType]
@@ -560,14 +561,10 @@ extension JNISwift2JavaGenerator {
         continue
       }
 
-      guard let parameterName = parameter.parameterName else {
-        // TODO: Throw
-        fatalError()
-      }
       let swiftClassName = JNISwift2JavaGenerator.protocolParameterWrapperClassName(
-        methodName: decl.name,
+        methodName: translatedDecl.name,
         parameterName: parameterName,
-        parentName: decl.parentType?.asNominalType?.nominalTypeDecl.qualifiedTypeName ?? SwiftQualifiedTypeName(swiftModuleName),
+        parentName: translatedDecl.parentName,
       )
       let implementingProtocols = protocolWrappers.map(\.wrapperName).joined(separator: .comma)
 

Tests/JExtractSwiftTests/JNI/JNIProtocolTests.swift

@@ -366,6 +366,87 @@ struct JNIProtocolTests {
     )
   }
 
+  @Test
+  func takeAsSetterNewValue() throws {
+    let source = """
+      public protocol Animal {
+        public func bark()
+      }
+
+      public struct Owner {
+        public var animal: any Animal
+      }
+      """
+
+    try assertOutput(
+      input: source,
+      config: config,
+      .jni,
+      .java,
+      detectChunkByInitialLines: 1,
+      expectedChunks: [
+        """
+        public <_T0 extends Animal> void setAnimal(_T0 newValue) {
+          Owner.$setAnimal(newValue, this.$memoryAddress());
+        }
+        """,
+        """
+        private static native void $setAnimal(java.lang.Object newValue, long selfPointer);
+        """,
+      ]
+    )
+
+    try assertOutput(
+      input: source,
+      config: config,
+      .jni,
+      .swift,
+      detectChunkByInitialLines: 1,
+      expectedChunks: [
+        """
+        final class _Owner_setAnimal_newValue_Wrapper: SwiftJavaAnimalWrapper {
+          ...
+        }
+        """,
+        """
+        @_cdecl("Java_com_example_swift_Owner__00024setAnimal__Ljava_lang_Object_2J")
+        public func Java_com_example_swift_Owner__00024setAnimal__Ljava_lang_Object_2J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, newValue: jobject?, selfPointer: jlong) {
+        """,
+        """
+            newValueswiftObject$ = _Owner_setAnimal_newValue_Wrapper(_javaAnimalInterface: JavaAnimal(javaThis: newValue!, environment: environment))
+        """,
+      ]
+    )
+  }
+
+  @Test
+  func takeAsOverloadedParameter() throws {
+    let source = """
+      public protocol Animal {
+        func bark()
+      }
+
+      public struct Owner {
+        public func take(first: any Animal) {}
+        public func take(second: any Animal) {}
+      }
+      """
+
+    try assertOutput(
+      input: source,
+      config: config,
+      .jni,
+      .swift,
+      detectChunkByInitialLines: 1,
+      expectedChunks: [
+        "final class _Owner_takeFirst_first_Wrapper: SwiftJavaAnimalWrapper {",
+        "firstswiftObject$ = _Owner_takeFirst_first_Wrapper(_javaAnimalInterface: JavaAnimal(javaThis: first!, environment: environment))",
+        "final class _Owner_takeSecond_second_Wrapper: SwiftJavaAnimalWrapper {",
+        "secondswiftObject$ = _Owner_takeSecond_second_Wrapper(_javaAnimalInterface: JavaAnimal(javaThis: second!, environment: environment))",
+      ]
+    )
+  }
+
   @Test
   func generatesProtocolWrappers() throws {
     try assertOutput(