-remove implicit overload synthesis, and raw unsafe buf ptr return

It's not really a great idea to support this so we'll wait until anyone
actually has a real reason for it; it complicated code a lot as well

Author: ktoso

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/UnsafeRawBufferPointer.swift

@@ -14,7 +14,6 @@
 
 import SwiftJava
 
-/// Sum all bytes in the buffer
 public func sumOfBytes(data: UnsafeRawBufferPointer) -> Int64 {
   var sum: Int64 = 0
   for byte in data {
@@ -23,22 +22,6 @@ public func sumOfBytes(data: UnsafeRawBufferPointer) -> Int64 {
   return sum
 }
 
-/// Return the count of bytes in the buffer
 public func bufferCount(data: UnsafeRawBufferPointer) -> Int64 {
   Int64(data.count)
 }
-
-/// Allocates a buffer of `count` bytes, each set to its index (mod 256)
-public func makeByteBuffer(count: Int32) -> UnsafeRawBufferPointer {
-  let ptr = UnsafeMutableRawBufferPointer.allocate(byteCount: Int(count), alignment: 1)
-  for i in 0..<Int(count) {
-    ptr[i] = UInt8(i % 256)
-  }
-  return UnsafeRawBufferPointer(ptr)
-}
-
-/// Deallocates a buffer previously returned by makeByteBuffer
-public func freeByteBuffer(pointer: UnsafeRawBufferPointer) {
-  guard let base = pointer.baseAddress else { return }
-  UnsafeMutableRawPointer(mutating: base).deallocate()
-}

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

@@ -42,12 +42,4 @@ void bufferCount_empty() {
         byte[] input = new byte[] {};
         assertEquals(0, MySwiftLibrary.bufferCount(input));
     }
-
-    @Test
-    void makeByteBuffer() {
-        var buf = MySwiftLibrary.makeByteBuffer(10);
-        assertNotEquals(0, buf.pointer);
-        assertEquals(10, buf.count);
-        MySwiftLibrary.freeByteBuffer(buf);
-    }
 }

Sources/JExtractSwiftLib/ImportedDecls.swift

@@ -127,22 +127,6 @@ public final class ImportedFunc: ImportedDecl, CustomStringConvertible {
 
   var functionSignature: SwiftFunctionSignature
 
-  /// Whether this declaration was synthesized during import (not from source)
-  var isImplicit: Bool { self.implicitOverloadKind != nil }
-
-  /// If non-nil, this is a synthesized overload with alternative parameter translation
-  var implicitOverloadKind: ImplicitJavaOverloadKind?
-
-  /// Determines if we should handle this method slightly differently than usual.
-  /// 
-  /// This allows to provide secondary / compatibility overloads for methods which 
-  /// may have different useful ways to call them from Java.
-  enum ImplicitJavaOverloadKind {
-    /// Overload with `UnsafeRawBufferPointer` parameters translated as `SwiftUnsafeRawBufferPointer`
-    /// (pointer+count longs) instead of byte[]
-    case unsafeRawBufferPointerParams
-  }
-
   public var signatureString: String {
     self.swiftDecl.signatureString
   }

Sources/JExtractSwiftLib/ImportedFunc+ImplicitOverloads.swift

@@ -87,7 +87,6 @@ extension JNISwift2JavaGenerator {
     let protocolWrappers: [ImportedNominalType: JavaInterfaceSwiftWrapper]
     let logger: Logger
     var javaIdentifiers: JavaIdentifierFactory
-    var implicitOverloadKind: ImportedFunc.ImplicitJavaOverloadKind?
 
     func translate(enumCase: ImportedEnumCase) throws -> TranslatedEnumCase {
       let nativeTranslation = NativeJavaTranslation(
@@ -217,15 +216,14 @@ extension JNISwift2JavaGenerator {
     }
 
     func translate(_ decl: ImportedFunc) throws -> TranslatedFunctionDecl {
-      var nativeTranslation = NativeJavaTranslation(
+      let nativeTranslation = NativeJavaTranslation(
         config: self.config,
         javaPackage: self.javaPackage,
         javaClassLookupTable: self.javaClassLookupTable,
         knownTypes: self.knownTypes,
         protocolWrappers: self.protocolWrappers,
         logger: self.logger
       )
-      nativeTranslation.implicitOverloadKind = decl.implicitOverloadKind
 
       // Types with no parent will be outputted inside a "module" class.
       let parentName = decl.parentType?.asNominalType?.nominalTypeDecl.qualifiedName ?? swiftModuleName
@@ -234,9 +232,7 @@ extension JNISwift2JavaGenerator {
       let javaName = javaIdentifiers.makeJavaMethodName(decl)
 
       // Swift -> Java
-      var copy = self
-      copy.implicitOverloadKind = decl.implicitOverloadKind
-      var translatedFunctionSignature = try copy.translate(
+      var translatedFunctionSignature = try self.translate(
         functionSignature: decl.functionSignature,
         methodName: javaName,
         parentName: parentName
@@ -504,21 +500,10 @@ extension JNISwift2JavaGenerator {
             break // Handled as wrapped struct
 
           case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
-            switch implicitOverloadKind {
-            case .unsafeRawBufferPointerParams:
-              return TranslatedParameter(
-                parameter: JavaParameter(name: parameterName, type: .swiftUnsafeRawBufferPointer),
-                conversion: .commaSeparated([
-                  .member(.placeholder, field: "pointer"),
-                  .member(.placeholder, field: "count"),
-                ])
-              )
-            default:
-              return TranslatedParameter(
-                parameter: JavaParameter(name: parameterName, type: .array(.byte)),
-                conversion: .placeholder
-              )
-            }
+            return TranslatedParameter(
+              parameter: JavaParameter(name: parameterName, type: .array(.byte)),
+              conversion: .placeholder
+            )
 
           case .foundationUUID, .essentialsUUID:
             return TranslatedParameter(
@@ -959,21 +944,6 @@ extension JNISwift2JavaGenerator {
             // Handled as wrapped struct
             break
 
-          case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
-            let outParam = "\(resultName)$unsafeBufferPointer"
-            return TranslatedResult(
-              javaType: .swiftUnsafeRawBufferPointer,
-              outParameters: [
-                OutParameter(name: outParam, type: .array(.long), allocation: .newArray(.long, size: 2)),
-              ],
-              conversion: .tupleSameTypeFromOutParam(
-                className: "new SwiftUnsafeRawBufferPointer",
-                outParamName: outParam,
-                elementCount: 2,
-                elementConversion: .placeholder
-              )
-            )
-
           case .foundationUUID, .essentialsUUID:
             return TranslatedResult(
               javaType: .javaUtilUUID,
@@ -1816,7 +1786,7 @@ extension JNISwift2JavaGenerator {
     case tupleFromOutParams(tupleClassName: String, elements: [(outParamName: String, elementConversion: JavaNativeConversionStep)])
 
     /// Constructs a value from a single out-parameter array where all elements are the same type
-    /// E.g. `new SwiftUnsafeRawBufferPointer(result$urbp[0], result$urbp[1])`
+    /// E.g. `new SomeType(result$arr[0], result$arr[1])`
     indirect case tupleSameTypeFromOutParam(className: String, outParamName: String, elementCount: Int, elementConversion: JavaNativeConversionStep)
 
     /// `Arrays.stream(args)`

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -25,7 +25,6 @@ extension JNISwift2JavaGenerator {
     var knownTypes: SwiftKnownTypes
     let protocolWrappers: [ImportedNominalType: JavaInterfaceSwiftWrapper]
     let logger: Logger
-    var implicitOverloadKind: ImportedFunc.ImplicitJavaOverloadKind?
 
     /// Translates a Swift function into the native JNI method signature.
     func translate(
@@ -127,29 +126,14 @@ extension JNISwift2JavaGenerator {
             )
 
           case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
-            switch implicitOverloadKind {
-            case .unsafeRawBufferPointerParams:
-              let pointerParam = "\(parameterName)$pointer"
-              let countParam = "\(parameterName)$count"
-              return NativeParameter(
-                parameters: [
-                  JavaParameter(name: pointerParam, type: .long),
-                  JavaParameter(name: countParam, type: .long),
-                ],
-                conversion: .jniLongsToUnsafeRawBufferPointer(pointerParam: pointerParam, countParam: countParam),
-                indirectConversion: nil,
-                conversionCheck: nil
-              )
-            default:
-              return NativeParameter(
-                parameters: [
-                  JavaParameter(name: parameterName, type: .array(.byte))
-                ],
-                conversion: .jniByteArrayToUnsafeRawBufferPointer(.placeholder, name: parameterName),
-                indirectConversion: nil,
-                conversionCheck: nil
-              )
-            }
+            return NativeParameter(
+              parameters: [
+                JavaParameter(name: parameterName, type: .array(.byte))
+              ],
+              conversion: .jniByteArrayToUnsafeRawBufferPointer(.placeholder, name: parameterName),
+              indirectConversion: nil,
+              conversionCheck: nil
+            )
 
           case .foundationDate, .essentialsDate, .foundationData, .essentialsData:
             // Handled as wrapped struct
@@ -725,16 +709,6 @@ extension JNISwift2JavaGenerator {
               resultName: resultName
             )
 
-          case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
-            let outParam = "\(resultName)$unsafeBufferPointer"
-            return NativeResult(
-              javaType: .void,
-              conversion: .unsafeRawBufferPointerDestructure(.placeholder, outParam: outParam),
-              outParameters: [
-                JavaParameter(name: outParam, type: .array(.long)),
-              ]
-            )
-
           case .foundationDate, .essentialsDate, .foundationData, .essentialsData:
             // Handled as wrapped struct
             break
@@ -1201,19 +1175,13 @@ extension JNISwift2JavaGenerator {
     /// Converts a jbyteArray to UnsafeRawBufferPointer via GetByteArrayElements + defer
     indirect case jniByteArrayToUnsafeRawBufferPointer(NativeSwiftConversionStep, name: String)
 
-    /// Constructs UnsafeRawBufferPointer from two jlong params (pointer, count) — zero copy
-    case jniLongsToUnsafeRawBufferPointer(pointerParam: String, countParam: String)
-
     /// Constructs a Swift tuple from individually-converted elements.
     /// E.g. `(label0: conv0, conv1)` for `(label0: Int, String)`
     indirect case tupleConstruct(elements: [(label: String?, conversion: NativeSwiftConversionStep)])
 
     /// Destructures a Swift tuple result and writes each element to an out-parameter.
     indirect case tupleDestructure(elements: [(index: Int, label: String?, conversion: NativeSwiftConversionStep, outParamName: String, javaType: JavaType)])
 
-    /// Destructures an UnsafeRawBufferPointer into a long[2] out-parameter: [0]=pointer, [1]=count
-    indirect case unsafeRawBufferPointerDestructure(NativeSwiftConversionStep, outParam: String)
-
     /// Promotes the outermost `.getJNIValue` to `.getJNILocalRefValue`.
     /// Used for `@_cdecl` return positions to ensure the local ref survives
     /// ARC destruction of temporary `JavaObject`s.
@@ -1770,13 +1738,6 @@ extension JNISwift2JavaGenerator {
         )
         return rbpVar
 
-      case .jniLongsToUnsafeRawBufferPointer(let pointerParam, let countParam):
-        let rbpVar = "\(pointerParam)$rbp"
-        printer.print(
-          "let \(rbpVar) = UnsafeRawBufferPointer(start: UnsafeRawPointer(bitPattern: Int(\(pointerParam)))!, count: Int(\(countParam)))"
-        )
-        return rbpVar
-
       case .tupleConstruct(let elements):
         let parts = elements.enumerated().map { idx, element in
           let converted = element.conversion.render(&printer, "\(placeholder)_\(idx)")
@@ -1808,20 +1769,6 @@ extension JNISwift2JavaGenerator {
           }
         }
         return ""
-
-      case .unsafeRawBufferPointerDestructure(let inner, let outParam):
-        let inner = inner.render(&printer, placeholder)
-        let resultVar = "\(outParam)$result"
-        printer.print("let \(resultVar) = \(inner)")
-        printer.print(
-          """
-          var \(outParam)$jni_0 = jlong(Int(bitPattern: \(resultVar).baseAddress))
-          environment.interface.SetLongArrayRegion(environment, \(outParam), 0, 1, &\(outParam)$jni_0)
-          var \(outParam)$jni_1 = jlong(\(resultVar).count)
-          environment.interface.SetLongArrayRegion(environment, \(outParam), 1, 1, &\(outParam)$jni_1)
-          """
-        )
-        return ""
       }
     }
   }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+NativeTranslation.swift

@@ -30,7 +30,7 @@ package struct JavaIdentifierFactory {
   private mutating func record(_ methods: [ImportedFunc]) {
     // Group methods by their Java base name.
     var methodsByBaseName: [String: [ImportedFunc]] = [:]
-    for method in methods where !method.isImplicit {
+    for method in methods {
       let baseName: String =
         switch method.apiKind {
         case .getter, .subscriptGetter: method.javaGetterName

Sources/JExtractSwiftLib/JavaIdentifierFactory.swift

@@ -59,7 +59,4 @@ extension JavaType {
     .class(package: "java.util", name: "UUID")
   }
 
-  static var swiftUnsafeRawBufferPointer: JavaType {
-    .class(package: "org.swift.swiftkit.core", name: "SwiftUnsafeRawBufferPointer")
-  }
 }

Sources/JExtractSwiftLib/JavaTypes/JavaType+JDK.swift

@@ -106,9 +106,6 @@ extension Swift2JavaTranslator {
     }
 
     self.visitFoundationDeclsIfNeeded(with: visitor)
-    // If we have any decls that have implicit overloads, synthesize imported funcs for those.
-    // Rest of the pipeline will be able to treat them as-if normal funcs
-    self.synthesizeImplicitOverloads()
   }
 
   private func visitFoundationDeclsIfNeeded(with visitor: Swift2JavaVisitor) {
@@ -142,22 +139,6 @@ extension Swift2JavaTranslator {
     }
   }
 
-  private func synthesizeImplicitOverloads() {
-    for decl in importedGlobalFuncs {
-      if decl.hasUnsafeRawBufferPointerParameters {
-        importedGlobalFuncs.append(decl.makeImplicitOverloadFunc(.unsafeRawBufferPointerParams))
-      }
-    }
-
-    for (_, type) in importedTypes {
-      for method in type.methods {
-        if method.hasUnsafeRawBufferPointerParameters {
-          type.methods.append(method.makeImplicitOverloadFunc(.unsafeRawBufferPointerParams))
-        }
-      }
-    }
-  }
-
   package func prepareForTranslation() {
     let dependenciesSource = self.buildDependencyClassesSourceFile()