Move configuration deeper and allow confifuring unsigned handling mode

Author: ktoso

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -105,9 +105,16 @@ extension FFMSwift2JavaGenerator {
     var params: [String] = []
     var args: [String] = []
     for param in cFunc.parameters {
-      // ! unwrapping because cdecl lowering guarantees the parameter named.
-      params.append("\(param.type.javaType) \(param.name!)")
-      args.append(param.name!)
+      let name = param.name! // !-safe, because cdecl lowering guarantees the parameter named.
+
+      let annotationsStr =
+        if param.type.javaType.parameterAnnotations.isEmpty {
+          ""
+        } else {
+          param.type.javaType.parameterAnnotations.map({$0.render()}).joined(separator: " ") + " "
+        }
+      params.append("\(annotationsStr)\(param.type.javaType) \(name)")
+      args.append(name)
     }
     let paramsStr = params.joined(separator: ", ")
     let argsStr = args.joined(separator: ", ")
@@ -316,9 +323,12 @@ extension FFMSwift2JavaGenerator {
     let translatedSignature = translated.translatedSignature
     let returnTy = translatedSignature.result.javaResultType
 
+    var annotationsStr = translatedSignature.annotations.map({ $0.render() }).joined(separator: "\n")
+    if !annotationsStr.isEmpty { annotationsStr += "\n" }
+
     var paramDecls = translatedSignature.parameters
       .flatMap(\.javaParameters)
-      .map { "\($0.type) \($0.name)" }
+      .map { $0.renderParameter() }
     if translatedSignature.requiresSwiftArena {
       paramDecls.append("AllocatingSwiftArena swiftArena$")
     }
@@ -332,7 +342,7 @@ extension FFMSwift2JavaGenerator {
        * \(decl.signatureString)
        * }
        */
-      \(modifiers) \(returnTy) \(methodName)(\(paramDecls.joined(separator: ", ")))
+      \(annotationsStr) \(modifiers) \(returnTy) \(methodName)(\(paramDecls.joined(separator: ", ")))
       """
     ) { printer in
       if case .instance(_) =  decl.functionSignature.selfParameter {

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 import JavaTypes
+import JavaKitConfigurationShared
 
 extension FFMSwift2JavaGenerator {
   func translatedDecl(
@@ -24,7 +25,7 @@ extension FFMSwift2JavaGenerator {
 
     let translated: TranslatedFunctionDecl?
     do {
-      let translation = JavaTranslation(symbolTable: self.symbolTable)
+      let translation = JavaTranslation(config: self.config, symbolTable: self.symbolTable)
       translated = try translation.translate(decl)
     } catch {
       self.log.info("Failed to translate: '\(decl.swiftDecl.qualifiedNameForDebug)'; \(error)")
@@ -52,6 +53,9 @@ extension FFMSwift2JavaGenerator {
     /// Java type that represents the Swift result type.
     var javaResultType: JavaType
 
+    /// Java annotations that should be propagated from the result type onto the method
+    var annotations: [JavaAnnotation] = []
+
     /// Required indirect return receivers for receiving the result.
     ///
     /// 'JavaParameter.name' is the suffix for the receiver variable names. For example
@@ -85,15 +89,32 @@ extension FFMSwift2JavaGenerator {
     /// Function signature.
     let translatedSignature: TranslatedFunctionSignature
 
-    /// Cdecl lowerd signature.
+    /// Cdecl lowered signature.
     let loweredSignature: LoweredFunctionSignature
+
+    /// Annotations to include on the Java function declaration
+    var annotations: [JavaAnnotation] {
+      self.translatedSignature.annotations
+    }
   }
 
   /// 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
+   }
   }
 
   /// Represent a Swift closure type in the user facing Java API.
@@ -113,9 +134,11 @@ extension FFMSwift2JavaGenerator {
   }
 
   struct JavaTranslation {
+    let config: Configuration
     var knownTypes: SwiftKnownTypes
 
-    init(symbolTable: SwiftSymbolTable) {
+    init(config: Configuration, symbolTable: SwiftSymbolTable) {
+      self.config = config
       self.knownTypes = SwiftKnownTypes(symbolTable: symbolTable)
     }
 
@@ -299,21 +322,27 @@ extension FFMSwift2JavaGenerator {
     ) throws -> TranslatedParameter {
 
       // If we need to handle unsigned integers "safely" do so here
-      if let unsignedWrapperType = JavaType.unsignedWrapper(for: swiftType) /* and we're in safe wrapper mode */ {
-        return TranslatedParameter(
-          javaParameters: [
-            JavaParameter(name: parameterName, type: unsignedWrapperType)
-          ], conversion: .call(.placeholder, function: "UnsignedNumbers.toPrimitive", withArena: false))
+      if config.unsignedNumbersMode.needsConversion {
+        if let unsignedWrapperType = JavaType.unsignedWrapper(for: swiftType) /* and we're in safe wrapper mode */ {
+          return TranslatedParameter(
+            javaParameters: [
+              JavaParameter(name: parameterName, type: unsignedWrapperType)
+            ], 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
+              name: parameterName, type: javaType,
+              annotations: parameterAnnotations
             )
           ],
           conversion: .placeholder
@@ -326,7 +355,10 @@ extension FFMSwift2JavaGenerator {
         return TranslatedParameter(
           javaParameters: [
             JavaParameter(
-              name: parameterName, type: JavaType.class(package: "org.swift.swiftkit.ffm", name: "SwiftAnyType"))
+              name: parameterName,
+              type: JavaType.class(package: "org.swift.swiftkit.ffm", name: "SwiftAnyType"),
+              annotations: parameterAnnotations
+            )
           ],
           conversion: .swiftValueSelfSegment(.placeholder)
         )
@@ -505,7 +537,22 @@ extension FFMSwift2JavaGenerator {
       }
     }
 
-    func unsignedResultConversion(_ from: SwiftType, to javaType: JavaType) -> JavaConversionStep {
+  /// 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.unsignedNumbersMode == .annotate {
+      return [JavaAnnotation.unsigned]
+    }
+
+    return []
+  }
+
+  func unsignedResultConversion(_ from: SwiftType, to javaType: JavaType,
+                                mode: JExtractUnsignedIntegerMode) -> JavaConversionStep {
+    guard mode == .wrap else {
+      return .placeholder
+    }
+
     guard let className = javaType.className else {
       fatalError("Missing target class name for result conversion step from \(from) to \(javaType)")
     }
@@ -537,20 +584,28 @@ extension FFMSwift2JavaGenerator {
       let swiftType = swiftResult.type
 
       // If we need to handle unsigned integers "safely" do so here
-      if let unsignedWrapperType = JavaType.unsignedWrapper(for: swiftType) /* and we're in safe wrapper mode */ {
-        return TranslatedResult(
-          javaResultType: unsignedWrapperType,
-          outParameters: [],
-          conversion: unsignedResultConversion(swiftType, to: unsignedWrapperType)
-        )
+      if config.unsignedNumbersMode.needsConversion {
+        if let unsignedWrapperType = JavaType.unsignedWrapper(for: swiftType) /* and we're in safe wrapper mode */ {
+          return TranslatedResult(
+            javaResultType: unsignedWrapperType,
+            outParameters: [],
+            conversion: unsignedResultConversion(
+                swiftType, to: unsignedWrapperType,
+                mode: self.config.unsignedNumbersMode)
+          )
+        }
       }
 
+      // If the result type should cause any annotations on the method, include them here.
+      let resultAnnotations: [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 TranslatedResult(
           javaResultType: javaType,
+          annotations: resultAnnotations,
           outParameters: [],
           conversion: .placeholder
         )
@@ -562,6 +617,7 @@ extension FFMSwift2JavaGenerator {
         let javaType = JavaType.class(package: "org.swift.swiftkit.ffm", name: "SwiftAnyType")
         return TranslatedResult(
           javaResultType: javaType,
+          annotations: resultAnnotations,
           outParameters: [],
           conversion: .construct(.placeholder, javaType)
         )
@@ -572,6 +628,7 @@ extension FFMSwift2JavaGenerator {
           case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
             return TranslatedResult(
               javaResultType: .javaForeignMemorySegment,
+              annotations: resultAnnotations,
               outParameters: [
                 JavaParameter(name: "pointer", type: .javaForeignMemorySegment),
                 JavaParameter(name: "count", type: .long),
@@ -611,6 +668,7 @@ extension FFMSwift2JavaGenerator {
         let javaType: JavaType = .class(package: nil, name: swiftNominalType.nominalTypeDecl.name)
         return TranslatedResult(
           javaResultType: javaType,
+          annotations: resultAnnotations,
           outParameters: [
             JavaParameter(name: "", type: javaType)
           ],
@@ -716,7 +774,7 @@ extension CType {
     case .integral(.signed(bits: 32)): return .int
     case .integral(.signed(bits: 64)): return .long
     case .integral(.unsigned(bits: 8)): return .byte
-    case .integral(.unsigned(bits: 16)): return .short
+    case .integral(.unsigned(bits: 16)): return .char // char is Java's only unsigned primitive, we can use it!
     case .integral(.unsigned(bits: 32)): return .int
     case .integral(.unsigned(bits: 64)): return .long
 

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift

@@ -15,10 +15,12 @@
 import JavaTypes
 import SwiftSyntax
 import SwiftSyntaxBuilder
+import JavaKitConfigurationShared
 import struct Foundation.URL
 
 package class FFMSwift2JavaGenerator: Swift2JavaGenerator {
   let log: Logger
+  let config: Configuration
   let analysis: AnalysisResult
   let swiftModuleName: String
   let javaPackage: String
@@ -40,12 +42,14 @@ package class FFMSwift2JavaGenerator: Swift2JavaGenerator {
   var expectedOutputSwiftFiles: Set<String>
 
   package init(
+    config: Configuration,
     translator: Swift2JavaTranslator,
     javaPackage: String,
     swiftOutputDirectory: String,
     javaOutputDirectory: String
   ) {
     self.log = Logger(label: "ffm-generator", logLevel: translator.log.logLevel)
+    self.config = config
     self.analysis = translator.result
     self.swiftModuleName = translator.swiftModuleName
     self.javaPackage = javaPackage

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -219,7 +219,7 @@ extension JNISwift2JavaGenerator {
     _ printer: inout CodePrinter,
     _ functionType: TranslatedFunctionType
   ) {
-    let apiParams = functionType.parameters.map(\.parameter.asParameter)
+    let apiParams = functionType.parameters.map({ $0.parameter.renderParameter() })
 
     printer.print(
         """
@@ -243,7 +243,7 @@ extension JNISwift2JavaGenerator {
 
     let translatedSignature = translatedDecl.translatedFunctionSignature
     let resultType = translatedSignature.resultType.javaType
-    var parameters = translatedDecl.translatedFunctionSignature.parameters.map(\.parameter.asParameter)
+    var parameters = translatedDecl.translatedFunctionSignature.parameters.map({ $0.parameter.renderParameter() })
     if translatedSignature.requiresSwiftArena {
       parameters.append("SwiftArena swiftArena$")
     }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -300,12 +300,24 @@ extension JNISwift2JavaGenerator {
 
   struct TranslatedFunctionSignature {
     let selfParameter: TranslatedParameter?
+    var annotations: [JavaAnnotation] = []
     let parameters: [TranslatedParameter]
     let resultType: TranslatedResult
 
     var requiresSwiftArena: Bool {
       return self.resultType.conversion.requiresSwiftArena
     }
+
+    init(selfParameter: TranslatedParameter?,
+         parameters: [TranslatedParameter],
+         resultType: TranslatedResult) {
+      self.selfParameter = selfParameter
+      // if the result type implied any annotations,
+      // propagate them onto the function the result is returned from
+      self.annotations = resultType.annotations
+      self.parameters = parameters
+      self.resultType = resultType
+   }
   }
 
   /// Represent a Swift API parameter translated to Java.
@@ -318,6 +330,9 @@ extension JNISwift2JavaGenerator {
   struct TranslatedResult {
     let javaType: JavaType
 
+    /// Java annotations that should be propagated from the result type onto the method
+    var annotations: [JavaAnnotation] = []
+
     /// Represents how to convert the Java native result into a user-facing result.
     let conversion: JavaNativeConversionStep
   }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator.swift

@@ -13,16 +13,19 @@
 //===----------------------------------------------------------------------===//
 
 import JavaTypes
+import JavaKitConfigurationShared
 
 /// A table that where keys are Swift class names and the values are
 /// the fully qualified canoical names.
 package typealias JavaClassLookupTable = [String: String]
 
 package class JNISwift2JavaGenerator: Swift2JavaGenerator {
+
+  let logger: Logger
+  let config: Configuration
   let analysis: AnalysisResult
   let swiftModuleName: String
   let javaPackage: String
-  let logger: Logger
   let swiftOutputDirectory: String
   let javaOutputDirectory: String
 
@@ -42,12 +45,14 @@ package class JNISwift2JavaGenerator: Swift2JavaGenerator {
   var expectedOutputSwiftFiles: Set<String>
 
   package init(
+    config: Configuration,
     translator: Swift2JavaTranslator,
     javaPackage: String,
     swiftOutputDirectory: String,
     javaOutputDirectory: String,
     javaClassLookupTable: JavaClassLookupTable
   ) {
+    self.config = config
     self.logger = Logger(label: "jni-generator", logLevel: translator.log.logLevel)
     self.analysis = translator.result
     self.swiftModuleName = translator.swiftModuleName

Sources/JExtractSwiftLib/JavaParameter.swift

@@ -18,8 +18,20 @@ import JavaTypes
 struct JavaParameter {
   let name: String
   let type: JavaType
+  let annotations: [JavaAnnotation]
 
-  var asParameter: String {
-    "\(type) \(name)"
+  init(name: String, type: JavaType, annotations: [JavaAnnotation] = []) {
+    self.name = name
+    self.type = type
+    self.annotations = annotations
+  }
+
+  func renderParameter() -> String {
+    if annotations.isEmpty {
+      return "\(type) \(name)"
+    }
+
+    let annotationsStr = annotations.map({$0.render()}).joined(separator: "")
+    return "\(annotationsStr) \(type) \(name)"
   }
 }