PR feedback

Author: madsodgaard

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -16,8 +16,6 @@ import JavaTypes
 
 // MARK: Defaults
 
-private let globalArenaName = "GLOBAL_ARENA"
-
 extension JNISwift2JavaGenerator {
   /// Default set Java imports for every generated file
   static let defaultJavaImports: Array<String> = [
@@ -74,11 +72,6 @@ extension JNISwift2JavaGenerator {
     printImports(&printer)
 
     printModuleClass(&printer) { printer in
-      if config.effectiveMemoryManagementMode.requiresGlobalArena {
-        printer.print("static final SwiftArena \(globalArenaName) = SwiftArena.ofAuto();")
-        printer.println()
-      }
-
       printer.print(
         """
         static final String LIB_NAME = "\(swiftModuleName)";
@@ -277,7 +270,8 @@ extension JNISwift2JavaGenerator {
       printer.printBraceBlock(
         "\(annotationsStr)\(modifiers.joined(separator: " ")) \(resultType) \(translatedDecl.name)(\(parametersStr))\(throwsClause)"
       ) { printer in
-        let arguments = translatedDecl.translatedFunctionSignature.parameters.map(\.parameter.name) + ["\(swiftModuleName).\(globalArenaName)"]
+        let globalArenaName = "SwiftMemoryManagement.GLOBAL_SWIFT_JAVA_ARENA"
+        let arguments = translatedDecl.translatedFunctionSignature.parameters.map(\.parameter.name) + [globalArenaName]
         let call = "\(translatedDecl.name)(\(arguments.joined(separator: ", ")))"
         if translatedDecl.translatedFunctionSignature.resultType.javaType.isVoid {
           printer.print("\(call);")
@@ -288,10 +282,6 @@ extension JNISwift2JavaGenerator {
       printer.println()
     }
 
-    // Make any function with explicit arena private if we force automatic.
-    if config.effectiveMemoryManagementMode == .forceAutomatic && translatedSignature.requiresSwiftArena {
-      modifiers[0] = "private"
-    }
     if translatedSignature.requiresSwiftArena {
       parameters.append("SwiftArena swiftArena$")
     }

Sources/JavaKitConfigurationShared/GenerationMode.swift

@@ -81,24 +81,20 @@ extension JExtractMinimumAccessLevelMode {
 /// Configures how memory should be managed by the user
 public enum JExtractMemoryManagementMode: String, Codable {
   /// Force users to provide an explicit `SwiftArena` to all calls that require them.
-  case forceExplicit
+  case explicit
 
   /// Provide both explicit `SwiftArena` support
   /// and a default global automatic `SwiftArena` that will deallocate memory when the GC decides to.
-  case allowAutomatic
-
-  /// Force all memory management to a default global automatic `SwiftArena`
-  /// that will deallocate memory when the GC decides to.
-  case forceAutomatic
+  case allowGlobalAutomatic
 
   public static var `default`: Self {
-    .forceExplicit
+    .explicit
   }
 
   public var requiresGlobalArena: Bool {
     switch self {
-    case .forceExplicit: false
-    case .allowAutomatic, .forceAutomatic: true
+    case .explicit: false
+    case .allowGlobalAutomatic: true
     }
   }
 }

Sources/SwiftJavaTool/Commands/JExtractCommand.swift

@@ -122,7 +122,7 @@ extension SwiftJava.JExtractCommand {
         () // OK
       }
     } else if self.mode == .ffm {
-      guard self.memoryManagementMode == .forceExplicit else {
+      guard self.memoryManagementMode == .explicit else {
         throw IllegalModeCombinationError("FFM mode does not support '\(self.memoryManagementMode)' memory management mode! \(Self.helpMessage)")
       }
     }

SwiftKitCore/src/main/java/org/swift/swiftkit/core/AutoSwiftMemorySession.java

@@ -15,7 +15,7 @@
 package org.swift.swiftkit.core;
 
 
-import org.swift.swiftkit.core.ref.Cleaner;
+import org.swift.swiftkit.core.ref.SwiftCleaner;
 
 import java.util.Objects;
 import java.util.concurrent.ThreadFactory;
@@ -38,10 +38,10 @@
  * <p> Whenever possible, prefer using an explicitly managed {@link SwiftArena}, such as {@link SwiftArena#ofConfined()}.
  */
 final class AutoSwiftMemorySession implements SwiftArena {
-    private final Cleaner cleaner;
+    private final SwiftCleaner swiftCleaner;
 
     public AutoSwiftMemorySession(ThreadFactory cleanerThreadFactory) {
-        this.cleaner = Cleaner.create(cleanerThreadFactory);
+        this.swiftCleaner = SwiftCleaner.create(cleanerThreadFactory);
     }
 
     @Override
@@ -51,6 +51,6 @@ public void register(SwiftInstance instance) {
         // We make sure we don't capture `instance` in the
         // cleanup action, so we can ignore the warning below.
         var cleanupAction = instance.$createCleanup();
-        cleaner.register(instance, cleanupAction);
+        swiftCleaner.register(instance, cleanupAction);
     }
 }

SwiftKitCore/src/main/java/org/swift/swiftkit/core/SwiftArena.java

@@ -23,7 +23,7 @@
  * <p> A confined arena has an associated owner thread that confines some operations to
  * associated owner thread such as {@link ClosableSwiftArena#close()}.
  */
-public interface SwiftArena  {
+public interface SwiftArena {
     /**
      * Register a Swift object.
      * Its memory should be considered managed by this arena, and be destroyed when the arena is closed.

SwiftKitCore/src/main/java/org/swift/swiftkit/core/SwiftMemoryManagement.java

@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+package org.swift.swiftkit.core;
+
+public class SwiftMemoryManagement {
+    public static final SwiftArena GLOBAL_SWIFT_JAVA_ARENA = SwiftArena.ofAuto();
+}

SwiftKitCore/src/main/java/org/swift/swiftkit/core/ref/PhantomCleanable.java

@@ -18,17 +18,17 @@
 
 public class PhantomCleanable extends PhantomReference<Object> {
     private final Runnable cleanupAction;
-    private final Cleaner cleaner;
+    private final SwiftCleaner swiftCleaner;
 
-    public PhantomCleanable(Object referent, Cleaner cleaner, Runnable cleanupAction) {
-        super(referent, cleaner.referenceQueue);
+    public PhantomCleanable(Object referent, SwiftCleaner swiftCleaner, Runnable cleanupAction) {
+        super(referent, swiftCleaner.referenceQueue);
         this.cleanupAction = cleanupAction;
-        this.cleaner = cleaner;
-        cleaner.list.add(this);
+        this.swiftCleaner = swiftCleaner;
+        swiftCleaner.list.add(this);
     }
 
     public void cleanup() {
-        if (cleaner.list.remove(this)) {
+        if (swiftCleaner.list.remove(this)) {
             cleanupAction.run();
         }
     }

…org/swift/swiftkit/core/ref/Cleaner.java …wift/swiftkit/core/ref/SwiftCleaner.javaSwiftKitCore/src/main/java/org/swift/swiftkit/core/ref/Cleaner.java renamed to SwiftKitCore/src/main/java/org/swift/swiftkit/core/ref/SwiftCleaner.java SwiftKitCore/src/main/java/org/swift/swiftkit/core/ref/Cleaner.java renamed to SwiftKitCore/src/main/java/org/swift/swiftkit/core/ref/SwiftCleaner.java

@@ -21,19 +21,19 @@
 import java.util.Objects;
 import java.util.concurrent.ThreadFactory;
 
-public class Cleaner implements Runnable {
+public class SwiftCleaner implements Runnable {
     final ReferenceQueue<Object> referenceQueue;
     final List<PhantomCleanable> list;
 
-    private Cleaner() {
+    private SwiftCleaner() {
         this.referenceQueue = new ReferenceQueue<>();
         this.list = Collections.synchronizedList(new LinkedList<>());
     }
 
-    public static Cleaner create(ThreadFactory threadFactory) {
-        Cleaner cleaner = new Cleaner();
-        cleaner.start(threadFactory);
-        return cleaner;
+    public static SwiftCleaner create(ThreadFactory threadFactory) {
+        SwiftCleaner swiftCleaner = new SwiftCleaner();
+        swiftCleaner.start(threadFactory);
+        return swiftCleaner;
     }
 
     void start(ThreadFactory threadFactory) {