Support UInt handling in jextract JNI mode (#460)

Co-authored-by: pelekon <[email protected]>
Co-authored-by: Konrad `ktoso` Malawski <[email protected]>
Co-authored-by: Konrad Malawski <[email protected]>

Author: pelekon

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/EnumWithValueCases.swift

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+public enum EnumWithValueCases {
+  case firstCase(UInt)
+}

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/ObjectWithInts.swift

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+public final class ObjectWithInts {
+  public var normalInt: Int
+  public var unsignedInt: UInt
+
+  public init(normalInt: Int, unsignedInt: UInt) {
+    self.normalInt = normalInt
+    self.unsignedInt = unsignedInt
+  }
+
+  public func callMe(arg: UInt) -> UInt {
+    return arg
+  }
+}

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

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+package com.example.swift;
+
+import org.junit.jupiter.api.Test;
+import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
+import org.swift.swiftkit.core.SwiftArena;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class EnumWithValueCasesTest {
+    @Test
+    void fn() {
+        try (var arena = SwiftArena.ofConfined()) {
+            EnumWithValueCases e = EnumWithValueCases.firstCase(48, arena);
+            EnumWithValueCases.FirstCase c = (EnumWithValueCases.FirstCase) e.getCase();
+            assertNotNull(c);
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+package com.example.swift;
+
+import org.junit.jupiter.api.Test;
+import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
+import org.swift.swiftkit.core.SwiftArena;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ObjectWithIntsTest {
+    @Test
+    void init() {
+        try (var arena = SwiftArena.ofConfined()) {
+            ObjectWithInts obj = ObjectWithInts.init(-45, 45, arena);
+            assertEquals(-45, obj.getNormalInt());
+            assertEquals(45, obj.getUnsignedInt());
+        }
+    }
+
+    @Test
+    void callMe() {
+        try (var arena = SwiftArena.ofConfined()) {
+            ObjectWithInts obj = ObjectWithInts.init(-45, 45, arena);
+            assertEquals(66, obj.callMe(66));
+        }
+    }
+}

Sources/JExtractSwiftLib/JNI/JNIJavaTypeTranslator.swift

@@ -32,20 +32,55 @@ enum JNIJavaTypeTranslator {
 
     case .int64: return .long
     case .uint64: return .long
+    
+    case .int, .uint: 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,
+    case .unsafeRawPointer, .unsafeMutableRawPointer,
         .unsafePointer, .unsafeMutablePointer,
         .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer,
         .unsafeBufferPointer, .unsafeMutableBufferPointer,
         .optional, .foundationData, .foundationDataProtocol, .essentialsData, .essentialsDataProtocol, .array:
       return nil
     }
   }
+
+  static func indirectConversionStepSwiftType(for knownKind: SwiftKnownTypeDeclKind, from knownTypes: SwiftKnownTypes) -> SwiftType? {
+    switch knownKind {
+    case .int: knownTypes.int64
+    case .uint: knownTypes.uint64
+
+    case .bool, .int8, .uint8, .int16, .uint16, .int32, .uint32, .int64, .uint64,
+      .float, .double, .void, .string,
+      .unsafeRawPointer, .unsafeMutableRawPointer,
+      .unsafePointer, .unsafeMutablePointer,
+      .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer,
+      .unsafeBufferPointer, .unsafeMutableBufferPointer,
+      .optional, .foundationData, .foundationDataProtocol, .essentialsData, .essentialsDataProtocol,
+      .array:
+      nil
+    }
+  }
+
+  static func checkStep(for knownKind: SwiftKnownTypeDeclKind, from knownTypes: SwiftKnownTypes) -> JNISwift2JavaGenerator.NativeSwiftConversionCheck? {
+    switch knownKind {
+    case .int: .check32BitIntOverflow(typeWithMinAndMax: knownTypes.int32)
+    case .uint: .check32BitIntOverflow(typeWithMinAndMax: knownTypes.uint32)
+
+    case .bool, .int8, .uint8, .int16, .uint16, .int32, .uint32, .int64, .uint64,
+      .float, .double, .void, .string,
+      .unsafeRawPointer, .unsafeMutableRawPointer,
+      .unsafePointer, .unsafeMutablePointer,
+      .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer,
+      .unsafeBufferPointer, .unsafeMutableBufferPointer,
+      .optional, .foundationData, .foundationDataProtocol, .essentialsData, .essentialsDataProtocol,
+      .array:
+      nil
+    }
+  }
 }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -509,7 +509,7 @@ extension JNISwift2JavaGenerator {
     let translatedSignature = translatedDecl.translatedFunctionSignature
     let resultType = translatedSignature.resultType.javaType
     var parameters = translatedDecl.translatedFunctionSignature.parameters.map { $0.parameter.renderParameter() }
-    let throwsClause = translatedDecl.isThrowing && !translatedDecl.isAsync ? " throws Exception" : ""
+    let throwsClause = translatedDecl.throwsClause()
 
     let generics = translatedDecl.translatedFunctionSignature.parameters.reduce(into: [(String, [JavaType])]()) { generics, parameter in
       guard case .generic(let name, let extends) = parameter.parameter.type else {

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -121,6 +121,12 @@ extension JNISwift2JavaGenerator {
           .class(package: nil,name: caseName)
         )
       ])
+      var exceptions: [JavaExceptionType] = []
+
+      if enumCase.parameters.contains(where: \.type.isArchDependingInteger) {
+        exceptions.append(.integerOverflow)
+      }
+
       let getAsCaseFunction = TranslatedFunctionDecl(
         name: getAsCaseName,
         isStatic: false,
@@ -144,12 +150,15 @@ extension JNISwift2JavaGenerator {
             javaType: .class(package: nil, name: "Optional<\(caseName)>"),
             outParameters: conversions.flatMap(\.translated.outParameters),
             conversion: enumCase.parameters.isEmpty ? constructRecordConversion : .aggregate(variable: ("$nativeParameters", nativeParametersType), [constructRecordConversion])
-          )
+          ),
+          exceptions: exceptions
         ),
         nativeFunctionSignature: NativeFunctionSignature(
           selfParameter: NativeParameter(
             parameters: [JavaParameter(name: "self", type: .long)],
-            conversion: .extractSwiftValue(.placeholder, swiftType: .nominal(enumCase.enumType), allowNil: false)
+            conversion: .extractSwiftValue(.placeholder, swiftType: .nominal(enumCase.enumType), allowNil: false),
+            indirectConversion: nil,
+            conversionCheck: nil
           ),
           parameters: [],
           result: NativeResult(
@@ -299,12 +308,19 @@ extension JNISwift2JavaGenerator {
         genericRequirements: functionSignature.genericRequirements
       )
 
+      var exceptions: [JavaExceptionType] = []
+
+      if functionSignature.parameters.contains(where: \.type.isArchDependingInteger) {
+        exceptions.append(.integerOverflow)
+      }
+
       let resultType = try translate(swiftResult: functionSignature.result)
 
       return TranslatedFunctionSignature(
         selfParameter: selfParameter,
         parameters: parameters,
-        resultType: resultType
+        resultType: resultType,
+        exceptions: exceptions
       )
     }
 
@@ -952,12 +968,22 @@ extension JNISwift2JavaGenerator {
     var annotations: [JavaAnnotation] {
       self.translatedFunctionSignature.annotations
     }
+
+    func throwsClause() -> String {
+      guard !translatedFunctionSignature.exceptions.isEmpty else {
+        return isThrowing && !isAsync ? " throws Exception" : ""
+      }
+
+      let signatureExceptions = translatedFunctionSignature.exceptions.compactMap(\.type.className).joined(separator: ", ")
+      return " throws \(signatureExceptions)\(isThrowing ? ", Exception" : "")"
+    }
   }
 
   struct TranslatedFunctionSignature {
     var selfParameter: TranslatedParameter?
     var parameters: [TranslatedParameter]
     var resultType: TranslatedResult
+    var exceptions: [JavaExceptionType]
 
     // if the result type implied any annotations,
     // propagate them onto the function the result is returned from