diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
index a0f2eda5f..ae3b61e8f 100644
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@@ -176,6 +176,72 @@ jobs:
       - name: Swift Test
         run: "swift test"
 
+  # Test that projects depending on swift-java can build with C++ interoperability enabled.
+  # This is important because users may enable -cxx-interoperability-mode=default in their
+  # own projects, and swift-java's public API must be compatible with that mode.
+  # See: https://github.com/swiftlang/swift-java/issues/391
+  verify-samples-cxx-interop:
+    name: Sample ${{ matrix.sample_app }} (C++ Interop) (${{ matrix.os_version }} swift:${{ matrix.swift_version }} jdk:${{matrix.jdk_vendor}})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        swift_version: ['6.2']
+        os_version: ['jammy']
+        jdk_vendor: ['corretto']
+        sample_app: [
+          'JavaDependencySampleApp',
+          'JavaKitSampleApp',
+          'JavaProbablyPrime',
+          'JavaSieve',
+          'SwiftAndJavaJarSampleLib',
+          'SwiftJavaExtractFFMSampleApp',
+          'SwiftJavaExtractJNISampleApp',
+        ]
+    container:
+      image: ${{ (contains(matrix.swift_version, 'nightly') && 'swiftlang/swift') || 'swift' }}:${{ matrix.swift_version }}-${{ matrix.os_version }}
+    env:
+      CXX_INTEROP: '1'
+      SWIFT_JAVA_VERBOSE: true
+    steps:
+      - uses: actions/checkout@v4
+      - name: Prepare CI Environment
+        uses: ./.github/actions/prepare_env
+      - name: "Verify sample with C++ Interop: ${{ matrix.sample_app }}"
+        run: .github/scripts/validate_sample.sh Samples/${{ matrix.sample_app }}
+
+  verify-samples-cxx-interop-macos:
+    name: Sample ${{ matrix.sample_app }} (C++ Interop) (${{ matrix.os_version }} swift:${{ matrix.swift_version }} jdk:${{matrix.jdk_vendor}})
+    runs-on: [self-hosted, macos, sequoia, ARM64]
+    strategy:
+      fail-fast: false
+      matrix:
+        swift_version: ['6.2']
+        os_version: ['macos']
+        jdk_vendor: ['corretto']
+        sample_app: [
+          'JavaDependencySampleApp',
+          'JavaKitSampleApp',
+          'JavaProbablyPrime',
+          'JavaSieve',
+          'SwiftAndJavaJarSampleLib',
+          'SwiftJavaExtractFFMSampleApp',
+          'SwiftJavaExtractJNISampleApp',
+        ]
+    env:
+      CXX_INTEROP: '1'
+      SWIFT_JAVA_VERBOSE: true
+    steps:
+      - uses: actions/checkout@v4
+      - name: Prepare CI Environment
+        uses: ./.github/actions/prepare_env
+      - name: Install Swiftly
+        run: ./.github/scripts/install_swiftly.sh
+        env:
+          SWIFT_VERSION: "${{ matrix.swift_version }}"
+      - name: "Verify sample with C++ Interop: ${{ matrix.sample_app }}"
+        run: .github/scripts/validate_sample.sh Samples/${{ matrix.sample_app }}
+
   build-swift-android:
     name: Sample SwiftJavaExtractJNISampleApp (Android) (${{ matrix.os_version }} swift:${{ matrix.swift_version }} jdk:${{matrix.jdk_vendor}} android:${{matrix.sdk_triple}})
     runs-on: ubuntu-latest
diff --git a/Samples/JavaDependencySampleApp/Package.swift b/Samples/JavaDependencySampleApp/Package.swift
index 573a60cc2..c60d4e874 100644
--- a/Samples/JavaDependencySampleApp/Package.swift
+++ b/Samples/JavaDependencySampleApp/Package.swift
@@ -40,6 +40,12 @@ let javaIncludePath = "\(javaHome)/include"
   #error("Currently only macOS and Linux platforms are supported, this may change in the future.")
 #endif
 
+// Support C++ interoperability mode via CXX_INTEROP environment variable.
+// This is used to test that swift-java's public API is compatible with projects
+// that enable C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+let cxxInteropEnabled = ProcessInfo.processInfo.environment["CXX_INTEROP"] == "1"
+
 let package = Package(
   name: "JavaDependencySampleApp",
   platforms: [
@@ -73,6 +79,7 @@ let package = Package(
       swiftSettings: [
         .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
         .swiftLanguageMode(.v5),
+        .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
       ],
       plugins: [
         .plugin(name: "SwiftJavaPlugin", package: "swift-java"),
@@ -92,6 +99,7 @@ let package = Package(
       swiftSettings: [
         .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
         .swiftLanguageMode(.v5),
+        .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
       ],
       plugins: [
 //        .plugin(name: "SwiftJavaBootstrapJavaPlugin", package: "swift-java"),
diff --git a/Samples/JavaKitSampleApp/Package.swift b/Samples/JavaKitSampleApp/Package.swift
index 082d61ac9..937695576 100644
--- a/Samples/JavaKitSampleApp/Package.swift
+++ b/Samples/JavaKitSampleApp/Package.swift
@@ -39,6 +39,12 @@ let javaIncludePath = "\(javaHome)/include"
   let javaPlatformIncludePath = "\(javaIncludePath)/win32)"
 #endif
 
+// Support C++ interoperability mode via CXX_INTEROP environment variable.
+// This is used to test that swift-java's public API is compatible with projects
+// that enable C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+let cxxInteropEnabled = ProcessInfo.processInfo.environment["CXX_INTEROP"] == "1"
+
 let package = Package(
   name: "JavaKitSampleApp",
   platforms: [
@@ -70,7 +76,8 @@ let package = Package(
       ],
       swiftSettings: [
         .swiftLanguageMode(.v5),
-        .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"])
+        .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
+        .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
       ],
       plugins: [
         .plugin(name: "JavaCompilerPlugin", package: "swift-java"),
diff --git a/Samples/JavaProbablyPrime/Package.swift b/Samples/JavaProbablyPrime/Package.swift
index 3ebf8fcb5..baa372ccd 100644
--- a/Samples/JavaProbablyPrime/Package.swift
+++ b/Samples/JavaProbablyPrime/Package.swift
@@ -4,6 +4,47 @@
 import CompilerPluginSupport
 import PackageDescription
 
+import class Foundation.FileManager
+import class Foundation.ProcessInfo
+
+// Note: the JAVA_HOME environment variable must be set to point to where
+// Java is installed, e.g.,
+//   Library/Java/JavaVirtualMachines/openjdk-21.jdk/Contents/Home.
+func findJavaHome() -> String {
+  if let home = ProcessInfo.processInfo.environment["JAVA_HOME"] {
+    return home
+  }
+
+  // This is a workaround for envs (some IDEs) which have trouble with
+  // picking up env variables during the build process
+  let path = "\(FileManager.default.homeDirectoryForCurrentUser.path()).java_home"
+  if let home = try? String(contentsOfFile: path, encoding: .utf8) {
+    if let lastChar = home.last, lastChar.isNewline {
+      return String(home.dropLast())
+    }
+
+    return home
+  }
+
+  fatalError("Please set the JAVA_HOME environment variable to point to where Java is installed.")
+}
+let javaHome = findJavaHome()
+
+let javaIncludePath = "\(javaHome)/include"
+#if os(Linux)
+  let javaPlatformIncludePath = "\(javaIncludePath)/linux"
+#elseif os(macOS)
+  let javaPlatformIncludePath = "\(javaIncludePath)/darwin"
+#elseif os(Windows)
+  let javaPlatformIncludePath = "\(javaIncludePath)/win32)"
+#endif
+
+// Support C++ interoperability mode via CXX_INTEROP environment variable.
+// This is used to test that swift-java's public API is compatible with projects
+// that enable C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+let cxxInteropEnabled = ProcessInfo.processInfo.environment["CXX_INTEROP"] == "1"
+
 let package = Package(
   name: "JavaProbablyPrime",
   platforms: [
@@ -34,7 +75,9 @@ let package = Package(
         .product(name: "ArgumentParser", package: "swift-argument-parser"),
       ],
       swiftSettings: [
-        .swiftLanguageMode(.v5)
+        .swiftLanguageMode(.v5),
+        .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
+        .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
       ],
       plugins: [
         .plugin(name: "SwiftJavaPlugin", package: "swift-java"),
diff --git a/Samples/JavaSieve/Package.swift b/Samples/JavaSieve/Package.swift
index c34d83318..4d88bf463 100644
--- a/Samples/JavaSieve/Package.swift
+++ b/Samples/JavaSieve/Package.swift
@@ -39,6 +39,12 @@ let javaIncludePath = "\(javaHome)/include"
   #error("Currently only macOS and Linux platforms are supported, this may change in the future.")
 #endif
 
+// Support C++ interoperability mode via CXX_INTEROP environment variable.
+// This is used to test that swift-java's public API is compatible with projects
+// that enable C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+let cxxInteropEnabled = ProcessInfo.processInfo.environment["CXX_INTEROP"] == "1"
+
 let package = Package(
     name: "JavaSieve",
     platforms: [
@@ -59,7 +65,8 @@ let package = Package(
             ],
             exclude: ["swift-java.config"],
             swiftSettings: [
-              .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"])
+              .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
+              .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
             ],
             plugins: [
               .plugin(name: "SwiftJavaPlugin", package: "swift-java"),
@@ -77,7 +84,8 @@ let package = Package(
             ],
             exclude: ["swift-java.config"],
             swiftSettings: [
-              .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"])
+              .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
+              .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
             ],
             plugins: [
               .plugin(name: "SwiftJavaPlugin", package: "swift-java"),
diff --git a/Samples/SwiftAndJavaJarSampleLib/Package.swift b/Samples/SwiftAndJavaJarSampleLib/Package.swift
index 32ffbb287..d4a4215fc 100644
--- a/Samples/SwiftAndJavaJarSampleLib/Package.swift
+++ b/Samples/SwiftAndJavaJarSampleLib/Package.swift
@@ -40,6 +40,12 @@ let javaIncludePath = "\(javaHome)/include"
   #error("Currently only macOS and Linux platforms are supported, this may change in the future.")
 #endif
 
+// Support C++ interoperability mode via CXX_INTEROP environment variable.
+// This is used to test that swift-java's public API is compatible with projects
+// that enable C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+let cxxInteropEnabled = ProcessInfo.processInfo.environment["CXX_INTEROP"] == "1"
+
 let package = Package(
   name: "SwiftAndJavaJarSampleLib",
   platforms: [
@@ -70,7 +76,8 @@ let package = Package(
       ],
       swiftSettings: [
         .swiftLanguageMode(.v5),
-        .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"])
+        .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
+        .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
       ],
       plugins: [
         .plugin(name: "JExtractSwiftPlugin", package: "swift-java"),
diff --git a/Samples/SwiftJavaExtractFFMSampleApp/Package.swift b/Samples/SwiftJavaExtractFFMSampleApp/Package.swift
index 98d1bd33f..2395e0285 100644
--- a/Samples/SwiftJavaExtractFFMSampleApp/Package.swift
+++ b/Samples/SwiftJavaExtractFFMSampleApp/Package.swift
@@ -40,6 +40,12 @@ let javaIncludePath = "\(javaHome)/include"
   #error("Currently only macOS and Linux platforms are supported, this may change in the future.")
 #endif
 
+// Support C++ interoperability mode via CXX_INTEROP environment variable.
+// This is used to test that swift-java's public API is compatible with projects
+// that enable C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+let cxxInteropEnabled = ProcessInfo.processInfo.environment["CXX_INTEROP"] == "1"
+
 let package = Package(
   name: "SwiftJavaExtractFFMSampleApp",
   platforms: [
@@ -72,7 +78,8 @@ let package = Package(
       ],
       swiftSettings: [
         .swiftLanguageMode(.v5),
-        .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"])
+        .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
+        .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
       ],
       plugins: [
         .plugin(name: "JExtractSwiftPlugin", package: "swift-java"),
diff --git a/Samples/SwiftJavaExtractJNISampleApp/Package.swift b/Samples/SwiftJavaExtractJNISampleApp/Package.swift
index 6343e0dbd..4cb5ae477 100644
--- a/Samples/SwiftJavaExtractJNISampleApp/Package.swift
+++ b/Samples/SwiftJavaExtractJNISampleApp/Package.swift
@@ -40,6 +40,12 @@ let javaIncludePath = "\(javaHome)/include"
   #error("Currently only macOS and Linux platforms are supported, this may change in the future.")
 #endif
 
+// Support C++ interoperability mode via CXX_INTEROP environment variable.
+// This is used to test that swift-java's public API is compatible with projects
+// that enable C++ interoperability mode.
+// See: https://github.com/swiftlang/swift-java/issues/391
+let cxxInteropEnabled = ProcessInfo.processInfo.environment["CXX_INTEROP"] == "1"
+
 let package = Package(
   name: "JExtractJNISampleApp",
   platforms: [
@@ -70,6 +76,7 @@ let package = Package(
       swiftSettings: [
         .swiftLanguageMode(.v5),
         .unsafeFlags(["-I\(javaIncludePath)", "-I\(javaPlatformIncludePath)"]),
+        .interoperabilityMode(.Cxx, .when(platforms: cxxInteropEnabled ? [.macOS, .linux] : [])),
       ],
       plugins: [
         .plugin(name: "JExtractSwiftPlugin", package: "swift-java")
diff --git a/Sources/CSwiftJavaJNI/include/CSwiftJavaJNI.h b/Sources/CSwiftJavaJNI/include/CSwiftJavaJNI.h
index fb5f71afd..80a0450dc 100644
--- a/Sources/CSwiftJavaJNI/include/CSwiftJavaJNI.h
+++ b/Sources/CSwiftJavaJNI/include/CSwiftJavaJNI.h
@@ -17,4 +17,47 @@
 
 #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
+typedef const struct JNINativeInterface_ *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;
+#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 */
diff --git a/Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift b/Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift
index 6628be333..a225eca1f 100644
--- a/Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift
+++ b/Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift
@@ -381,8 +381,16 @@ extension JNISwift2JavaGenerator {
     func innerBody(in printer: inout CodePrinter) -> String {
       let loweredResult = nativeSignature.result.conversion.render(&printer, result)
 
-      if !decl.functionSignature.result.type.isVoid {
-        return "return \(loweredResult)"
+      // For async functions, loweredResult is empty as they handle return internally
+      // via CompletableFuture. Only apply unsafeBitCast for non-void, non-async functions.
+      if !decl.functionSignature.result.type.isVoid && !loweredResult.isEmpty {
+        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
       }
@@ -468,7 +476,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)" : ""
diff --git a/Sources/JExtractSwiftLib/JavaParameter.swift b/Sources/JExtractSwiftLib/JavaParameter.swift
index 0b243b3a4..a658e7330 100644
--- a/Sources/JExtractSwiftLib/JavaParameter.swift
+++ b/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?"
       }
     }
 
diff --git a/Sources/JavaTypes/JavaType+JNI.swift b/Sources/JavaTypes/JavaType+JNI.swift
index b9b00ccb8..861386b4f 100644
--- a/Sources/JavaTypes/JavaType+JNI.swift
+++ b/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?"
     }
   }
 
diff --git a/Sources/SwiftJava/JVM/JavaVirtualMachine.swift b/Sources/SwiftJava/JVM/JavaVirtualMachine.swift
index 1c7936a34..85e46363f 100644
--- a/Sources/SwiftJava/JVM/JavaVirtualMachine.swift
+++ b/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
diff --git a/Sources/SwiftJava/JavaEnvironment.swift b/Sources/SwiftJava/JavaEnvironment.swift
index 9506dbead..bad36cb16 100644
--- a/Sources/SwiftJava/JavaEnvironment.swift
+++ b/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 }
 }
diff --git a/Sources/SwiftJava/JavaValue.swift b/Sources/SwiftJava/JavaValue.swift
index 46efdb3fc..db921f833 100644
--- a/Sources/SwiftJava/JavaValue.swift
+++ b/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
diff --git a/Sources/SwiftJavaMacros/ImplementsJavaMacro.swift b/Sources/SwiftJavaMacros/ImplementsJavaMacro.swift
index b3057ae43..4df34ca50 100644
--- a/Sources/SwiftJavaMacros/ImplementsJavaMacro.swift
+++ b/Sources/SwiftJavaMacros/ImplementsJavaMacro.swift
@@ -77,9 +77,11 @@ extension JavaImplementationMacro: PeerMacro {
       }
 
       // Map the parameters.
+      // Use CJNIEnv for C++ interoperability compatibility.
+      // See: https://github.com/swiftlang/swift-java/issues/391
       let cParameters: [FunctionParameterSyntax] =
         [
-          "environment: UnsafeMutablePointer<JNIEnv?>!",
+          "environment: UnsafeMutablePointer<CJNIEnv?>!",
           isStatic ? "thisClass: jclass" : "thisObj: jobject",
         ]
         + parametersClause.parameters.map { param in
@@ -126,8 +128,13 @@ extension JavaImplementationMacro: PeerMacro {
             return \(raw: tryClause)\(raw: swiftTypeName).\(raw: swiftName)(\(raw: swiftArguments.map { $0.description }.joined(separator: ", ")))\(raw: getJNIValue)
           """
       } else {
+        // Use unsafeBitCast to convert thisObj to OpaquePointer for C++ interoperability.
+        // In C++ mode, jobject is UnsafeMutablePointer<_jobject>, but the library
+        // (compiled without C++ interop) expects jobject as OpaquePointer.
+        // The bitcast ensures compatibility in both modes since both have the same
+        // memory representation (a pointer).
         innerBody = """
-            let obj = \(raw: swiftTypeName)(javaThis: thisObj, environment: environment!)
+            let obj = \(raw: swiftTypeName)(javaThis: unsafeBitCast(thisObj, to: OpaquePointer.self), environment: environment!)
             return \(raw: tryClause)obj.\(raw: swiftName)(\(raw: swiftArguments.map { $0.description }.joined(separator: ", ")))\(raw: getJNIValue)
           """
       }
diff --git a/Tests/JExtractSwiftTests/JNI/JNIArrayTest.swift b/Tests/JExtractSwiftTests/JNI/JNIArrayTest.swift
index ebe3f807b..019aec907 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIArrayTest.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIArrayTest.swift
@@ -46,8 +46,8 @@ struct JNIArrayTest {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024f___3B")
-        func Java_com_example_swift_SwiftModule__00024f___3B(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, array: jbyteArray?) -> jbyteArray? { 
-          return SwiftModule.f(array: [UInt8](fromJNI: array, in: environment)).getJNIValue(in: environment)
+        func Java_com_example_swift_SwiftModule__00024f___3B(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, array: CjbyteArray?) -> CjbyteArray? {
+          return unsafeBitCast(SwiftModule.f(array: [UInt8](fromJNI: array, in: environment)).getJNIValue(in: environment), to: CjbyteArray?.self)
         }
         """
       ]
@@ -82,8 +82,8 @@ struct JNIArrayTest {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024f___3B")
-        func Java_com_example_swift_SwiftModule__00024f___3B(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, array: jbyteArray?) -> jbyteArray? { 
-          return SwiftModule.f(array: [UInt8](fromJNI: array, in: environment)).getJNIValue(in: environment)
+        func Java_com_example_swift_SwiftModule__00024f___3B(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, array: CjbyteArray?) -> CjbyteArray? {
+          return unsafeBitCast(SwiftModule.f(array: [UInt8](fromJNI: array, in: environment)).getJNIValue(in: environment), to: CjbyteArray?.self)
         }
         """
       ]
@@ -118,8 +118,8 @@ struct JNIArrayTest {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024f___3J")
-        func Java_com_example_swift_SwiftModule__00024f___3J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, array: jlongArray?) -> jlongArray? { 
-          return SwiftModule.f(array: [Int64](fromJNI: array, in: environment)).getJNIValue(in: environment)
+        func Java_com_example_swift_SwiftModule__00024f___3J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, array: CjlongArray?) -> CjlongArray? {
+          return unsafeBitCast(SwiftModule.f(array: [Int64](fromJNI: array, in: environment)).getJNIValue(in: environment), to: CjlongArray?.self)
         }
         """
       ]
@@ -163,8 +163,8 @@ struct JNIArrayTest {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024f___3J")
-        func Java_com_example_swift_SwiftModule__00024f___3J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, array: jlongArray?) -> jlongArray? { 
-          return SwiftModule.f(array: [Int64](fromJNI: array, in: environment).map( { (pointer$) in
+        func Java_com_example_swift_SwiftModule__00024f___3J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, array: CjlongArray?) -> CjlongArray? {
+          return unsafeBitCast(SwiftModule.f(array: [Int64](fromJNI: array, in: environment).map( { (pointer$) in
             assert(pointer$ != 0, "pointer$ memory address was null")
             let pointer$Bits$ = Int(pointer$)
             let pointer$$ = UnsafeMutablePointer<MySwiftClass>(bitPattern: pointer$Bits$)
@@ -179,7 +179,7 @@ struct JNIArrayTest {
             let object$Bits$ = Int64(Int(bitPattern: object$$))
             return object$Bits$
           }
-          ).getJNIValue(in: environment)
+          ).getJNIValue(in: environment), to: CjlongArray?.self)
         }
         """
       ]
diff --git a/Tests/JExtractSwiftTests/JNI/JNIAsyncTests.swift b/Tests/JExtractSwiftTests/JNI/JNIAsyncTests.swift
index f246bd0f7..b644cee8e 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIAsyncTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIAsyncTests.swift
@@ -58,7 +58,7 @@ struct JNIAsyncTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024asyncVoid__Ljava_util_concurrent_CompletableFuture_2")
-        func Java_com_example_swift_SwiftModule__00024asyncVoid__Ljava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, result_future: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024asyncVoid__Ljava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, result_future: Cjobject?) {
           let globalFuture = environment.interface.NewGlobalRef(environment, result_future)
           var task: Task<Void, Never>? = nil
           #if swift(>=6.2)
@@ -132,7 +132,7 @@ struct JNIAsyncTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024async__Ljava_util_concurrent_CompletableFuture_2")
-        func Java_com_example_swift_SwiftModule__00024async__Ljava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, result_future: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024async__Ljava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, result_future: Cjobject?) {
           let globalFuture = environment.interface.NewGlobalRef(environment, result_future)
           var task: Task<Void, Never>? = nil
           #if swift(>=6.2)
@@ -220,7 +220,7 @@ struct JNIAsyncTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024async__JLjava_util_concurrent_CompletableFuture_2")
-        func Java_com_example_swift_SwiftModule__00024async__JLjava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, i: jlong, result_future: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024async__JLjava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, i: jlong, result_future: Cjobject?) {
           let globalFuture = environment.interface.NewGlobalRef(environment, result_future)
           var task: Task<Void, Never>? = nil
           #if swift(>=6.2)
@@ -251,7 +251,6 @@ struct JNIAsyncTests {
               environment.interface.CallBooleanMethodA(environment, globalFuture, _JNIMethodIDCache.CompletableFuture.complete, [jvalue(l: boxedResult$)])
             }
           }
-          return 
         }
         """
       ]
@@ -305,7 +304,7 @@ struct JNIAsyncTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024async__JLjava_util_concurrent_CompletableFuture_2")
-        func Java_com_example_swift_SwiftModule__00024async__JLjava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, c: jlong, result_future: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024async__JLjava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, c: jlong, result_future: Cjobject?) {
           assert(c != 0, "c memory address was null")
           let cBits$ = Int(Int64(fromJNI: c, in: environment))
           let c$ = UnsafeMutablePointer<MyClass>(bitPattern: cBits$)
@@ -348,7 +347,6 @@ struct JNIAsyncTests {
               environment.interface.CallBooleanMethodA(environment, globalFuture, _JNIMethodIDCache.CompletableFuture.complete, [jvalue(l: boxedResult$)])
             }
           }
-          return 
         }
         """
       ]
@@ -392,7 +390,7 @@ struct JNIAsyncTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024async__Ljava_lang_String_2Ljava_util_concurrent_CompletableFuture_2")
-        func Java_com_example_swift_SwiftModule__00024async__Ljava_lang_String_2Ljava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, s: jstring?, result_future: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024async__Ljava_lang_String_2Ljava_util_concurrent_CompletableFuture_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, s: Cjstring?, result_future: Cjobject?) {
           let s = environment.interface.NewGlobalRef(environment, s)
           let globalFuture = environment.interface.NewGlobalRef(environment, result_future)
           ...
@@ -459,12 +457,12 @@ struct JNIAsyncTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024async__JLorg_swift_swiftkit_core_SimpleCompletableFuture_2")
-        func Java_com_example_swift_SwiftModule__00024async__JLorg_swift_swiftkit_core_SimpleCompletableFuture_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, c: jlong, result_future: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024async__JLorg_swift_swiftkit_core_SimpleCompletableFuture_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, c: jlong, result_future: Cjobject?) {
           ...
           var task: Task<Void, Never>? = nil
           ...
           environment.interface.CallBooleanMethodA(environment, globalFuture, _JNIMethodIDCache.SimpleCompletableFuture.complete, [jvalue(l: boxedResult$)])
-          ... 
+          ...
         }
         """
       ]
diff --git a/Tests/JExtractSwiftTests/JNI/JNIClassTests.swift b/Tests/JExtractSwiftTests/JNI/JNIClassTests.swift
index c3102a623..09e3f0953 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIClassTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIClassTests.swift
@@ -162,7 +162,7 @@ struct JNIClassTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024method__")
-        func Java_com_example_swift_MyClass__00024method__(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) {
+        func Java_com_example_swift_MyClass__00024method__(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass) {
           MyClass.method()
         }
         """
@@ -219,20 +219,20 @@ struct JNIClassTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024init__JJ")
-        func Java_com_example_swift_MyClass__00024init__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, x: jlong, y: jlong) -> jlong {
+        func Java_com_example_swift_MyClass__00024init__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, x: jlong, y: jlong) -> jlong {
           let result$ = UnsafeMutablePointer<MyClass>.allocate(capacity: 1)
           result$.initialize(to: MyClass.init(x: Int64(fromJNI: x, in: environment), y: Int64(fromJNI: y, in: environment)))
           let resultBits$ = Int64(Int(bitPattern: result$))
-          return resultBits$.getJNIValue(in: environment)
+          return unsafeBitCast(resultBits$.getJNIValue(in: environment), to: jlong.self)
         }
         """,
         """
         @_cdecl("Java_com_example_swift_MyClass__00024init__")
-        func Java_com_example_swift_MyClass__00024init__(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) -> jlong {
+        func Java_com_example_swift_MyClass__00024init__(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass) -> jlong {
           let result$ = UnsafeMutablePointer<MyClass>.allocate(capacity: 1)
           result$.initialize(to: MyClass.init())
           let resultBits$ = Int64(Int(bitPattern: result$))
-          return resultBits$.getJNIValue(in: environment)
+          return unsafeBitCast(resultBits$.getJNIValue(in: environment), to: jlong.self)
         }
         """,
       ]
@@ -249,7 +249,7 @@ struct JNIClassTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024destroy__J")
-        func Java_com_example_swift_MyClass__00024destroy__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
+        func Java_com_example_swift_MyClass__00024destroy__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
           guard let env$ = environment else {
             fatalError("Missing JNIEnv in downcall to \\(#function)")
           }
@@ -301,7 +301,7 @@ struct JNIClassTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024doSomething__JJ")
-        func Java_com_example_swift_MyClass__00024doSomething__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, x: jlong, self: jlong) {
+        func Java_com_example_swift_MyClass__00024doSomething__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, x: jlong, self: jlong) {
           assert(self != 0, "self memory address was null")
           let selfBits$ = Int(Int64(fromJNI: self, in: environment))
           let self$ = UnsafeMutablePointer<MyClass>(bitPattern: selfBits$)
@@ -350,7 +350,7 @@ struct JNIClassTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024copy__J")
-        func Java_com_example_swift_MyClass__00024copy__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
+        func Java_com_example_swift_MyClass__00024copy__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
           assert(self != 0, "self memory address was null")
           let selfBits$ = Int(Int64(fromJNI: self, in: environment))
           let self$ = UnsafeMutablePointer<MyClass>(bitPattern: selfBits$)
@@ -360,7 +360,7 @@ struct JNIClassTests {
           let result$ = UnsafeMutablePointer<MyClass>.allocate(capacity: 1)
           result$.initialize(to: self$.pointee.copy())
           let resultBits$ = Int64(Int(bitPattern: result$))
-          return resultBits$.getJNIValue(in: environment)
+          return unsafeBitCast(resultBits$.getJNIValue(in: environment), to: jlong.self)
         }
         """
       ]
@@ -402,7 +402,7 @@ struct JNIClassTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024isEqual__JJ")
-        func Java_com_example_swift_MyClass__00024isEqual__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, other: jlong, self: jlong) -> jboolean {
+        func Java_com_example_swift_MyClass__00024isEqual__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, other: jlong, self: jlong) -> jboolean {
           assert(other != 0, "other memory address was null")
           let otherBits$ = Int(Int64(fromJNI: other, in: environment))
           let other$ = UnsafeMutablePointer<MyClass>(bitPattern: otherBits$) 
@@ -415,7 +415,7 @@ struct JNIClassTests {
           guard let self$ else {
             fatalError("self memory address was null in call to \\(#function)!")
           }
-          return self$.pointee.isEqual(to: other$.pointee).getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee.isEqual(to: other$.pointee).getJNIValue(in: environment), to: jboolean.self)
         }
         """
       ]
diff --git a/Tests/JExtractSwiftTests/JNI/JNIClosureTests.swift b/Tests/JExtractSwiftTests/JNI/JNIClosureTests.swift
index b54749c13..88bb0f70e 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIClosureTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIClosureTests.swift
@@ -61,7 +61,7 @@ struct JNIClosureTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024emptyClosure__Lcom_example_swift_SwiftModule_00024emptyClosure_00024closure_2")
-        func Java_com_example_swift_SwiftModule__00024emptyClosure__Lcom_example_swift_SwiftModule_00024emptyClosure_00024closure_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, closure: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024emptyClosure__Lcom_example_swift_SwiftModule_00024emptyClosure_00024closure_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, closure: Cjobject?) {
           SwiftModule.emptyClosure(closure: { 
             let class$ = environment.interface.GetObjectClass(environment, closure)
             let methodID$ = environment.interface.GetMethodID(environment, class$, "apply", "()V")!
@@ -113,7 +113,7 @@ struct JNIClosureTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024closureWithArgumentsAndReturn__Lcom_example_swift_SwiftModule_00024closureWithArgumentsAndReturn_00024closure_2")
-        func Java_com_example_swift_SwiftModule__00024closureWithArgumentsAndReturn__Lcom_example_swift_SwiftModule_00024closureWithArgumentsAndReturn_00024closure_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, closure: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024closureWithArgumentsAndReturn__Lcom_example_swift_SwiftModule_00024closureWithArgumentsAndReturn_00024closure_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, closure: Cjobject?) {
           SwiftModule.closureWithArgumentsAndReturn(closure: { _0, _1 in
             let class$ = environment.interface.GetObjectClass(environment, closure)
             let methodID$ = environment.interface.GetMethodID(environment, class$, "apply", "(JZ)J")!
diff --git a/Tests/JExtractSwiftTests/JNI/JNIEnumTests.swift b/Tests/JExtractSwiftTests/JNI/JNIEnumTests.swift
index 38ef87895..a97f017de 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIEnumTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIEnumTests.swift
@@ -135,7 +135,7 @@ struct JNIEnumTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyEnum__00024getDiscriminator__J")
-        func Java_com_example_swift_MyEnum__00024getDiscriminator__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, selfPointer: jlong) -> jint {
+        func Java_com_example_swift_MyEnum__00024getDiscriminator__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, selfPointer: jlong) -> jint {
           ...
           switch (self$.pointee) {
             case .first: return 0
@@ -220,29 +220,29 @@ struct JNIEnumTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyEnum__00024first__")
-        func Java_com_example_swift_MyEnum__00024first__(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) -> jlong {
+        func Java_com_example_swift_MyEnum__00024first__(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass) -> jlong {
           let result$ = UnsafeMutablePointer<MyEnum>.allocate(capacity: 1)
           result$.initialize(to: MyEnum.first)
           let resultBits$ = Int64(Int(bitPattern: result$))
-          return resultBits$.getJNIValue(in: environment)
+          return unsafeBitCast(resultBits$.getJNIValue(in: environment), to: jlong.self)
         }
         """,
         """
         @_cdecl("Java_com_example_swift_MyEnum__00024second__Ljava_lang_String_2")
-        func Java_com_example_swift_MyEnum__00024second__Ljava_lang_String_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, arg0: jstring?) -> jlong {
+        func Java_com_example_swift_MyEnum__00024second__Ljava_lang_String_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, arg0: Cjstring?) -> jlong {
           let result$ = UnsafeMutablePointer<MyEnum>.allocate(capacity: 1)
           result$.initialize(to: MyEnum.second(String(fromJNI: arg0, in: environment)))
           let resultBits$ = Int64(Int(bitPattern: result$))
-          return resultBits$.getJNIValue(in: environment)
+          return unsafeBitCast(resultBits$.getJNIValue(in: environment), to: jlong.self)
         }
         """,
         """
         @_cdecl("Java_com_example_swift_MyEnum__00024third__JI")
-        func Java_com_example_swift_MyEnum__00024third__JI(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, x: jlong, y: jint) -> jlong {
+        func Java_com_example_swift_MyEnum__00024third__JI(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, x: jlong, y: jint) -> jlong {
           let result$ = UnsafeMutablePointer<MyEnum>.allocate(capacity: 1)
           result$.initialize(to: MyEnum.third(x: Int64(fromJNI: x, in: environment), y: Int32(fromJNI: y, in: environment)))
           let resultBits$ = Int64(Int(bitPattern: result$))
-          return resultBits$.getJNIValue(in: environment)
+          return unsafeBitCast(resultBits$.getJNIValue(in: environment), to: jlong.self)
         }
         """
       ])
@@ -293,7 +293,7 @@ struct JNIEnumTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyEnum__00024getAsSecond__J")
-        func Java_com_example_swift_MyEnum__00024getAsSecond__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jobject? {
+        func Java_com_example_swift_MyEnum__00024getAsSecond__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> Cjobject? {
           ...
           guard case .second(let _0) = self$.pointee else {
             fatalError("Expected enum case 'second', but was '\\(self$.pointee)'!")
@@ -308,7 +308,7 @@ struct JNIEnumTests {
         """,
         """
         @_cdecl("Java_com_example_swift_MyEnum__00024getAsThird__J")
-        func Java_com_example_swift_MyEnum__00024getAsThird__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jobject? {
+        func Java_com_example_swift_MyEnum__00024getAsThird__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> Cjobject? {
           ...
           guard case .third(let x, let y) = self$.pointee else {
             fatalError("Expected enum case 'third', but was '\\(self$.pointee)'!")
diff --git a/Tests/JExtractSwiftTests/JNI/JNIJavaKitTests.swift b/Tests/JExtractSwiftTests/JNI/JNIJavaKitTests.swift
index 69d77b737..413342e4d 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIJavaKitTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIJavaKitTests.swift
@@ -64,7 +64,7 @@ struct JNIJavaKitTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024function__Ljava_lang_Long_2Ljava_lang_Integer_2J")
-        func Java_com_example_swift_SwiftModule__00024function__Ljava_lang_Long_2Ljava_lang_Integer_2J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, javaLong: jobject?, javaInteger: jobject?, int: jlong) {
+        func Java_com_example_swift_SwiftModule__00024function__Ljava_lang_Long_2Ljava_lang_Integer_2J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, javaLong: Cjobject?, javaInteger: Cjobject?, int: jlong) {
           guard let javaLong_unwrapped$ = javaLong else {
             fatalError("javaLong was null in call to \\(#function), but Swift requires non-optional!")
           }
diff --git a/Tests/JExtractSwiftTests/JNI/JNIModuleTests.swift b/Tests/JExtractSwiftTests/JNI/JNIModuleTests.swift
index dddf11478..a5ee0d13b 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIModuleTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIModuleTests.swift
@@ -123,19 +123,19 @@ struct JNIModuleTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024helloWorld__")
-        func Java_com_example_swift_SwiftModule__00024helloWorld__(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) {
+        func Java_com_example_swift_SwiftModule__00024helloWorld__(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass) {
           SwiftModule.helloWorld()
         }
         """,
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024takeIntegers__BSIJ")
-        func Java_com_example_swift_SwiftModule__00024takeIntegers__BSIJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, i1: jbyte, i2: jshort, i3: jint, i4: jlong) -> jchar {
-          return SwiftModule.takeIntegers(i1: Int8(fromJNI: i1, in: environment), i2: Int16(fromJNI: i2, in: environment), i3: Int32(fromJNI: i3, in: environment), i4: Int64(fromJNI: i4, in: environment)).getJNIValue(in: environment)
+        func Java_com_example_swift_SwiftModule__00024takeIntegers__BSIJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, i1: jbyte, i2: jshort, i3: jint, i4: jlong) -> jchar {
+          return unsafeBitCast(SwiftModule.takeIntegers(i1: Int8(fromJNI: i1, in: environment), i2: Int16(fromJNI: i2, in: environment), i3: Int32(fromJNI: i3, in: environment), i4: Int64(fromJNI: i4, in: environment)).getJNIValue(in: environment), to: jchar.self)
         }        
         """,
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024otherPrimitives__ZFD")
-        func Java_com_example_swift_SwiftModule__00024otherPrimitives__ZFD(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, b: jboolean, f: jfloat, d: jdouble) {
+        func Java_com_example_swift_SwiftModule__00024otherPrimitives__ZFD(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, b: jboolean, f: jfloat, d: jdouble) {
           SwiftModule.otherPrimitives(b: Bool(fromJNI: b, in: environment), f: Float(fromJNI: f, in: environment), d: Double(fromJNI: d, in: environment))
         }
         """
@@ -178,8 +178,8 @@ struct JNIModuleTests {
       expectedChunks: [
           """
           @_cdecl("Java_com_example_swift_SwiftModule__00024copy__Ljava_lang_String_2")
-          func Java_com_example_swift_SwiftModule__00024copy__Ljava_lang_String_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, string: jstring?) -> jstring? {
-            return SwiftModule.copy(String(fromJNI: string, in: environment)).getJNIValue(in: environment)
+          func Java_com_example_swift_SwiftModule__00024copy__Ljava_lang_String_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, string: Cjstring?) -> Cjstring? {
+            return unsafeBitCast(SwiftModule.copy(String(fromJNI: string, in: environment)).getJNIValue(in: environment), to: Cjstring?.self)
           }
           """,
       ]
@@ -235,7 +235,7 @@ struct JNIModuleTests {
       expectedChunks: [
           """
           @_cdecl("Java_com_example_swift_SwiftModule__00024methodA__")
-          func Java_com_example_swift_SwiftModule__00024methodA__(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) {
+          func Java_com_example_swift_SwiftModule__00024methodA__(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass) {
             do {
               try SwiftModule.methodA()
             } catch {
@@ -245,9 +245,9 @@ struct JNIModuleTests {
           """,
           """
           @_cdecl("Java_com_example_swift_SwiftModule__00024methodB__")
-          func Java_com_example_swift_SwiftModule__00024methodB__(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) -> jlong {
+          func Java_com_example_swift_SwiftModule__00024methodB__(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass) -> jlong {
             do {
-              return try SwiftModule.methodB().getJNIValue(in: environment)
+              return unsafeBitCast(try SwiftModule.methodB().getJNIValue(in: environment), to: jlong.self)
             } catch {
               environment.throwAsException(error)
               return Int64.jniPlaceholderValue
diff --git a/Tests/JExtractSwiftTests/JNI/JNINestedTypesTests.swift b/Tests/JExtractSwiftTests/JNI/JNINestedTypesTests.swift
index 67d966e3a..aa053c431 100644
--- a/Tests/JExtractSwiftTests/JNI/JNINestedTypesTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNINestedTypesTests.swift
@@ -74,25 +74,25 @@ struct JNINestedTypesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_A__00024destroy__J")
-        func Java_com_example_swift_A__00024destroy__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
+        func Java_com_example_swift_A__00024destroy__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
           ...
         }
         """,
         """
         @_cdecl("Java_com_example_swift_A_00024B__00024destroy__J")
-        func Java_com_example_swift_A_00024B__00024destroy__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
+        func Java_com_example_swift_A_00024B__00024destroy__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
           ...
         }
         """,
         """
         @_cdecl("Java_com_example_swift_A_00024B__00024destroy__J")
-        func Java_com_example_swift_A_00024B__00024destroy__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
+        func Java_com_example_swift_A_00024B__00024destroy__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
           ...
         }
         """,
         """
         @_cdecl("Java_com_example_swift_A_00024B_00024C__00024h__JJ")
-        func Java_com_example_swift_A_00024B_00024C__00024h__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, b: jlong, self: jlong) {
+        func Java_com_example_swift_A_00024B_00024C__00024h__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, b: jlong, self: jlong) {
           ...
         }
         """
diff --git a/Tests/JExtractSwiftTests/JNI/JNIOptionalTests.swift b/Tests/JExtractSwiftTests/JNI/JNIOptionalTests.swift
index 6c931d7b4..19fb213b1 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIOptionalTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIOptionalTests.swift
@@ -71,11 +71,11 @@ struct JNIOptionalTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024optionalSugar__BJ")
-        func Java_com_example_swift_SwiftModule__00024optionalSugar__BJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, arg_discriminator: jbyte, arg_value: jlong) -> jlong {
+        func Java_com_example_swift_SwiftModule__00024optionalSugar__BJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, arg_discriminator: jbyte, arg_value: jlong) -> jlong {
           let result_value$ = SwiftModule.optionalSugar(arg_discriminator == 1 ? Int64(fromJNI: arg_value, in: environment) : nil).map {
             Int64($0) << 32 | Int64(1)
           } ?? 0
-          return result_value$.getJNIValue(in: environment)
+          return unsafeBitCast(result_value$.getJNIValue(in: environment), to: jlong.self)
         }
         """
       ]
@@ -121,8 +121,8 @@ struct JNIOptionalTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024optionalExplicit__BLjava_lang_String_2_3B")
-        func Java_com_example_swift_SwiftModule__00024optionalExplicit__BLjava_lang_String_2_3B(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, arg_discriminator: jbyte, arg_value: jstring?, result_discriminator$: jbyteArray?) -> jstring? {
-          let result$: jstring?
+        func Java_com_example_swift_SwiftModule__00024optionalExplicit__BLjava_lang_String_2_3B(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, arg_discriminator: jbyte, arg_value: Cjstring?, result_discriminator$: CjbyteArray?) -> Cjstring? {
+          let result$: Cjstring?
           if let innerResult$ = SwiftModule.optionalExplicit(arg_discriminator == 1 ? String(fromJNI: arg_value, in: environment) : nil) {
             result$ = innerResult$.getJNIValue(in: environment) 
             var flag$ = Int8(1)
@@ -133,7 +133,7 @@ struct JNIOptionalTests {
             var flag$ = Int8(0)
             environment.interface.SetByteArrayRegion(environment, result_discriminator$, 0, 1, &flag$)
           }
-          return result$
+          return unsafeBitCast(result$, to: Cjstring?.self)
         }
         """
       ]
@@ -179,7 +179,7 @@ struct JNIOptionalTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024optionalClass__J_3B")
-        func Java_com_example_swift_SwiftModule__00024optionalClass__J_3B(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, arg: jlong, result_discriminator$: jbyteArray?) -> jlong {
+        func Java_com_example_swift_SwiftModule__00024optionalClass__J_3B(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, arg: jlong, result_discriminator$: CjbyteArray?) -> jlong {
           let argBits$ = Int(Int64(fromJNI: arg, in: environment))
           let arg$ = UnsafeMutablePointer<MyClass>(bitPattern: argBits$)
           let result$: jlong
@@ -196,7 +196,7 @@ struct JNIOptionalTests {
             var flag$ = Int8(0)
             environment.interface.SetByteArrayRegion(environment, result_discriminator$, 0, 1, &flag$)
           }
-          return result$
+          return unsafeBitCast(result$, to: jlong.self)
         }
         """
       ]
@@ -240,7 +240,7 @@ struct JNIOptionalTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024optionalJavaKitClass__Ljava_lang_Long_2")
-        func Java_com_example_swift_SwiftModule__00024optionalJavaKitClass__Ljava_lang_Long_2(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, arg: jobject?) {
+        func Java_com_example_swift_SwiftModule__00024optionalJavaKitClass__Ljava_lang_Long_2(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, arg: Cjobject?) {
           SwiftModule.optionalJavaKitClass(arg.map {
             return JavaLong(javaThis: $0, environment: environment)
           }
diff --git a/Tests/JExtractSwiftTests/JNI/JNIProtocolTests.swift b/Tests/JExtractSwiftTests/JNI/JNIProtocolTests.swift
index c5302ca64..13104a716 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIProtocolTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIProtocolTests.swift
@@ -106,7 +106,7 @@ struct JNIProtocolTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024takeProtocol__JJJJ")
-        func Java_com_example_swift_SwiftModule__00024takeProtocol__JJJJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, x: jlong, x_typeMetadataAddress: jlong, y: jlong, y_typeMetadataAddress: jlong) {
+        func Java_com_example_swift_SwiftModule__00024takeProtocol__JJJJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, x: jlong, x_typeMetadataAddress: jlong, y: jlong, y_typeMetadataAddress: jlong) {
           guard let xTypeMetadataPointer$ = UnsafeRawPointer(bitPattern: Int(Int64(fromJNI: x_typeMetadataAddress, in: environment))) else {
             fatalError("x_typeMetadataAddress memory address was null")
           }
@@ -171,7 +171,7 @@ struct JNIProtocolTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024takeGeneric__JJ")
-        func Java_com_example_swift_SwiftModule__00024takeGeneric__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, s: jlong, s_typeMetadataAddress: jlong) {
+        func Java_com_example_swift_SwiftModule__00024takeGeneric__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, s: jlong, s_typeMetadataAddress: jlong) {
           guard let sTypeMetadataPointer$ = UnsafeRawPointer(bitPattern: Int(Int64(fromJNI: s_typeMetadataAddress, in: environment))) else {
             fatalError("s_typeMetadataAddress memory address was null")
           }
@@ -221,7 +221,7 @@ struct JNIProtocolTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_SwiftModule__00024takeComposite__JJ")
-        func Java_com_example_swift_SwiftModule__00024takeComposite__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, x: jlong, x_typeMetadataAddress: jlong) {
+        func Java_com_example_swift_SwiftModule__00024takeComposite__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, x: jlong, x_typeMetadataAddress: jlong) {
           guard let xTypeMetadataPointer$ = UnsafeRawPointer(bitPattern: Int(Int64(fromJNI: x_typeMetadataAddress, in: environment))) else {
             fatalError("x_typeMetadataAddress memory address was null")
           }
diff --git a/Tests/JExtractSwiftTests/JNI/JNIStructTests.swift b/Tests/JExtractSwiftTests/JNI/JNIStructTests.swift
index f8830b644..ccc89b04e 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIStructTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIStructTests.swift
@@ -140,11 +140,11 @@ struct JNIStructTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyStruct__00024init__JJ")
-        func Java_com_example_swift_MyStruct__00024init__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, x: jlong, y: jlong) -> jlong {
+        func Java_com_example_swift_MyStruct__00024init__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, x: jlong, y: jlong) -> jlong {
           let result$ = UnsafeMutablePointer<MyStruct>.allocate(capacity: 1)
           result$.initialize(to: MyStruct.init(x: Int64(fromJNI: x, in: environment), y: Int64(fromJNI: y, in: environment)))
           let resultBits$ = Int64(Int(bitPattern: result$))
-          return resultBits$.getJNIValue(in: environment)
+          return unsafeBitCast(resultBits$.getJNIValue(in: environment), to: jlong.self)
         }
         """
       ]
@@ -160,7 +160,7 @@ struct JNIStructTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyStruct__00024destroy__J")
-        func Java_com_example_swift_MyStruct__00024destroy__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
+        func Java_com_example_swift_MyStruct__00024destroy__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, selfPointer: jlong) {
           guard let env$ = environment else {
             fatalError("Missing JNIEnv in downcall to \\(#function)")
           }
@@ -212,7 +212,7 @@ struct JNIStructTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyStruct__00024doSomething__JJ")
-        func Java_com_example_swift_MyStruct__00024doSomething__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, x: jlong, self: jlong) {
+        func Java_com_example_swift_MyStruct__00024doSomething__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, x: jlong, self: jlong) {
           assert(self != 0, "self memory address was null")
           let selfBits$ = Int(Int64(fromJNI: self, in: environment))
           let self$ = UnsafeMutablePointer<MyStruct>(bitPattern: selfBits$)
diff --git a/Tests/JExtractSwiftTests/JNI/JNISubscriptsTests.swift b/Tests/JExtractSwiftTests/JNI/JNISubscriptsTests.swift
index 0f7b131d0..f329d4888 100644
--- a/Tests/JExtractSwiftTests/JNI/JNISubscriptsTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNISubscriptsTests.swift
@@ -96,18 +96,18 @@ struct JNISubscriptsTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyStruct__00024getSubscript__J")
-        func Java_com_example_swift_MyStruct__00024getSubscript__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jdouble {
+        func Java_com_example_swift_MyStruct__00024getSubscript__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jdouble {
           assert(self != 0, "self memory address was null")
           let selfBits$ = Int(Int64(fromJNI: self, in: environment))
           let self$ = UnsafeMutablePointer<MyStruct>(bitPattern: selfBits$)
           guard let self$ else {
             fatalError("self memory address was null in call to \\(#function)!")
           }
-          return self$.pointee[].getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee[].getJNIValue(in: environment), to: jdouble.self)
         """,
         """
         @_cdecl("Java_com_example_swift_MyStruct__00024setSubscript__DJ")
-        func Java_com_example_swift_MyStruct__00024setSubscript__DJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, newValue: jdouble, self: jlong) {
+        func Java_com_example_swift_MyStruct__00024setSubscript__DJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, newValue: jdouble, self: jlong) {
           assert(self != 0, "self memory address was null")
           let selfBits$ = Int(Int64(fromJNI: self, in: environment))
           let self$ = UnsafeMutablePointer<MyStruct>(bitPattern: selfBits$)
@@ -129,18 +129,18 @@ struct JNISubscriptsTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyStruct__00024getSubscript__IJ")
-        func Java_com_example_swift_MyStruct__00024getSubscript__IJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, index: jint, self: jlong) -> jint {
+        func Java_com_example_swift_MyStruct__00024getSubscript__IJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, index: jint, self: jlong) -> jint {
           assert(self != 0, "self memory address was null")
           let selfBits$ = Int(Int64(fromJNI: self, in: environment))
           let self$ = UnsafeMutablePointer<MyStruct>(bitPattern: selfBits$)
           guard let self$ else {
             fatalError("self memory address was null in call to \\(#function)!")
           }
-          return self$.pointee[Int32(fromJNI: index, in: environment)].getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee[Int32(fromJNI: index, in: environment)].getJNIValue(in: environment), to: jint.self)
         """,
         """
         @_cdecl("Java_com_example_swift_MyStruct__00024setSubscript__IIJ")
-        func Java_com_example_swift_MyStruct__00024setSubscript__IIJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, index: jint, newValue: jint, self: jlong) {
+        func Java_com_example_swift_MyStruct__00024setSubscript__IIJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, index: jint, newValue: jint, self: jlong) {
           assert(self != 0, "self memory address was null")
           let selfBits$ = Int(Int64(fromJNI: self, in: environment))
           let self$ = UnsafeMutablePointer<MyStruct>(bitPattern: selfBits$)
diff --git a/Tests/JExtractSwiftTests/JNI/JNIVariablesTests.swift b/Tests/JExtractSwiftTests/JNI/JNIVariablesTests.swift
index 363c117d6..9f41f911c 100644
--- a/Tests/JExtractSwiftTests/JNI/JNIVariablesTests.swift
+++ b/Tests/JExtractSwiftTests/JNI/JNIVariablesTests.swift
@@ -68,9 +68,9 @@ struct JNIVariablesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024getConstant__J")
-        func Java_com_example_swift_MyClass__00024getConstant__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
+        func Java_com_example_swift_MyClass__00024getConstant__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
           ...
-          return self$.pointee.constant.getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee.constant.getJNIValue(in: environment), to: jlong.self)
         }
         """
       ]
@@ -127,7 +127,7 @@ struct JNIVariablesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024getMutable__J")
-        func Java_com_example_swift_MyClass__00024getMutable__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
+        func Java_com_example_swift_MyClass__00024getMutable__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
           assert(self != 0, "self memory address was null")
           ...
           let self$ = UnsafeMutablePointer<MyClass>(bitPattern: selfBits$)
@@ -135,12 +135,12 @@ struct JNIVariablesTests {
             fatalError("self memory address was null in call to \\(#function)!")
           }
           ...
-          return self$.pointee.mutable.getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee.mutable.getJNIValue(in: environment), to: jlong.self)
         }
         """,
         """
         @_cdecl("Java_com_example_swift_MyClass__00024setMutable__JJ")
-        func Java_com_example_swift_MyClass__00024setMutable__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, newValue: jlong, self: jlong) {
+        func Java_com_example_swift_MyClass__00024setMutable__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, newValue: jlong, self: jlong) {
           assert(self != 0, "self memory address was null")
           ...
           self$.pointee.mutable = Int64(fromJNI: newValue, in: environment)
@@ -186,9 +186,9 @@ struct JNIVariablesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024getComputed__J")
-        func Java_com_example_swift_MyClass__00024getComputed__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
+        func Java_com_example_swift_MyClass__00024getComputed__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
           ...
-          return self$.pointee.computed.getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee.computed.getJNIValue(in: environment), to: jlong.self)
         }
         """,
       ]
@@ -231,10 +231,10 @@ struct JNIVariablesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024getComputedThrowing__J")
-        func Java_com_example_swift_MyClass__00024getComputedThrowing__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
+        func Java_com_example_swift_MyClass__00024getComputedThrowing__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
           ...
           do {
-            return try self$.pointee.computedThrowing.getJNIValue(in: environment)
+            return unsafeBitCast(try self$.pointee.computedThrowing.getJNIValue(in: environment), to: jlong.self)
           } catch {
             environment.throwAsException(error)
             return Int64.jniPlaceholderValue
@@ -295,14 +295,14 @@ struct JNIVariablesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024getGetterAndSetter__J")
-        func Java_com_example_swift_MyClass__00024getGetterAndSetter__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
+        func Java_com_example_swift_MyClass__00024getGetterAndSetter__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jlong {
           ...
-          return self$.pointee.getterAndSetter.getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee.getterAndSetter.getJNIValue(in: environment), to: jlong.self)
         }
         """,
         """
         @_cdecl("Java_com_example_swift_MyClass__00024setGetterAndSetter__JJ")
-        func Java_com_example_swift_MyClass__00024setGetterAndSetter__JJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, newValue: jlong, self: jlong) {
+        func Java_com_example_swift_MyClass__00024setGetterAndSetter__JJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, newValue: jlong, self: jlong) {
           ...
           self$.pointee.getterAndSetter = Int64(fromJNI: newValue, in: environment)
         }
@@ -361,14 +361,14 @@ struct JNIVariablesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024isSomeBoolean__J")
-        func Java_com_example_swift_MyClass__00024isSomeBoolean__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jboolean {
+        func Java_com_example_swift_MyClass__00024isSomeBoolean__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jboolean {
           ...
-          return self$.pointee.someBoolean.getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee.someBoolean.getJNIValue(in: environment), to: jboolean.self)
         }
         """,
         """
         @_cdecl("Java_com_example_swift_MyClass__00024setSomeBoolean__ZJ")
-        func Java_com_example_swift_MyClass__00024setSomeBoolean__ZJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, newValue: jboolean, self: jlong) {
+        func Java_com_example_swift_MyClass__00024setSomeBoolean__ZJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, newValue: jboolean, self: jlong) {
           ...
           self$.pointee.someBoolean = Bool(fromJNI: newValue, in: environment)
         }
@@ -427,14 +427,14 @@ struct JNIVariablesTests {
       expectedChunks: [
         """
         @_cdecl("Java_com_example_swift_MyClass__00024isBoolean__J")
-        func Java_com_example_swift_MyClass__00024isBoolean__J(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, self: jlong) -> jboolean {
+        func Java_com_example_swift_MyClass__00024isBoolean__J(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, self: jlong) -> jboolean {
           ...
-          return self$.pointee.isBoolean.getJNIValue(in: environment)
+          return unsafeBitCast(self$.pointee.isBoolean.getJNIValue(in: environment), to: jboolean.self)
         }
         """,
         """
         @_cdecl("Java_com_example_swift_MyClass__00024setBoolean__ZJ")
-        func Java_com_example_swift_MyClass__00024setBoolean__ZJ(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, newValue: jboolean, self: jlong) {
+        func Java_com_example_swift_MyClass__00024setBoolean__ZJ(environment: UnsafeMutablePointer<CJNIEnv?>!, thisClass: jclass, newValue: jboolean, self: jlong) {
           ...
           self$.pointee.isBoolean = Bool(fromJNI: newValue, in: environment)
         }