WIP

Author: rintaro

Sources/JExtractSwift/ImportedDecls.swift

@@ -127,54 +127,6 @@ public final class ImportedFunc: ImportedDecl, CustomStringConvertible {
   }
 }
 
-public final class ImportedVariable: ImportedDecl, CustomStringConvertible {
-
-  public var module: String
-
-  /// Parent type if this is a type member.
-  var parentType: SwiftType
-
-  /// The variable name.
-  public var name: String
-
-  /// The value type
-  var type: SwiftType
-
-  /// The syntax of the variable
-  public var swiftDecl: any DeclSyntaxProtocol
-
-  /// Function signatures for accessors.
-  var accessors: [ImportedFunc]
-
-  init(
-    module: String,
-    parentType: SwiftType,
-    name: String,
-    type: SwiftType,
-    swiftDecl: any DeclSyntaxProtocol,
-    accessors: [ImportedFunc]
-  ) {
-    self.module = module
-    self.parentType = parentType
-    self.name = name
-    self.type = type
-    self.swiftDecl = swiftDecl
-    self.accessors = accessors
-  }
-
-  public var description: String {
-    """
-    ImportedVaraiable {
-      module: \(module)
-      parentType: \(parentType)
-      name: \(name)
-      type: \(type)
-      signature: \(self.swiftDecl.signatureString)
-    }
-    """
-  }
-}
-
 extension ImportedFunc: Hashable {
   public func hash(into hasher: inout Hasher) {
     hasher.combine(ObjectIdentifier(self))
@@ -183,12 +135,3 @@ extension ImportedFunc: Hashable {
     return lhs === rhs
   }
 }
-
-extension ImportedVariable: Hashable {
-  public func hash(into hasher: inout Hasher) {
-    hasher.combine(ObjectIdentifier(self))
-  }
-  public static func == (lhs: ImportedVariable, rhs: ImportedVariable) -> Bool {
-    return lhs === rhs
-  }
-}

Sources/JExtractSwift/JavaConstants/ForeignValueLayouts.swift

@@ -83,9 +83,4 @@ extension ForeignValueLayout {
 
   public static let SwiftFloat = Self(javaConstant: "SWIFT_FLOAT")
   public static let SwiftDouble = Self(javaConstant: "SWIFT_DOUBLE")
-
-  var isPrimitive: Bool {
-    // FIXME: This is a hack, we need an enum to better describe this!
-    value != "SWIFT_POINTER"
-  }
 }

Sources/JExtractSwift/Swift2Java.swift

@@ -90,7 +90,7 @@ public struct SwiftToJava: ParsableCommand {
 
     try translator.analyze()
     try translator.writeSwiftThunkSources(outputDirectory: outputDirectorySwift)
-    try translator.writeExportedJavaSources(outputDirectory: outputDirectoryJava)
+    try translator.writeJavaBindingsSources(outputDirectory: outputDirectoryJava)
     print("[swift-java] Generated Java sources (\(packageName)) in: \(outputDirectoryJava)/")
     print("[swift-java] Imported Swift module '\(swiftModule)': " + "done.".green)
   }

Sources/JExtractSwift/Swift2JavaTranslator+JavaThunkPrinting.swift renamed to Sources/JExtractSwift/Swift2JavaTranslator+JavaBindingsPrinting.swift

@@ -13,12 +13,11 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
+import JavaTypes
 import SwiftBasicFormat
 import SwiftParser
 import SwiftSyntax
 
-import JavaTypes
-
 // ==== ---------------------------------------------------------------------------------------------------------------
 // MARK: File writing
 
@@ -27,12 +26,12 @@ let PATH_SEPARATOR = "/"  // TODO: Windows
 extension Swift2JavaTranslator {
 
   /// Every imported public type becomes a public class in its own file in Java.
-  public func writeExportedJavaSources(outputDirectory: String) throws {
+  public func writeJavaBindingsSources(outputDirectory: String) throws {
     var printer = CodePrinter()
-    try writeExportedJavaSources(outputDirectory: outputDirectory, printer: &printer)
+    try writeJavaBindingsSources(outputDirectory: outputDirectory, printer: &printer)
   }
 
-  public func writeExportedJavaSources(outputDirectory: String, printer: inout CodePrinter) throws {
+  public func writeJavaBindingsSources(outputDirectory: String, printer: inout CodePrinter) throws {
     for (_, ty) in importedTypes.sorted(by: { (lhs, rhs) in lhs.key < rhs.key }) {
       let filename = "\(ty.swiftNominal.name).java"
       log.info("Printing contents: \(filename)")
@@ -120,12 +119,12 @@ extension Swift2JavaTranslator {
         }
         """
       )
-      printer.print("")
+      printer.println()
 
       // Layout of the class
       printClassMemoryLayout(&printer, decl)
 
-      printer.print("")
+      printer.println()
 
       printer.print(
         """
@@ -184,14 +183,9 @@ extension Swift2JavaTranslator {
   package func printNominal(
     _ printer: inout CodePrinter, _ decl: ImportedNominalType, body: (inout CodePrinter) -> Void
   ) {
-    let parentProtocol: String
-    if decl.swiftNominal.isReferenceType {
-      parentProtocol = " implements SwiftHeapObject"
-    } else {
-      parentProtocol = ""
-    }
+    let baseProtocol = decl.swiftNominal.isReferenceType ? "SwiftHeapObject" : "SwiftValue"
 
-    printer.printBraceBlock("public final class \(decl.swiftNominal.name) extends SwiftValue\(parentProtocol)") { printer in
+    printer.printBraceBlock("public final class \(decl.swiftNominal.name) extends SwiftInstance implements \(baseProtocol)") { printer in
       // Constants
       printClassConstants(printer: &printer)
 

Sources/JExtractSwift/SwiftTypes/SwiftSymbolTable.swift

@@ -50,65 +50,6 @@ package class SwiftSymbolTable {
   }
 }
 
-extension SwiftSymbolTable {
-  func setup(_ sourceFiles: some Collection<SourceFileSyntax>) {
-    // First, register top-level and nested nominal types to the symbol table.
-    for sourceFile in sourceFiles {
-      self.addNominalTypeDeclarations(sourceFile)
-    }
-
-    // Register nested nominal in extensions to the symbol table.
-    func handleExtension(_ extensionDecl: ExtensionDeclSyntax) -> Bool {
-      // Try to resolve the type referenced by this extension declaration.
-      // If it fails, we'll try again later.
-      guard let extendedType = try? SwiftType(extensionDecl.extendedType, symbolTable: self) else {
-        return false
-      }
-      guard let extendedNominal = extendedType.asNominalTypeDeclaration else {
-        // Extending type was not a nominal type. Ignore it.
-        return true
-      }
-
-      // We have successfully resolved the extended type. Record it and
-      // remove the extension from the list of unresolved extensions.
-      self.parsedModule.addExtension(extensionDecl, extending: extendedNominal)
-      return true
-    }
-
-    // The work queue is required because, the extending type might be declared
-    // in another extension that hasn't been processed. E.g.:
-    //
-    //   extension Outer.Inner { struct Deeper {} }
-    //   extension Outer { struct Inner {} }
-    //   struct Outer {}
-    //
-    var unresolvedExtensions: [ExtensionDeclSyntax] = []
-    for sourceFile in sourceFiles {
-      // Find extensions.
-      for statement in sourceFile.statements {
-        // We only care about extensions at top-level.
-        if case .decl(let decl) = statement.item, let extNode = decl.as(ExtensionDeclSyntax.self) {
-          let resolved = handleExtension(extNode)
-          if !resolved {
-            unresolvedExtensions.append(extNode)
-          }
-        }
-      }
-    }
-
-    while !unresolvedExtensions.isEmpty {
-      let numExtensionsBefore = unresolvedExtensions.count
-      unresolvedExtensions.removeAll(where: handleExtension(_:))
-
-      // If we didn't resolve anything, we're done.
-      if numExtensionsBefore == unresolvedExtensions.count {
-        break
-      }
-      assert(numExtensionsBefore > unresolvedExtensions.count)
-    }
-  }
-}
-
 extension SwiftSymbolTable {
   package func setup(_ sourceFiles: some Collection<SourceFileSyntax>) {
     // First, register top-level and nested nominal types to the symbol table.

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

@@ -48,16 +48,16 @@ public AutoSwiftMemorySession(ThreadFactory cleanerThreadFactory) {
     }
 
     @Override
-    public void register(SwiftValue value) {
-        Objects.requireNonNull(value, "value");
+    public void register(SwiftInstance instance) {
+        Objects.requireNonNull(instance, "value");
 
         // We're doing this dance to avoid keeping a strong reference to the value itself
-        var statusDestroyedFlag = value.$statusDestroyedFlag();
+        var statusDestroyedFlag = instance.$statusDestroyedFlag();
         Runnable markAsDestroyed = () -> statusDestroyedFlag.set(true);
 
-        MemorySegment resource = value.$memorySegment();
-        var cleanupAction = new SwiftValueCleanup(resource, value.$swiftType(), markAsDestroyed);
-        cleaner.register(value, cleanupAction);
+        MemorySegment resource = instance.$memorySegment();
+        var cleanupAction = new SwiftInstanceCleanup(resource, instance.$swiftType(), markAsDestroyed);
+        cleaner.register(instance, cleanupAction);
     }
 
     @Override

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

@@ -61,13 +61,13 @@ public void close() {
     }
 
     @Override
-    public void register(SwiftValue value) {
+    public void register(SwiftInstance value) {
         checkValid();
 
         var statusDestroyedFlag = value.$statusDestroyedFlag();
         Runnable markAsDestroyed = () -> statusDestroyedFlag.set(true);
 
-        var cleanup = new SwiftValueCleanup(
+        var cleanup = new SwiftInstanceCleanup(
                 value.$memorySegment(),
                 value.$swiftType(),
                 markAsDestroyed);

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

@@ -36,10 +36,10 @@ static SwiftArena ofAuto() {
     }
 
     /**
-     * Register a struct, enum or other non-reference counted Swift object.
+     * Register a Swift object.
      * Its memory should be considered managed by this arena, and be destroyed when the arena is closed.
      */
-    void register(SwiftValue value);
+    void register(SwiftInstance value);
 
 }
 

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

@@ -20,9 +20,12 @@
  * Represents a wrapper around a Swift heap object, e.g. a {@code class} or an {@code actor}.
  */
 public interface SwiftHeapObject {
-    default MemorySegment $instance() {
+    MemorySegment $memorySegment();
+
+    /**
+     * Pointer to the instance.
+     */
+    public default MemorySegment $instance() {
         return this.$memorySegment().get(SwiftValueLayout.SWIFT_POINTER, 0);
     }
-
-    MemorySegment $memorySegment();
 }

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

@@ -17,36 +17,87 @@
 import java.lang.foreign.GroupLayout;
 import java.lang.foreign.MemorySegment;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
 
-public interface SwiftInstance {
+public abstract class SwiftInstance {
+    /// Pointer to the "self".
+    private final MemorySegment selfMemorySegment;
 
     /**
      * The pointer to the instance in memory. I.e. the {@code self} of the Swift object or value.
      */
-    MemorySegment $memorySegment();
+    public final MemorySegment $memorySegment() {
+        return this.selfMemorySegment;
+    }
+
+    // TODO: make this a flagset integer and/or use a field updater
+    /** Used to track additional state of the underlying object, e.g. if it was explicitly destroyed. */
+    private final AtomicBoolean $state$destroyed = new AtomicBoolean(false);
+
+    /**
+     * Exposes a boolean value which can be used to indicate if the object was destroyed.
+     * <p/>
+     * This is exposing the object, rather than performing the action because we don't want to accidentally
+     * form a strong reference to the {@code SwiftInstance} which could prevent the cleanup from running,
+     * if using an GC managed instance (e.g. using an {@link AutoSwiftMemorySession}.
+     */
+    public final AtomicBoolean $statusDestroyedFlag() {
+        return this.$state$destroyed;
+    }
 
     /**
      * The in memory layout of an instance of this Swift type.
      */
-    GroupLayout $layout();
+    public abstract GroupLayout $layout();
 
-    SwiftAnyType $swiftType();
+    /**
+     * The Swift type metadata of this type.
+     */
+    public abstract SwiftAnyType $swiftType();
 
     /**
-     * Returns `true` if this swift instance is a reference type, i.e. a `class` or (`distributed`) `actor`.
+     * The designated constructor of any imported Swift types.
      *
-     * @return `true` if this instance is a reference type, `false` otherwise.
+     * @param segment the memory segment.
+     * @param arena the arena this object belongs to. When the arena goes out of scope, this value is destroyed.
      */
-    default boolean isReferenceType() {
-        return this instanceof SwiftHeapObject;
+    protected SwiftInstance(MemorySegment segment, SwiftArena arena) {
+        this.selfMemorySegment = segment;
+        arena.register(this);
     }
 
     /**
-     * Exposes a boolean value which can be used to indicate if the object was destroyed.
+     * Convenience constructor subclasses can call like:
+     * {@snippet :
+     * super(() -> { ...; return segment; }, swiftArena$)
+     * }
+     *
+     * @param segmentSupplier Should return the memory segment of the value
+     * @param arena the arena where the supplied segment belongs to. When the arena goes out of scope, this value is destroyed.
+     */
+    protected SwiftInstance(Supplier<MemorySegment> segmentSupplier, SwiftArena arena) {
+        this(segmentSupplier.get(), arena);
+    }
+
+    /**
+     * Ensures that this instance has not been destroyed.
      * <p/>
-     * This is exposing the object, rather than performing the action because we don't want to accidentally
-     * form a strong reference to the {@code SwiftInstance} which could prevent the cleanup from running,
-     * if using an GC managed instance (e.g. using an {@link AutoSwiftMemorySession}.
+     * If this object has been destroyed, calling this method will cause an {@link IllegalStateException}
+     * to be thrown. This check should be performed before accessing {@code $memorySegment} to prevent
+     * use-after-free errors.
      */
-    AtomicBoolean $statusDestroyedFlag();
+    protected final void $ensureAlive() {
+        if (this.$state$destroyed.get()) {
+            throw new IllegalStateException("Attempted to call method on already destroyed instance of " + getClass().getSimpleName() + "!");
+        }
+    }
+
+    /**
+     * Returns `true` if this swift instance is a reference type, i.e. a `class` or (`distributed`) `actor`.
+     *
+     * @return `true` if this instance is a reference type, `false` otherwise.
+     */
+    public boolean isReferenceType() {
+        return this instanceof SwiftHeapObject;
+    }
 }