fix: add C-compatible JNI type aliases for C++ interoperability

This commit introduces C-compatible type aliases (CJNIEnv, Cjobject,
Cjstring, etc.) to resolve type mismatches when Swift modules with
C++ interoperability enabled import SwiftJava.

The root cause is that jni.h defines JNI types differently in C vs C++:
- C mode: JNIEnv = const struct JNINativeInterface_ * (pointer)
- C++ mode: JNIEnv = JNIEnv_ (struct)

When a module like HelloWorld has C++ interop enabled but imports
SwiftJava (which is compiled without C++ interop), the JNI type
definitions conflict, causing compilation errors.

Changes:
- CSwiftJavaJNI.h: Add C-compatible type aliases that resolve to the
  same underlying type in both C and C++ modes
- JavaType+JNI.swift: Use C-compatible types (Cjstring, Cjobject, etc.)
  in generated JNI method signatures
- JNISwift2JavaGenerator: Add unsafeBitCast for return values to convert
  between SwiftJava's internal JNI types and C-compatible types
- JavaValue.swift, JavaEnvironment.swift: Use CJNIEnv in JNIEnvironment
  typealias for consistent type definitions

Fixes: #391

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: NakaokaRei

Sources/CSwiftJavaJNI/include/CSwiftJavaJNI.h

@@ -17,4 +17,52 @@
 
 #include <jni.h>
 
+// Provide C-compatible type aliases for JNI types.
+// When Swift modules have C++ interoperability enabled, jni.h is parsed
+// in C++ mode where JNIEnv is defined as a struct (JNIEnv_). However,
+// SwiftJava modules are compiled without C++ interop, causing JNIEnv
+// to be a pointer type. This mismatch causes type errors.
+//
+// These typedefs provide consistent C-style pointer types that work
+// regardless of the C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+#ifdef __cplusplus
+// Android NDK uses JNINativeInterface instead of JNINativeInterface_
+#ifdef __ANDROID__
+typedef const JNINativeInterface *CJNIEnv;
+#else
+typedef const JNINativeInterface_ *CJNIEnv;
+#endif
+typedef _jobject *Cjobject;
+typedef _jclass *Cjclass;
+typedef _jstring *Cjstring;
+typedef _jarray *Cjarray;
+typedef _jobjectArray *CjobjectArray;
+typedef _jbooleanArray *CjbooleanArray;
+typedef _jbyteArray *CjbyteArray;
+typedef _jcharArray *CjcharArray;
+typedef _jshortArray *CjshortArray;
+typedef _jintArray *CjintArray;
+typedef _jlongArray *CjlongArray;
+typedef _jfloatArray *CjfloatArray;
+typedef _jdoubleArray *CjdoubleArray;
+typedef _jthrowable *Cjthrowable;
+#else
+typedef JNIEnv CJNIEnv;
+typedef jobject Cjobject;
+typedef jclass Cjclass;
+typedef jstring Cjstring;
+typedef jarray Cjarray;
+typedef jobjectArray CjobjectArray;
+typedef jbooleanArray CjbooleanArray;
+typedef jbyteArray CjbyteArray;
+typedef jcharArray CjcharArray;
+typedef jshortArray CjshortArray;
+typedef jintArray CjintArray;
+typedef jlongArray CjlongArray;
+typedef jfloatArray CjfloatArray;
+typedef jdoubleArray CjdoubleArray;
+typedef jthrowable Cjthrowable;
+#endif
+
 #endif /* CSwiftJavaJNI_h */

Sources/CSwiftJavaJNI/include/module.modulemap

@@ -1,8 +1,4 @@
 module CSwiftJavaJNI {
     umbrella header "CSwiftJavaJNI.h"
-    // Force C-mode JNI type definitions to ensure compatibility with
-    // Swift modules that have C++ interoperability enabled.
-    // See: https://github.com/swiftlang/swift-java/issues/391
-    requires !cplusplus
     export *
 }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift

@@ -355,7 +355,13 @@ extension JNISwift2JavaGenerator {
       let loweredResult = nativeSignature.result.conversion.render(&printer, result)
 
       if !decl.functionSignature.result.type.isVoid {
-        return "return \(loweredResult)"
+        let resultType = nativeSignature.result.javaType.jniTypeName
+        // Use unsafeBitCast for C++ interoperability compatibility.
+        // SwiftJava uses JNI types (jstring, jobject, etc.) internally,
+        // but generated thunks use C-compatible types (Cjstring, Cjobject, etc.)
+        // to ensure compatibility with modules that have C++ interop enabled.
+        // See: https://github.com/swiftlang/swift-java/issues/391
+        return "return unsafeBitCast(\(loweredResult), to: \(resultType).self)"
       } else {
         return loweredResult
       }
@@ -441,7 +447,9 @@ extension JNISwift2JavaGenerator {
 
     let thunkParameters =
       [
-        "environment: UnsafeMutablePointer<JNIEnv?>!",
+        // Use CJNIEnv for C++ interoperability compatibility.
+        // See: https://github.com/swiftlang/swift-java/issues/391
+        "environment: UnsafeMutablePointer<CJNIEnv?>!",
         "thisClass: jclass"
       ] + translatedParameters
     let thunkReturnType = resultType != .void ? " -> \(resultType.jniTypeName)" : ""

Sources/JExtractSwiftLib/JavaParameter.swift

@@ -47,7 +47,8 @@ struct JavaParameter {
     var jniTypeName: String {
       switch self {
       case .concrete(let type): type.jniTypeName
-      case .generic: "jobject?"
+      // Use C-compatible type for C++ interoperability
+      case .generic: "Cjobject?"
       }
     }
 

Sources/JavaTypes/JavaType+JNI.swift

@@ -14,6 +14,8 @@
 
 extension JavaType {
   /// Map this Java type to the appropriate JNI type name.
+  /// Uses C-compatible types (Cjobject, Cjstring, etc.) for C++ interoperability.
+  /// See: https://github.com/swiftlang/swift-java/issues/391
   package var jniTypeName: String {
     switch self {
     case .boolean: "jboolean"
@@ -25,19 +27,19 @@ extension JavaType {
     case .int: "jint"
     case .long: "jlong"
     case .void: "void"
-    case .array(.boolean): "jbooleanArray?"
-    case .array(.byte): "jbyteArray?"
-    case .array(.char): "jcharArray?"
-    case .array(.short): "jshortArray?"
-    case .array(.int): "jintArray?"
-    case .array(.long): "jlongArray?"
-    case .array(.float): "jfloatArray?"
-    case .array(.double): "jdoubleArray?"
-    case .array: "jobjectArray?"
-    case .class(package: "java.lang", name: "String", _): "jstring?"
-    case .class(package: "java.lang", name: "Class", _): "jclass?"
-    case .class(package: "java.lang", name: "Throwable", _): "jthrowable?"
-    case .class: "jobject?"
+    case .array(.boolean): "CjbooleanArray?"
+    case .array(.byte): "CjbyteArray?"
+    case .array(.char): "CjcharArray?"
+    case .array(.short): "CjshortArray?"
+    case .array(.int): "CjintArray?"
+    case .array(.long): "CjlongArray?"
+    case .array(.float): "CjfloatArray?"
+    case .array(.double): "CjdoubleArray?"
+    case .array: "CjobjectArray?"
+    case .class(package: "java.lang", name: "String", _): "Cjstring?"
+    case .class(package: "java.lang", name: "Class", _): "Cjclass?"
+    case .class(package: "java.lang", name: "Throwable", _): "Cjthrowable?"
+    case .class: "Cjobject?"
     }
   }
 

Sources/SwiftJava/JVM/JavaVirtualMachine.swift

@@ -19,8 +19,10 @@ import Foundation
 #endif
 
 public typealias JavaVMPointer = UnsafeMutablePointer<JavaVM?>
+// Use CJNIEnv for C++ interoperability compatibility.
+// See: https://github.com/swiftlang/swift-java/issues/391
 #if canImport(Android)
-typealias JNIEnvPointer = UnsafeMutablePointer<JNIEnv?>
+typealias JNIEnvPointer = UnsafeMutablePointer<CJNIEnv?>
 #else
 typealias JNIEnvPointer = UnsafeMutableRawPointer
 #endif

Sources/SwiftJava/JavaEnvironment.swift

@@ -18,6 +18,8 @@ import CSwiftJavaJNI
 public typealias JNINativeInterface_ = JNINativeInterface
 #endif
 
-extension UnsafeMutablePointer<JNIEnv?> {
+// Extension on CJNIEnv for C++ interoperability compatibility.
+// See: https://github.com/swiftlang/swift-java/issues/391
+extension UnsafeMutablePointer<CJNIEnv?> {
   public var interface: JNINativeInterface_ { self.pointee!.pointee }
 }

Sources/SwiftJava/JavaValue.swift

@@ -93,7 +93,9 @@ public protocol JavaValue: ~Copyable {
 }
 
 /// The JNI environment.
-public typealias JNIEnvironment = UnsafeMutablePointer<JNIEnv?>
+/// Uses CJNIEnv for C++ interoperability compatibility.
+/// See: https://github.com/swiftlang/swift-java/issues/391
+public typealias JNIEnvironment = UnsafeMutablePointer<CJNIEnv?>
 
 /// Type of an operation that performs a JNI method call.
 public typealias JNIMethodCall<Result> = (JNIEnvironment, jobject, jmethodID, UnsafePointer<jvalue>?) -> Result