jextract: hide memory location wrapping constructor, give it proper name

The reason here is that it's too easy to accidentally autocomplete into
new Thing(bla) which can often be incorrect because we probably intended
to call init on the Thing. This popped up with Data a lot, because it is
so easy to wrongly use new Data rather than Data.init which performs the
proper initialization

Author: ktoso

Sources/JExtractSwiftLib/FFM/ConversionStep.swift

@@ -123,7 +123,7 @@ enum ConversionStep: Equatable {
       // of splatting out text.
       let renderedArgumentList = renderedArguments.joined(separator: ", ")
       return "\(raw: type.description)(\(raw: renderedArgumentList))"
-
+    
     case .tuplify(let elements):
       let renderedElements: [String] = elements.enumerated().map { (index, element) in
         element.asExprSyntax(placeholder: "\(placeholder)_\(index)", bodyItems: &bodyItems)!.description

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift

@@ -216,9 +216,22 @@ extension FFMSwift2JavaGenerator {
 
       printer.print(
         """
-        public \(decl.swiftNominal.name)(MemorySegment segment, AllocatingSwiftArena arena) {
+        private \(decl.swiftNominal.name)(MemorySegment segment, AllocatingSwiftArena arena) {
           super(segment, arena);
         }
+
+        /** 
+         * Assume that the passed {@code MemorySegment} represents a memory address of a {@link \(decl.swiftNominal.name)}.
+         * <p/>
+         * Warnings:
+         * <ul>
+         *   <li>No checks are performed about the compatibility of the pointed at memory and the actual \(decl.swiftNominal.name) types.</li>
+         *   <li>This operation does not copy, or retain, the pointed at pointer, so its lifetime must be ensured manually to be valid when wrapping.</li>
+         * </ul>
+         */
+        public static \(decl.swiftNominal.name) wrapMemoryAddressUnsafe(MemorySegment selfPointer, AllocatingSwiftArena swiftArena) {
+          return new \(decl.swiftNominal.name)(selfPointer, swiftArena);
+        }
         """
       )
 

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -117,9 +117,22 @@ extension JNISwift2JavaGenerator {
 
       printer.print(
         """
-        public \(decl.swiftNominal.name)(long selfPointer, SwiftArena swiftArena) {
+        private \(decl.swiftNominal.name)(long selfPointer, SwiftArena swiftArena) {
           super(selfPointer, swiftArena);
         }
+
+        /** 
+         * Assume that the passed {@code long} represents a memory address of a {@link \(decl.swiftNominal.name)}.
+         * <p/>
+         * Warnings:
+         * <ul>
+         *   <li>No checks are performed about the compatibility of the pointed at memory and the actual \(decl.swiftNominal.name) types.</li>
+         *   <li>This operation does not copy, or retain, the pointed at pointer, so its lifetime must be ensured manually to be valid when wrapping.</li>
+         * </ul>
+         */
+        public static \(decl.swiftNominal.name) wrapMemoryAddressUnsafe(long selfPointer, SwiftArena swiftArena) {
+          return new \(decl.swiftNominal.name)(selfPointer, swiftArena);
+        }
         """
       )
 

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -383,7 +383,7 @@ extension JNISwift2JavaGenerator {
           javaType: javaType,
           annotations: resultAnnotations,
           outParameters: [],
-          conversion: .constructSwiftValue(.placeholder, javaType)
+          conversion: .wrapMemoryAddressUnsafe(.placeholder, javaType)
         )
 
       case .tuple([]):
@@ -465,7 +465,7 @@ extension JNISwift2JavaGenerator {
             discriminatorName: "result_discriminator$",
             optionalClass: "Optional",
             javaType: .long,
-            toValue: .constructSwiftValue(.placeholder, .class(package: nil, name: nominalTypeName))
+            toValue: .wrapMemoryAddressUnsafe(.placeholder, .class(package: nil, name: nominalTypeName))
           )
         )
 
@@ -582,6 +582,9 @@ extension JNISwift2JavaGenerator {
     /// Call `new \(Type)(\(placeholder), swiftArena$)`
     indirect case constructSwiftValue(JavaNativeConversionStep, JavaType)
 
+    /// Call the `MyType.wrapMemoryAddressUnsafe` in order to wrap a memory address using the Java binding type
+    indirect case wrapMemoryAddressUnsafe(JavaNativeConversionStep, JavaType)
+
     indirect case call(JavaNativeConversionStep, function: String)
 
     indirect case method(JavaNativeConversionStep, function: String, arguments: [JavaNativeConversionStep] = [])
@@ -641,6 +644,10 @@ extension JNISwift2JavaGenerator {
       case .constructSwiftValue(let inner, let javaType):
         let inner = inner.render(&printer, placeholder)
         return "new \(javaType.className!)(\(inner), swiftArena$)"
+        
+      case .wrapMemoryAddressUnsafe(let inner, let javaType):
+        let inner = inner.render(&printer, placeholder)
+        return "\(javaType.className!).wrapMemoryAddressUnsafe(\(inner), swiftArena$)"
 
       case .call(let inner, let function):
         let inner = inner.render(&printer, placeholder)
@@ -705,7 +712,7 @@ extension JNISwift2JavaGenerator {
       case .placeholder, .constant, .isOptionalPresent:
         return false
 
-      case .constructSwiftValue:
+      case .constructSwiftValue, .wrapMemoryAddressUnsafe:
         return true
 
       case .valueMemoryAddress(let inner):

Tests/JExtractSwiftTests/JNI/JNIClassTests.swift

@@ -66,11 +66,17 @@ struct JNIClassTests {
             System.loadLibrary(LIB_NAME);
             return true;
           }
-
-          public MyClass(long selfPointer, SwiftArena swiftArena) {
+        """,
+        """
+          private MyClass(long selfPointer, SwiftArena swiftArena) {
             super(selfPointer, swiftArena);
           }
         """,
+        """
+        public static MyClass wrapMemoryAddressUnsafe(long selfPointer, SwiftArena swiftArena) {
+          return new MyClass(selfPointer, swiftArena);
+        }
+        """
       ])
     try assertOutput(
       input: source,

Tests/JExtractSwiftTests/JNI/JNIOptionalTests.swift

@@ -158,7 +158,7 @@ struct JNIOptionalTests {
         public static Optional<MyClass> optionalClass(Optional<MyClass> arg, SwiftArena swiftArena$) {
           byte[] result_discriminator$ = new byte[1];
           long result$ = SwiftModule.$optionalClass(arg.map(MyClass::$memoryAddress).orElse(0L), result_discriminator$);
-          return (result_discriminator$[0] == 1) ? Optional.of(new MyClass(result$, swiftArena$)) : Optional.empty();
+          return (result_discriminator$[0] == 1) ? Optional.of(MyClass.wrapMemoryAddressUnsafe(result$, swiftArena$)) : Optional.empty();
         }
       """,
       """

Tests/JExtractSwiftTests/JNI/JNIStructTests.swift

@@ -56,10 +56,16 @@ struct JNIStructTests {
             System.loadLibrary(LIB_NAME);
             return true;
           }
-
-          public MyStruct(long selfPointer, SwiftArena swiftArena) {
+        """,
+        """
+          private MyStruct(long selfPointer, SwiftArena swiftArena) {
             super(selfPointer, swiftArena);
           }
+        """,
+        """
+        public static MyStruct wrapMemoryAddressUnsafe(long selfPointer, SwiftArena swiftArena) {
+          return new MyStruct(selfPointer, swiftArena);
+        }
         """
       ])
     try assertOutput(