[JExtract] Rework WIP

Author: rintaro

Samples/SwiftKitSampleApp/Sources/MySwiftLibrary/MySwiftClass.swift

@@ -34,6 +34,10 @@ public class MySwiftClass {
 
   public var counter: Int32 = 0
 
+  public static func factory(len: Int, cap: Int) -> MySwiftClass {
+    return MySwiftClass(len: len, cap: cap)
+  }
+
   public func voidMethod() {
     p("")
   }

Samples/SwiftKitSampleApp/build.gradle

@@ -81,7 +81,7 @@ def jextract = tasks.register("jextract", Exec) {
 
     workingDir = layout.projectDirectory
     commandLine "swift"
-    args("package", "jextract", "-v", "--log-level", "info") // TODO: pass log level from Gradle build
+    args("package", "jextract", "-v", "--log-level", "debug") // TODO: pass log level from Gradle build
 }
 
 // Add the java-swift generated Java sources

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

@@ -16,13 +16,16 @@
 
 // Import swift-extract generated sources
 
-import com.example.swift.MySwiftLibrary;
-import com.example.swift.MySwiftClass;
-
 // Import javakit/swiftkit support libraries
 import org.swift.swiftkit.SwiftArena;
 import org.swift.swiftkit.SwiftKit;
-import org.swift.swiftkit.SwiftValueWitnessTable;
+import org.swift.swiftkit.SwiftValueLayout;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemoryLayout;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+import java.util.concurrent.Callable;
 
 public class HelloJava2Swift {
 
@@ -40,18 +43,33 @@ static void examples() {
 
         MySwiftLibrary.globalTakeInt(1337);
 
+        long cnt =  MySwiftLibrary.globalWriteString("String from Java");
+
+        SwiftKit.trace("count = " + cnt);
+
+        MySwiftLibrary.globalCallMeRunnable(() -> {
+            SwiftKit.trace("running runnable");
+        });
+
         // Example of using an arena; MyClass.deinit is run at end of scope
         try (var arena = SwiftArena.ofConfined()) {
-             MySwiftClass obj = new MySwiftClass(arena, 2222, 7777);
+            MySwiftClass obj = new MySwiftClass(2222, 7777, arena);
+
+            // just checking retains/releases work
+            SwiftKit.trace("retainCount = " + SwiftKit.retainCount(obj));
+            SwiftKit.retain(obj);
+            SwiftKit.trace("retainCount = " + SwiftKit.retainCount(obj));
+            SwiftKit.release(obj);
+            SwiftKit.trace("retainCount = " + SwiftKit.retainCount(obj));
 
-             // just checking retains/releases work
-             SwiftKit.retain(obj.$memorySegment());
-             SwiftKit.release(obj.$memorySegment());
+            obj.setCounter(12);
+            SwiftKit.trace("obj.counter = " + obj.getCounter());
 
-             obj.voidMethod();
-             obj.takeIntMethod(42);
+            obj.voidMethod();
+            obj.takeIntMethod(42);
 
-            MySwiftStruct swiftValue = new MySwiftStruct(arena, 2222, 1111);
+            MySwiftStruct swiftValue = new MySwiftStruct(2222, 1111, arena);
+            SwiftKit.trace("swiftValue.capacity = " + swiftValue.getCapacity());
         }
 
         System.out.println("DONE.");

Sources/JExtractSwift/CDeclLowering/CDeclConversions.swift

@@ -21,13 +21,25 @@ extension CType {
   /// function, first go through Swift -> cdecl lowering. This function
   /// will throw an error if it encounters a type that is not expressible in
   /// C.
-  init(cdeclType: SwiftType) throws {
+init(cdeclType: SwiftType) throws {
     switch cdeclType {
     case .nominal(let nominalType):
-      if let knownType = nominalType.nominalTypeDecl.knownStandardLibraryType,
-        let primitiveCType = knownType.primitiveCType {
-        self = primitiveCType
-        return
+      if let knownType = nominalType.nominalTypeDecl.knownStandardLibraryType {
+        if let primitiveCType = knownType.primitiveCType {
+          self = primitiveCType
+          return
+        }
+
+        switch knownType {
+        case .unsafePointer where nominalType.genericArguments?.count == 1:
+          self = .pointer(.qualified(const: true, volatile: false, type: try CType(cdeclType: nominalType.genericArguments![0])))
+          return
+        case .unsafeMutablePointer where nominalType.genericArguments?.count == 1:
+          self = .pointer(try CType(cdeclType: nominalType.genericArguments![0]))
+          return
+        default:
+          break
+        }
       }
 
       throw CDeclToCLoweringError.invalidNominalType(nominalType.nominalTypeDecl)
@@ -109,7 +121,8 @@ extension KnownStandardLibraryType {
     case .unsafeRawPointer: .pointer(
       .qualified(const: true, volatile: false, type: .void)
     )
-    case .unsafePointer, .unsafeMutablePointer, .unsafeBufferPointer, .unsafeMutableBufferPointer:
+    case .void: .void
+    case .unsafePointer, .unsafeMutablePointer, .unsafeBufferPointer, .unsafeMutableBufferPointer, .string:
        nil
     }
   }