FIX

Author: rintaro

Samples/SwiftKitSampleApp/src/main/java/com/example/swift/HelloJava2Swift.java

@@ -83,10 +83,10 @@ static void examples() {
         }
 
         // Example of using 'Data'.
-        try (var arena = SwiftArena.ofConfined()) {
+        try (var arena = AllocatingSwiftArena.ofConfined()) {
             var origBytes = arena.allocateFrom("foobar");
             var origDat = Data.init(origBytes, origBytes.byteSize(), arena);
-            SwiftKit.trace("origDat.count = " + origDat.getCount());
+            SwiftRuntime.trace("origDat.count = " + origDat.getCount());
 
             // var origBytes = arena.allocate(ValueLayout.JAVA_INT, arry.length);
             // origBytes.copyFrom(MemorySegment.ofArray(arry));

Tests/JExtractSwiftTests/DataImportTests.swift

@@ -61,9 +61,16 @@ final class DataImportTests {
         """,
 
         """
-        @_cdecl("swiftjava_SwiftModule_Data_withUnsafeBytes_body")
-        public func swiftjava_SwiftModule_Data_withUnsafeBytes_body(_ body: @convention(c) (UnsafeRawPointer?, Int) -> Void, _ self: UnsafeRawPointer) {
-          self.assumingMemoryBound(to: Data.self).pointee.withUnsafeBytes(body: { (_0) in
+        @_cdecl("swiftjava_SwiftModule_Data_count$get")
+        public func swiftjava_SwiftModule_Data_count$get(_ self: UnsafeRawPointer) -> Int {
+          return self.assumingMemoryBound(to: Data.self).pointee.count
+        }
+        """,
+
+        """
+        @_cdecl("swiftjava_SwiftModule_Data_withUnsafeBytes__")
+        public func swiftjava_SwiftModule_Data_withUnsafeBytes__(_ body: @convention(c) (UnsafeRawPointer?, Int) -> Void, _ self: UnsafeRawPointer) {
+          self.assumingMemoryBound(to: Data.self).pointee.withUnsafeBytes({ (_0) in
             return body(_0.baseAddress, _0.count)
           })
         }
@@ -202,21 +209,61 @@ final class DataImportTests {
         """
         /**
          * {@snippet lang=c :
-         * void swiftjava_SwiftModule_Data_withUnsafeBytes_body(void (*body)(const void *, ptrdiff_t), const void *self)
+         * ptrdiff_t swiftjava_SwiftModule_Data_count$get(const void *self)
+         * }
+         */
+        private static class swiftjava_SwiftModule_Data_count$get {
+          private static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            /* -> */SwiftValueLayout.SWIFT_INT,
+            /* self: */SwiftValueLayout.SWIFT_POINTER
+          );
+          private static final MemorySegment ADDR =
+            SwiftModule.findOrThrow("swiftjava_SwiftModule_Data_count$get");
+          private static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC);
+          public static long call(java.lang.foreign.MemorySegment self) {
+            try {
+              if (SwiftRuntime.TRACE_DOWNCALLS) {
+                SwiftRuntime.traceDowncall(self);
+              }
+              return (long) HANDLE.invokeExact(self);
+            } catch (Throwable ex$) {
+              throw new AssertionError("should not reach here", ex$);
+            }
+          }
+        } 
+        """,
+
+        """
+        /**
+         * Downcall to Swift:
+         * {@snippet lang=swift :
+         * public var count: Int
+         * }
+         */
+        public long getCount() {
+          $ensureAlive();
+          return swiftjava_SwiftModule_Data_count$get.call(this.$memorySegment());
+        }
+        """,
+
+        """
+        /**
+         * {@snippet lang=c :
+         * void swiftjava_SwiftModule_Data_withUnsafeBytes__(void (*body)(const void *, ptrdiff_t), const void *self)
          * }
          */
-        private static class swiftjava_SwiftModule_Data_withUnsafeBytes_body {
+        private static class swiftjava_SwiftModule_Data_withUnsafeBytes__ {
           private static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
             /* body: */SwiftValueLayout.SWIFT_POINTER,
             /* self: */SwiftValueLayout.SWIFT_POINTER
           );
           private static final MemorySegment ADDR =
-            SwiftModule.findOrThrow("swiftjava_SwiftModule_Data_withUnsafeBytes_body");
+            SwiftModule.findOrThrow("swiftjava_SwiftModule_Data_withUnsafeBytes__");
           private static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC);
           public static void call(java.lang.foreign.MemorySegment body, java.lang.foreign.MemorySegment self) {
             try {
-              if (SwiftKit.TRACE_DOWNCALLS) {
-                SwiftKit.traceDowncall(body, self);
+              if (SwiftRuntime.TRACE_DOWNCALLS) {
+                SwiftRuntime.traceDowncall(body, self);
               }
               HANDLE.invokeExact(body, self);
             } catch (Throwable ex$) {
@@ -237,7 +284,7 @@ final class DataImportTests {
               /* _0: */SwiftValueLayout.SWIFT_POINTER,
               /* _1: */SwiftValueLayout.SWIFT_INT
             );
-            private static final MethodHandle HANDLE = SwiftKit.upcallHandle(Function.class, "apply", DESC);
+            private static final MethodHandle HANDLE = SwiftRuntime.upcallHandle(Function.class, "apply", DESC);
             private static MemorySegment toUpcallStub(Function fi, Arena arena) {
               return Linker.nativeLinker().upcallStub(HANDLE.bindTo(fi), DESC, arena);
             }
@@ -252,7 +299,7 @@ final class DataImportTests {
             void apply(java.lang.foreign.MemorySegment _0);
           }
           private static MemorySegment $toUpcallStub(body fi, Arena arena) {
-            return swiftjava_SwiftModule_Data_withUnsafeBytes_body.$body.toUpcallStub((_0_pointer, _0_count) -> {
+            return swiftjava_SwiftModule_Data_withUnsafeBytes__.$body.toUpcallStub((_0_pointer, _0_count) -> {
               fi.apply(_0_pointer.reinterpret(_0_count));
             }, arena);
           }
@@ -264,13 +311,13 @@ final class DataImportTests {
         /**
          * Downcall to Swift:
          * {@snippet lang=swift :
-         * public func withUnsafeBytes(body: (UnsafeRawBufferPointer) -> Void)
+         * public func withUnsafeBytes(_ body: (UnsafeRawBufferPointer) -> Void)
          * }
          */
         public void withUnsafeBytes(withUnsafeBytes.body body) {
           $ensureAlive();
           try(var arena$ = Arena.ofConfined()) {
-            swiftjava_SwiftModule_Data_withUnsafeBytes_body.call(withUnsafeBytes.$toUpcallStub(body, arena$), this.$memorySegment());
+            swiftjava_SwiftModule_Data_withUnsafeBytes__.call(withUnsafeBytes.$toUpcallStub(body, arena$), this.$memorySegment());
           }
         }
         """