Prefer VarHandle to raw offset APIs

A bit more idiomatic to use var handles rather than raw offsets.

Author: ktoso

SwiftKit/src/main/java/org/swift/swiftkit/SwiftValueWitnessTable.java

@@ -16,6 +16,7 @@
 
 import java.lang.foreign.*;
 import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
 
 import static java.lang.foreign.ValueLayout.JAVA_BYTE;
 import static org.swift.swiftkit.SwiftKit.getSwiftInt;
@@ -70,8 +71,7 @@ public static MemorySegment fullTypeMetadata(MemorySegment typeMetadata) {
      */
     public static MemorySegment valueWitnessTable(MemorySegment typeMetadata) {
         return fullTypeMetadata(typeMetadata)
-                 .get(SwiftValueLayout.SWIFT_POINTER, SwiftValueWitnessTable.fullTypeMetadata$vwt$offset);
-//                .get(ValueLayout.ADDRESS, SwiftValueWitnessTable.fullTypeMetadata$vwt$offset);
+                .get(SwiftValueLayout.SWIFT_POINTER, SwiftValueWitnessTable.fullTypeMetadata$vwt$offset);
     }
 
 
@@ -81,22 +81,33 @@ public static MemorySegment valueWitnessTable(MemorySegment typeMetadata) {
     static final long $size$offset =
             $LAYOUT.byteOffset(MemoryLayout.PathElement.groupElement("size"));
 
+    /**
+     * Variable handle for the "stride" field within the value witness table.
+     */
+    static final VarHandle $size$mh =
+            $LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("size"));
+
     /**
      * Determine the size of a Swift type given its type metadata.
      *
      * @param typeMetadata the memory segment must point to a Swift metadata
      */
     public static long sizeOfSwiftType(MemorySegment typeMetadata) {
-        return getSwiftInt(valueWitnessTable(typeMetadata), SwiftValueWitnessTable.$size$offset);
+        return getSwiftInt(valueWitnessTable(typeMetadata), $size$mh);
     }
 
-
     /**
      * Offset for the "stride" field within the value witness table.
      */
     static final long $stride$offset =
             $LAYOUT.byteOffset(MemoryLayout.PathElement.groupElement("stride"));
 
+    /**
+     * Variable handle for the "stride" field within the value witness table.
+     */
+    static final VarHandle $stride$mh =
+            $LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("size"));
+
     /**
      * Determine the stride of a Swift type given its type metadata, which is
      * how many bytes are between successive elements of this type within an
@@ -107,7 +118,7 @@ public static long sizeOfSwiftType(MemorySegment typeMetadata) {
      * @param typeMetadata the memory segment must point to a Swift metadata
      */
     public static long strideOfSwiftType(MemorySegment typeMetadata) {
-        return getSwiftInt(valueWitnessTable(typeMetadata), SwiftValueWitnessTable.$stride$offset);
+        return getSwiftInt(valueWitnessTable(typeMetadata), $stride$mh);
     }
 
 
@@ -117,7 +128,7 @@ public static long strideOfSwiftType(MemorySegment typeMetadata) {
      * @param typeMetadata the memory segment must point to a Swift metadata
      */
     public static long alignmentOfSwiftType(MemorySegment typeMetadata) {
-        long flags = getSwiftInt(valueWitnessTable(typeMetadata), SwiftValueWitnessTable.$flags$offset);
+        long flags = getSwiftInt(valueWitnessTable(typeMetadata), $flags$offset);
         return (flags & 0xFF) + 1;
     }
 
@@ -161,9 +172,12 @@ public static MemoryLayout layoutOfSwiftType(MemorySegment typeMetadata) {
     static final long $flags$offset =
             $LAYOUT.byteOffset(MemoryLayout.PathElement.groupElement("flags"));
 
+    // ==== ------------------------------------------------------------------------------------------------------------
+    // destroy
+
     /**
      * {@snippet lang = C:
-     * ///void(*destroy)(T *object, witness_t *self);
+     * ///    void(*destroy)(T *object, witness_t *self);
      * ///
      * /// Given a valid object of this type, destroy it, leaving it as an
      * /// invalid object. This is useful when generically destroying
@@ -202,7 +216,6 @@ static MethodHandle handle(SwiftAnyType ty) {
         }
     }
 
-
     /**
      * Destroy the value/object.
      * <p>
@@ -225,6 +238,9 @@ public static void destroy(SwiftAnyType type, MemorySegment object) {
         }
     }
 
+    // ==== ------------------------------------------------------------------------------------------------------------
+    // initializeWithCopy
+
     /**
      * {@snippet lang = C:
      * ///   T *(*initializeWithCopy)(T *dest, T *src, M *self);
@@ -238,26 +254,23 @@ public static void destroy(SwiftAnyType type, MemorySegment object) {
      *}
      */
     private static class initializeWithCopy {
-
         static final long $offset =
-                $LAYOUT.byteOffset(MemoryLayout.PathElement.groupElement("initializeWithCopy"));
+                $LAYOUT.byteOffset(MemoryLayout.PathElement.groupElement("destroy"));
 
-        static final FunctionDescriptor DESC = FunctionDescriptor.of(
-                /* -> */ ValueLayout.ADDRESS, // returns the destination object
-                ValueLayout.ADDRESS, // destination
-                ValueLayout.ADDRESS, // source
+        static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+                ValueLayout.ADDRESS, // witness table functions expect a pointer to self pointer
                 ValueLayout.ADDRESS // pointer to the witness table
         );
 
         /**
-         * Function pointer for the initializeWithCopy operation
+         * Function pointer for the destroy operation
          */
         static MemorySegment addr(SwiftAnyType ty) {
             // Get the value witness table of the type
             final var vwt = SwiftValueWitnessTable.valueWitnessTable(ty.$memorySegment());
 
-            // Get the address of the function stored at the offset of the witness table
-            long funcAddress = getSwiftInt(vwt, initializeWithCopy.$offset);
+            // Get the address of the destroy function stored at the offset of the witness table
+            long funcAddress = getSwiftInt(vwt, destroy.$offset);
             return MemorySegment.ofAddress(funcAddress);
         }
 
@@ -266,31 +279,7 @@ static MethodHandle handle(SwiftAnyType ty) {
         }
     }
 
+    public static void initializeWithCopy(SwiftAnyType type, MemorySegment from, MemorySegment target) {
 
-    /**
-     * Given an invalid object of this type, initialize it as a copy of
-     * the source object.
-     * <p/>
-     * Returns the dest object.
-     */
-    public static MemorySegment initializeWithCopy(SwiftAnyType type, MemorySegment dest, MemorySegment src) {
-        var fullTypeMetadata = fullTypeMetadata(type.$memorySegment());
-        var wtable = valueWitnessTable(fullTypeMetadata);
-
-        var mh = initializeWithCopy.handle(type);
-
-        try (var arena = Arena.ofConfined()) {
-            // we need to make a pointer to the self pointer when calling witness table functions:
-            MemorySegment indirectDest = arena.allocate(SwiftValueLayout.SWIFT_POINTER);
-            MemorySegmentUtils.setSwiftPointerAddress(indirectDest, dest);
-            MemorySegment indirectSrc = arena.allocate(SwiftValueLayout.SWIFT_POINTER);
-            MemorySegmentUtils.setSwiftPointerAddress(indirectSrc, src);
-
-            var returnedDest = (MemorySegment) mh.invokeExact(indirectDest, indirectSrc, wtable);
-            return returnedDest;
-        } catch (Throwable th) {
-            throw new AssertionError("Failed to initializeWithCopy '" + type + "' (" + dest + ", " + src + ")", th);
-        }
     }
-
 }