Implement @unchecked integer types for jextract-jni

Author: ktoso

Sources/JExtractSwiftLib/Common/TypeAnnotations.swift

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 JavaTypes
+import JavaKitConfigurationShared
+
+/// Determine if the given type needs any extra annotations that should be included
+/// in Java sources when the corresponding Java type is rendered.
+func getTypeAnnotations(swiftType: SwiftType, config: Configuration) -> [JavaAnnotation] {
+  if swiftType.isUnsignedInteger, config.effectiveUnsignedNumbersMode == .annotate {
+    return [JavaAnnotation.unsigned]
+  }
+
+  return []
+}

Sources/JExtractSwiftLib/Configuration+Extensions.swift

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 JavaKitConfigurationShared // TODO: this should become SwiftJavaConfigurationShared
+import JavaTypes // TODO: this should become SwiftJavaConfigurationShared
+
+extension Configuration {
+  public var effectiveUnsignedNumericsMode: UnsignedNumericsMode {
+    switch effectiveUnsignedNumbersMode {
+    case .annotate: .ignoreSign
+    case .wrapGuava: .wrapUnsignedGuava
+    }
+  }
+}

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -334,14 +334,9 @@ extension FFMSwift2JavaGenerator {
     }
 
     // TODO: we could copy the Swift method's documentation over here, that'd be great UX
+    printDeclDocumentation(&printer, decl)
     printer.printBraceBlock(
       """
-      /**
-       * Downcall to Swift:
-       * {@snippet lang=swift :
-       * \(decl.signatureString)
-       * }
-       */
       \(annotationsStr)\(modifiers) \(returnTy) \(methodName)(\(paramDecls.joined(separator: ", ")))
       """
     ) { printer in
@@ -354,6 +349,19 @@ extension FFMSwift2JavaGenerator {
     }
   }
 
+  private func printDeclDocumentation(_ printer: inout CodePrinter, _ decl: ImportedFunc) {
+    printer.print(
+      """
+      /**
+       * Downcall to Swift:
+       * {@snippet lang=swift :
+       * \(decl.signatureString)
+       * }
+       */
+      """
+    )
+  }
+
   /// Print the actual downcall to the Swift API.
   ///
   /// This assumes that all the parameters are passed-in with appropriate names.

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -25,7 +25,9 @@ extension FFMSwift2JavaGenerator {
 
     let translated: TranslatedFunctionDecl?
     do {
-      let translation = JavaTranslation(config: self.config, knownTypes: SwiftKnownTypes(symbolTable: lookupContext.symbolTable))
+      let translation = JavaTranslation(
+        config: self.config,
+        knownTypes: SwiftKnownTypes(symbolTable: lookupContext.symbolTable))
       translated = try translation.translate(decl)
     } catch {
       self.log.info("Failed to translate: '\(decl.swiftDecl.qualifiedNameForDebug)'; \(error)")
@@ -101,20 +103,14 @@ extension FFMSwift2JavaGenerator {
   /// Function signature for a Java API.
   struct TranslatedFunctionSignature {
     var selfParameter: TranslatedParameter?
-    var annotations: [JavaAnnotation] = []
     var parameters: [TranslatedParameter]
     var result: TranslatedResult
 
-    init(selfParameter: TranslatedParameter?,
-         parameters: [TranslatedParameter],
-         result: TranslatedResult) {
-      self.selfParameter = selfParameter
-      // if the result type implied any annotations,
-      // propagate them onto the function the result is returned from
-      self.annotations = result.annotations
-      self.parameters = parameters
-      self.result = result
-   }
+    // if the result type implied any annotations,
+    // propagate them onto the function the result is returned from
+    var annotations: [JavaAnnotation] {
+      self.result.annotations
+    }
   }
 
   /// Represent a Swift closure type in the user facing Java API.
@@ -142,9 +138,7 @@ extension FFMSwift2JavaGenerator {
       self.knownTypes = knownTypes
     }
 
-    func translate(
-      _ decl: ImportedFunc
-    ) throws -> TranslatedFunctionDecl {
+    func translate(_ decl: ImportedFunc) throws -> TranslatedFunctionDecl {
       let lowering = CdeclLowering(knownTypes: knownTypes)
       let loweredSignature = try lowering.lowerFunctionSignature(decl.functionSignature)
 
@@ -326,30 +320,29 @@ extension FFMSwift2JavaGenerator {
       genericParameters: [SwiftGenericParameterDeclaration],
       genericRequirements: [SwiftGenericRequirement]
     ) throws -> TranslatedParameter {
+      // If the result type should cause any annotations on the method, include them here.
+      let parameterAnnotations: [JavaAnnotation] = getTypeAnnotations(swiftType: swiftType, config: config)
 
       // If we need to handle unsigned integers do so here
       if config.effectiveUnsignedNumbersMode.needsConversion {
-        if let unsignedWrapperType = JavaType.unsignedWrapper(for: swiftType) /* and we're in safe wrapper mode */ {
+        if let unsignedWrapperType = JavaType.unsignedWrapper(for: swiftType) {
           return TranslatedParameter(
             javaParameters: [
-              JavaParameter(name: parameterName, type: unsignedWrapperType)
+              JavaParameter(name: parameterName, type: unsignedWrapperType, annotations: parameterAnnotations)
             ], conversion: .call(.placeholder, function: "UnsignedNumbers.toPrimitive", withArena: false))
         }
       }
 
-      // If the result type should cause any annotations on the method, include them here.
-      let parameterAnnotations: [JavaAnnotation] = getTypeAnnotations(swiftType: swiftType)
-
       // If there is a 1:1 mapping between this Swift type and a C type, that can
       // be expressed as a Java primitive type.
       if let cType = try? CType(cdeclType: swiftType) {
         let javaType = cType.javaType
         return TranslatedParameter(
           javaParameters: [
             JavaParameter(
-              name: parameterName, type: javaType,
-              annotations: parameterAnnotations
-            )
+              name: parameterName,
+              type: javaType,
+              annotations: parameterAnnotations)
           ],
           conversion: .placeholder
         )
@@ -564,46 +557,36 @@ extension FFMSwift2JavaGenerator {
       }
     }
 
-  /// Determine if the given type needs any extra annotations that should be included
-  /// in Java sources when the corresponding Java type is rendered.
-  func getTypeAnnotations(swiftType: SwiftType) -> [JavaAnnotation] {
-    if swiftType.isUnsignedInteger, config.effectiveUnsignedNumbersMode == .annotate {
-      return [JavaAnnotation.unsigned]
-    }
-
-    return []
-  }
-
-  func unsignedResultConversion(_ from: SwiftType, to javaType: JavaType,
-                                mode: JExtractUnsignedIntegerMode) -> JavaConversionStep {
-    switch mode {
-    case .annotate:
-      return .placeholder // no conversions
+    func unsignedResultConversion(_ from: SwiftType, to javaType: JavaType,
+                                  mode: JExtractUnsignedIntegerMode) -> JavaConversionStep {
+      switch mode {
+      case .annotate:
+        return .placeholder // no conversions
 
-    case .wrapGuava:
-      guard let typeName = javaType.fullyQualifiedClassName else {
-        fatalError("Missing target class name for result conversion step from \(from) to \(javaType)")
-      }
+      case .wrapGuava:
+        guard let typeName = javaType.fullyQualifiedClassName else {
+          fatalError("Missing target class name for result conversion step from \(from) to \(javaType)")
+        }
 
-      switch from {
-      case .nominal(let nominal):
-       switch nominal.nominalTypeDecl.knownTypeKind {
-       case .uint8:
-         return .call(.placeholder, function: "\(typeName).fromIntBits", withArena: false)
-       case .uint16:
-         return .placeholder // no conversion, UInt16 can be returned as-is and will be seen as char by Java
-       case .uint32:
-         return .call(.placeholder, function: "\(typeName).fromIntBits", withArena: false)
-       case .uint64:
-         return .call(.placeholder, function: "\(typeName).fromLongBits", withArena: false)
-       default:
-         fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
-       }
-       default:
-         fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
+        switch from {
+        case .nominal(let nominal):
+         switch nominal.nominalTypeDecl.knownTypeKind {
+         case .uint8:
+           return .call(.placeholder, function: "\(typeName).fromIntBits", withArena: false)
+         case .uint16:
+           return .placeholder // no conversion, UInt16 can be returned as-is and will be seen as char by Java
+         case .uint32:
+           return .call(.placeholder, function: "\(typeName).fromIntBits", withArena: false)
+         case .uint64:
+           return .call(.placeholder, function: "\(typeName).fromLongBits", withArena: false)
+         default:
+           fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
+         }
+         default:
+           fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
+        }
       }
     }
-  }
 
     /// Translate a Swift API result to the user-facing Java API result.
     func translate(
@@ -626,7 +609,7 @@ extension FFMSwift2JavaGenerator {
       }
 
       // If the result type should cause any annotations on the method, include them here.
-      let resultAnnotations: [JavaAnnotation] = getTypeAnnotations(swiftType: swiftType)
+      let resultAnnotations: [JavaAnnotation] = getTypeAnnotations(swiftType: swiftType, config: config)
 
       // If there is a 1:1 mapping between this Swift type and a C type, that can
       // be expressed as a Java primitive type.

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+SwiftThunkPrinting.swift

@@ -38,7 +38,7 @@ extension FFMSwift2JavaGenerator {
     let moduleFilenameBase = "\(self.swiftModuleName)Module+SwiftJava"
     let moduleFilename = "\(moduleFilenameBase).swift"
     do {
-      log.info("Printing contents: \(moduleFilename)")
+      log.debug("Printing contents: \(moduleFilename)")
 
       try printGlobalSwiftThunkSources(&printer)
 
@@ -58,7 +58,7 @@ extension FFMSwift2JavaGenerator {
     for (_, ty) in self.analysis.importedTypes.sorted(by: { (lhs, rhs) in lhs.key < rhs.key }) {
       let fileNameBase = "\(ty.swiftNominal.qualifiedName)+SwiftJava"
       let filename = "\(fileNameBase).swift"
-      log.info("Printing contents: \(filename)")
+      log.debug("Printing contents: \(filename)")
 
       do {
         try printSwiftThunkSources(&printer, ty: ty)

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift

@@ -100,7 +100,6 @@ extension FFMSwift2JavaGenerator {
     "org.swift.swiftkit.core.*",
     "org.swift.swiftkit.core.util.*",
     "org.swift.swiftkit.ffm.*",
-    "org.swift.swiftkit.ffm.SwiftRuntime",
 
     // NonNull, Unsigned and friends
     "org.swift.swiftkit.core.annotations.*",
@@ -127,7 +126,7 @@ extension FFMSwift2JavaGenerator {
   package func writeExportedJavaSources(printer: inout CodePrinter) throws {
     for (_, ty) in analysis.importedTypes.sorted(by: { (lhs, rhs) in lhs.key < rhs.key }) {
       let filename = "\(ty.swiftNominal.name).java"
-      log.info("Printing contents: \(filename)")
+      log.debug("Printing contents: \(filename)")
       printImportedNominal(&printer, ty)
 
       if let outputFile = try printer.writeContents(
@@ -141,7 +140,7 @@ extension FFMSwift2JavaGenerator {
 
     do {
       let filename = "\(self.swiftModuleName).java"
-      log.info("Printing contents: \(filename)")
+      log.debug("Printing contents: \(filename)")
       printModule(&printer)
 
       if let outputFile = try printer.writeContents(

Sources/JExtractSwiftLib/JNI/JNIJavaTypeTranslator.swift

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024-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 JavaTypes
+import JavaKitConfigurationShared
+
+enum JNIJavaTypeTranslator {
+
+  static func translate(knownType: SwiftKnownTypeDeclKind, config: Configuration) -> JavaType? {
+    let unsigned = config.effectiveUnsignedNumbersMode
+    guard unsigned == .annotate else {
+      // We do not support wrap mode in JNI mode currently;
+      // In the future this is where it would be interesting to implement Kotlin UInt support.
+      return nil
+    }
+
+    switch knownType {
+    case .bool: return .boolean
+
+    case .int8: return .byte
+    case .uint8: return .char
+    case .int16: return .short
+    case .uint16: return .char
+
+    case .int32: return .int
+    case .uint32: return .int
+
+    case .int64: return .long
+    case .uint64: return .long
+
+    case .float: return .float
+    case .double: return .double
+    case .void: return .void
+
+    case .string: return .javaLangString
+    case .int, .uint, // FIXME: why not supported int/uint?
+        .unsafeRawPointer, .unsafeMutableRawPointer,
+        .unsafePointer, .unsafeMutablePointer,
+        .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer,
+        .unsafeBufferPointer, .unsafeMutableBufferPointer,
+        .optional, .data, .dataProtocol:
+      return nil
+    }
+  }
+}